javasourcemininodecodevisitor.java

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

       generate ( pad ( ) + "  ",
         nameSequenceMiniNode.getNameMiniNodeList ( ),
         " = Integer.parseInt ( new java.io.BufferedReader ("
         + System.getProperty ( "line.separator" )
         + pad ( ) + "    "
         + "new java.io.InputStreamReader ( System.in ) ).readLine ( ) );"
         + System.getProperty ( "line.separator" ),
         null );

       out.println ( pad ( ) + "}" );
       out.println ( pad ( ) + "catch ( java.io.IOException  ex )" );
       out.println ( pad ( ) + "{" );
       out.println ( pad ( )
         + "  throw new RuntimeException ( \"input error\" );" );
       out.println ( pad ( ) + "}" );
     }

     public void  generateIntegerDeclaration ( MiniNode  miniNode )
     //////////////////////////////////////////////////////////////////////
     {
       IntegerDeclarationMiniNode  integerDeclarationMiniNode
         = ( IntegerDeclarationMiniNode ) miniNode;

       out.print ( "int  " );

       integerDeclarationMiniNode.getNameSequenceMiniNode ( ).generate (
         this );

       out.println ( ";" );
     }

     public void  generateName ( MiniNode  miniNode )
     //////////////////////////////////////////////////////////////////////
     {
       NameMiniNode  nameMiniNode = ( NameMiniNode ) miniNode;

       out.print ( nameMiniNode.getName ( ) );
     }

     public void  generateNameSequence ( MiniNode  miniNode )
     //////////////////////////////////////////////////////////////////////
     {
       NameSequenceMiniNode  nameSequenceMiniNode
         = ( NameSequenceMiniNode ) miniNode;

       generate ( null, nameSequenceMiniNode.getNameMiniNodeList ( ),
         null, ", " );
     }

     public void  generateOperator ( MiniNode  miniNode )
     //////////////////////////////////////////////////////////////////////
     {
       OperatorMiniNode  operatorMiniNode = ( OperatorMiniNode ) miniNode;

       String  s = null;

       switch ( operatorMiniNode.getOperator ( ) )
       {
         case MiniSymbols.DIVIDE:  s = "/"; break;
         case MiniSymbols.MINUS :  s = "-"; break;
         case MiniSymbols.PLUS  :  s = "+"; break;
         case MiniSymbols.TIMES :  s = "*"; break;

         default:
           throw new RuntimeException ( "unknown operator" );
       }

       out.print ( s );
     }

     public void  generateOutputStatement ( MiniNode  miniNode )
     //////////////////////////////////////////////////////////////////////
     {
       OutputStatementMiniNode  outputStatementMiniNode
         = ( OutputStatementMiniNode ) miniNode;

       ExpressionSequenceMiniNode  expressionSequenceMiniNode
         = outputStatementMiniNode.getExpressionSequenceMiniNode ( );

       generate ( pad ( ) + "System.out.println ( ",
         expressionSequenceMiniNode.getExpressionMiniNodeList ( ),
         " );" + System.getProperty ( "line.separator" ),
         null );
     }

     public void  generateParameterSequence ( MiniNode  miniNode )
     //////////////////////////////////////////////////////////////////////
     {
       ParameterSequenceMiniNode  parameterSequenceMiniNode
         = ( ParameterSequenceMiniNode ) miniNode;

       NameSequenceMiniNode  nameSequenceMiniNode
         = parameterSequenceMiniNode.getNameSequenceMiniNode ( );

       List  nameMiniNodeList
         = nameSequenceMiniNode.getNameMiniNodeList ( );

       generate ( "int  ", nameMiniNodeList, null, ", " );
     }

     public void  generateProcedureCallStatement ( MiniNode  miniNode )
     //////////////////////////////////////////////////////////////////////
     {
       ProcedureCallStatementMiniNode  procedureCallStatementMiniNode
         = ( ProcedureCallStatementMiniNode ) miniNode;

       NameMiniNode  nameMiniNode
         = procedureCallStatementMiniNode.getNameMiniNode ( );

       indent ( );

       if ( procedureCallStatementMiniNode.callsNested (
         ).booleanValue ( ) )
       {
         out.print ( "new " );

         nameMiniNode.generate ( this );

         out.print ( " ( ).procedure (" );

       }
       else
       {
         nameMiniNode.generate ( this );
         out.print ( " (" );
       }

       ExpressionSequenceMiniNode  expressionSequenceMiniNode
         = procedureCallStatementMiniNode.getExpressionSequenceMiniNode (
         );

       if ( expressionSequenceMiniNode != null )
       {
         out.print ( " " );

         expressionSequenceMiniNode.generate ( this );
       }

       out.println ( " );" );
     }

     public void  generateProcedureDeclaration ( MiniNode  miniNode )
     //////////////////////////////////////////////////////////////////////
     {
       ProcedureDeclarationMiniNode  procedureDeclarationMiniNode
         = ( ProcedureDeclarationMiniNode ) miniNode;

       NameMiniNode  nameMiniNode
         = procedureDeclarationMiniNode.getNameMiniNode ( );

       BlockMiniNode  blockMiniNode
         = procedureDeclarationMiniNode.getBlockMiniNode ( );

       DeclarationSequenceMiniNode  declarationSequenceMiniNode
         = blockMiniNode.getDeclarationSequenceMiniNode ( );

       boolean  hasNestedProcedures = false;

       if ( declarationSequenceMiniNode != null )
       {
         List  declarationMiniNodeList
           = declarationSequenceMiniNode.getDeclarationMiniNodeList ( );

         Iterator  i = declarationMiniNodeList.iterator ( );
         while ( i.hasNext ( ) )
         {
           if ( i.next ( ) instanceof ProcedureDeclarationMiniNode )
           {
             hasNestedProcedures = true;
             break;
           }
         }
       }

       out.println ( "" );

       if ( !hasNestedProcedures )
       {
         out.print ( margin + "public void  " );
         nameMiniNode.generate ( this );
         out.print ( " (" );

         ParameterSequenceMiniNode  parameterSequenceMiniNode
           = procedureDeclarationMiniNode.getParameterSequenceMiniNode ( );

         if ( parameterSequenceMiniNode != null )
         {
           out.print ( " " );
           parameterSequenceMiniNode.generate ( this );
         }

         out.println ( " )" );

         out.println ( margin + demarkLine );

         out.println ( margin + "{" );

         depth++;

         blockMiniNode.generate ( this );

         depth--;

         out.println ( margin + "}" );

         out.println ( "" );
       }
       else
       {
         out.print ( margin + "public class  " );
         nameMiniNode.generate ( this );
         out.println ( "" );

         out.println ( margin + demarkLine );
         out.print ( margin + "// Start of inner class " );
         nameMiniNode.generate ( this );
         out.println ( "" );
         out.println ( margin + demarkLine );
         out.println ( margin + "{" );

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

         out.println ( "" );

         out.print ( margin + "public void  procedure (" );

         ParameterSequenceMiniNode  parameterSequenceMiniNode
           = procedureDeclarationMiniNode.getParameterSequenceMiniNode ( );

         if ( parameterSequenceMiniNode != null )
         {
           out.print ( " " );
           parameterSequenceMiniNode.generate ( this );
         }

         out.println ( " )" );

         out.println ( margin + demarkLine );

         out.println ( margin + "{" );

         depth++;

         blockMiniNode.getStatementSequenceMiniNode ( ).generate ( this );

         depth--;

         out.println ( margin + "}" );

         out.println ( "" );

         out.println ( margin + demarkLine );
         out.print ( margin + "// End of inner class " );
         nameMiniNode.generate ( this );
         out.println ( "" );
         out.println ( margin + demarkLine );
         out.println ( margin + "}" );
         out.println ( "" );
       }
     }

     public void  generateProgram ( MiniNode  miniNode )
     //////////////////////////////////////////////////////////////////////
     {
       ProgramMiniNode  programMiniNode = ( ProgramMiniNode ) miniNode;

       out.println ( margin + "public class  " + className );
       out.println ( margin + demarkLine );
       out.println ( margin + "// Start of " + className );
       out.println ( margin + demarkLine );
       out.println ( margin + "{" );

       BlockMiniNode  blockMiniNode = programMiniNode.getBlockMiniNode ( );

       DeclarationSequenceMiniNode  declarationSequenceMiniNode
         = blockMiniNode.getDeclarationSequenceMiniNode ( );

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

       out.println ( "" );
       out.println ( margin + "public void  procedure ( )" );

       out.println ( margin + demarkLine );

       out.println ( margin + "{" );

       depth++;

       blockMiniNode.getStatementSequenceMiniNode ( ).generate ( this );

       depth--;

       out.println ( margin + "}" );

       out.println ( "" );
       out.println (
         margin + "public static void  main ( String [ ]  args )" );
       out.println ( margin + demarkLine );
       out.println ( margin + "{" );
       out.println (
         margin + "  new " + className + " ( ).procedure ( );" );
       out.println ( margin + "}" );
       out.println ( "" );
       
       out.println ( margin + demarkLine );
       out.println ( margin + "// End of " + className );
       out.println ( margin + demarkLine );
       out.println ( margin + "}" );
     }

     public void  generateRelation ( MiniNode  miniNode )
     //////////////////////////////////////////////////////////////////////
     {
       RelationMiniNode  relationMiniNode = ( RelationMiniNode ) miniNode;

       String  s = null;

       switch ( relationMiniNode.getRelation ( ) )
       {
         case MiniSymbols.EQ:  s = "=="; break;
         case MiniSymbols.LE:  s = "<="; break;
         case MiniSymbols.LT:  s = "<" ; break;
         case MiniSymbols.GT:  s = ">" ; break;
         case MiniSymbols.GE:  s = ">="; break;
         case MiniSymbols.NE:  s = "!="; break;

         default:
           throw new RuntimeException ( "unknown relation" );
       }

       out.print ( s );
     }

     public void  generateStatementSequence ( MiniNode  miniNode )
     //////////////////////////////////////////////////////////////////////
     {
       StatementSequenceMiniNode  statementSequenceMiniNode
         = ( StatementSequenceMiniNode ) miniNode;

       generate ( null,
         statementSequenceMiniNode.getStatementMiniNodeList ( ),
         null, System.getProperty ( "line.separator" ) );
     }

     public void  generateTerm ( MiniNode  miniNode )
     //////////////////////////////////////////////////////////////////////
     {
       TermMiniNode  termMiniNode = ( TermMiniNode ) miniNode;

       MiniNode  term = termMiniNode.getTermMiniNode ( );

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

         out.print ( " " );

         termMiniNode.getOperatorMiniNode ( ).generate ( this );

         out.print ( " " );
       }

       termMiniNode.getElementMiniNode ( ).generate ( this );
     }

     //////////////////////////////////////////////////////////////////////
     //////////////////////////////////////////////////////////////////////
     }