JBurg / News: Recent posts

JBurg 2.0 has two main user-visible features:

• The syntax has been rationalized and slightly modified in other respects.
  • JBurg 1.x's keywords were a mix of simple identifiers, e.g., ReturnType, and "qualified" identifiers, e.g., JBurg.Include. JBurg 2.0's keywords all start with the character '@' -- chosen because it's not too likely to conflict with identifiers in the target languages. For example, ReturnType becomes @ReturnType, and JBurg.Include becomes @Include.
  • Notes on the new syntax are available at https://sourceforge.net/p/jburg/wiki/JBurg2%20Reference/
• The C++ code emitter has undergone a top-to-bottom overhaul and is now on par with the Java emitter.

JBurg 1.22's C++ emitter uses the "specialized annotations" algorithm to build its BURM. This algorithm was developed to solve scalability problems in Java BURMs in 2011; the C++ emitter was not similarly modified, since the existing C++ code emitter was a formidable challenge to maintain.

The C++ emitter has since been migrating to a StringTemplate based form, which simplified maintenance immensely. Thanks and kudos as always to Terence Parr for a great tool.... read more

JBurg 1.21 is the first phase of an upgrade to the C++ target; the C++ target can now handle most JBurg features. Conversion to the optimized pattern matcher is still in progress.

The TL/1 and TL/2 compilers have been superseded for some time now by the self-verifying BurmTest series of basic acceptance tests and by the Falcon compiler as a larger-scale test.

Now that Falcon is available as open source software, these early test compilers are no longer maintained (and TL/1 has become confused with a protocol by the same name), so they have been removed.

JBurg 1.1.13 contains some enhanced debugging facilities, such as a dump(inode, PrintWriter) method to dump a labeled tree for analysis.

The code emitter is now partially based on Ter Parr's excellent StringTemplate engine and requires an ANTLR 3.x .jar file to build.

The Falcon README file references jburg-1.10.1.tar.gz, which is a JBurg source distribution. Falcon only requires the 1.10.1 jar file, which is available for download:

http://sourceforge.net/projects/jburg/files/jburg-1.10.1.jar/download

JBurg 1.11's Java target supports the "extends" attribute, which causes the generated BURM to extend the base class specified. This is useful if a library of similar pattern matchers can share some common support routines, such as cost functions.

Adobe's ASC 2.0 compiler (and its cousins Apache Falcon and FalconJS) use JBurg to generate their code generator. This two year long effort has given rise to a number of improvements in JBurg, especially "programming in the large" constructs such as shared pattern libraries, and greatly improved compile-time speed in the generated pattern matchers.

Many thanks to Adobe for their vision and support for this effort!

The CVS repository will remain until we get a good off-site backup made.

JBurg 1.9.0 is a performance release, meant to raise JBurg-generated tree parsers' performance to a level where they can be used for online parsing of very large programs.

This work is described in http://jburg.sourceforge.net/annotations.html

The JBurg2 project will be a rewrite of JBurg 1.x to use a compiler-compile time algorithm to compute the least-cost tree cover.

JBurg2 will be largely compatible with JBurg 1.x in its specification language; the major changes are:
* Costs must be constant
* Goal states must be explicitly specified via a JBurg.GoalState directive.

More information will be posted early next week.

JBurg.Reduction allows the BURM's reduction logic to be specified in a user-specified reduction routine, instead of inline in the specification.
This allows better sharing of the BURG specification between projects.

JBurg 1.7.4 has performance enhancements for pattern matchers. The biggest change is the way costs are added up; using a variadic routine to add them imposed a significant performance penalty.

Cost specifications may now also be specified as multipart identifiers.

JBurg 1.7.3 eliminates temporary JBurgSubgoal objects, replacing them with a static lookup table. C++ handling of n-ary matchers also got some enabling work; the pattern-matching algorithms should now handle them correctly, with some additional work needed in the reduce actions' setup phase to present a correctly typed vector of the reduced values.

JBurg 1.7.2 emits pattern matching logic that groups pattern matchers matching a common pattern into a common structural pattern match, and factors out common cost computations.

JBurg 1.7.1 fixes 3110065, which notes that cost computations were vulnerable to integer overflow. Costs are now added up via a routine that returns the platform's "infinite" cost if the aggregate costs overflow integer precision.

JBurg.include now accepts macro parameters. There are two types of macros:

foo="new token stream" macros are applied to JBurg syntax (everything that's not part of a block of implementation code). The substituted text is re-lexed, but no further substitutions will occur.

{ "regex"="replacement" } macros are applied to implementation code blocks. This is a straight text substitution.

See test/BurmTest/tests/include for an example.

C++ targets have been broken for some time, in part because the original C++ emitter was ANTLR-specific and I wanted to transition to a more general model that uses the INodeAdapter to generate code.

This work has now been completed, except for the debugging logic, which needs a little more thought on how it can interact with the ErrorAnalyzer.

JBurg 1.6.3 contains performance enhancements:
- Refactored and improved reduceAntecedentStates() by switching to a recursive model.
- Only create JBurgAnnotation.m_children for a node that does, in fact, have children.

JBurg 1.6.2 is a minor feature release. It supports feature request 3108459 (Present n-ary parameters as specialized container type)

Changes in JBurg 1.6.0:
- Supports OpcodeType directive so enums can be used as node IDs.
- Supports terminal pattern matchers embedded in patterns (3073474)

1.6.1 is a bugfix release:
- Fixed 3063143, shared patterns must not be altered.

Experience with n-ary patterns makes the usefulness of the "*" zero-or-more n-ary pattern evident. JBurg 1.5.0 implements support for this n-ary pattern.

JBurg 1.3.0 supports n-ary operands in all the contexts where they can be sensibly interpreted by the BURM. For example:

expression = PAREN(PAREN(ADD(expression l, expression r)), PAREN ( expression tail+))
expression = ADD(expression first, expression second, expression rest+)

JBurg 1.2 has a bug (#3033201) in the implementation of named patterns that results in incorrect generated output. JBurg 1.2.2 has a fix for this bug, and some enhancements to the ErrorAnalyzer GUI.

JBurg 1.1 and 1.2 are feature releases with enhancements for larger-scale JBurg projects.

JBurg 1.1:
- ErrorAnalyzer: jburg.debugging.ErrorAnalyzer is a java application that presents JBurg diagnostic dumps in a GUI. ErrorAnalyzer can quickly find problems with the input tree's labeling.

JBurg 1.2:
- Named patterns and reductions: larger projects may need to run several passes over a tree. The tree-parsing patterns can be shared using named patterns, for example:... read more