# $Id: NEWS 79697 2009-02-13 21:08:34Z kjs $ New in February 2009 release (r79697) - Implementation + Support for portable 'Inf' and 'NaN' + pbc_disassemble prints constants in constants table + Removed (incomplete) Bignum implementation + Pair is now a dynamic loadable PMC + Various function name sanification + New implementation of Strings component + Replace various PMC value union access code by VTABLE method invocations + Replace various PMC value unions by ATTRibutes + Removed SArray PMC. Use FixedPMCArray instead. - Documentation + Book 1- Language Structure 2- PIR Basics 3- 4- 5- 6- Some pytfaills and bugs 7- Hashes 8- 9- Robust programing techniques 10- 11- Advanced PIR 12- 13- What's go on Beyond? 14- + Function documentation + Pod documentation style modernized; no longer Perl 5 style. + PMC has an additional acronym: Poly Morphic Container + The DOD (Dead Object Detection) acronym is no longer used; use 'GC' to refer to the Garbage Collector component. - Compilers + IMCC999 - :named flag can now take string registers as argument - A single '=cut' directive is now ignored (without initial Pod directive) - :vtable subs now have proper access to 'self' pseudo variable - Languages + add new 'Pod' documentation parser999 + Pipp (PHP implementation):999 - support for 'print', 'dirname', 'implode', 'str_replace', 'switch' - various grammar fixes + ECMAScript999 + add 'quit', 'readline' builtins + fix 'Boolean' type and 'print' builtin + Lua999 - left the nest and is now at http://github.com/fperrad/lua/ + Rakudo999 - left the nest and is now at http://github.com/rakudo/rakudo/ - build instructions can be found at http://tinyurl.com/rakudo + lazy-k999 - left the nest and is now at http://github.com/bschmalhofer/lazy-k.git + unlambda999 - left the nest and is now at http://github.com/bschmalhofer/unlambda/ + WMLScript999 - left the nest and is now at http://github.com/fperrad/wmlscript.git + removed Zcode implementation - Tools + pmc2C999 - ATTRs are now inherited automatically in subclassing PMCs - Deprecations999 + Parrot_readbc, Parrot_loadbc renamed to Parrot_pbc_read, Parrot_pbc_load. + .HLL_map directive in favour of 'hll_map' method on Parrot interpreter + Data::Escape library - Tools999 + pbc_disassemble options added + pbc_dump renamed from pdump - Miscellaneous999 + Parrot is now Copyright Parrot Foundation + Parrot's SVN repository is now hosted at https://svn.parrot.org + Various code cleanups, consting, 64-bit incompatibilities and other bug fixes New in January 2009 release (0.9.0-79697) - Implementation + Implemented bytecode annotations + Role composition is now aware of multi-subs + Unbuffered IO PMCs now autopromote when buffering is necessary + Installation parrot binary and libparrot shared library now supported + Class registry now respects HLLs - Compilers + IMCC - removed keyed string indexing, e.g. $S0[1]. - removed slice syntax, e.g. $P0[1..2] - removed .namespace /.endnamespace pair - fixed 'new $P0, [classname]' syntax + PIRC - refactoring of various data structures - various bug fixes and updates - complete bytecode generation - add '-x' commandline option to run compiled code + PCT - add 'hll' and 'subid' attributes to PAST::Block - refactor loop handling code to handle last/redo/next - add :pasttype('stmts') and :pasttype('null') - improve "scope not found" error message - allow PAST::Val nodes to contain block references + PGE - add "skipkey" option to PGE::OPTable - allow spaces before modifiers in regexes - add '(' ~ ')' goal matching syntax - skip creating a class/grammar if it already exists - Languages + Rakudo - improved error mesages in multi dispatch - implemented clone method for all objects - implemented MAIN sub - Unicode versions of infix hyper operators - refactored IO.readline - basic support for Inf and NaN - list and array slices with whatever star - hash slices - implemented last and redo - pointy blocks as terms - refactored variable and parameter passing - improved assignment semantics - improved parsing of type names and subs - mostly implemented parametric roles - separate types for blocks, subs and methods - basic support for submethods - implemented Junction autothreading of user code (not builtins yet) - eval supports :lang attribute - proto makes other subs in scope multis, including in role composition + Befunge - back to working state - ported to pir + Pipp - add support for predefined constant __CLASS__ and __METHOD__ - add initial support for static members - add support for namespaced constants - constants are now handled as package vars - variables are now lexical variables - add support for superglobals in functions - Call the class __constructor when there is one - added incomplete support for closures - removed support for the alternative parsing strategies - added support for 'elsif' - added support for 'do-while' + HQ9+999 - left the nest and is now at https://github.com/bschmalhofer/hq9plus/ + Eclectus999 - left the nest and is now at http://github.com/bschmalhofer/eclectus/ + m4999 - left the nest and is now at http://github.com/bschmalhofer/m4/ + Lua:999 - add a minimalist user back trace + PIR999 - "does" and "morph" VTABLE interfaces are now overridable from PIR - Miscellaneous + Infrastructure - 'make smoke' now generates Smolder reports sent to http://smolder.plusthree.com/app/public_projects/smoke_reports/8 + Improved const and null correctness for C function parameters + Sped up STRING manipulation (append, chop), improving PGE about 30% + BOOK999 - Added sections about Classes, OO programming, and methods. - Added information about Annotations, Exceptions, and Handlers + STM999 - Removed non-functional STM subsystem New in 0.8.2-79697 - Implementation + fixed lexical semantics + added the 'capture_lex' opcode + added automatic resume for nonfatal exceptions + added multidispatch cache + applied miscellaneous performance improvements, including startup time + fixed several bugs and leaks found by Coverity Scan + removed race conditions from parallel testing - Compilers + IMCC999 - removed undocumented .param int => syntax - .line directive now only takes an integer argument - new .file directive to specify the file name being compiled + PCT999 - properly handles lexical generation and closure semantics - uses :subid instead of name lookups to reference PAST::Block nodes - added PAST::Control node type (exception handlers) + PGE999 - add support for and assertions - Match objects use Capture PMC instead of Capture_PIR + PIRC999 - add macro handling to PASM mode - disable vanilla register allocation in PASM mode, but do allow optimization - add tests and bug fixes - first bits of bytecode generation. No sub calling/returning yet. - Languages + Rakudo999 - fixed lexical handling and recursion - refactored subtypes implementation - support for quotes with multi-character delimiters - implemented list slices (Positional role) - list assignment - reduction meta operators - hyper meta operators - cross meta operators - more builtin functions - added Nil type - basic support for protos - iterator on filehandle objects - basic support for exception handlers - warn + Lua999 - added complex & mathx libraries - merged LuaClosure & LuaFunction PMC + Pipp999 - added support for a return value from user defined functions - added incomplete implemention of 'require_once' + Ecmascript999 - parser fixes, parses spidermonkey's top level test/shell.js - Deprecations + PARROT_API999 is now PARROT_EXPORT999 + PIR999 - :lexid is now :subid - .arg is now .set_arg - .result is now .get_result - .yield (in .begin/end_yield) is now .set_yield - .return (in .begin/end_return) is now .set_return - .namespace x / .endnamespace x syntax is removed + Capture_PIR (runtime/parrot/library/Parrot/Capture_PIR.pir) New in 0.8.1-79697 - Implementation + added CPAN module Storable 2.12 as a configuration and build dependency + removed the pseudo PIR opcode 'addr' + added the 'box' opcode + fixed 'pop_eh' handling in PIR libraries and examples + removed usage of .return for tailcalls (use .tailcall instead) + removed 'get_hash' and 'get_array' from Capture PMC and Capture_PIR + improved debugger and HLL coordination + allowed MMD primitive autoboxing + fixed all known memory leaks in PIR "Hello, world!" + NCI signatures now JITted on x86-32 platforms (Windows and Linux) + made the .const directive take a quoted type name instead of a constant + made IMCC more re-entrant - Languages + Rakudo999 - refactored Junctions implementation - added "fire and forget" tool to rebase/rebuild/test Parrot and Rakudo - updated container/reference semantics - added more builtin methods and functions - improved support for multilevel namespaces - added support for .Str, .succ, .pred in user-defined classes - implemented pointy blocks on if/loops - increased STD.pm convergence - added %*VM hash - improved MMD candidate sorting - improved integration of Num and Int - implemented increment on protoobjects - added initial support for MAIN subs - added .PARROT method + Pipp999 - added some predefined constants - added implemention of the function basename() + Cardinal (Ruby)999 - Added initial support for the classes Proc, Continuation, Queue, Dir, File, and FileStat - fixed various minor bugs - fixed broken Regexes - Compilers + PCT999 - added '.isa' method to PCT::Node - cleaned up 'immediate block' handling - allowed arguments to immediate blocks in loops/conditionals - metaclass objects can now 'add_method' + PIRC999 - integrated macro processing in PIRC's lexer - integrated heredoc lexer in PIRC executable - added preprocess and heredoc-preprocess commandline options - integrated the PASM grammar into PIRC - added a register allocator to optimize the built-in vanilla allocator - code cleanups and documentation - added 'make test' target + TGE999 - updated to work with new namespace/classname syntax - Deprecations + PARROT_API will become PARROT_EXPORT999 + :lexid will become :subid - Miscellaneous + Documentation - updates and additions to the Parrot book (see docs/book/) + OpenGL999 - minor fixes to Parrot's base OpenGL bindings - converted OpenGL PIR examples to Perl 6 (two complete, one WIP) - added simplified OpenGL PIR example for NCI JIT testing + Tests999 - further improvements to parallel tests - tests no longer leave filesystem breadcrumbs - more thorough testing of Parrot::Test itself New in 0.8.0-79697 - Implementation + float precision expanded to 17 significant digits from 15 + large integers autopromoted in PIR so as not to lose precision + improved precision of complex square root + exception handlers can register types of exceptions they catch - Languages + Cardinal (Ruby)999 - implemented gather, take, and yield builtins - Range, Time, Math, GC, Kernel classes - many more tests - added a new committer + Markdown : new lightweight markup language999 - start implementation with PCT/NQP + partcl (Tcl 8.5.4) 9 - Moved to its own repository: http://code.google.com/p/partcl/ + Rakudo (Perl 6c9) 9 - split() works with regexes - implemented Str.comb - ord() and chr() builtins - improved parsing of literal numbers - support for hyphens and dashes in identifiers - next() on for-loops - fixed floating point constant precision - improved namespace handling, closer to STD.pm model - support for exporting symbols - Compilers + P6c9object - now generates classes in nested namespaces instead of :: names - supports class creation in caller's HLL namespace + PCT / PGE - now using true nested namespaces instead of :: names - cleaned up HLLCompiler interactive prompts and readline mode - updated to use typed exception handler registration - added initial support for loop control exceptions + PIRC - fixed Heredoc preprocessor - cleaned up Macro preprocessor - many code clean-ups, warning fixes and consting - updated Makefile for easier compilation + IMCC - Added .tailcall syntax to replace .return in tailcall context - Examples + pirric (BASIC) - an old style line numbered Basic interpreter able to use parrot objects - example connecting to mysql via nci - example using classes to write and run an embedded Basic program - Documentation + Book - Added chapters for PCT, PMCs, and Opcodes/Runcores - Expanded and improved formatting in various chapters - Renumbered chapters New in 0.7.1-79697 - Implementation + add -I and -L command line options + support for null strings in NCI calls + preliminary support for resumable exceptions + add '.hll_map' method for dynamic HLL type mapping + more parrot_debugger fixes + remove obsolete '.past' extension - Languages + Rakudo (Perl 6c9) - now over 3300 passing spectests - precompiled modules - precompiled scripts (--target=pir can now be executed standalone) - Support for @*INC and %*INC varialbes - additional builtin methods and subs - added 'fail' function, warnings on use of undefined values - m/.../ regexes - qq, qw, q quoting forms - run tests in parallel - gather/take - Perl6MultiSub + Cardinal (Ruby): - 'require' and precompiled modules - many new tests - all Array tests pass - regexes - default arguments to functions - new committer - Compilers + PCT: - add :loadinit attribute for PAST::Block + PIRC: - major refactoring to allow all PIR keywords as identifiers - links to libparrot now, so all Parrot ops are recognized as such - implemented .loadlib, .HLL_map, .HLL - Miscellaneous + add Xlib and Mysql modules and test programs to NCI examples + many updates and cleanups to PDD documents New in 0.7.0-79697 - Specification + PDD27: add multisub lookup - Implementation + new concurrency implementation (see PDD25) + Exception PMC now captures a return continuation + improved PMC encapsulation (Iterator, Key, Pair) - Languages + Cardinal (Ruby): - class variables - parsing improvements - minor additions to class builtins - add support for block parameters to functions + Lua: - various language fixes - refactor all libraries (namespace, method registration) - add a OpenGL binding (still incomplete) - lost user back trace (see ppd25 & pushaction) + Pipp (PHP): - add support for while- and for-loops - add support for increment and decrement - designate PHP 5.3 as the reference implementation - improve support for string literals + Pugs (Perl 6c9): - removed due to bit rot + Rakudo (Perl 6c9):or 969 - now over 2200 passing spectests - updated the Rakudo roadmap - Perl 6 multi dispatch - dispatch with slurpies - class attributes ("my $.x") - anonymous classes - OO and metaclass improvements (.WHAT, .WHICH, .WHENCE) - additional builtin methods and subs - improved make test targets and harness + Tcl: - implement [lreverse], [lsort -command] - allow [incr] to autovivify - update tclsh spec target to 8.5.3 - fix bug in TclDict PMC, allowing ~200 more [dict] spec tests to pass - update 'make spectest' fudging, using TODO instead of SKIP if possible - Compilers + PCT: - :scope('register') for PAST::Var nodes - allow invocant specification in attribute scope PAST::Var nodes - correct ordering of sub generation from POST - add 'loadinit' attribute to PAST::Block for block initialization + PIRC: - PIR registers now use the vanilla register allocator - all PASM output now uses PASM registers - all .locals and $registers are mapped - clean-up of grammar, back-end and documentation - implemented constant folding - implemented instruction selection - Configuration + tests now clean up after themselves + improved parallel test support + ports/cygwin added + Darwin problems fixed - Tools + parrot_debugger renamed from pdb, numerous tweaks - Miscellaneous + IMCC cleanups + :vtable implies self in PIR + modest core speed improvements + Cygwin support improved + "say" now an opcode (was dispatched to a method; see Deprecations) - Deprecations + ".pragma n_operators" is deprecated + old PASM register syntax (without "$") is deprecated + bare (unquoted) method names are deprecated + "#line" will be replaced with ".line" + ".HLL_map" syntax will change + ".loadlib" is now separate from ".HLL" + mmdvtregister and mmdvtablefind opcodes are deprecated + removed getfd, getclass opcodes + removed IMCC syntax that treated some methods as builtins + removed numeric get_attr and set_attr vtable entries New in 0.6.4 - Documentation + removed a lot of old information from the FAQ + improved function level documentation - Configuration + removed the configuration item 'has_gnu_m4' + refactored ICU-detection - Languages + ChitChat - improved the Smalltalk implementation + Pipp - renamed Plumhead to Pipp - support for a lot of builtin functions. - Pipp now uses PHP specific data types. - converted from PCT with TGE to PCT with NQP actions - improvements in the PCT variant by using optok parsing - start of object support + pir - simple assignments work + json - added a PCT-based implementation of JSON parsing + lolcode - improved handling of symbols - added support for block handling - added support for globals + Lua - more tests + Rakudo - updated Range implementation - added enums - added generic type declarations (::T) - added runtime mixing of roles with 'does' and 'but' - fixed handling of implicit lexicals ($_, $!, and $/) - fixed implicit method calls on $_ - improved complex math builtins, added Complex - moved many builtins to class Any - declaration of lists of variables now work - improved test infrastructure - 910 additional passing spec tests since last release - more convergence with STD.pm grammar - added named 0-ary parsing and ops - Compilers + PCT: - allowed subroutine and method names to be a PAST tree that produces the name - Improved lexical handling - Tools + pbc_disassemble renamed from disassemble - Implementation + allowed .macro_const in PIR + added the flag :lexid(...) for subroutines + made multiple dispatch work for sub types + fixed garbage collection bug related to the metadata attached to a PMC_EXT structure + added a warning when using deprecated opcodes + simplified the stacks implementation + fixed C++ build + improved closure and lexical support + improved IMCC register allocator + added cache for all runtime-constant strings, reducing memory usage - Miscellaneous + improved OpenGL/GLU/GLUT bindings + added a standard profile for Perl::Critic coding standard testing + added support for smoke testing with Smolder + enabled use of Test::Harness 3.0 if available, but don't require it for 'make test' + added the executable 'parrot_config' to query Parrot configuration New in 0.6.3 - Specification + updated pdd09_gc.pod - Languages + Cardinal: - dramatically improved parsing speed - added support for defining and instantiating classes - started fleshing out the builtin class hierarchy - added support for hashes and arrays + Chitchat: added the start of a smalltalk compiler + Pheme: updated to match PGE changes + Pynie: return statement, other minor updates + Rakudo: - added working list and hash contexts - added 'return' statements - added => pair constructor - added ?? !! ternary - added Range, range operators, Complex - added common List, Hash methods - refactored base classes - added Mutable, Perl6Scalar classes - added type-checking, is readonly/rw/copy for parameters - added make localtest, docs/spectest-progress.csv - fix named unaries + Squaak: implement return statement + Tcl: updated control flow exceptions to use new builtin types - Compilers + All tools converted to P6object metamodel + PGE: - is now a zero-width match - reduced backtracking to improve parsing speed + PCT: - added "return" PAST.op node type for subroutine returns - added "keyed_int" scoping to PAST::Var - fixed calls to closures - automatically transcode 7-bit unicode to ascii for faster processing + NQP: added "return" statement, ?? !! ternary operator - Configuration + expanded step gen::opengl - Implementation + updated function and macro names to match pdd09_gc.pod + removed Super PMC + add ".namespace []" as alternative to ".namespace" + "make codetest" target runs standard coding tests - Miscellaneous + added P6object class for Perl 6 interfaces to objects in Parrot + ported OpenGL/GLU/GLUT bindings to Win32, BSD, and more Mac OS X variants + generate OpenGL/GLU/GLUT bindings by parsing system headers + new OpenGL example shapes.pir, covering basic OpenGL 1.1 / GLUT 3 APIs + new float4.pir structure-packing benchmark + reduced memory use for variables + improved constant string caching + made code g++ and gcc (with optimizations) safe + the usual collection of bugfixes and optimizations New in 0.6.2 - Specification + updated and launched pdd28_strings.pod + updated pdd19_pir.pod - Implementation + added implementation of Rational PMC. + simplified ops control flow syntax + enabled backtrace on non-glibc platforms too + improved some PIR error reporting + removed user stack opcodes (save, restore, lookback, entrytype, depth, rotate_up) (NOTE: This was scheduled to occur after 0.7.0, moved up to this release) + removed register stack, saveall, and restoreall opcodes + removed various deprecated features and unused code - Languages + Amber: retired + C99: grammar updated + Cardinal: resurrected, method calls and do blocks work now + Eclectus: use NQP as PAST generating code + Lua: - added big number library - updated to match PGE changes - added a bytecode disassembler & a Lua 5.1 VM bytecode translator + Pheme: updated to match PGE/PCT changes + Plumhead: - use NQP as PAST generating code - use riaxpander for macro expansion + Rakudo: - updated ROADMAP - conditional and loop statement modifiers - lots of class, object, role, and method improvements - Str increment and decrement - improved spectest reporting - type checking on assignment - regexes and grammars - undef and self - placeholder vars roadmap updated + Squaak: added to repository + TAP: retired - Compilers + PGE: updated to match Synopsis 5, deprecated features removed + PCT: - improve handling of register types, conversion between registers - improved error diagnostics - add 'arity' to for loops - Configuration + added step auto::opengl + added step gen::opengl + added step gen::call_list - Miscellaneous + still more optimizations and performance improvements, especially in GC + new libraries: OpenGL/GLU/GLUT bindings (small subset working) + new dump_pbc.pl utility: PBC disassembly/source code weaver + improved C++ compiler support + optimized builds work again New in 0.6.1 - Specification + drafted pdd29_compiler_tools.pod + updated pdd28_character_sets.pod draft + updated pdd19_pir.pod draft - Languages + c99: added independent C pre-processor + HQ9+: reimplemented with PCT + Lua: . reimplementation with PCT, using PAST and POST . behavior aligned wih 5.1.3 + Rakudo: . implemented basic I/O, including '$*IN', '$*OUT', '$*ERR', 'prefix:=' . implemented simple typing and runtime type checking . added basic multi-method dispatch . expanded named argument handling, including Pair and colonpairs . added 'Whatever' and 'Capture' classes . implemented 'handles' trait verb . added 'loop' statement . implemented 'given', 'when', 'for', 'while', 'until' statement modifiers . implemented Hash methods '.keys' and '.values' . fixed bug to get '.WHAT' working correctly . initial implementation of 'eval' - Compilers + NQP: . created a bootstrapped build, see 'make boot' . added 'infix:<', 'infix:<=', 'infix:>', 'infix:>=' relational operators . added 'postfix:++', 'postfix:--' operators + PCT: . added methods specifying default behaviors in PAST, reducing repeated code . improved symbol table lookup + PGE: . removed deprecated code including: P6Regex, P6Grammar, PAST-pm - Miscellaneous + notable speedups during compilation and execution of parrot and HLLs + pdb (the parrot debugger) can now catch parrot exceptions + better detection of glibc and gettext during configuration + various bugfixes, code cleanups, deprecations, and coding standard fixes New in 0.6.0 - Specification + launched pdd18_security.pod + updated pdd17_pmc.pod + launching draft of pdd28_character_sets.pod - Documentation + cleanup of IMCC documentation - Configuration + add step auto::gettext + add step auto::crypto - Compilers + PCT: . Fix '-e' option . Phase out P6Regex in favor of Perl6Regex + IMCC: '.local Array my_arr' is illegal now - Languages + C99: reimplementation with PCT + lolcode: . various updates . add support for functions with params . add math functions + Rakudo: . support for 'say' . first cut at smart matching . indirect method calls . support for Pairs . added methods 'grep' and 'first' . implement auto{increment,decrement} . initial implementation of 'perl6doc' + Lua: . various updates . add base64 library + Cardinal: basic support for functions with parameters + Pheme: various updates + Ecmascript: various updates + Tcl: now targeting tcl 8.5.1, no more expected failures in test suite. (No, this doesn't mean everything's implemented. =-) + Eclectus: various updates + WMLScript: various updates - Implementation + PDD17 (PMCs) + Add library YAML::Dumper + Add the MD2, MD4, MD5, RIPEMD160, SHA & SHA1 PMC, as a wrapper around libcrypto - Miscellaneous + various bugfixes, code cleanups and coding standard fixes + consting + remove external Perl 5 modules from the Parrot distribution New in 0.5.3 - Documentation + PDD09 (garbage collection) - approved + PDD28 (character sets) - draft started + added function documentation to some core functions + PCT beginners guide, optable guide and PAST nodes guide, bug fixes - Compilers + IMCC: plugged various memory leaks and other cleanups + PCT: . add "attribute" as a scope variant to PAST::Var nodes . add 'shift' and 'pop' methods to PAST:: nodes + NQP: add '=:=' op, tests for scalar and list contextualizers, \x escapes - Languages + APL: reimplementation with PCT + Cardinal (Ruby): reimplemention with PCT + Ecmascript: reimplementation with PCT + lolcode: improved expression parsing, ifthen, IT, YARN + lua: . aligned with Lua official release 5.1.3. . added initial PCT-based implementation. + Punie (Perl 1): refactor to use standard PCT-based filenames + Pynie (Python): add functions + Rakudo (Perl 6): . rebranded, formerly known as 'perl6' . passes many more official Perl 6 Specification tests . added 'perl6doc' utility . oo including meta?classes, objects, methods, attributes, role composition . match variables, while/until statements, traits . many new methods for Str, List, Hash, Junction - Implementation - Deprecations + PCCINVOKE syntax for named arguments using []; use () instead. + see DEPRECATED.pod for details - Miscellaneous + pbc_to_exe refactored for code reduction, portability, and maintainability + various bug fixes + #line directives added to generated JIT files, improving debugging + consting, attribute marking, refactoring, warnings cleanup New in 0.5.2 - Documentation + PDD27 (multiple dispatch) - debut of new design + Numerous small updates to glossary.pod, etc - Compiler Toolkit + NQP: optional, named, and named/required parameters + PIRC: cleanups + PAST: "defined-or" - Languages + New mk_language_shell.pl script creates language stubs + LOLCODE: new + Lua: various + Eclectus: start with support for local variables and procedures, use SXML as intermediate representation + Perl 6: list builtins, compiler directives, command-line options, etc. + "make perl6" now builds a Perl 6 executable + punie: more builtins, control structures, code refactoring + pynie: builtin stubs, more tests - Implementation + New "pbc_to_exe" utility turns bytecode to executables + New set_outer method for subs + Further configuration refactoring for testability + All functions now completely headerized + Concurrency: interpreter schedulers - Deprecations + DYNSELF (changes to SELF; SELF to STATICSELF) + METHOD (replaced by renaming PCCMETHOD) + pmcinfo op (superseded by 'inspect') + get_attr, set_attr, and 8 other vtable methods + See DEPRECATED.pod for details - Miscellaneous + Many bug fixes + Minor speed enhancements with UTF-8 string handling + Debian packaging + consting, attribute marking, warnings cleanup, memory leaks plugged ... New in 0.5.1 - Documentation + PDD19 (PIR) - reflect state on the ground; incorporate old IMCC docs + PDD25 (Concurrency) - launch out of draft + Improve documentation of deprecated parrot features. - Compilers + PCT: Parrot Compiler Toolkit redesigned and updated + NQP: major updates, including support for namespaces, module/class declarations, methods + IMCC: remove .sym as alias for .local. Remove .pcc_ prefix for calling directives (.pcc_begin became .begin_call). + PIRC: creates an AST during the parse. + PGE: more updates to match S05 syntax. - Languages + perl6: re-implemented using PCT and NQP, new object subsystem + abc: re-implemented using PCT and NQP + eclectus: initial implementation + plumhead: add PCT variant + punie: re-implemented using PCT and NQP, extended to handle subroutines Happy 20th Birthday, Perl! + pynie: re-implemented using PCT and NQP + PIR: start conversion to NQP (under construction) - Implementation + new opcodes: 'die', 'addhandler', 'copy' + Initial implementation of Concurrency PDD + Add 'arity' method to Sub and NCI PMCs - Miscellaneous + Bug cleanup + consting, attribute marking, warnings cleanup, memory leaks, GC... + dead code removal (includes some defunct languages) New in 0.5.0 - Implementation + PDD15 (OO) branch merged with trunk; this release contains a working, tested implementation of the latest OO model + Added pop_eh/push_eh_p/count_eh opcodes + Add --runcore command line option + Add gcdebug runcore to help track down GC bugs + minor improvements to IA-32 JIT - Documentation + PDD19 (PIR): updates to macros, .pcc* directives + PDD25 (Concurrency): updated + PDD26 (AST): draft approved + PDD23 (Exceptions): draft approved + Copyright cleanups - Languages/Compilers + languages/APL: minor updates, PDD15 conformance + languages/dotnet: minor updates + languages/lua: minor updates, PDD15 conformance + languages/lisp: minor updates + languages/perl6: minor updates, PDD15 conformance + languages/plumhead: minor updates + languages/punie: minor updates, PDD15 conformance + languages/nqp: minor updates + languages/scheme: many updates, PDD15 conformance, improved tests, use PMCs instead of primitive registers to represent values + languages/tcl: bugfixes, PDD15 conformance + languages/WMLScript: minor updates + compilers/pirc: updates from PDD19, PDD06 + compilers/pct: minor updates, PDD15 conformance + compilers/pge: PDD15 conformance + compilers/tge: PDD15 conformance - Configuration + Improve test coverage + Improve reporting when a step fails; allow abort on failure - Miscellaneous + More coding standard conformance, tests, cleanup, speedups, warnings cleanup + Bug cleanup, esp. GC bugs + Eliminate .imc extension (use .pir) + Simplify some core config steps to not allow interactive prompting - Removed + clear_eh opcode 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 "Perl 6 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 Perl 6 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, Perl 6 rule compiler - PGE improvements including return values for closure - parts of a Perl 6 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 Perl 6 & 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 = 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, Perl 6/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 Perl 6 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)