Balafon

In the past couple of months I have released new versions of NeuroLab and IronMeta.

NeuroLab version 1.2.3 is a maintenance release containing numerous fixes:

• Fixed grid generation after resize.
• Fixed grid viewer not always reflecting latest grid status.
• Fixed grid saving and loading losing grid network.
• Fixed activation gradient rendering for links of length greater than 1.
• Fixed inhibition for links of length greater than 1.
• Source code fixes and refactoring.

IronMeta version 2.3 contains the following:

• Made generated code more general so it is now possible to combine parsers by inheritance or encapsulation.
• Added the ability to use anonymous object literals in rules. They match by comparing their public properties with the input object’s properties.
• Fixed a bug where string and char literals were not correctly handled in parsers whose input was not of type char.
• Fixed an off-by-one error in input enumerables.
• Generated code now compiles with Mono.

IronMeta version 2.1 has been released.

Version 2.1 contains some refactoring, miscellaneous bug fixes, as well as:

• Better error handling and reporting.
• Added IronMeta.Matcher.CharMatcher.Input() and IronMeta.Matcher.CharMatcher.Trimmed() for more convenient string handling.
• Added min/max repeats syntax (e.g. 'a' {1, 3}).

IronMeta is an implementation of Alessandro Warth’s OMeta metaprogramming system in C#. It provides a packrat parser generator that generates parsers for Parsing Expression Grammars that operate on arbitrary streams of objects.

I have released version 2.0 of the IronMeta parser generator. IronMeta is an implementation of OMeta for C#. It generates Packrat PEG parsers that can recognize streams of any C# type and output any other type.

This version contains massive efficiency improvements, and an implementation of Sergio Medeiros’s algorithm for handling left recursion, which is simpler and more general than Warth et al‘s.

This algorithm can handle grammars of the form:

    A <- A a | B
    B <- B b | A | C
    C <- C c | B | d

This grammar would drive ordinary recursive-descent parsers to drink, but IronMeta handles it fine.

I have released a new version of IronMeta. It makes the syntax closer to the usual OMeta syntax.

I also fixed a bug that caused some redundant evaluation to be done. Performance is still pretty bad, though.

I will be focusing on

You can download the new version at SourceForge, or via Subversion at https://ironmeta.svn.sourceforge.net/svnroot/ironmeta/tags/1.2/.

IronMeta provides a programming language and application for generating pattern matchers on arbitrary streams of objects. It is an implementation of Alessandro Warth’s OMeta system for C# on .NET.

In between the new job and the new baby I have still managed to finish up the project I’ve been working on for myself.

It’s a C# implementation of Alessandro Warth’s OMeta pattern matching meta-language.

The IronMeta system builds parsers that can operate not only on streams of characters, but streams of objects of arbitrary types. The matchers can operate using the semantics of Parsing Expression Grammars or as fully backtracking recursive descent parsers.

IronMeta uses Warth, Douglass and Millstein’s algorithm for handling both direct and indirect left-recursion.

Grammar rules in IronMeta can take parameters, and in fact can match parameters against a pattern, allowing for different rule patterns depending on the number, type and value of parameters passed to them.

IronMeta also allows for higher-order rules, i.e. rules that can take other rules as parameters.