////////////////////////////////////////////////////////////////////////////////
   // MillScript: an Open Spice interpreter and batch website creation tool
   // Copyright (C) 2001-2004 Open World Ltd
   //
   // This file is part of MillScript.
   //
   // MillScript is free software; you can redistribute it and/or modify it under
   // the terms of the GNU General Public License as published by the Free
   // Software Foundation; either version 2 of the License, or (at your option)
  // any later version.
  //
  // MillScript is distributed in the hope that it will be useful, but WITHOUT
  // ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  // FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  // more details.
  //
  // You should have received a copy of the GNU General Public License along with
  // MillScript; if not, write to the Free Software Foundation, Inc., 59 Temple
  // Place, Suite 330, Boston, MA  02111-1307  USA
  ////////////////////////////////////////////////////////////////////////////////
  package org.millscript.millscript.expr;
  
  import org.millscript.commons.util.IList;
  import org.millscript.millscript.action.Action;
  import org.millscript.millscript.action.ForAction;
  import org.millscript.millscript.action.ForConditionAction;
  import org.millscript.millscript.vm.CompilerState;
  
  import java.util.Stack;
  
  /**
   * This class represents a For loop expression. A for loop expression may
   * contain multiple condition/binding expressions, a single body expression and
   * a single termination expression.
   *
   * @see org.millscript.millscript.syntax.ForSyntax
   * @see ForAction
   */
  public final class ForExpr extends Expr< ForAction > {
  
      /**
       * This list holds the conditions and bindings that control this for loops
       * iteration.
       */
      private final IList< ForConditionExpr > bindings;
  
      /**
       * The for loops body expression. This will be executed on each iteration of
       * the for loop.
       */
      private final Expr< ? > body;
  
      /**
       * The for loops termination expression. This will be executed when the for
       * loop terminates, unless one of the other conditions has an override.
       */
      private final Expr< ? > terminateExpr;
  
      /**
       * Construct a new For Expression with the supplied conditions/bindings,
       * body and normal termination expression.
       *
       * @param   a   list of conditions and bindings
       * @param   b   body Expr
       * @param   t   normal termination Expr
       */
      public ForExpr( final IList< ForConditionExpr > a, final Expr< ? > b, final Expr< ? > t ) {
          bindings = a;
          body = b;
          terminateExpr = t;
      }
  
      /**
       * {@inheritDoc}
       *
       * <p>
       * If the for loop body has an arity of zero, the for loops arity is zero,
       * otherwise the for loop arity is unknown. The for loop arity would depend
       * on the number of iterations, etc.
       * </p>
       */
      @Override
      public int arity() {
          return body.arity() == 0 ? 0 : -1;
      }
  
      /**
       * @see org.millscript.millscript.expr.Expr#compileIt()
       */
      @Override
      public ForAction compileIt() {
  
          // we compile the termination expression once...
          final Action finalAct = terminateExpr.compile();
  
          // ... and then compile each condition/binding, passing each one the
          // same compiled termination expression
          ForConditionAction[] fa = new ForConditionAction[ this.bindings.size() ];
          for ( int i = 0; i < this.bindings.size(); i++ ) {
             ForConditionExpr< ? > b = this.bindings.get0( i );
             fa[ i ] = b.compile();
             fa[ i ].setFinallyAction( finalAct );
         }
         return new ForAction( fa, body.compile() );
     }
 
     /**
      * @see org.millscript.millscript.expr.Expr#resolve(org.millscript.millscript.vm.CompilerState)
      *
      * <p>
      * In a for expression, the renaming process is slightly more compilcated
      * than usual. The renaming uses the following sequence:
      * <ol>
      * <li>binding expressions children are pushed onto the stack</li>
      * <li>binding expressions are renamed</li>
      * <li>the termination expression is renamed</li>
      * <li>a new scope is declared
      *   <ol>
      *   <li>any bound variables are pushed onto the stack</li>
      *   <li>remaining for conditions are renamed</li>
      *   <li>for loop body is renamed</li>
      *   </ol>
      * </li>
      * </ol>
      * Which ensures that the relevant bindings are available within the
      * condition and body expression.
      * </p>
      */
     @Override
     public void resolve( final CompilerState state ) {
         // Rename the expressions in the bindings
         // e.g <name> in <expr>, we are renaming the <expr>
         // NOTE - This phase only renames the binding expressions, not the
         //        condition expressions, such as while, until or where.
         for ( int i = 1; i <= this.bindings.size(); i++ ) {
             ForConditionExpr e = this.bindings.get( i );
             if ( e instanceof BindingExpr ) {
                 e.resolve( state );
             }
         }
 
         // Rename the termination expression
         // This expression cannot refer to loop bindings, what would their value
         // be when the loop exits or if the loop never executes at all.
         // NOTE - This caused problems when first done as on refering to a loop
         //        variable in the termination expression, it returned null.
         terminateExpr.resolve( state );
 
         // Now declare the loop variables and rename the body
         // e.g. <name> in <expr>, we are declaring the <name> as a local
         // variable
         Stack< Expr > scopes = state.getScopes();
         int n = scopes.size();
         for ( int i = 1; i <= this.bindings.size(); i++ ) {
             ForConditionExpr< ? > e = this.bindings.get( i );
             if ( e instanceof BindingExpr ) {
                 ((BindingExpr< ? >) e).pushNames( scopes );
             }
         }
         state.declareLocalsFrom( n );
 
         // Now that we have declared the loop variables, we can safely rename
         // the for conditions, e.g. while <expr> else <expr>, as these may
         // refer back to loop variables
         for ( int i = 1; i <= this.bindings.size(); i++ ) {
             ForConditionExpr e = this.bindings.get( i );
             if ( !( e instanceof BindingExpr ) ) {
                 // Rename the ForConditions now that the local variables
                 // have been declared.
                 e.resolve( state );
             }
         }
 
         // Rename the body expression
         body.resolve( state );
         scopes.setSize( n );
     }
 
     /**
      * @see org.millscript.millscript.expr.Expr#showComponents(int)
      */
     @Override
     void showComponents( final int n ) {
         for ( int i = 1; i <= this.bindings.size(); i++ ) {
             ForConditionExpr e = this.bindings.get( i );
             e.show( n );
         }
         this.body.show( n );
         this.terminateExpr.show( n );
     }
 
 }