Documentation for JTB Pre-Release Versions

This section details the new features of JTB found in versions cumulatively through 1.1pre3.

JTB 1.1pre1 adds a new option in addition to the ones described above.  The main change with this version of JTB is the addition of a syntax tree builder for the Scheme programming language.  The command-line option -scheme does two things:

1. Generates records.scm to the current directory.  This file is analgous to the syntaxtree directory in that it defines the syntax tree.  The difference is that this file contains Scheme record definitions as opposed to Java classes.
2. Generates the visitor SchemeTreeBuilder.java into the visitor directory and package.  This visitor will traverse a syntax tree and output the Scheme equivalent of the tree.  The default output location is standard output, but this can be modified by passing the constructor a Java Writer object.

1. Choices such as ( x | y ) may only occur at the top level of a production.  The choice may only be between two nonterminal symbols.  For example, ( x y | z ) would be illegal.
2. Whatever goes within a list, optional list, or optional, such as ( x )+, ( y )*, or [ z ] may only be a single nonterminal symbol.  For example, [ x y ] would be illegal.

• The special token will be stored in the in the next NodeToken that occurs in the input.  Should several special tokens appear in the input prior to a regular token, the NodeToken representing that token will contain each of those special tokens.
• The NodeToken class has been modified to accomodate this new feature.  Its new interface is as follows:

 

//***Note these methods have changed for version 1.1pre3***
public class NodeToken implements Node {
   public NodeToken(String s);
   public int numSpecials();
   public String getSpecialAt(int i);
   public void addSpecial(String s);
   public void trimSpecials();
   public String toString();
   public String withSpecials();
   public void accept(visitor.Visitor v);

   public String tokenImage;
}

• numSpecials() and getSpecialAt() are used to access the specials in the NodeToken.
• addSpecial() and trimSpecials() are used when the tree is being built.  The programmer probably won't need to use these methods.
• toString() returns the string of the regular token.
• withSpecials() works like toString(), but it preceeds the regular token with all the special tokens.  If the special tokens need special formatting, it would be best to override the visit(NodeToken) method in the visitor rather than altering this method.

• The Visitor class has been changed to an interface.  A new visitor named DepthFirstVisitor has been added to the list of files JTB generates.  It essentially duplicates functionality of the Visitor class in previous versions of JTB (i.e. it visits all the nodes of the tree in depth-first order).
• This change breaks code written for versions of JTB prior to 1.1pre3.  In order to fix it, simply replace all occurances of Visitor with DepthFirstVisitor.
• NodeTokens now store the JavaCC Token fields beginLine, endLine, beginColumn, and endColumn.
• The specialToken field now stores a Vector of NodeTokens rather than a Vector of Strings as it did in 1.1pre2.  The methods of NodeToken have been altered accordingly.
• The command-line option -jd causes JTB to generate JavaDoc-friendly comments.  For example, a comment in the Visitor class which, in previous versions, looked like this:

   //
   // f0 -> "class"
   // f1 -> <IDENTIFIER>
   // f2 -> [ "extends" Name() ]
   // f3 -> [ "implements" NameList() ]
   // f4 -> ClassBody()
   //

Looks like this in 1.1pre3 when the -jd flag is used:
   /**
    * <PRE>
    * f0 -> "class"
    * f1 -> &lt;IDENTIFIER&gt;
    * f2 -> [ "extends" Name() ]
    * f3 -> [ "implements" NameList() ]
    * f4 -> ClassBody()
    * </PRE>
    */

• The visitor TreeDumper, when used on a syntax tree, will output (to standard output or another OutputStream or Writer of your choice) the tree based on the token location variables in each NodeToken.  If you use this visitor on an unmodified syntax tree, it will print the tree out exactly as it was read in.  It contains several methods:

• Using these methods, it is possible to only print certain parts of the tree.  For example, to only print method signatures in the Java grammar,  the following annonymous class could be used:

      root.accept(new DepthFirstVisitor() {
         public void visit(MethodDeclaration n) {
            dumper.startAtNextToken();
            n.f0.accept(dumper);
            n.f1.accept(dumper);
            n.f2.accept(dumper);
            n.f3.accept(dumper);
            // skip n.f4, the method body
            System.out.println();
         }
      });

• The TreeFormatter visitor is a skeleton pretty printer template.  It contains convenience methods to modify the token location information in each NodeToken:

• For example, this is how the CompilationUnit visit() method looks in the rewritten Java pretty printer example:

   /**
    * f0 -> [ PackageDeclaration() ]
    * f1 -> ( ImportDeclaration() )*
    * f2 -> ( TypeDeclaration() )*
    * f3 -> <EOF>
    */
   public void visit(CompilationUnit n) {
      if ( n.f0.present() ) {
         n.f0.accept(this);
         add(force(2));
      }
      if ( n.f1.present() ) {
         processList(n.f1, force());
         add(force(2));
      }
      if ( n.f2.present() ) {
         processList(n.f2, force(2));
         add(force());
      }
      n.f3.accept(this);
   }

Back