# $Id: NEWS 22156 2007-10-17 04:46:19Z coke $

New in 0.4.17
- 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)

New in 0.4.16
- Implementation:
 + Performed code review on every PMC
 + Modified PMC code generation to use Storable, reducing compile times
 + Added a makefile target to generate test coverage data of C sources
- Languages:
 + NQP: added lists, for loops, operators, comparison and multiplicative operators
 + Announced Kea-CL, Kea Common Lisp, an ANSI Common Lisp implementation
   The repository is available at https://rgrjr.dyndns.org/svn/kea-cl/trunk/
- Documentation
 + PDD17 "PMCs" - draft approved, the design is complete
 + Added more PIR tutorials, see examples/tutorial/00_README.pod
- Miscellaneous:
 + Many bugfixes, enhancements, documentation, and coding standard updates
 + Deprecated PMC constants and other crufty syntax, see DEPRECATED.pod
 + Improved icc compiler compatibility for error line reporting

New in 0.4.15
- Implementation:
 + Lots of code review, many bugs fixed
 + Many more code cleanups and compiler warning levels
 + Started a new jit engine for 64-bit processors
 + Refactored configure process, with tests and new diagnostic options
 + Added new CodeString PMC for dynamic generation of PIR code
 + More pdd15 support for object metamodel.
- Languages:
 + Added NQP ("Not Quite Perl"), a very lightweight Perl 6-like language
 + Significant improvements and refactors to PCT (Parrot Compiler Toolkit)
 + perl6 passes more spec tests
 + Lua works now with a PGE/TGE/PAST-pm based compiler, lives in one pbc,
   and the interpreter has same behavior as original.
- Documentation
 + Added a committers' HOWTO
 + More PIR tutorial examples
 + Added PAUSE guide

New in 0.4.14
- Now, with Seat Belts!
 + added makefile targets for Sun lint, BSD lint, and splint
 + corrected many errors picked up by these tools
 + decorated source code with compiler hints, assertions, and attribute macros
 + automated creation of function declarations to prevent common errors
 + increased compiler warnings levels
 + converted more exceptions to a recoverable form
- Languages:
 + updated Lisp, Lua, Perl 6, tcl, regex, Scheme ("Pheme")
 + Perl 6 now fetches selected tests from pugs, and even passes some
 + PGE modified to handle {*} action subs for top-down and bottom-up parsers,
   and to allow grammar subclassing
 + HLLCompiler now has better exception, eval, and exit support
 + Introduced PCT, a refactor of HLLCompiler and PAST-pm
- Design:
 + PDD15 "Objects" - details added to 'new' and 'getattribute' opcodes
 + PDD17 "PMCs" - notes added on instantiation and dynamic extention in PIR
- Documentation:
 + added Parrot-related text from "Perl6 and Parrot Essentials" book,
   tutorial examples from "Learning PIR" talk, and PDD15 metamodel diagrams
- Implementation:
 + reduced memory footprint when using named registers
 + implemented overridding of vtable methods by PDD15 classes
 + improved PDD15 support for 'new', 'instantiate', and others
 + added makefile targets to ease core and HLL makefile regeneration
 + updated parrot dubugger, "pdb", to allow loading of commands from file
- Misc:
 + many bugfixes, enhancements, documentation, and coding standard updates

New in 0.4.13
- Languages:
 + Updated Lisp, Lua, PHP ("Plumhead"), Python ("Pynie"), ABC,
   WMLScript, and Tcl ("ParTcl").
 + Perl 6 passes all of the sanity tests.
 + PGE supports latest Perl 6 grammar syntax. Perl 6, Python
   ("Pynie"), and ABC parsers updated to match.
 + Updated PHP ("Plumhead") to Antlr 3.0.
 + Lua added the beginnings of a PGE/TGE based compiler (not yet
   replacing the Perl/Yapp compiler).
 + Lisp updated for current features, added a test suite.
- Core Implementation:
 + Filled in features and backward compatibility for PDD 15 objects.
   New object metamodel passes 85% of old test suite.
 + GCC API symbols are visible externally only when explicitly exported.
 + Added generated GCC compiler attributes to increase warnings, and
   cleaned up resulting warnings.
 + Code cleanup efforts and fixed memory leaks by the cage cleaners,
   resulting in notable speed increases.
- Misc:
 + Updated Parrot distribution to Artistic License 2.0, from dual
   Artistic 1/GPL license.
 + SDL examples brought up-to-date with current features.

New in 0.4.12
- Build:
 + even more refactorings and improvements in configuration system
 + improved tests and documentation for configuration system
- Languages:
 + Updated abc, PHP ("Plumhead"), Lua, Tcl
 + Reclaimed Lisp
- Design:
 + new PMC PDD draft partially completed
- Implementation:
 + continued implementation of PDD 15 (Objects)
 + minor garbage collector and memory management improvements
 + several memory leaks resolved
 + extended support for compilers other than GCC
 + improved C++ compiler compatibility
 + enhanced support for Solaris, non-MSVC Win32, and other platforms

New in 0.4.11

- Compilers:
 + IMCC: added documentation for C-based Parrot Calling Conventions,
   refactorings and bug fixes
 + PGE: new perl6regex front end reflecting recent S05 syntax changes
 + PIRC: new prototype PIR parser
- Languages:
 + Updated Lua, PHP ("Plumhead"), BASIC, pynie
 + Lua implements environment
- Design:
 + PDD15 "Objects" - details added, and draft approved
- Documentation:
 + Added guidelines for PMC documentation
- Implementation:
 + PDD15 implementation is largely complete, including role-based composition,
   introspection, and C3 method resolution order
 + new Exporter PMC for importing globals between namespaces
 + new string utilities for radix conversion
 + PCCINVOKE and Parrot_PCCINVOKE allow calling using the full Parrot Calling
   Conventions from PMCs and C code respectively
- Build:
 + Refactorings and improvements in test coverage for 'Configure.pl'
- Misc:
 + many bugfixes, enhancements, and code cleanup
 + added example subversion config file
 + extended support for gcc, icc, and other compilers
 + extended support for Solaris and other platforms


New in 0.4.10

- Compilers:
 + IMCC: Parrot calling conventions now available between two C PMCs (PMINVOKE)
 + PGE: Match object improvements
 + smop: added Attribute and Class PMCs
 + HLLCompiler: improvements for interactive mode
- PAST:
 + extended binding to a list of variables
- Languages:
 + Updated Lua, PHP ("Plumhead"), Tcl ("ParTcl"), Ruby ("Cardinal")
 + Update PIR, regex, Zcode
 + New language: Pynie - a Python compiler for Parrot
 + Lua implements require and many other ops, improved regex support
 + Remove parakeet
- Design:
 + PDD01 "Overview" - updated architecture and platform information
 + PDD15 "Objects" - details on roles, objects, and classes added
 + PDD22 "I/O" - added async ops and Status PMC details
- Documentation:
 + Added guides for Metacommitter, Relase Manager, and Cage Cleaner roles
- Implementation:
 + Object, Class, Role, and Attribute PMC implementation has begun
 + Perl 5 module "Parrot::Embed" now compiles and links on all platforms
- Build:
 + Major improvements in test coverage for 'ops2c.pl'
- Misc:
 + New utility: Crow, a template processor
 + New library module: Config/JSON for reading/writing JSON files
 + many bugfixes, enhancements, and coding standard updates, code cleanup

New in 0.4.9

- Compilers:
   + IMCC: Parrot calling conventions now available in C PMCs, allowing
     named, optional, slurpy, and flat parameter passing
   + PGE: extended support for Perl 5 Regexes
   + smop: prototype object model implementation
   + hllcompiler: refactored to run a configurable set of compilation stages
- PAST:
   + redesigned assign/binding to support Perl 6 binding semantics
- Languages:
   + Updated Lua, PHP ("Plumhead"), Tcl ("ParTcl"), perl6, perl5
   + New language: PIR - a PGE-based implementation of Parrot PIR
   + perl6 now supports binding (':=') and 'join'
   + lua generates tail calls, and supports its own regex flavor (PGE-based)
   + Pheme still works, huzzah!
- Design:
   + PDD21 "Objects" - rewritten
   + PDD22 "I/O" - updated and 'TODO' tests added
- Documentation:
   + Interface stability classification standards approved
   + Roles and Responsibilities documented approved
   + Official 'drafts' directory created (was 'clip')
- Implementation:
   + More NameSpace and OS PMC methods implemented
   + Parrot executable fullname and basename now available in PIR/PASM code
   + new 'chomp' library function
- Build:
   + Major improvements in test coverage for 'ops2pm.pl'
- Misc:
   + many bugfixes, enhancements, and coding standard updates
   + extended support for Sun Workshop Compilers
   + Parrot now builds on PocketPC platform

New in 0.4.8

- Compilers:
   + HLLCompiler: added tracing options, modified api
   + PGE & TGE bugfixes and updates
- PAST:
   + added global and lexical variable support
   + added looping constructs, arrays, hashes
- Languages:
   + Updated PHP ("Plumhead"), Tcl ("ParTcl"),
     forth, perl6, lua, abc, APL, WMLScript, punie
   + ParTcl is passing > 24.9% of Tcl cvs-latest test suite
   + perl6 now supports hashes, arrays, method calls, arity-based
     multisubs, quoted terms, ranges (non-lazy), try blocks, $!
- Design:
   + PDD01 "Overview" - updated
   + PDD22 "I/O" - rewritten and approved
- Test Suite:
   + Converted Perl 5 Regex tests to PIR, with notable speedup
   + Added tests for opcodes, compilers, languages, and coding standards
- Build:
   + Major improvements in test coverage for 'pmc2c.pl'
- Misc:
   + many bugfixes, enhancements, and coding standard updates
   + extended support for non-core platforms including Cygwin, Tru64

New in 0.4.7

- New languages: PHP ("Plumhead"), Forth
- Updated languages: Ruby ("Cardinal"), Tcl, Lua
- Remove old Python implementation from Parrot repository; the new Python
  language code is hosted at http://pirate.tangentcode.com
- Compilers:
   + PGE updated with more expressions, latest changes to S05
   + new Perl6 grammar compiler
- Integration:
   + Perl 5 module "Parrot::Embed" allows easy embedding of a Parrot
     runtime into a Perl 5 program
- PIR:
   + new :init pragma for subs that must run before the main function
   + new :vtable pragma to identify subs that override PMC vtable methods,
     eliminating the need for special subroutine names
   + PIR parser/compiler does not stop on first syntax error
   + Vanilla register allocator ("register alligator") greatly improves
     performance compiling large functions
   + Eliminated limit on number of PIR macros
- PMCs:
   + hash lookups return null instead of None for missing keys
- Design:
   + PDD13 "Bytecode files: format and manipulation" - new
   + PDD10 "Embedding" - new
   + PDD25 "Concurrency" - rewritten
   + PDD15 "Objects" - new section on redesign requirements
   + PDD07 "Coding standards" - significant updates and automated tests
- Test Suite:
   + Many many more new tests
- Build Process:
   + autoconf compatible install options
- Misc:
   + Namespace refinements
   + Coroutine improvements
   + An impressive swarm of other bugfixes and enhancements

New in 0.4.6

- New languages: Ruby ("Cardinal"), Javascript ("ecmascript")
- Updated languages: Tcl, dotnet, bc, Pheme, Punie, WMLScript
- Updated compilers: PGE, TGE
- IMCC updates:
   + ".loadlib" directive expresses dependencies
   + ".namespace" with no parameter goes to HLL root
   + lexer is reentrant (reentrant grammar in progress)
- Namespace improvements:
   + new suite of opcodes to access namespaces and globals
     ("find_global" and "store_global" will be phased out)
   + namespace '' no longer means HLL root
- Design document updates:
    namespaces (pdd23), basic types (pdd17), embedding
- Updated tool requirements for developers:
    flex 2.5.33, bison 2.1, perl 5.6.1
- New to-do list for people new to Parrot:
    cage/todo.pod
- The usual plethora of bugfixes and enhancements

New in 0.4.5

- unicode subroutine names
- hierarchical class names finished including MMD support
- new dotnet CLI to PIR translator
- improved TGE code and compiler
- APL: vector handling
- new STM branch in the svn repository
- the usual bugfixes and enhancements

New in 0.4.4

- hierarchical class names
- APL compiler
  - under development
  - understands simple vector ops, strings
  - demonstrates use of Unicode in Parrot
- pgc, a compiler for rules and operator precedence parsers
- Major redesign and improvements for PGE
  - compilers understand named parameter options
  - :ratchet option implemented to support non-backtracking quantifiers
- TGE (tree grammar engine) for tree transformations
  - tgc, tree grammar compiler
- perl6 compiler
  - support for many operators, lexical scalars, regex matches
- new pheme (Parrot scheme) compiler

New in 0.4.3

- namespaces partially implemented
- rulec, Perl6 rule compiler
- PGE improvements including return values for closure
- parts of a Perl6 parser based on PGE
- complex trigonometric methods
- type of Sub PMC is now overridable by HLL
- NetBSD support
- many bug fixes and improvements

New in 0.4.2

- improved PPC and x86 JIT support including JIT compilation
  of very simple PASM/PIR subroutines
- preliminary libreadline support
- better trace and debug features
- pkgconfig support
- META.yml to support proper indexing on CPAN
- new opcode: hcf (in "my_ops" in dynamic op library)
- new File pmc for file specific ops (is_dir, is_file, copy, rename...)
- named arguments and parameters (both :named("") and => syntaxes)
- ongoing config improvements
- tons of bug fixes and other small improvements - too much to list all

New in 0.4.1

- Installation: 'make install' is using standard locations now
  (/usr/local is the default --prefix)
- Produce static and shared libraries on some systems
- Configure system rearragement
- OS pmc started (mkdir,cd,cwd,rm,umask,stat)
- Shootout examples
- Test files are now testable with 'prove'
- Smoke (and smokej) outputs progress
- PIR supports: I = A < B (>,<=,>=,==,!=)
- Add support for octal number constants
- partcl updates:
  - almost finish [string]; start [file]
  - add build tool for generating inline'd tcl builtins from templates.
- Jako updates: NCI, subroutines, global variables and constants all work.
  (Gregor)

New in 0.4.0

- New lexical handling and closure support including better
  introspection for caller and outer
- PGE (Parrot Grammar Engine) provides now compilers for P6Rule,
  P6Grammar, P5Regexp, and Glob
- ca. 1000 new tests including 800 for Perl5 regexp
- Improved unicode charset and encoding support
- Calling conventions for exception handlers
- Punie (Perl 1) uses TGE (Tree Grammar Engine) to convert from
  PGE match objects to AST via two steps of tree transformation grammars
- New languages: amber and lua
- The usual code fixes, cleanup, and improvements, including an overhaul
  of the config and test framework

New in 0.3.1

- Variable sized register frames are finished. Each subroutine gets
  the amount of registers that it actually needs. No more spilling.
- Vastly improved PGE (Parrot Grammar Engine) including shift-reduce,
  precedence-based expression parser and support for matching of
  bracketed text delimited by e.g. ()[]{}'"
- uniccode character classification (is_upper ...)
- support for heredoc syntax in assembler
- improved examples, basic JSON support
- debian packaging support
- the usual improvements, bug fixes, and cleanup
- test count exceeds 3000

New in 0.3.0

- New calling conventions implemented: see PDD03 for details
- Merge multiple Parrot bytecode (PBC) files into a singe PBC file
- 'make smoke' target going beta
- bc now supports if statements, comparison ops, prefix inc/dec
- ParTcl adds [lassign], [switch] (partially); [expr] converted to a compiler
- Many exciting doc updates, tests, and bugfixes, too numerous to mention

New in 0.2.3

- Dynamic classes now compile on Windows (including ParTcl)
- New Super PMC allows easy access to superclass methods
- Implement C3 method resolution order (just like Perl6 & Python)
- ParTcl has new PIR-based parser and passes more Tcl tests
- added character class support in Globs to PGE
- added language implementations of unlambda, Lazy-k
- many bugfixes, including GC and memory leaks
- the new calling scheme continued to evolve in branches/leo-ctx5

New in 0.2.2

- new call scheme: docs/pdds/pdd03_calling_conventions.pod
- partial implementation of the new calling conventions
  PASM only, don't mix PIR foo() call syntax with the new scheme
- grammar and rule support in PGE - the Parrot Grammar Engine
- TCL passes >10% of the tcl test suite
- the usual bugfixes and improvements

New in 0.2.1

- better HLL support (short names for object attributes, and
  .HLL and n_operators pragmas)
- string encoding and charset can now be set independently
- experimental mmap IO layer for slurping files
- distinct debug and trace flag settings
- glob support in PGE
- new character classification opcodes and interfaces

New in 0.2.0

- parrot repository is now under subversion
- MMD (Multi Method Dispatch) enhanced
- new unary and infix opcodes that return new result PMCs
- dynamic scalar PMCs inherit now almost all from Parrot core PMCs
- more unification of PMCs and ParrotObjects
- tailcalls for functions and methods
- PGE (Parrot Grammar Engine) reworked
- Pugs creates Parrot code and Pugs is a registered compiler now
- new languages/lisp
- the usual bug fixes and improvements

New in 0.1.2

- New string handling code. Strings now have charset and encoding
- Parts of a generation garbage collector
- Better Python code, separated in dynclasses
- Parrot Grammar Engine
- Improved test coverage and documentation

New in 0.1.1

Parrot 0.1.1 is an intermediate release with tons of updates and fixes.
 - Python support: Parrot runs 4/7 of the pie-thon test suite
 - Better OS support: more platforms, compiler, OS functions
 - Improved PIR syntax for method calls and <op>= assignment
 - Dynamic loading reworked including a "make install" target
 - MMD - multi method dispatch for binary vtable methods
 - Library improvement and cleanup
 - BigInt, Complex, *Array, Slice, Enumerate, None PMC classes
 - IA64 and hppa JIT support
 - Tons of fixes, improvements, new tests, and documentation updates.
A lot is unfinished and keeps changing. Nethertheless Parrot is stable
and usable at the surface, while internals are moving.

New in 0.1.0
 - "Ladies and gentlemen, I give you... objects!"
 - Huge documentation overhaul
 - More supported platforms, s. PLATFORMS
 - Basic thread support for pthread based architectures
 - Basic event handling for timers and signals including:
 - PASM callbacks for NCI (native C) functions.
 - Improved platform configuration
 - COW stacks now working, stacks code redone
 - Structure handling vastly improved
 - Random PMC and rand primitives
 - Better subroutine call syntax in PIR
 - Make PIR subroutines compliant with pdd03
 - Improved profiling (DOD, GC timings)
 - Hash code improvements, incl. random key order support
 - Experimental freeze/thaw code for some PMC types
 - IO improvements for buffered layer and Win32
 - String iterators
 - String bitwise vtables
 - Many new opcodes
 - Support for JIT, where malloced memory isn't executable
 - Priority DOD scheme for objects that need timely destruction
 - Improved byte code loading (e.g. onLoad functions)
 - Language updates: forth, Perl6/P6C, m4
 - Libraries: Getopt_Long, SDL, Dumper, Sort
 - new JAPH examples
 - Unified imcc and parrot test handling
 - Many new tests (make test reports 1386 tests)
 - Numerous bug fixes

New in 0.0.13
 - The Big Move: Parrot source and build files rearranged into sub dirs
 - Build imcc as parrot
 - Objects more finished
 - Delegate vtable methods to byte code
 - Binary multi-method dispatching
 - Isa and does methods for PMCs
 - Call byte code from C
 - Start of extension interface
 - Experimental struct handling
 - Catch access to NULL PMCs
 - Experimental network socket interface code and opcodes
 - IO fixes and improvements
 - Dynamic opcode libraries
 - Fix-assigned opcode numbers
 - Argument flattening for function calls
 - More native call interface (NCI) signatures
 - Ncurses, postgres, and pcre interface libraries
 - Forth language is vastly improved
 - BSD and Win32 build improvements
 - Many new tests and fixes

New in 0.0.12
 - This number intentionally left blank

New in 0.0.11
 - Executable output
 - Dynamic PMC registration
 - Trial exception system
 - Beginnings of object system
 - Iterators
 - Ordered hashes
 - I/O system improvements
 - References
 - Documentation for basic PMC types
 - IMCC support of Parrot Calling Conventions
 - Runtime loading of chartypes (and other string improvements)
 - Conditional breakpoints
 - Dramatically accelerated sweeps for finalizable objects
 - Small PMCs (PMCs split into core and extensions)
 - Loadable bytecode packfiles
 - Constant PMCs
 - Sub variants that deal with the stack correctly
 - Switched runops core
 - Line numbers in warnings
 - Environment access
 - Many documentation cleanups
 - Conversion to CPS style!
 - BASIC debugger and many other wacky features
 - Filename, line number parsing support in IMCC

New in 0.0.10
 - IMCC integration
 - eval
 - some more benchmarking
 - cgp core
 - optimized math ops
 - intersegment branches
 - more complete use of PObjs
 - beefed up packfiles
 - sub/continuation/coroutine fixes
 - better NCI (native calling interface)
 - many imcc improvements
 - jako improvements

New in 0.0.9

- Native function calling interface (Dan)
- Stack/list aggregate rewrite (Leo)
- Scratchpads (Jonathan Sillito)
- Preliminary DotGNU support -- type conversion ops (Gopal V + Leo)
- Buffer/PMC unification (Leo)
- stabs debugging support for JIT (Leo)
- Jako overhaul (Gregor)
- Optional Lea allocator (Leo)
- Parrot sprintf (Brent)
- Miniparrot (Josh)
- PMC Properties (Dan)
- Various JIT improvements (D. Grunblatt + Leo)
- Extensible packfiles (Juergen)
- Restructured PMC hierarchy (Leo)
- Real Scheme (Juergen)

New in 0.0.8

- Several new grammars and a BNF -> perl5 and perl6 converter (Jeff)
- Working Perl6 REs (Sean)
- Keyed Access (Tom Hughes et al)
- New PMCs (Alberto et al)
- Better Documentation
- New COW semantics
- GC acceleration (Mike Lambert)
- Lexical scope (Jonathan Sillito)
- IMCC patches
- JIT for the ARM

New in 0.0.7

- Perl 6 Grammar and Compiler (Sean)
- Subroutines, coroutines, and continuations (Melvin)
- GC improvements (Peter Gibbs, Mike Lambert)
- Global variables (Melvin)
- Intermediate bytecode compiler (Melvin, Angel)
- And much, much more.

New in 0.0.6

- New assembler that support keyed types (Jeff)
- New macro layer, allowing constants (Jeff)
- New Configure.pl (Brent)
- Changes to bytecode format, endian issues resolved (Melvin)
- GC improvements and bug fixes (Peter Gibbs, Mike Lambert)
- JIT compiler rewrite (Jason and Daniel)
- Parrot assembler in Parrot (Daniel)
- Parrot debugger (Daniel)
- BASIC polished, Eliza.bas is new (Clint)
- Cola compiler committed and working, with limited OOP (Melvin)
- Keyed aggregates (Steve Fink)
- Global ops (Melvin)
- Compile-time speedup (Melvin)
- Much documentation
- New PDDs (Dan)
- Contributed tetris and lzw files
- And many more, from the cast of thousands

New in 0.0.5

- Full GC
- Perl Scalar support in PMCs
- Array and Hash types almost ready for prime-time
- Internal support for keyed types
- EMACS editing mode
- New PDDs
- New Language - BASIC
- Regular expression compiler
- More tests
- Many, many bug fixes, enhancements, and speedups

New in 0.0.4

- Arena-based memory allocation system
- Copying GC
- New IO subsystem
- "Predereferencing" mode - ./parrot -P - 22% speedup
- JIT compiler - ./parrot -j
- Parrot now builds warnings-clean on many platforms
- Many more PMC methods implemented
- Regular expression operations
- Added a FAQ
- Basic support for embedding Parrot in other programs
- Warnings support
- Added PDDs to distribution
- Bignum library

- PMC inheritance
- Added an assembly optimizer
- Improved string encoding/type support
- Many more tests
- Source reformatting
- Major refactoring in packfile library
- More Miniperl functionality
- New PMC "clone" operator
- Beginnings of key-based access to PMCs - arrays and hashes
- MOPS comparisons in examples/mops/

New in 0.0.3

- PMCs!
- Perl base scalar types implemented
- A new minilanguage, Scheme
- Much improved documentation
- Register stacks pushing and popping
- User stack pushing, popping and rotating
- Jako updates: subroutines, more example programs, optimizations
- test_prog renamed to 'parrot'

- Added features to the assembler: @ for current location, and global
  labels
- Build tweaks for VMS
- Bytecode typing clean-ups
- More platforms: OS X, HPUX, OS/2
- The proliferation of runops cores reduced to one fast and one slow one
- Opcode tracing, bounds checking, profiling
- Vastly improved string support, with separation of encoding and
  charset
- Lots more tests
- Multiple interpreter creation support - the beginnings of threading
- Much better resource handling - the beginnings of GC

New in 0.0.2

- Parrot now works on all core platforms
- A large number of tests, in the standard Perl testing framework
- A new minilanguage (Jako) which compiles to Parrot assembly
- Documentation about the assembly language (docs/parrot_assembly.pod)

- Separate modules for assembly (Parrot::Assemble) and bytecode
  manipulation (Parrot::PackFile::*, packfile.c)
- Assembler completely rewritten
- Better operand-type guessing in the assembler
- Assembler support for '\n' etc. in string constants
- Code reformatted to match the coding standards
- New ops for register-constant INTEGER comparisons
- Macro expansion in the assembler
- IVs and NVs renamed to more friendly INTVAL and NUMVAL
- Hard-coded pack("") formats removed
- Better handling of floating-point numbers in assembler
- Moved floats to constant table (fixing many alignment issues)
