////////////////////////////////////////////////////////////////////////////////
   // MillScript: an Open Spice interpreter and batch website creation tool
   // Copyright (C) 2004-2005 Kevin Rogers
   //
   // 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.syntax;
  
  import org.millscript.commons.util.EList;
  import org.millscript.commons.util.list.EArrayList;
  import org.millscript.millscript.alert.Alerts;
  import org.millscript.millscript.expr.ApplyExpr;
  import org.millscript.millscript.expr.CommaExpr;
  import org.millscript.millscript.expr.Expr;
  import org.millscript.millscript.expr.NameExpr;
  import org.millscript.millscript.expr.SkipExpr;
  
  
  /**
   * This class represents a function header. The function header is the
   * signature of a function, made up of the function name and it's argument
   * list. e.g. <code>somefunc( arg1, arg2 )</code>.
   */
  public final class FunctionHeader {
  
      /**
       * This is the function name, as a name expression.
       */
      private NameExpr name = null;
  
      /**
       * This stack contains the function argument list. This stack should
       * only contain {@link NameExpr}s.
       */
      private final EList< NameExpr > arglist = new EArrayList< NameExpr >( 8 );
  
      /**
       * Returns a list holding the arguments for this function header.
       *
       * @return  a list holding the arguments for this function header.
       */
      public EList< NameExpr > getArglist() {
          return arglist;
      }
  
      /**
       * Returns the function name expression for this header.
       *
       * @return  the NameExpr for the function name
       */
      public NameExpr getName() {
          return name;
      }
  
      /**
       * Returns the symbol for this function. It is possible to declare
       * annonymous functions, in which case their symbol will be "lambda".
       *
       * @return  a String containing the function name, or
       *          <code>"lambda"</code> if it doesn't have one.
       */
      public String getSymbol() {
          if ( name == null ) {
              return "lambda";
          } else {
              return name.getName();
          }
      }
  
      /**
       * Flattens the supplied function definition expression into its
       * function name and arguments. This method takes a standard function
       * definition expression, e.g. <code>somefunc( arg1, arg2 )</code>, and
       * extracts the function and argument name expressions.
       *
       * @param   e   a function definition expression, i.e. the function and
       *              it's arguments.
       * @param   nameNeeded  a boolean indicating if this function must have
       *                      a name or not.
       */
      void flatten( final Expr e, final boolean nameNeeded ) {
          // Check what kind of expression we've been supplied
          if ( e instanceof ApplyExpr ) {
              // We were supplied an apply expression, which means we have a
              // function name and some arguments. Hence, extract the function
             // name from the apply expression.
             Expr fun = ((ApplyExpr)e).getFun();
             // Now extract the function argument expression from the apply
             // expression.
             Expr args = ((ApplyExpr)e).getArgs();
             // Check that the function name expression is indeed a name
             // expression
             if ( fun instanceof NameExpr ) {
                 // Set the function name expression
                 name = (NameExpr)fun;
                 // Process the argument expression
                 pushArgs( args );
             } else {
                 // This is an invalid function definition
                 throw(
                     Alerts.parse(
                         "Invalid procedure definition",
                         "Proceedure names must be a name!"
                     ).culprit( "procedure name", fun ).mishap()
                 );
             }
         } else if ( nameNeeded ) {
             // We weren't supplied an apply expression, but we need a
             // function name, so this is an error.
             throw(
                 Alerts.parse(
                     "Invalid procedure definition",
                     "Procedures must have a name"
                 ).mishap()
             );
         } else {
             // We don't need a name, so the supplied expression is just a
             // list of arguments. Hence process them.
             pushArgs( e );
         }
     }
 
     /**
      * Extracts all the argument names from the supplied expression for the
      * arguments. Each argument will be pushed onto the argument stack,
      * {@link #arglist}. An error will be raised if the specified expression
      * contains expressions that are illegal in a function definition.
      *
      * @param   args    the expression containing the set of arguments for
      *                  this function definition
      */
     private void pushArgs( final Expr args ) {
         if ( args instanceof NameExpr ) {
             // The supplied argument is a name expression, so just push it
             // onto the argument stack
             arglist.addLast( (NameExpr) args );
         } else if ( args instanceof CommaExpr ) {
             // The supplied argument is a comma expression, so push the left
             // hand side, then the right hand side.
             pushArgs( ((CommaExpr)args).getLeft() );
             pushArgs( ((CommaExpr)args).getRight() );
         } else if ( !( args instanceof SkipExpr ) ) {
             // Invalid expression in argument list
             throw(
                 Alerts.parse(
                     "Invalid procedure definition",
                     "Procedure arguments must names(at the moment)"
                 ).culprit( "arg", args ).mishap()
             );
         }
     }
 
 }