Re: Seeking recommendations for a Visual Parser to replace Visual Parse++

Chris F Clark <>
Tue, 11 Dec 2007 02:00:03 -0500

          From comp.compilers

Related articles
Seeking recommendations for a Visual Parser to replace Visual Parse++ (2007-12-10)
Re: Seeking recommendations for a Visual Parser to replace Visual Pars (Chris F Clark) (2007-12-11)
Re: Seeking recommendations for a Visual Parser to replace Visual Pars (Hans-Peter Diettrich) (2007-12-12)
Re: Seeking recommendations for a Visual Parser to replace Visual Pars (Tom Copeland) (2007-12-12)
Re: Seeking recommendations for a Visual Parser to replace Visual Pars gneuner2/@/ (George Neuner) (2007-12-13)
Re: Seeking recommendations for a Visual Parser to replace Visual Pars (Chris F Clark) (2007-12-15)
Re: Seeking recommendations for a Visual Parser to replace Visual Pars (Paul B Mann) (2008-02-14)
Re: Seeking recommendations for a Visual Parser to replace Visual Pars (Marcel Satchell) (2008-03-28)
| List of all articles for this month |

From: Chris F Clark <>
Newsgroups: comp.compilers
Date: Tue, 11 Dec 2007 02:00:03 -0500
Organization: The World Public Access UNIX, Brookline, MA
References: 07-12-032
Keywords: parse, tools
Posted-Date: 11 Dec 2007 11:17:14 EST writes:

> Can you recommend a Visual Parser which is as good as Visual Parse++?
> Please share your experience. We are looking for a visual parser which
> can generate C++ files.

Depending on why you liked VP++, I will give you several distinct
recommendations, and my caveats. Note all of these should purely be
considered *strongly* biased opinions. I am the [co-]author of one of
the tools mentioned (and you will find a hopefully relevant if
somewhat self-serving and certainly shameless plug of said tool).

1) If you specifically liked the IDE, your best choice is probably
      grammarforge (aka meta-S) by Quinn Tyler Jackson. I believe Quinn
      worked with Will Donahue for a while and integrated the VP++ IDE
      into grammarforge. Grammarforge also has integrated regular
      expression support within the grammars, although for my taste the
      regular expression notation isn't as well integrated as some of the
      other tools. Two caveats. First, the tool is LL rather than LR
      based, so if you use precedence and associativity declarations, you
      will have to rework those. Second, Quinn may no longer be
      associated with the product (and it may not even be available).

      Your second best choice in that case, may be ANTLR by Terence Parr.
      It won't be the VP++ IDE, it will be one designed for ANTLR, but I
      suspect you will find it has a similar number of bells and
      whistles. ANTLR also has integrated regular expression/parsing
      support and the notation is generally quite natural to my mind. A
      further plus is ANTLR has traditionally had good community support
      (although JavaCC has syphoned some of the interest away), which
      means even if Terence is not working on it (and I don't know one
      way or the other as I haven't chatted with him in a couple of
      years), you are unlikely to be stuck. In addition, ANTLR is free
      software--so if you need to fix it yourself (or hire someone to fix
      it), you will be able to do so. Caveats, ANTLR is again LL not LR.
      ANTLR is also primarily targeted to Java, but it does generate C++
      (and I believe C#).

2) If you primarily want regular expression integrated into LR
      parsing, there are two choices I would recommend. The DMS toolkit
      is a high-end product, with Ira Baxter as the CTO of the developing
      company. I believe it has integrated regular expressions into its
      parsing notation. It uses GLR parsing, so it can parse just about
      any formalism. It has attribute grammar support, which is a more
      tightly intgrated form of semantic actions. I also presume it has
      an IDE, and possibly quite a sophisticated one. Caveats. First,
      it is a buy-into system with cradle-to-grave semantics. Second, it
      is likely to be relatively pricey.

      I would also recommend Yacc++ (my product) in that category. It
      has about the same power (LR with integrated regular expressions)
      as VP++ and has a library with about the same number of features
      and intrusiveness. You will find the "Language Objects Library",
      as we call it, a bit more featureful and thus a bit more complex
      than the VP++ library. The commercial version (with one year of
      support) will cost you $1K. Caveats. First, no IDE--we had one
      once, but dropped it as not particularly useful (and it was tied to
      the original Sun Windows system, not Microsoft Windows, not X
      Windows, not even NeWS). Second, it is truly C++ centric. We have
      a C# version in a limited beta, but the code is so non-idiomatic C#
      that we are going to have to rewrite it before releasing it to the
      general public.

      Potential plus that you are unlikely to find elsewhere, We are real
      interested in servicing the VP++ market and would like to provide a
      version of Yacc++ that can read VP++ grammars and generate code for
      our library (possibly extended with some VP++-like APIs). We would
      be willing to work with some early customers to develop this and
      verify that the product works on their grammars. Later customers
      would then get our normal bug-fix support for VP++ compatibility
      problems. If the VP++ IDE is important, we would even be willing
      to develop a similar IDE to "your" specifications, splitting the
      cost amongst the various VP++ customers. If you are interested in
      this, let's try to find at least 4 more customers.

      Another plus is that Yacc++ will soon have complete Perl compatible
      regular expression integrated into its LR engine (and not with some
      hack of calling libpcre and hoping it works). We believe we have
      the theory worked out and someone beginning to implement the key
      missing feature, back-references. (This, of course, is not the
      only technical uniqueness to Yacc++. It's also the only predicated
      LR parser generator. We believe the AST constuctors are also
      uniquely powerful.)

Other generators worth investigating:

      Bison and/or yacc. This is "the standard" tool. Recent versions
      have supported GLR parsing, but not integrated regular expressions
      as far as I know. Versions that generate C++ are definitely
      available. Lots of spin-off projects, many of which unfortunately
      die-off after the initial author moves on (e.g. graduates).

      JavaCC, a spin-off of ANTLR, with a very active community and some
      nice add-on tools (JTB and JJTREE). Unfortunately, I think it is
      Java only.

      ASF+SDF, a GLR tool that has definite popularity in academic
      circles. I don't know much beyond that.

      LALR by Paul Mann a quite capable and light-weight tool.

      ELI a powerful system, probably nearly on par with the DMS toolkit,
      composed from parts of a variety of academic researchers with some
      clever glue to tie it all together, as a result sometimes a little

      Cocktail by Josef Groelsch--a really great tool in its time, but I
      don't know if it was ever migrated from Modula-2.

There are, of course, many other options beyond these I have listed
(e.g. Gold by Devin Cook), but I don't know enough about them to make
any comments at all.

One general caveat about the parser generator market. Very few people
actually make money in the parser generator market. As a result, most
parser generators are toys (or initially one use tools*) written by one
person and unfortunately only with support as long as the person stays
interested, but you know that as an ex-Sandstone customer. The tools
I listed have shown some longevity by being around (and supported) for
more than a year or two. In fact, I believe that yacc, LALR, Bison,
Yacc++, and ANTLR all predate VP++ (and I listed them in order of when
I think they first existed), so that those which are still supported
are likely to continue to be supported. Some of them yacc, Bison, and
ANTLR are effectively community supported and thus may continue
indefinitely. (Yacc++ also has recently been released in a free
version which may also acquire a community but hasn't yet.) On the
other hand, LALR and Yacc++ have developers that have both continued
to do so for atleast 20 years--the first pre-version of Yacc++ was
described at a 1987 Sigplan conference.

Well, this is probably more than you wanted in some ways and less in

Still, I hope this helps,

Chris Clark Internet :
Compiler Resources, Inc. Web Site :
23 Bailey Rd voice : (508) 435-5016
Berlin, MA 01503 USA fax : (978) 838-0263 (24 hours)

*) BTW, the first version of Yacc++ was intended as a one use tool and
      part of a bigger project. It was only after the scope of that
      larger project was realized that it took on a life of its own.

Post a followup to this message

Return to the comp.compilers page.
Search the comp.compilers archives again.