////////////////////////////////////////////////////////////////////////////////
   // 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.ELinkedList;
  import org.millscript.millscript.alert.Alerts;
  import org.millscript.millscript.expr.CommaExpr;
  import org.millscript.millscript.expr.ConstantExpr;
  import org.millscript.millscript.expr.Expr;
  import org.millscript.millscript.expr.NameExpr;
  import org.millscript.millscript.expr.SkipExpr;
  import org.millscript.millscript.expr.SpiceClassExpr;
  import org.millscript.millscript.expr.SpiceClassSlotExpr;
  import org.millscript.millscript.expr.VarExpr;
  import org.millscript.millscript.functions.SlotFunction;
  
  /**
   * This class implements <code>class</code> syntax.
   *
   * @see org.millscript.millscript.expr.SpiceClassExpr
   * @see org.millscript.millscript.expr.VarExpr
   */
  public final class SpiceClassSyntax extends PrefixSyntax {
  
      /**
       * The closing character sequence for this instance of class syntax.
       */
      private final String closingKeyword;
  
      /**
       * The define syntax used for parsing method definitions.
       */
      private static final DefineSyntax DEFINE = new DefineSyntax();
  
      /**
       * Creates a class syntax parser instance, with the specified closing
       * character sequence.
       *
       * @param   x   the closing character seqeunce for this class syntax parser
       * instance
       */
      SpiceClassSyntax( final String x ) {
          closingKeyword = x;
      }
  
      /**
       * @see org.millscript.millscript.syntax.PrefixSyntaxInterface#prefix(java.lang.String, org.millscript.millscript.syntax.ParserImpl)
       */
      @Override
      public Expr prefix( final String sym, final Parser parser ) {
          // This holds all the definitions in the class,e.g. slots, methods and
          // functions
          Expr definitions = new SkipExpr();
  
          // This holds the parent classes we inherit from
          Expr parentClasses = new SkipExpr();
  
          // This stack will hold all the slot initialisers for this class
          final EList< SpiceClassSlotExpr > slotInitialisers = new ELinkedList< SpiceClassSlotExpr >();
  
          // Read the class name
          final NameExpr className = parser.readName();
  
          // Have a look for any inheritance
          if ( parser.tryRead( "extends" ) ) {
              // Oooo, single inheritance for now, so read a single name
              parentClasses = CommaExpr.make( parentClasses, parser.readName() );
          } else {
              parentClasses = null;
          }
  
          // We use this parser for parsing the class body, so that we know we
          // are inside a particular class definition when we parse methods
          final SpiceClassParserDelegate classParser = new SpiceClassParserDelegate( parser, className );
  
          // Read the body of the class definition
          while ( !parser.tryRead( closingKeyword ) ) {
              if ( parser.tryRead( "slot" ) ) {
                  // Read the slot name
                  final NameExpr slotName = parser.readName();
                 // The slot value, we default to whatever we like. For an easy
                 // ride we choose absent.
                 Expr slotValue = new ConstantExpr( null );
                 // Check for the equals
                 if ( parser.tryRead( "=" ) ) {
                     // Read the slots initial value
                     slotValue = parser.readExpr();
                 }
                 final SlotFunction sf = (SlotFunction) new SlotFunction().modName( slotName.getName() );
                 // Store the new slot function
                 definitions = CommaExpr.make(
                     definitions,
                     new VarExpr(
                         false,
                         slotName,
                         new ConstantExpr( sf )
                     )
                 );
                 // Store the new slot initialiser
                 slotInitialisers.addLast(
                     new SpiceClassSlotExpr( sf, slotValue )
                 );
             } else if ( parser.tryRead( "define" ) ) {
                 // Ah ha, parse the define using the SpiceClassParserDelegate
                 // so that methods will know their enclosing class
                 definitions = CommaExpr.make(
                     definitions,
                     DEFINE.prefix( "define", classParser )
                 );
             } else {
                 // Unexpected token in class body
                 throw(
                     Alerts.parse(
                         "Unexpected token in class definition",
                         "Only 'slot' is a valid token in a class body(at the moment)"
                     ).culprit( "token", parser.getErrorString() ).mishap()
                 );
             }
             // Read the semi-colon separating expressions.
             // TODO - When is this optional?
             parser.tryRead( ";" );
         }
 
         // Make a new variable to hold the class
         return CommaExpr.make(
             new VarExpr(
                 false,
                 className,
                 new SpiceClassExpr( className.getName(), parentClasses, slotInitialisers )
             ),
             definitions
         );
     }
 
 }