javasourcemininodecodevisitor.java

CroftSoft Code Library是一个开源的可移植的纯Java游戏库

     package com.croftsoft.apps.compiler.mini.code;

     import java.io.PrintStream;
     import java.util.*;

     import com.croftsoft.apps.compiler.mini.node.*;
     import com.croftsoft.apps.compiler.mini.parse.MiniSymbols;

     /*********************************************************************
     * Generates Java source code from MiniNode objects.
     *
     * @see
     *   com.croftsoft.apps.compiler.mini.node.MiniNodeCodeVisitor
     *
     * @author
     *   <A HREF="http://www.alumni.caltech.edu/~croft/">David W. Croft</A>
     * @version
     *   1999-04-27
     *********************************************************************/

     public class  JavaSourceMiniNodeCodeVisitor
       implements MiniNodeCodeVisitor, MiniSymbols
     //////////////////////////////////////////////////////////////////////
     //////////////////////////////////////////////////////////////////////
     {

     protected PrintStream  out;
     protected String       className;

     protected int          depth;
     protected int          nextTemp;

     protected String  margin = "     ";
     protected String  demarkLine
       = "///////////////////////////////////"
       + "///////////////////////////////////";

     //////////////////////////////////////////////////////////////////////
     //////////////////////////////////////////////////////////////////////

     public  JavaSourceMiniNodeCodeVisitor (
       PrintStream  out,
       String       className )
     //////////////////////////////////////////////////////////////////////
     {
       this.out       = out;
       this.className = className;
     }

     //////////////////////////////////////////////////////////////////////
     //////////////////////////////////////////////////////////////////////

     public int  nextTemp ( )
     //////////////////////////////////////////////////////////////////////
     {
       return nextTemp++;
     }

     //////////////////////////////////////////////////////////////////////
     //////////////////////////////////////////////////////////////////////

     protected void  indent ( )
     //////////////////////////////////////////////////////////////////////
     {
       out.print ( pad ( ) );
     }

     protected String  pad ( )
     //////////////////////////////////////////////////////////////////////
     {
       String  s = margin;

       for ( int  i = 0; i < depth; i++ ) s += "  ";

       return s;
     }

     protected void  generate (
       String  prefix, List  miniNodeList, String  postfix,
       String  delimiter )
     //////////////////////////////////////////////////////////////////////
     {
       if ( miniNodeList == null ) return;

       Iterator  i = miniNodeList.iterator ( );

       while ( i.hasNext ( ) )
       {
         if ( prefix != null )
         {
           out.print ( prefix );
         }

         ( ( MiniNode ) i.next ( ) ).generate ( this );

         if ( postfix != null ) out.print ( postfix );

         if ( delimiter != null )
         {
           if ( i.hasNext ( ) ) out.print ( delimiter );
         }
       }
     }

     protected void  generate ( List  miniNodeList )
     //////////////////////////////////////////////////////////////////////
     {
       generate ( null, miniNodeList, null, null );
     }

     //////////////////////////////////////////////////////////////////////
     //////////////////////////////////////////////////////////////////////

     public void  generateAssignmentStatement ( MiniNode  miniNode )
     //////////////////////////////////////////////////////////////////////
     {
       AssignmentStatementMiniNode  assignmentStatementMiniNode
         = ( AssignmentStatementMiniNode ) miniNode;

       indent ( );

       assignmentStatementMiniNode.getNameMiniNode ( ).generate ( this );

       out.print ( " = " );

       assignmentStatementMiniNode.getExpressionMiniNode ( ).generate (
         this );

       out.println ( ";" );
     }

     public void  generateBlock ( MiniNode  miniNode )
     //////////////////////////////////////////////////////////////////////
     {
       BlockMiniNode  blockMiniNode = ( BlockMiniNode ) miniNode;

       DeclarationSequenceMiniNode  declarationSequenceMiniNode
         = blockMiniNode.getDeclarationSequenceMiniNode ( );

       if ( declarationSequenceMiniNode != null )
       {
         declarationSequenceMiniNode.generate ( this );
         out.println ( "" );
       }

       StatementSequenceMiniNode  statementSequenceMiniNode
         = blockMiniNode.getStatementSequenceMiniNode ( );

       if ( statementSequenceMiniNode != null )
       {
         statementSequenceMiniNode.generate ( this );
       }
     }

     public void  generateComparison ( MiniNode  miniNode )
     //////////////////////////////////////////////////////////////////////
     {
       ComparisonMiniNode  comparisonMiniNode
         = ( ComparisonMiniNode ) miniNode;

       comparisonMiniNode.getLeftExpressionMiniNode  ( ).generate ( this );

       out.print ( " " );

       comparisonMiniNode.getRelationMiniNode ( ).generate ( this );

       out.print ( " " );

       comparisonMiniNode.getRightExpressionMiniNode ( ).generate ( this );
     }

     public void  generateConditionalStatement ( MiniNode  miniNode )
     //////////////////////////////////////////////////////////////////////
     {
       ConditionalStatementMiniNode  conditionalStatementMiniNode
         = ( ConditionalStatementMiniNode ) miniNode;

       indent ( );

       out.print ( "if ( " );

       conditionalStatementMiniNode.getComparisonMiniNode ( ).generate (
         this );

       out.println ( " )" );

       indent ( );

       out.println ( "{" );

       depth++;

       conditionalStatementMiniNode.getThenStatementSequenceMiniNode (
         ).generate ( this );

       depth--;

       indent ( );

       out.println ( "}" );

       StatementSequenceMiniNode  elseStatementSequenceMiniNode
         = conditionalStatementMiniNode.getElseStatementSequenceMiniNode (
         );

       if ( elseStatementSequenceMiniNode != null )
       {
         indent ( );

         out.println ( "else" );

         indent ( );

         out.println ( "{" );

         depth++;

         elseStatementSequenceMiniNode.generate ( this );

         depth--;

         indent ( );

         out.println ( "}" );
       }
     }

     public void  generateConstant ( MiniNode  miniNode )
     //////////////////////////////////////////////////////////////////////
     {
       ConstantMiniNode  constantMiniNode
         = ( ConstantMiniNode ) miniNode;

       out.print ( constantMiniNode.getI ( ) );
     }

     public void  generateDeclarationSequence ( MiniNode  miniNode )
     //////////////////////////////////////////////////////////////////////
     {
       DeclarationSequenceMiniNode  declarationSequenceMiniNode
         = ( DeclarationSequenceMiniNode ) miniNode;

       generate ( pad ( ),
         declarationSequenceMiniNode.getDeclarationMiniNodeList ( ),
         null, null );
     }

     public void  generateDefiniteLoopStatement ( MiniNode  miniNode )
     //////////////////////////////////////////////////////////////////////
     {
       DefiniteLoopStatementMiniNode  definiteLoopStatementMiniNode
         = ( DefiniteLoopStatementMiniNode ) miniNode;

       indent ( );

       // Underscores are not used in the Mini language so it is safe to
       // use them to create new variables without fear of namespace
       // conflicts.

       String  countStr = "count_" + nextTemp ( );
       String  indexStr = "index_" + nextTemp ( );

       out.print ( "int  " + countStr + " = " );

       definiteLoopStatementMiniNode.getExpressionMiniNode ( ).generate (
         this );

       out.println ( ";" );

       indent ( );

       out.println ( "for ( int  " + indexStr + " = 0; "
         + indexStr + " < " + countStr + "; " + indexStr + "++ )" );

       indent ( );

       out.println ( "{" );

       depth++;

       definiteLoopStatementMiniNode.getStatementSequenceMiniNode (
         ).generate ( this );

       depth--;

       indent ( );

       out.println ( "}" );
     }

     public void  generateExpression ( MiniNode  miniNode )
     //////////////////////////////////////////////////////////////////////
     {
       ExpressionMiniNode  expressionMiniNode
         = ( ExpressionMiniNode ) miniNode;

       MiniNode  expression = expressionMiniNode.getExpressionMiniNode ( );

       if ( expression != null )
       {
         expression.generate ( this );

         out.print ( " " );

         expressionMiniNode.getOperatorMiniNode ( ).generate ( this );

         out.print ( " " );
       }

       expressionMiniNode.getTermMiniNode ( ).generate ( this );
     }

     public void  generateExpressionElement ( MiniNode  miniNode )
     //////////////////////////////////////////////////////////////////////
     {
       ExpressionElementMiniNode  expressionElementMiniNode
         = ( ExpressionElementMiniNode ) miniNode;

       out.print ( "( " );

       expressionElementMiniNode.getExpressionMiniNode ( ).generate (
         this );

       out.print ( " )" );
     }

     public void  generateExpressionSequence ( MiniNode  miniNode )
     //////////////////////////////////////////////////////////////////////
     {
       ExpressionSequenceMiniNode  expressionSequenceMiniNode
         = ( ExpressionSequenceMiniNode ) miniNode;

       generate ( null,
         expressionSequenceMiniNode.getExpressionMiniNodeList ( ),
         null, ", " );
     }

     public void  generateIndefiniteLoopStatement ( MiniNode  miniNode )
     //////////////////////////////////////////////////////////////////////
     {
       IndefiniteLoopStatementMiniNode  indefiniteLoopStatementMiniNode
         = ( IndefiniteLoopStatementMiniNode ) miniNode;

       indent ( );

       out.print ( "while ( " );

       indefiniteLoopStatementMiniNode.getComparisonMiniNode ( ).generate (
         this );

       out.println ( " )" );

       indent ( );

       out.println ( "{" );

       depth++;

       indefiniteLoopStatementMiniNode.getStatementSequenceMiniNode (
         ).generate ( this );

       depth--;

       indent ( );

       out.println ( "}" );
     }

     public void  generateInputStatement ( MiniNode  miniNode )
     //////////////////////////////////////////////////////////////////////
     {
       InputStatementMiniNode  inputStatementMiniNode
         = ( InputStatementMiniNode ) miniNode;

       NameSequenceMiniNode  nameSequenceMiniNode
         = inputStatementMiniNode.getNameSequenceMiniNode ( );

       out.println ( pad ( ) + "try" );
       out.println ( pad ( ) + "{" );