////////////////////////////////////////////////////////////////////////////////
   // 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.SwitchAction;
  import org.millscript.millscript.vm.CompilerState;
  
  /**
   * This class implements a <code>switch</code> expression.
   *
   * @see org.millscript.millscript.syntax.SwitchSyntax
   * @see SwitchAction
   */
  public final class SwitchExpr extends Expr< SwitchAction > {
  
      /**
       * The expression representing our choice. This will be compared against the
       * individual case expressions to find a match.
       */
      private final Expr< ? > choice;
  
      /**
       * The list of case expressions.
       */
      private final IList< CaseExpr > cases;
  
      /**
       * The default block to execute if no cases match.
       */
      private final Expr< ? > def;
  
      /**
       * Creates a new <code>switch</code> expression for the specified choice,
       * case and default expressions.
       *
       * @param   a   the choice expression
       * @param   b   the list of case expressions
       * @param   c   the default expression
       */
      public SwitchExpr( final Expr< ? > a, final IList< CaseExpr > b, final Expr< ? > c ) {
          // The choice expression must return a single result
          this.choice = CheckExpr.make( a );
          // Set the list of cases
          this.cases = b;
          // Set the default expression. If null is specified, then set it to a
          // skip expression
          this.def = c == null ? new SkipExpr() : c;
      }
  
      /**
       * @see org.millscript.millscript.expr.Expr#arity()
       */
      @Override
      public int arity() {
          // For a <code>switch</code> expression, the arity is only known
          // exactly if the arity of each case expression body and default
          // expression are the same.
          int a = def.arity();
          for ( int i = 1; i <= this.cases.size(); i++ ) {
              final CaseExpr ce = this.cases.get( i );
              if ( ce.getAct().arity() != a ) {
                  return -1;
              }
          }
          return a;
      }
  
      /**
       * @see org.millscript.millscript.expr.Expr#compileIt()
       */
      @Override
      public SwitchAction compileIt() {
  
          // How many separate patterns are there?
          int count = 0;
          for ( int i = 1; i <= this.cases.size(); i++ ) {
              count += this.cases.get( i ).getPatterns().size();
          }
  
         // This will hold all the compiled patterns for this instances case
         // expressions
         final Action[] preds = new Action[ count ];
         // This keeps track of each compiled pattern and which case expression
         // it relates to, hence which compiled body expression
         final int[] switches = new int[ count ];
         // This will hold all the complied bodies for this instances case
         // expressions
         final Action[] acts = new Action[ cases.size() ];
         // TODO - I think having both switches and acts is overkill. Why not
         // make switches simply point to the required case action?
 
         // i counts the case expressions, k counts the patterns
         for ( int i = 0, k = 0; i < this.cases.size(); i++ ) {
             final CaseExpr ce = this.cases.get0( i );
             // Iterate over each pattern for the case expression
             for ( int p = 0; p < ce.getPatterns().size(); p++, k++ ) {
                 final Expr< ? > patn = ce.getPatterns().get0( p );
                 // Compile the pattern
                 preds[ k ] = patn.compile();
                 // Store the body expression this pattern relates to, e.g. a
                 // pointer into the acts array.
                 switches[ k ] = i;
             }
             // Compile the case expressions body
             acts[ i ] = ce.getAct().compile();
         }
         return new SwitchAction( choice.compile(), preds, switches, acts, def.compile() );
     }
 
     /**
      * @see org.millscript.millscript.expr.Expr#resolve(org.millscript.millscript.vm.CompilerState)
      */
     @Override
     public void resolve( final CompilerState state ) {
         this.choice.resolve( state );
         Expr.resolveList( state, this.cases );
         this.def.resolve( state );
     }
 
     /**
      * @see org.millscript.millscript.expr.Expr#showComponents(int)
      */
     @Override
     void showComponents( final int n ) {
         this.choice.show( n );
         for ( int i = 1; i <= this.cases.size(); i++ ) {
             ((Expr) this.cases.get( i )).show( n );
         }
         this.def.show( n );
     }
 
 }