These are the changes made to JavaCC's Java1.1.jj example grammar.

An annotation [x.y.z] means the change first appeared in the grammar
distributed with version x.y.z of JavaCC.  No annotation means the
change appeared with the first grammar used, that from JavaCC 0.6.1.



		Finding References
		------------------

These changes are made to extract the symbols referenced and defined.

* Name
  - the rule returns String value of name matched
  - when this rule is used, it may be a def or ref (all occurences of
    Name() must be checked, as they may not be listed below)

* NameList
  - returns Vector of Strings

* PackageDeclaration
  - package name passed to deps

* ImportDeclaration
  - import list passed to deps

* ClassDeclaration
  - added parameter "true" to UnmodifiedClassDeclaration rule invocation

* UnmodifiedClassDeclaration
  - takes a boolean parameter "isToplevel"; if true, it means the
    declaration is done at "top level", and hence should be processed:
    currently, no inner classes (or methods) get processed
  - if declaration is processed, the following happens:
    - class name used to start a new definition
    - "extends" class, if present, added as reference
    - list of "implements" interfaces added as references

* NestedClassDeclaration
  - added parameter "false" to UnmodifiedClassDeclaration rule
    invocation

* InterfaceDeclaration
  - added parameter "true" to UnmodifiedInterfaceDeclaration rule invocation

* NestedInterfaceDeclaration
  - added parameter "false" to UnmodifiedInterfaceDeclaration rule invocation

* UnmodifiedInterfaceDeclaration
  - takes "isToplevel" parameter as in UnmodifiedClassDeclaration
  - if top level, start new definition; add "extends" list as references

* MethodDeclaration
  - added call to deps.hasNative() for methods marked "native", to
    indicate the class has native methods
  - any listed "throws" are added as references

* ConstructorDeclaration
  - listed "throws" are added as references

* Type
  - named type added as reference

* PrimaryPrefix [0.7]
  - if a name appears, it is a qualified variable or method reference;
    we add a reference to the name, with last component stripped off
  - the grammar is cleaned up so that none of the other nonsense added
    for 0.6.1 is needed for class literals; these are caught by the
    ResultType() "." "class" alternative, which invokes Type (hence Name)

* PrimaryExpression [0.6.1]
  - adds reference in certain cases:
    - the prefix (from PrimaryPrefix) is saved
    - the first suffix is checked to see if we need to strip off the
      last component of the prefix (value of first PrimarySuffix is saved)
    - if prefix is not null, add reference, possibly stripping it
  - see the justification of this in the PrimarySuffix rule

* PrimaryPrefix [0.6.1]
  - returns String
  - value is null unless the Name rule invoked

* PrimarySuffix [0.6.1]
  - returns boolean
  - value is true unless suffix is ".class"
  - the logic behind this is: 
    - in most cases when PrimaryExpression encounters a symbol name,
      it will be a qualified reference to a variable or method call; 
      in this case, we want to strip off the variable/method name, 
      to obtain the class name being referenced
    - in the case of a "class literal" (i.e. java.lang.String.class),
      the prefix is just "java.lang.String", and ".class" is matched
      in the suffix rule; hence we don't want to strip the last
      component of the prefix

* AllocationExpression
  - reference added if a named type is being constructed

* BlockStatement
  - add "false" to UnmodifiedClassDeclaration rule invocation
  - ditto for UnmodifiedInterfaceDeclaration rule [0.7]


		Language Changes
		----------------

These are changes to make the language accepted closer to what Sun's
JDK accepts.

* TypeDeclaration, ClassDeclaration
  - allow "synchronized class" (stupid, but allowed by JDK 1.1 compiler)

* ClassBodyDeclaration
  - added semicolon alternative, to allow semicolon after a class
    declaration (accepted by JDK compilers, but not allowed in
    language spec!)

* PrimarySuffix [0.6.1 only]
  - alternative "[" Expression() "]" changed to make the expression
    optional
  - this is a real bug in the grammar, fixed in 0.7

* ArrayDimensions [0.6.1 only]
  - make expression optional, as in PrimarySuffix
  - this obviates the trailing ( "[" "]" )* part of the rule
  - part of same bug as PrimarySuffix
