http://www.codeplex.com/ometasharp/SourceControl/ListDownloadableCommits.aspxometasharp Source Control Rss Descriptionhttp://www.codeplex.com/ometasharp/SourceControl/ListDownloadableCommits.aspxAdded "Markup" project based off discussion question by nblumhardt on Codeplex. See http://www.codeplex.com/ometasharp/Thread/View.aspx?ThreadId=36146jeffmoserMon, 22 Sep 2008 23:57:05 GMTSource code checked in, #17706 20080922115705Phttp://www.codeplex.com/ometasharp/SourceControl/ListDownloadableCommits.aspxMoved CalculatorParser to be siblings with the Calculator example.jeffmoserTue, 16 Sep 2008 03:03:01 GMTSource code checked in, #17578 20080916030301Ahttp://www.codeplex.com/ometasharp/SourceControl/ListDownloadableCommits.aspxRemoved excess directoriesjeffmoserTue, 16 Sep 2008 02:57:32 GMTSource code checked in, #17577 20080916025732Ahttp://www.codeplex.com/ometasharp/SourceControl/ListDownloadableCommits.aspxVery initial check-in of some noticable restructuring of the entire project. Based off some good comments by Nicholas Blumhardt, I decided to do some re-arranging of the folders to improve the distinction between the core runtime, host languages, examples, and then unit tests. In addition, I created a console based interpreter playground where you can experiment with each grammar that you create. For example, if you set "Calculator" as your startup project and then run it, you can see a very primitive calculator in action :)

In addition, I put some work into the Prolog interpreter to make it handle basic queries via the console. 

Each project has sample input and responses that are shown right when you start the project so you get a feel for what's expected.

Finally, the "README" project basically does what the previous unit test runner did (e.g. compile all grammars and run most tests).

I'd love to hear feedback if you download the code. My contact info is on my blog at http://www.moserware.com/

(NOTE: Since I did some heavy moving in the source code, there might be some problems synchronizing everything in TFS. It might take another changeset to remove extra files)jeffmoserTue, 16 Sep 2008 02:54:49 GMTSource code checked in, #17576 20080916025449Ahttp://www.codeplex.com/ometasharp/SourceControl/ListDownloadableCommits.aspxAdded first glimpse of ideas for syntax sugar in the host semantic actions. I started with a simple list cons. This allows you to say { "add", x, y } instead of "Sugar.Cons("add", x, y)". This notably simplified CalculatorParser and NullOptimization grammars. 

The eventual goal is that "Sugar" wouldn't have to be explicitly referenced in an action but would rather rely on the CSharpRecgonizer to convert the nicer syntax to a Sugar usage. The nicer syntax should play nice with the overal goals of C#.jeffmoserMon, 08 Sep 2008 02:00:20 GMTSource code checked in, #17196 20080908020020Ahttp://www.codeplex.com/ometasharp/SourceControl/ListDownloadableCommits.aspxSmall update to Meta-FizzBuzz grammar by using C#'s type aliasing ability (e.g. "using E = System.Func<object>") to make the code less verbose. I'm not sure if this is best long term for readability/comprehension, but I do like how it makes things more compact.jeffmoserMon, 01 Sep 2008 21:15:34 GMTSource code checked in, #16907 20080901091534Phttp://www.codeplex.com/ometasharp/SourceControl/ListDownloadableCommits.aspxImplemented support for automatic casting of a type in the semantic action and host expression part of a grammar (e.g. the C# part) based on a grammar default ("ometa Factorial<int, ***int***>") or by specifying the type by the variable capture. The former allows you to get a notably simpler Calculator, Factorial, LittleTypeChecker, and NumberParser (take a peek at their new version in this changesteThe latter allows "Super(Digit):d<int>".

The focus on this release is therefore less typing. Hopefully with a few more iterations will bring us closer to the compactness similar to what can occur in a dynamic language like JavaScript but being strongly typed.jeffmoserFri, 29 Aug 2008 02:52:43 GMTSource code checked in, #16784 20080829025243Ahttp://www.codeplex.com/ometasharp/SourceControl/ListDownloadableCommits.aspxAdded a Meta-FizzBuzz implementation and two versions of FizzBuzz written in it.jeffmoserMon, 25 Aug 2008 10:41:48 GMTSource code checked in, #16572 20080825104148Ahttp://www.codeplex.com/ometasharp/SourceControl/ListDownloadableCommits.aspxAdded support for defining overrides in a grammar via the ^ character.

For example, the Calculator grammar now has

Digit ^= Super(Digit):d -> { d.ToDigit() },

since it is overriding the "Digit" rule in its base grammar. This now generates an "override" in the C# code. With this extension, I can now emit enough information to get rid of the warning about unverifiable code from using a base class reference in an anonymous method. I do this by storing the reference to a local variable "__baseRule__".

For the first time, the entire OMeta project compiles without any warnings.jeffmoserFri, 22 Aug 2008 02:27:36 GMTSource code checked in, #16467 20080822022736Ahttp://www.codeplex.com/ometasharp/SourceControl/ListDownloadableCommits.aspxMore syntax updates. I now make inheritance look more C++/C#-ish of "MyClass : BaseClass" instead of "MyClass <: BaseClass". 

This was driven by another change that I made where I add types to the grammar definition to specify what goes in (e.g. "ometa OMetaTranslator<HostExpression> : Parser<HostExpression>"). 

This annotation used to be done in the tests themselves. Now it's right in the grammar itself (by default I assume a char input).

You can also define the "default" type as in "ometa Calculator<char, int> : Parser<char> {". My thought is that in an upcoming change I can dramatically simplify the calculator grammar (among others) by making it unnecessary to do all those .As<int>() and have that be automatic if you define a default.jeffmoserFri, 15 Aug 2008 03:45:50 GMTSource code checked in, #16203 20080815034550Ahttp://www.codeplex.com/ometasharp/SourceControl/ListDownloadableCommits.aspxAdded preliminary support for namespaces. You can now use "using" statements like C# as well as specify a namespace prefix to your grammar name. If you don't specify one, defaults will be provided.

This is the first noticable addition to the grammar to make it more .NET friendly.jeffmoserTue, 12 Aug 2008 02:50:15 GMTSource code checked in, #16095 20080812025015Ahttp://www.codeplex.com/ometasharp/SourceControl/ListDownloadableCommits.aspxAdded Prolog library and grammar that I translated based off of the ones on the OMeta/JS project. This shows a symbiosis of OMeta# for the language aspects and C# for other logic (e.g. Prolog's unification concept)jeffmoserMon, 11 Aug 2008 01:48:33 GMTSource code checked in, #16066 20080811014833Ahttp://www.codeplex.com/ometasharp/SourceControl/ListDownloadableCommits.aspxRemoved about 30 lines from OMetaTranslator.ometacs by introducing a Format option to CodeGen. Slowly trying to get cleaner syntax.jeffmoserSat, 09 Aug 2008 03:50:12 GMTSource code checked in, #15986 20080809035012Ahttp://www.codeplex.com/ometasharp/SourceControl/ListDownloadableCommits.aspxGot rid of manually created grammar-ish code. Most notable is that the manual translator is out. The OMeta# one is quite a bit easier to understand.

This is symbolic of OMeta#'s future of more of it being written in itself. This requires removing the hints of the past where we had to manually bootstrap ourself :-)jeffmoserSat, 09 Aug 2008 02:24:48 GMTSource code checked in, #15985 20080809022448Ahttp://www.codeplex.com/ometasharp/SourceControl/ListDownloadableCommits.aspxUpdated OMetaParser's HostExpr and C# recognizer so that a HostExpr is

Expr = ParenExpr | Spaces (StringLiteral | FunctionCall | BasicName)

This finally allows for less ()'s

Compare

Block = EverythingInside(("{"), ("}"))

With

Block = EverythingInside("{", "}")jeffmoserSat, 09 Aug 2008 02:14:04 GMTSource code checked in, #15984 20080809021404Ahttp://www.codeplex.com/ometasharp/SourceControl/ListDownloadableCommits.aspxOMeta# now bootstraps itself!

Added a OMetaTranslator written in OMeta# to make this happen. This involved a new grammar (OMetaTranslator.ometacs). As of this check-in, no manually "parsed" grammar-ish code is used and thus the code generates the code that generates the code. 

This is a notable milestone in this project because the recognizer -> parser -> translator chain is a reasonably complex grammar and is a good proof of concept.

This will probably be the last changeset that has the manually created code in it. I'll use TFS to preserve the roots of where it came from so that the main project isn't littered with it.

The next major step is to clean things up in preparation of CTP 1.


jeffmoserFri, 08 Aug 2008 02:52:35 GMTSource code checked in, #15954 20080808025235Ahttp://www.codeplex.com/ometasharp/SourceControl/ListDownloadableCommits.aspxOMeta# now has an optimzer that was written in OMeta#!

Most of the code was just a port of the OMeta/JS optimizer. See the NullOptimization.ometacs, AndOrOptimization.ometacs, and OMetaOptimizer.ometacs grammars for more details.

One of the most fascinating lines of OMeta# is this one:

 OptimizeRule = :r (Foreign((typeof(AndOrOptimization)), ("Optimize"), (r)):r)* -> { r }

This basically keeps optimizing a rule until it can't be optimized any further. Very neat way of expressing it.

The optimizer is making a noticable improvement in generated code. Average savings is around 15% for simple grammars and 40% for more complicated ones. For example, the OMetaParser.cs generated code shrank from 3022 lines to 1843 lines with the optimizer turned on. A savings of 1179 lines or 39%.

The next piece of optimization will be to eliminate unnecessary wrapped functions from And expressions. That is, if the MetaRules.Apply(...) is the only function, then just generate the inner scope instead of wrapping it.

I'll defer this this last major optimization until after the code generator is rewritten into OMeta#.jeffmoserSat, 02 Aug 2008 17:50:53 GMTSource code checked in, #15766 20080802055053Phttp://www.codeplex.com/ometasharp/SourceControl/ListDownloadableCommits.aspxFixed the RegularString rule. Forgot to implode the list of EscapedChar'sjeffmoserSat, 02 Aug 2008 02:52:13 GMTSource code checked in, #15748 20080802025213Ahttp://www.codeplex.com/ometasharp/SourceControl/ListDownloadableCommits.aspxOops. Forgot to actually turn on OMetaParser. Previous version was using ManualOMetaParser. This exposed a bug in my implementation of RegularString that I'll need to fix soon.jeffmoserFri, 01 Aug 2008 03:31:11 GMTSource code checked in, #15710 20080801033111Ahttp://www.codeplex.com/ometasharp/SourceControl/ListDownloadableCommits.aspxDid work on CSharpRecognizer.ometacs so that it works properly. This required some changes in other spots to fix up a few problems.

Now OMeta# can parse itself and the C# recognizer. Furthermore, the generated parser now uses the generated C# recognizer.jeffmoserSun, 27 Jul 2008 23:23:39 GMTSource code checked in, #15493 20080727112339P