Blast from the Past, FreeCC Parser Generator

[Jonathan Revusky <re...@yandex.ru>]

Hi all.

I don't know offhand how many of the people receiving this email know 
who I am.  For those of you who don't, I was quite heavily involved with 
the FreeMarker project from some point in late 2001 to late 2008 or so. 
About 7 years. I was the original author of the first JavaCC grammar for 
FreeMarker. Before that, it was a hand-written parser.

As a result of that, and the evolution of FreeMarker, I became quite a 
JavaCC power user and eventually I did a lot of work on JavaCC, which I 
tried to donate to that project. Well, they basically refused to look at 
my work, so I ended up forking it and I labeled that as FreeCC.

Well, also, recently, I was trying to take a look at what was going on 
here and I noticed that the whole subject of parser generators came up 
-- this is a couple of years ago now, and nobody seemed to even know 
that FreeCC existed. Well, it was kind of abandoned and the only place 
to find it would have been on its archived Google Code site, which is 
still there. https://code.google.com/archive/p/freecc/

Of course, Google Code is basically defunct, so the first step to 
resuscitating the project was to put it on Github, which I did just 
yesterday. Here: https://github.com/revusky/freecc

If you want to get your hands on it and play with it, that is quite 
easy. It is simply:

git clone https://github.com/revusky/freecc.git

There are freecc and freecc.bat launchers that run straight out of the 
box since there is a "bootstrap" freecc.jar file, which is needed to do 
a build of freecc!

To do a build is really easy. After checking it out, it's just

cd freecc

ant

That builds a freecc.jar in the root directory that the launchers use in 
preference to the one in bin (if it is there, obviously...)

You can run the test cases such as they are with:

ant test

and generate some (rather limited) docs with

ant docs

In the examples, there is an example grammar for FreeMarker which I had 
actually intended to be the basis of the grammar in newer versions of 
FreeMarker. You can also eyeball those files here:

https://github.com/revusky/freecc/tree/master/examples/freemarker

Note how the FreeMarker grammar is broken into two files, FTL.freecc and 
FEL.freecc. The first is the grammar for directives while the second 
file is just for expressions, FEL being FreeMarker Expression Language. 
In fact, it would be fairly simple to have separate builds in which you 
swap in and out different FEL.freecc files and have alternative syntax 
for expressions. (I don't know how useful that is, but it is nifty and 
it is something that is, to all intents and purposes, not even possible 
with JavaCC, which is a much more inflexible and cumbersome tool.)

I had originally thought that, having abandoned FreeCC for a decade, 
that the work had no value now, since there would be so much progress 
over that time, but actually, I look at this, and see that, 
surprisingly, FreeCC could still be pretty useful, so I thought to try 
get it to a 1.0 release level.

Over the last few days, I've been updating the included Java grammar to 
handle more modern constructs. It now handles the newer try-catch 
blocks, the double colon :: operator, but I still haven't implemented 
the lambda expression syntax. But I intend to. I ran the java parser 
over the entire freemarker codebase and it fails on 2 files, precisely 
because those are the two that use lambda expressions.

Also, I fixed a couple of bugs that had been in the GoogleCode bug 
tracker for like 11 years.

FreeCC in its very core algorithmically is the same as JavaCC, but since 
it uses FreeMarker templates to generate the code, it is actually far 
more configurable and flexible than JavaCC. You can get an idea of the 
new (actually, not so new features at this point!) from these Wiki posts 
I wrote about 11 years ago.

https://code.google.com/archive/p/freecc/wikis

I had the beginnings of a tutorial written about 11 years ago. I put 
that up right here:

https://revusky.com/freecc/docs/

Well, the whole thing has quite a bit of potential, and it is a very 
good example of how FreeMarker can be used outside the web space, for 
code generation. It is quite striking to compare FreeCC's code with 
JavaCC and see how much more tersely and cleanly the whole thing is 
expressed using FreeMarker templates to generate the code of the parsers 
rather than the println statements approach used by JavaCC.

Well, I write this hoping that some people could really get interested 
in this. You might or might not, but it is easy to check out the project 
and play with it. There are some very old examples that are from JavaCC 
and then some examples I added. In particular, the included FTL.freecc 
and FEL.freecc are quite worthy of study, in particular, if you are 
interested in reworking FreeMarker.

I'll close the note here.

Best Regards,

Jonathan Revusky