User Comments

From ward@c2.com  Sun Aug  3 15:06:38 1997

2.  Please provide a short one paragraph description of the JavaCC
    tools as a recommendation to someone who has never seen or used
    our tools before.

Mastering a scanner and parser generator gives a programmer mastery
over structured text. For the Java programmer, JavaCC is the generator
to master.

3.  How would you classify your use of JavaCC?

serious product development 

At the heart of our application is a schema definition that describes
all of the business objects. From this definition, our JavaCC based
translators produce Java stubs, meta data, and other translators.

4.  What are your opinions of JavaCC?  At least provide a number from
    0(horrible) to 10(the greatest) and then preferably write something
    also.

	9

I would have given JavaCC a 10, but it keeps getting better.

5.  What are your opinions of JJTree?  At least provide a number from
    0(horrible) to 10(the greatest) and then preferably write something
    also.

	7

I learned a lot about JavaCC by studying JJTree. I chose not to use
JJTree simply because my colleagues were not skilled in compiler
issues.  I wanted to avoid the extra layer of indirection and
complexity. I also found it convenient to pass context through
production arguments and return values. By this means I did
substantial translation before constructing my simplified syntax
trees.

JJTree combined with the "Visitor" design pattern would make an
extreamly versitle multi-target translator.

6.  How would you rate support for the JavaCC tools.  Please compare it
    with other tools - both free tools and those that come with formal
    support.  At least provide a number from 0(horrible) to 10(the
    greatest) and then preferably write something also.

	8

Frankly, I am astounded that the developers at (Metamata) find the time
and patience to routinely deliver such thoughtfull replies to both
experts and compiler newbies.

I caught the documentation between generations (in March) but still
found it sufficient to answer every question I had. The prose were
concise and direct -- ideal for someone in a hurry. The examples
complemented these prose with useful techniques that I borrowed
freely.  I was able to learn JavaCC and JJTree, and produce a working
translator, in less than a week. And the experience was exhilerating.

8.  Have you used other similar tools such as PCCTS, JavaCup, Yacc,
    etc.?

Yes, Lex and Yacc.

9.  (If answer to 8 is YES) How would you compare JavaCC with these
    other tools?  At least provide a number from 0(very unfavorable) to
    10(very favorable) and then preferably write something also.

	10

I've found the LL vs LALR arguments rather accademic. Developers who
are really trying to solve problems don't mind writing the productions
the way that works. When problems occur, I find LL easier to think
through.  And, the solution to parsing problems usually involves
moving responsibilities between the scanner and the parser, so JavaCC
wins again by integrating these so nicely.

From sjb@research.bell-labs.com  Mon Jul 28 12:54:03 1997

2.  Please provide a short one paragraph description of the JavaCC
    tools as a recommendation to someone who has never seen or used
    our tools before.

JavaCC takes a grammatical description of a language and produces a
parser and lexical analyzer for that language.  The parser is a
top-down parser with a variable amount of lookahead.  The lexer
supports lexical states as well as a powerful (and clever) feature for
keeping the white space and comments from the input without having it
interfere with the parse output.

jjtree is a preprocessor for a javacc grammar file which adds code to
produce an AST (abstract syntax tree) as the result of the parser.  It
is very powerful and versatile.  It can be used to produce simple
trees with almost no work.  It can also be configured to produce
customized trees with user supplied classes for each node type.  It
can even be used to produce a parser which takes a factory object at
run time to determine the classes to use to represent the various
non-terminals in the grammar.
 
3.  How would you classify your use of JavaCC?

	 serious product development

I used javacc and jjtree to produce a parser for a "little language we
designed for our project.  The parser was designed to support a
pluggable backend and there are now three different backends in use or
under development.
 
4.  What are your opinions of JavaCC?  At least provide a number from
    0(horrible) to 10(the greatest) and then preferably write something
    also.

	10

I have found javacc to be a real pleasure to use.  I prefer its
top-down parser to the bottom-up parsers produced by tools like yacc
and bison.  In addition, the folks developing javacc seem to be
prescient.  Each time I started thinking about adding another feature
to my parser (preservation of comments and white space, better error
handling, etc.), they would announce support for it in the next
release.
 
5.  What are your opinions of JJTree?  At least provide a number from
    0(horrible) to 10(the greatest) and then preferably write something
    also.

	10

jjtree is a powerful complement to javacc.  It allows you to create a
parser which builds an AST (abstract syntax tree) with little more
work than is required to write the parser itself.  jjtree is highly
customizable allowing you to specify a class to associate with each
non-terminal of the grammar and generating code which creates an AST
of these objects.  If you don't need this generality, jjtree will
create classes for each non-terminal for you or even build the tree
with each node of the same class but identifying information inside.

There is even support for supplying a factory object at parser
execution time so that a single instance of the parser object can
produce ASTs using different classes on different invocations.  I used
this feature to produce my parser with a pluggable backend.

6.  How would you rate support for the JavaCC tools.  Please compare it
    with other tools - both free tools and those that come with formal
    support.  At least provide a number from 0(horrible) to 10(the
    greatest) and then preferably write something also.

	10

One of the best things about using javacc and jjtree has been the
support.  I've never used a product from a large company which has
been supported like this.  All of the folks developing javacc and
jjtree actually read AND REPLY to their mail.  They respond to bug
reports telling you whether it really is a bug or if you have goofed.
If it is a bug, they almost always commit to fixing it in the next
release (and they do).  If its your mistake, they tell you rather than
just ignoring your mail.

They are also very open to suggestions for changes and/or
enhancements.  Again, if you make one, they don't ignore you.
They respond and either accept the idea or tell you why they don't
or can't do it.  Amazing!!!
 
8.  Have you used other similar tools such as PCCTS, JavaCup, Yacc,
    etc.?

I've used yacc.

9.  (If answer to 8 is YES) How would you compare JavaCC with these
    other tools?  At least provide a number from 0(very unfavorable) to
    10(very favorable) and then preferably write something also.

	10

I prefer the top-down to the bottom-up model.  Also, there is nothing
(to the best of my knowledge) like jjtree for yacc.

10. (If answer to 8 is YES) How would you compare JJTree with these
    other tools?  At least provide a number from 0(very unfavorable) to
    10(very favorable) and then preferably write something also.

	10

As far as I know, there is nothing equivalent to jjtree that works
with yacc.

From: "Tribble, Louis E" 

2.  Please provide a short one paragraph description of the JavaCC
    tools as a recommendation to someone who has never seen or used
    our tools before.

JavaCC is a parser generator which takes a straightforward, intuitive
language specification and creates a 100% pure Java program which will
scan and parse a text file. Because JavaCC can use substantial
lookahead and/or semantic information to make parsing decisions,
JavaCC grammars don't need the kind of mangling that's often required
by YACC grammars to handle real languages.  JavaCC allows semantic
actions to be written, in Java, into the grammar, into the nodes of
the syntax tree, or into external code which manipulates the syntax
tree. Although there is not really a comprehensive tutorial available,
the examples, FAQs, and mailing list archives provide ample
information, and the developers and many users help out on the mailing
list. The developers have shown a tremendous commitment to supporting
and improving their product.

3.  How would you classify your use of JavaCC?

Research: I am using JavaCC to design and implement an experimental
object-oriented programming language.

4.  What are your opinions of JavaCC?  At least provide a number from
    0(horrible) to 10(the greatest) and then preferably write something
    also.

JavaCC is robust and never gets in my way (Yacc always got in my way).

5.  What are your opinions of JJTree?  At least provide a number from
    0(horrible) to 10(the greatest) and then preferably write something
    also.

JJTree is critical to my use of JavaCC. It allows me to completely
separate my semantic processing from my grammar. With very few lines
of code supplied by me, the generated parser creates the intermediate
representation of my compiler: a combination abstract syntax tree and
control flow graph.

6.  How would you rate support for the JavaCC tools.  Please compare it
    with other tools - both free tools and those that come with formal
    support.  At least provide a number from 0(horrible) to 10(the
    greatest) and then preferably write something also.

Support is excellent, whether compared to free or commercial (not
free) products. I consider the presence of users on the mailing list
and the web page resources to be essential parts of this (keep those
mailing list archives coming!).

I can imagine that the support would not be suited to a really
clueless user, but that's not the target audience of a parser
generator.

7.  List all platforms on which you have run the JavaCC tools
    successfully.  If your platform is already listed below (after the
    questionnaire), please don't worry about answering this one.

Macintosh Apple MRJ 1.0.2, Macintosh Apple MRJ 1.5, Macintosh
Metrowerks Java (CodeWarrior).

8.  Have you used other similar tools such as PCCTS, JavaCup, Yacc,
    etc.?

Bison and BYACC, extensively. I cursorily evaluated PCCTS 1.x.

9.  (If answer to 8 is YES) How would you compare JavaCC with these
    other tools?  At least provide a number from 0(very unfavorable) to
    10(very favorable) and then preferably write something also.

Much, much more powerful, easier to use, and it integrates much better
with the rest of the application than the Yacc family. JavaCC's
approach to passing values during the parse is much more symbolic and
less error-prone than Yacc's, and the placement of actions has no
impact on the parse, unlike with Yacc.

From my recollection of PCCTS 1.x, JavaCC is also much easier to use
and integrate than it is.

10. (If answer to 8 is YES) How would you compare JJTree with these
    other tools?  At least provide a number from 0(very unfavorable) to
    10(very favorable) and then preferably write something also.

JJTree automates most of the construction of an intermediate
representation, a task for which Yacc provides no support.

From Jason_Eaton@Vantive.COM  Tue Jul 29 09:27:33 1997

2.  Please provide a short one paragraph description of the JavaCC
    tools as a recommendation to someone who has never seen or used
    our tools before.

A Yacc like parser generator for Java, allowing easy integration of
java productions in the parser.

3.  How would you classify your use of JavaCC?

We have pieces of java code embedded into html which a Javacc
generated parser is used to extract the java embedded code and run it.

4.  What are your opinions of JavaCC?  At least provide a number from
    0(horrible) to 10(the greatest) and then preferably write something
    also.

	8

Very stable tool from day 1. I have only encountered one bug during
our development. I appreciate the amout of attention put into the code
to make it effecient and bug free.

6.  How would you rate support for the JavaCC tools.  Please compare it
    with other tools - both free tools and those that come with formal
    support.  At least provide a number from 0(horrible) to 10(the
    greatest) and then preferably write something also.

	8

What makes it different from other free tools is the support you
recieve if there are questions or problems.

8.  Have you used other similar tools such as PCCTS, JavaCup, Yacc,
    etc.?
	
	Yacc

9.  (If answer to 8 is YES) How would you compare JavaCC with these
    other tools?  At least provide a number from 0(very unfavorable) to
    10(very favorable) and then preferably write something also.

	9

Easier to use the Yacc. Easier to customize.

From jwb@megasoft.com  Mon Jul 28 11:40:18 1997

2.  Please provide a short one paragraph description of the JavaCC
    tools as a recommendation to someone who has never seen or used
    our tools before.

JavaCC is a robust and accessible tool for defining grammars.  The
parsers generated by JavaCC are quite efficient and can be easily
integrated in any Java application.  Programmers that use
StreamTokenizer are frequently reinventing the wheel.  Using a
parser-generator results in cleaner, more maintainable code.  With
JavaCC, it's easy to define the input grammar for virtually any
application that must accept (and verify) input that is more complex
than uniform records.  The grammar definitions clearly define the
input and this can be a great advantage when documenting the
interfaces among distributed components as well as for maintenance.
Problems that are introduced when hand-coded parsers are modified are
usually prevented by the checks that are made on the grammar
definition processed by JavaCC.

[This recommendation would be stronger if JJDoc were more robust.]

3.  How would you classify your use of JavaCC?

	. serious product development

JavaCC is used to define the structure of messages exchanged via HTTP
between CGI server and client applications.

4.  What are your opinions of JavaCC?  At least provide a number from
    0(horrible) to 10(the greatest) and then preferably write something
    also.

	8

JavaCC provides an especially "natural" notation for grammar definition.
The debugging features are very helpful, but 0.6 leaves a bit to be
desired.

6.  How would you rate support for the JavaCC tools.  Please compare it
    with other tools - both free tools and those that come with formal
    support.  At least provide a number from 0(horrible) to 10(the
    greatest) and then preferably write something also.

	9

The response from the JavaCC team is really good and they have the most
comprehensive FAQ of any product, Free or otherwise.

8.  Have you used other similar tools such as PCCTS, JavaCup, Yacc,
    etc.?

I have only used a few flavors of Yacc/Bison.

9.  (If answer to 8 is YES) How would you compare JavaCC with these
    other tools?  At least provide a number from 0(very unfavorable) to
    10(very favorable) and then preferably write something also.

	8

The ease/flexibility of integration of the parsers with the
application is much greater than Yacc/Bison.  Though I have had
difficulty with the specfics of the regular expression language and
grammar definition language, I believe they are more natural (to those
unbiased by previous exposure) than [f]lex+yacc/bison.

I haven't tried the error recovery in 0.7, but this is a significant
weakness.

From emeade@fvh.gtegsc.com  Mon Jul 28 11:59:47 1997

3.  How would you classify your use of JavaCC?

serious product development / Using or planing to use to gather
metrics, standardize coding standards (Pretty Print), and testing
(similar to JavaScope)

4.  What are your opinions of JavaCC?  At least provide a number from
    0(horrible) to 10(the greatest) and then preferably write something
    also.

	8

JavaCC is a very reliable well written tool, however speed leaves
something to be desired ( I currently Parse over 120 files. ) I am
sure that as Java speeds up this problem will go away.

5.  What are your opinions of JJTree?  At least provide a number from
    0(horrible) to 10(the greatest) and then preferably write something
    also.

	8

JJTree rocks.  It's usefulness is limited only by your imagination.
Packages can get a little crowded with all the Node classes though.

From theo@engr.mun.ca  Mon Jul 28 11:48:35 1997

2.  Please provide a short one paragraph description of the JavaCC
    tools as a recommendation to someone who has never seen or used
    our tools before.

	JavaCC converts regular expression lexical descriptions and
	EBNF grammars to java lexers and parsers.

3.  How would you classify your use of JavaCC?

	I am using it for serious, but part time development of
	educational software.  Specifically, our system provides
	a window on the workings of a computer program written in
	in a high-level language.  JavaCC is used to parse the
	program.

	I also encouraged my students to use JavaCC for a scaled down
	version of the same project. Because it is a fairly simple
	system, I wasn't too worried about my student's ability to
	figure it out, after some help from me getting started.

4.  What are your opinions of JavaCC?  At least provide a number from
    0(horrible) to 10(the greatest) and then preferably write something
    also.

	8

	What it does, it does quite well.

5.  What are your opinions of JJTree?  At least provide a number from
    0(horrible) to 10(the greatest) and then preferably write something
    also.

	8

	I haven't used it yet, but I plan to give it a try. Like JavaCC
	it does what it does very well (it seems). It might be nice to
	have a full blown attribute grammar system someday. Until then,
	JJTree does a nice job of the tree building part.

8.  Have you used other similar tools such as PCCTS, JavaCup, Yacc,
    etc.?

	Yes yacc.

9.  (If answer to 8 is YES) How would you compare JavaCC with these
    other tools?  At least provide a number from 0(very unfavorable) to
    10(very favorable) and then preferably write something also.

	6

	It's hard to beat LR(1) with top-down.

10. (If answer to 8 is YES) How would you compare JJTree with these
    other tools?  At least provide a number from 0(very unfavorable) to
    10(very favorable) and then preferably write something also.

	8

	Well there's nothing like JJTree in yacc.

From: Warren Pfeffer (slinky@pluto.njcc.com)

2.  Please provide a short one paragraph description of the JavaCC
    tools as a recommendation to someone who has never seen or used
    our tools before.

	I used JavaCC 0.6.1 to implement the JavaDepend
	utility. I've used lex/yacc extensively before
	but JavaCC blows them away when it comes to
	ease of use (no more struggling with yacc 
	inherited/synthesized attributes, you know $$, $-1).
	JavaCC is also portable (written in Java) so I
	don't need a yacc on Linux and a yacc on NT!

3.  How would you classify your use of JavaCC?

	serious product development

	I used JavaCC 0.6.1 to develop JavaDepend
	which is a makedepend for Java (available
	at http://pluto.njcc.com/~slinky/). It was
	very easy to modify the Java grammar that
	comes with JavaCC.

4.  What are your opinions of JavaCC?  At least provide a number from
    0(horrible) to 10(the greatest) and then preferably write something
    also.

	8

	I took away 1 point for performance, however
	I know this will be improved in the coming
	release. I also took a point away for documentation
	which could be better organized and more detailed
	(how's about a JavaCC in a Nutshell book?)

6.  How would you rate support for the JavaCC tools.  Please compare it
    with other tools - both free tools and those that come with formal
    support.  At least provide a number from 0(horrible) to 10(the
    greatest) and then preferably write something also.

	8

	I've only used JavaCC for one project so far.
	I must say that the JavaCC team has responded
	to my questions in a timely and concise manner.
	I subscribe to the interest list and I am looking
	forward to the news group.

8.  Have you used other similar tools such as PCCTS, JavaCup, Yacc,
    etc.?

	ATT lex/yacc
	Berkley byacc
	GNU flex/bison
	PCCTS

9.  (If answer to 8 is YES) How would you compare JavaCC with these
    other tools?  At least provide a number from 0(very unfavorable) to
    10(very favorable) and then preferably write something also.

	8

	See answer to question #2

From jheintz@iconcomp.com  Mon Jul 28 11:57:10 1997

2.  Please provide a short one paragraph description of the JavaCC
    tools as a recommendation to someone who has never seen or used
    our tools before.

JavaCC is a lexer/parser written in Java that generated Java code.  It
generated an ll(k) parser.  Additionally, it has integration to JJTree
and JavaScope.  JJTree is a tree generator that run from annotating
the JavaCC grammar.  JavaScope is designed to capture statistics of
usage of the various paths in the grammar.

3.  How would you classify your use of JavaCC?

Serious product development as well as multiple convenience apps.

4.  What are your opinions of JavaCC?  At least provide a number from
    0(horrible) to 10(the greatest) and then preferably write something
    also.

    8

I have never before used a lexer or parser so I am a bit new at this
stuff.  I would have given it a 10 because I am very happy with it,
but still do have some problems.  (For example I want to recognize a
specific string in one instance, but in others I want that string to
be treated as an IDENTIFIER token.  Basically I don't want that string
reserved.)

5.  What are your opinions of JJTree?  At least provide a number from
    0(horrible) to 10(the greatest) and then preferably write something
    also.

    6

I think that JJTree is a highly useful tool.  I also think that it has
the capability to grow.  (Not that it does things wrong now, just that
it could provide features to make development easier.)

Some of the things that I am running into deal with trying separate
Java packages based on the Open-Closed principle.  What I wanted to do
was have a package called parser that had all the JavaCC/JJTree file
in it, and a package called parser.nodes that had implementations of
the _important_ nodes.  Here is my type hierachy:

	parser.Node
		\
		parser.SimpleNode	some.package.Node1Interface
		|		\		|
	parser.ASTNode2	parser.nodes.Ancestor1	
					|
				parser.ASTNode1

Well, parser.nodes.Ancestor1 and parser.SimpleNode and parser.ASTNode1
are all circularly dependent.  Even the constructor for ASTNode1, and
thus for Ancestor1 has a reference to parser.Parser.  This makes it
really hard to compile by hand and it violates the Open-Closed
principle.

I have already made some suggestions to the JavaCC mailing list about
some added notations to the grammar file to generate the AST node
files.  I truly believe that a client to a generated file should never
modify that file.  The client should sub-class it, super-class it,
adapt-to it, or generate it with the needed behavior.  Since JJTree
instanciates the AST node class, this invalidates sub-classing them.

I think that JJTree is already a tremendous product, and that it has
tremendous potential as well to truly fit well into an object oriented
component system.

6.  How would you rate support for the JavaCC tools.  Please compare it
    with other tools - both free tools and those that come with formal
    support.  At least provide a number from 0(horrible) to 10(the
    greatest) and then preferably write something also.

    7


I want to stress that I am using JavaCC and JJTree in my products and
loving it!  Thanks for listening to my feedback, let me know if you
want any more of my opinions ;-) (Obviously I like to talk about this
stuff)

ps - I read about the Open-Closed Principle here:
Martin, R. C. "The Open-Closed Principle," C++ Report, Jan. 1996. 

From wkao@yahoo.com  Mon Jul 28 13:07:18 1997

2.  Please provide a short one paragraph description of the JavaCC
    tools as a recommendation to someone who has never seen or used
    our tools before.

	The document is very poor, although product is superior.

3.  How would you classify your use of JavaCC?

	Serious product development.
	I am using JavaCC as a very important part of my project.

4.  What are your opinions of JavaCC?  At least provide a number from
    0(horrible) to 10(the greatest) and then preferably write something
    also.

	I need user's guile, user's manual, and examples to pick up the
	information that I need to use JavaCC.

5.  What are your opinions of JJTree?  At least provide a number from
    0(horrible) to 10(the greatest) and then preferably write something
    also.

	I have hard time to find good documentation.

8.  Have you used other similar tools such as PCCTS, JavaCup, Yacc,
    etc.?

	Yacc.

9.  (If answer to 8 is YES) How would you compare JavaCC with these
    other tools?  At least provide a number from 0(very unfavorable) to
    10(very favorable) and then preferably write something also.

	9

From fmyers@cs.iupui.edu  Mon Jul 28 15:28:54 1997

2.  Please provide a short one paragraph description of the JavaCC
    tools as a recommendation to someone who has never seen or used
    our tools before.

	A lex/yacc equivalent for use with Java providing an acceptable
	object oriented framework to work with.

3.  How would you classify your use of JavaCC?

	educational research development

	development of a programming language/debugger/virtual machine
	for experiments by computer science students

4.  What are your opinions of JavaCC?  At least provide a number from
    0(horrible) to 10(the greatest) and then preferably write something
    also.

		6

	I really like the foundations of the tool.  JavaCC as a whole
	looses at least 2 points due to the lack of quality and
	informative documentation.  I would still recommend the
	product to anyone and am very pleased with it.  I look
	forward to future of a more complete product.

5.  What are your opinions of JJTree?  At least provide a number from
    0(horrible) to 10(the greatest) and then preferably write something
    also.

		7

	Once again, documentation is a critical issue.

6.  How would you rate support for the JavaCC tools.  Please compare it
    with other tools - both free tools and those that come with formal
    support.  At least provide a number from 0(horrible) to 10(the
    greatest) and then preferably write something also.

		4

8.  Have you used other similar tools such as PCCTS, JavaCup, Yacc,
    etc.?

	Yes

9.  (If answer to 8 is YES) How would you compare JavaCC with these
    other tools?  At least provide a number from 0(very unfavorable) to
    10(very favorable) and then preferably write something also.

		9 

	I find JavaCC much more intuitive with better syntax and
	layout.

10. (If answer to 8 is YES) How would you compare JJTree with these
    other tools?  At least provide a number from 0(very unfavorable) to
    10(very favorable) and then preferably write something also.

		9

	(same as above except s/JavaCC/JJTree/)

From speck@ruc.dk  Wed Jul 30 00:13:44 1997

2.  Please provide a short one paragraph description of the JavaCC
    tools as a recommendation to someone who has never seen or used
    our tools before.

It is _the_ replacement for lex/yacc when writing java appls.

3.  How would you classify your use of JavaCC?

serious product development

Parsing HTML like syntax for specialized database import from a DB2

4.  What are your opinions of JavaCC?  At least provide a number from
    0(horrible) to 10(the greatest) and then preferably write something
    also.

	9 (Same for JJTree, I don't use JavaCC without JJTree)

Easy to use. Easy to understand. (But you have to get used to that it
generates a lot of files).


6.  How would you rate support for the JavaCC tools.  Please compare it
    with other tools - both free tools and those that come with formal
    support.  At least provide a number from 0(horrible) to 10(the
    greatest) and then preferably write something also.

	3

The documentation is hard to find. The web pages are not too well
organized. There is too little documentation online. The tutorials are
many, but you don't learn much from them. Especially the LOOKAHEAD
tutorials doesn't help users not knowing the effects on beforehand.

8.  Have you used other similar tools such as PCCTS, JavaCup, Yacc,
    etc.?

  yacc

9.  (If answer to 8 is YES) How would you compare JavaCC with these
    other tools?  At least provide a number from 0(very unfavorable) to
    10(very favorable) and then preferably write something also.

	9

easy to use, fast to get running with a new grammer.

10. (If answer to 8 is YES) How would you compare JJTree with these
    other tools?  At least provide a number from 0(very unfavorable) to
    10(very favorable) and then preferably write something also.

	9

same. But I think we should have an option to let JJTree call JavaCC
directly, so that compiling the grammar is a one-step think. This
makes Macintosh (and any other GUI IDEs) users happier.

From vad@iaebox.iae.nsk.su  Thu Jul 31 03:06:56 1997

2.  Please provide a short one paragraph description of the JavaCC
    tools as a recommendation to someone who has never seen or used
    our tools before.

The system that genrates programs to process and analyse text files.

3.  How would you classify your use of JavaCC?

serious product development

We are developing a kind of Jscope product now. We plan also to use
JavaCC in a kind of Internet "Robot"

4.  What are your opinions of JavaCC?  At least provide a number from
    0(horrible) to 10(the greatest) and then preferably write something
    also.

	8

It works. The documentation at least can be understood. It is very
useful tool.

5.  What are your opinions of JJTree?  At least provide a number from
    0(horrible) to 10(the greatest) and then preferably write something
    also.

	6

Actually we do not use it (because we have no need to) but it seems to
be useful tool in principle.

6.  How would you rate support for the JavaCC tools.  Please compare it
    with other tools - both free tools and those that come with formal
    support.  At least provide a number from 0(horrible) to 10(the
    greatest) and then preferably write something also.

	8

Support is sufficient and is better than for many other tools. However
it would br nice to have more comprehansive documentation or tutorial
like for JDK.

From scott.davis@dsto.defence.GOV.AU  Thu Jul 31 16:56:23 1997

2.  Please provide a short one paragraph description of the JavaCC
    tools as a recommendation to someone who has never seen or used
    our tools before.

JavaCC is an easy-to-use-and-maintain method of writing a parser for a
text file. It takes a little bit of effort to learn it if you are
already familiar with Java and the StringTokenizer class, but it is
MUCH easier to maintain the reader as the format of the input file
evolves and becomes more complex.
 
3.  How would you classify your use of JavaCC?

internal organisation use.

I use JavaCC to read the (rather complex) "documents" or
"configuration files" for a project in our organisation. I guess these
files are a sort of scripting language for our research project. As
the project evolves, the content of these files is becoming larger and
more complex. JavaCC provides a much more error-proof way of reading
them than writing and maintaining the reader by hand.

4.  What are your opinions of JavaCC?  At least provide a number from
    0(horrible) to 10(the greatest) and then preferably write something
    also.

	9

I have never tried competing tools, so can't compare them.

6.  How would you rate support for the JavaCC tools.  Please compare it
    with other tools - both free tools and those that come with formal
    support.  At least provide a number from 0(horrible) to 10(the
    greatest) and then preferably write something also.

	5

The mailing list seems to be thriving, and always answers questions promptly.
I haven't required more formal support.

From CarlManning@AI.MIT.EDU  Wed Aug 20 20:07:21 1997

3.  How would you classify your use of JavaCC?

research/education

4.  What are your opinions of JavaCC?  At least provide a number from
    0(horrible) to 10(the greatest) and then preferably write something
    also.

	8

5.  What are your opinions of JJTree?  At least provide a number from
    0(horrible) to 10(the greatest) and then preferably write something
    also.

	7

nice tool, though doc doesn't show how to do left recursive
productions by parsing, then popping extra node off stack and fixing
up begin/end -- e.g., to parse x.y.z ... as (...(((x).y).z)...)

6.  How would you rate support for the JavaCC tools.  Please compare it
    with other tools - both free tools and those that come with formal
    support.  At least provide a number from 0(horrible) to 10(the
    greatest) and then preferably write something also.

	8

mailing list seems responsive

The following responses are to an older questionnaire and contain answers to the following three questions:

• What are your opinions of JavaCC and the other associated tools (JJTree and JJDoc)?

• Have you used other similar tools such as PCCTS, Yacc, etc.? How would you compare JavaCC with these tools?

• How would you classify your use of JavaCC?

We have taken the liberty of replacing occurrences of the old name with the new name of the tool.

Date: Sat, 25 Jan 1997 01:05:54 -0500 (EST)
From: pnfisher@pams.ncsu.edu

JavaCC is the coolest compiler-compiler that I've seen in years.
It's off to a great start and should be seriously considered
by any developer that's in need of this type of tool.  It's
easily capable of supporting the features necessary for a
very large and complex project.  JavaCC's input notation is a
breeze to use -- extremely logical, and much easier to use
than lex and yacc.

I've used flex and bison by the GNU Project.  JavaCC is much easier
to use than flex and bison for a full compiler-compiler where both
a grammar and lexer are necessary.  The interaction of the two
under JavaCC is the best that I've seen.  The only real work that
JavaCC needs is on its lexer, as it doesn't quite have the power of
flex as of yet, but I'm sure that in time, JavaCC will gain 
equivalent features.

[I use JavaCC for] Serious product development.

Date: Fri, 17 Jan 1997 19:12:22 -0500
From: kimbo@highway1.com (Kimbo Mundy)

JavaCC is fantastic.  It is more powerful *and* easy to use.  I love it!

I have used yacc and lex.  The way JavaCC handles grammars is so much more
straightforward than LALR(1) parsers.  The only downside is that the
parsers are not as fast.

I am the founder of a small Internet commerce startup.  The company was
founded to build a single commercial application.  The parser I am
writing with JavaCC is a critical component of our system.  Using JavaCC
will let us ship our first product weeks earlier than we could have
otherwise.  So it is fair to say that JavaCC is critical to our company's
success.

Date: Wed, 22 Jan 1997 16:08:42 -0400
From: Jim_Kimble@baan.com

JavaCC is as easy to use as Java, which makes it extremely
powerful because it's actually approachable by someone who has even
a modest command of Java programming -- the ability to recite from
memory hundreds of pages of Aho's seminal works isn't a pre-req for
using JavaCC (unlike lex/yacc).  JavaCC is extremely intuitive (just like
Java) and that makes for great synergy;  I've indirectly become a better
Java programmer while using JavaCC, and that's indirectly made me a better
JavaCC user... That kind of tight integration hasn't been seen since the
1970's releases of UNIX and C (both are elegant in their own rights but
together they're more than the sum of their parts, so to say).

JavaCC is much more useable, readable and tolerable [than other
tools].  I've used Lex in real-life programming to parse input streams
of unknown (human) origin, but not as often as I could have.  JavaCC
is so "friendly" that I use it routinely for tasks that are equally
well-suited for JavaCC, Lex/Yacc, etc. (for example, parsing a user's
config files or writing a home-grown scripting "language").

I stay involved for fun and person edification, but I've used JavaCC on
several occasions to do meat-and-potatoes kinds of hard-code lexing and/or
parsing.  Except for the fact that I needed to add a new entry
to the default rules' ".SUFFIX:" tag in our project-wide Makefile rules,
using JavaCC fits seemlessly in our development environment.

Date: Fri, 17 Jan 1997 20:19:16 -0600 (CST)
From: "Thomas H. Moog" (tmoog@mcs.net)

Conceptually clean, maintained, robust.  Haven't used JJTree.

Hate yacc.  Use pccts quite a bit, but it suffers from lack
of attention by the developer.

[I use JavaCC for] Serious development.

Date: Tue, 21 Jan 97 08:47:13 -0800
From: "David Wagner" (David.A.Wagner@jpl.nasa.gov)

JavaCC: Very easy to use, even with the very incomplete documentation
provided.  (Not to say that more documentation and examples aren't
needed, though).  Good points:

* error messages that suggest likely fixes

* combined lexer/parser generation

* use of regular expressions to express lexical and syntactic patterns.

Weak points:

* still needs a good generalized error handling mechanism instead of
  printing messages to System.out.

I haven't used JJTree.

I've used yacc quite a bit, with C and C++, and this is definitely
much better.  Part of that is just that JavaCC and Java are much
better integrated than C or C++ and Yacc.  JavaCC/Java makes it
somewhat easier to write a parser in the first place, because you
don't have to think about all of the gotcha's in Yacc (particularly
memory leaks).  With JavaCC/Java you also needn't write a separate
lexer.

[I use JavaCC for] Prototype product development.

Date: Fri, 17 Jan 1997 23:41:50 -0600
From: "Bob Horvath" (elvis@graceland.com)

JavaCC is very easy to use and is becoming more and more powerful 
with each release. My biggest complaint at this point is a lack of 
error handling which I understand is in an upcoming release.

I recently wrote a compiler using the flex and bison (GNU lex and
yacc imitations), and find JavaCC a lot easier to use.  Having the
lexer and parser in the same file makes it a lot easier to maintain.

I have not tried PCCTS, but the being able to express grammars
without left recursion is much more intuitive way of building a
parser. The compiler project I wrote in lex and yacc contained a lot
of lists of items, and there was a lot of left recursion.

Being able to pass objects up and down the parser is very
powerful. Using yacc, I could only pass pointers to structs - not 
even typedefs that were pointers to structs to pass up (couldn't pass 
anything down) anything of any complexity.  

The Token objects give you line and column information which is
something that I had to create myself using lex and yacc. 

I currently am using JavaCC on a project which I hope to 
turn into a product someday.

Date: Thu, 23 Jan 1997 15:52:44 +0100
From: Jonas Kvarnstrom (jonkv@lysator.liu.se)

I have only used JavaCC itself (not JJTree or any other tool).  I think
it is an excellent tool -- currently its documentation seems a bit out
of date and is not very "organized", but apart from that, it is very
useful.  I especially like the fact that it is an LL(k)-parser and not
an LR(1) parser; I used an LR(1) parser before and it seemed impossible
to get any reasonable error messages from it.  With JavaCC, at least I get
some kind of message telling me what the parser expected.

I have written my own grammar using Java_CUP.  Compared to that tool,
JavaCC grammars seem "cleaner" and definitely more powerful.  Even
disregarding the fact that Java_CUP is bottom-up and JavaCC is top-down,
Java_CUP forces you to declare tokens before you define them and has no
lexer generator.  All terminal tokens have to be declared and given
names (you can't simply use a quoted string such as "+" in the
grammar).  
It can only generate grammars with a given start symbol; in my JavaCC
version of the grammar, I use multiple start symbols -- one when I want
to parse a complete file, one when I want to parse a single statement
that a user enters, and so on.

I am developing a tool for a logic for reasoning for action and change
(within the Artificial Intelligence area).  I need to parse scenario
descriptions; the grammar is currently about 2000 lines including
actions.  I guess you could call it "serious product development" in the
sense that I am developing a system that we are using in our work and
research, but it is not a *commercial* product.

Date: Wed, 22 Jan 1997 15:20:02 -0800
From: Michael Van De Vanter (mlvdv@springboard)

I use only the lexical analysis part of JavaCC, but I push that hard.  I 
can say that it is a very flexible and robust tool, very well suited 
for the kind of work I'm doing.

JavaCC compares very favorably with lex, the other tool I've used to do 
similar work.

I use JavaCC for an experimental, nonstandard application

Date: Wed, 22 Jan 1997 18:28:59 -0500
From: Michael Keirnan (mgk@atg.com)

I'm very happy with JavaCC, thank you! It is easier for a non
"lanaguage guy" like myself to hack together a reliable parser using
JavaCC than lex+yacc.  Plus of course, since everything we do here is
Java all the Java benefits apply.

Yes, I've used yacc. I find JavaCC easier and more flexible to use
than yacc + lex.  However getting used to the JavaCC world was a
little difficult and required a dive-in and scratch your head
approach.

[I use JavaCC for] for serious product development and consulting
projects 

Date: Wed, 29 Jan 1997 14:13:35 -0500
From: "Kurt W Guenther" (Kurt.W.Guenther@MCI.Com)

JavaCC is very good.  I've only used lex/yacc in the past, so I found
JavaCC very easy to manipulate and use.  The resultant source code
executes faster then I would expect.

Once I got into it, I found JavaCC much easier to use.  One of our
applications uses 2 different parsers, so we were able to use to
separate parse classes for this.  (If I was using lex/yacc, I think I
would have to put one or both parsers into a shared object to avoid name
space collisions.

[I use JavaCC for] Serious product development.  I'm using JavaCC to
parse 800 routing data that doesn't qualify as a context free grammer.
I used JavaCC to lex and parse tokens into a parse "diagram" (ie, not
really a tree) that is (yet another) state machine to use context data
to transform the parse diagram to an object diagram.  The object
diagram is then presented to the user via an RMI interface.  A
previous C++ effort wrote a parser by hand, and I was able to write
the same in Java using JavaCC in a quarter the time.

Date: Mon, 20 Jan 1997 10:27:03 -0500
From: Joe Hutchinson (sasjeh@unx.sas.com)

JavaCC is a very useful and flexible tool, and its use has accelerated
my project development considerably

I have only a fleeting experience with PCCTS, and JavaCC seems to be
fairly comparable, only without some of the bells and whistles such as
automatic node creation and symbol table management. However, the ease
of programming these things yourself using java make those extras
unnecessary in my opinion.

[I use JavaCC for] serious product development

Date: Fri, 17 Jan 1997 17:07:40 -0600 (CST)
From: chenq@chistech.com (QiFan Chen)

Very handy for Java based development.

[Have used] Yacc, byacc, lex and flex. The size of the generated java
code [from JavaCC] concerns us a little bit (the size of the
TokenManager in parcular).

[I use JavaCC for] serious product development

Date: Fri, 17 Jan 1997 15:08:00 -0800
From: Mike Lehman (mgl@cereus7.com)

Very nice.  My only wish is that you make it easier to handle
line oriented languages by (1) providing a mechanism to detect
line transitions and continuations and (2) causing parsing to
stop at the end of the line.  Also, I would like to take the
error message output and be able to override it so that I could
route it to somewhere other than System.out.  Otherwise, It's great.
It came along at just the right time for our project and has saved
probably 80 - 100 hours in the past two months!

I've used a variety of other tools, though mostly older than Yacc.
I like the ability to have JAVACODE but I wish I could code
a real, boolean-returning, non-terminal in Java.

[I use JavaCC for] Definately serious product development

Date: Fri, 17 Jan 1997 15:25:04 -0800
From: Jeffrey Lichtman (swazoo@cloudscape.com)

This is a very useful tool.  Without it, I would have a hard time
completing my project.  It has a lot of useful features - the lexical
states feature will make certain things much easier by allowing the
grammar to do more validation without having to reserve as many
keywords for the entire language.

I believe JavaCC needs better documentation with more examples.
Features like look-ahead should show examples of how to use it in
specific cases.

I have used Yacc, and evaluated Java Cup (a Java-based parser
generator similar to Yacc).  JavaCC is far superior to both, partly
because it has more features, and partly because it generates a
top-down parser (bottom-up parsers are non-intuitive and have poor
error reporting).  JavaCC's error reporting on grammar ambiguities is
very good - it tells the user how to change the grammar to solve the
problem.

[I use JavaCC for] Serious product development

Date: Fri, 17 Jan 1997 15:31:21 -0800
From: Juei Chang (jueic@ix.netcom.com)

It's a very good tool.

JavaCC has a cleaner syntax and is less complicated than PCCTS.

[I use JavaCC for] serious product development

Date: Fri, 17 Jan 1997 14:48:14 -0800
From: rajgopal@raja (Narayan Rajgopal)

Very useful tool. Well designed and fairly intuitive to use. 

Much cleaner design evolves than from using JavaCC. YACC being bottom
up, YACC actions tend to manipulate global state. 
Waiting for lexical actions to work in JavaCC.

[I use JavaCC for] serious product development

Date: Fri, 17 Jan 1997 14:45:22 -0800 (PST)
From: Walter Korman (wkorman@cs.ucsd.edu)

Extremely useful.  Their reliance on Java for execution and code
generation is critically important for the project I'm working on, and
so JavaCC is perfect for my use.

I've used Yacc, and found that it helped a great deal in understanding
the (admittedly slightly outdated) documentation accompanying JavaCC.
At the same time, however, it would be nice if JavaCC's grammar
specification looked more like the format Yacc uses, as most people
are very familiar with Yacc already.  I did see a comment made
somewhere in one of the documentation files re: the possibility of
JavaCC being able to use Yacc-like formats in the future.  I think
this would be a very worthwhile endeavor.

[I use JavaCC for] Serious graduate Computer Science research project

Date: Fri, 17 Jan 1997 16:39:36 -0800 (PST)
From: "J. Jorr" (jelle@ns.net)

Sure beats writing parsers by hand. And since java is the language du 
jour, it's a no-brainer.

I've used yacc, bison, flex and I've started reading PCCTS.

[I use JavaCC for] serious product development, something like 'Cold
Fusion' but with business specific extensions integretated with Sun's
Jeeves.

Date: Sat, 18 Jan 1997 17:22:48 -0330 (NST)
From: Muthu Muthuraman (muthu@cs.mun.ca)

Great tool!

Using it my for Masters program research work. Find it very
useful. But needs *MORE* documents and help files.

Date: Sun, 19 Jan 1997 21:24:01 -0500
From: "Patrick D. Hunt" (phunt@corvid.com)

A great parser generator.

I have used PCCTS and Lex/Yacc, Bison/Flex

JavaCC is definitly better than Lex/Yacc and Bison/Flex but is still
missing some of the functionality available in PCCTS (but JavaCC is
still an excellent tool).

[I use JavaCC for] serious product development

Date: Mon, 20 Jan 1997 14:38:06 +0100
From: Christophe Roux (ch_roux@worldnet.fr)

JavaCC is a good product. I don't need other tools such as JJTree

comparison with JavaCup/JavaLex : JavaCC is faster and able to stand
with large files and easier to fit with semantic ambiguities

[I use JavaCC for] serious product development

Date: Wed, 22 Jan 1997 15:56:51 -0700 (MST)
From: Martin Shumway (shumwaym@CS.ColoState.EDU)

A good first crack at the job.  Rather complex options, though,
I find it rather difficult to understand everything.  Is there 
anything that can be done to simplify use of the tool by providing
a user interface?  Or would this be little more than semantic sugar?
For instance, some options are incompatible, others tend to be used
together; a UI might make it easier to visualize what you are doing.

Another suggestion is that the generated java codes should be formatted
in some canonical way (beautified).  
Like it or not, one has to read and possibly
modify them by hand, and it's hard to do when the text is incoherent.

lex and yacc are easier.

[I use JavaCC for] university research in software engineering

Date: Thu, 23 Jan 1997 10:53:14 +1100
From: Oliver Burn (oliverb@lucent.com)

great, useful, maturing

JavaCC is far easier to use the Yacc

[I use JavaCC for] for internal company use

Date: Wed, 22 Jan 1997 18:55:03 -0700 (MST)
From: Tony Gee (tgee@gpu.srv.ualberta.ca)

JavaCC is powerful, useful, and cool to use.

Date: Mon, 27 Jan 1997 09:14:11 +1100
From: Doug South (dsouth@squirrel.com.au)

Before I found JavaCC, I searched the Net for parser generates in Java. I
found CUP (Construction of Useful Parsers) and Jax. Both of which were
ok, but insufficient for what I was looking to do. Then I found JavaCC.
JavaCC is by far the superior Java parser generator.

JavaCC is my first serious encounter with a parser generator.

[I use JavaCC for] As a hobby, but looking to produce product from my hobby