////////////////////////////////////////////////////////////////////////////////
   // MillScript: an Open Spice interpreter and batch website creation tool
   // Copyright (C) 2001-2004 Open World Ltd
   // Copyright (C) 2004 Stephen F. K. Leach
   // 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.alert.Alert;
  import org.millscript.commons.util.IMap;
  import org.millscript.commons.util.MapIterator;
  import org.millscript.commons.util.map.EHashMap;
  import org.millscript.millscript.alert.Alerts;
  import org.millscript.millscript.conf.Configuration;
  import org.millscript.millscript.datatypes.Atom;
  import org.millscript.millscript.datatypes.XmlComment;
  import org.millscript.millscript.expr.ApplyExpr;
  import org.millscript.millscript.expr.Block;
  import org.millscript.millscript.expr.CheckNoneExpr;
  import org.millscript.millscript.expr.CommaExpr;
  import org.millscript.millscript.expr.ConstantExpr;
  import org.millscript.millscript.expr.Expr;
  import org.millscript.millscript.expr.ListExpr;
  import org.millscript.millscript.expr.NameExpr;
  import org.millscript.millscript.expr.SkipExpr;
  import org.millscript.millscript.tools.IntegerTools;
  
  import java.io.Reader;
  import java.io.StringReader;
  
  /**
   * This class implements the MillScript parser for use with configuration
   * files. As such it is actually the complete parser implementation but it
   * excludes nearly all syntax entries. The only syntax this parser understands
   * is <code>"(", "," and ")"</code>.
   */
  public class ConfigurationParserImpl extends TokenizerImpl implements Parser {
  
      /**
       * Lookup table mapping a syntax keyword to its syntax object.
       */
      static final EHashMap< String, Syntax > TABLE = new EHashMap< String, Syntax >();
  
      //    Initializer
      static {
          put( ")", new NonfixSyntax() );
          put( ",", new CommaSyntax().setPrec( COMMA_PREC ) );
          put( "(", new ParenSyntax().setPrec( TIGHT_PREC + 400 ) );
      }
  
      /**
       * Constructs a new <code>ParserImpl</code> with the specified origin, source,
       * interactive prompt and end of line comment status.
       *
       * @param origin    the origin message for this tokenizer
       * @param r         the character source to tokenize
       * @param eolc      flag indicating if end of line comments are supported
       * @param c         the configuration
       */
      public ConfigurationParserImpl( final String origin, final Reader r, final boolean eolc, final Configuration c ) {
          super( origin, r, eolc, c );
      }
  
      /**
       * Annotates the specified expression with the specified origin and line
       * number.
       *
       * @param e the expression to annotate
       * @param og    the origin message
       * @param ln    the line number
       * @return  the annotated expression
       */
      private Expr annotate( final Expr e, final String og, final int ln ) {
          e.setOrigin( og );
          e.setLineNumber( ln );
          return e;
      }
  
      /**
       * @see org.millscript.millscript.syntax.Parser#getEnclosingClass()
       */
      public NameExpr getEnclosingClass() {
          // For the default parser, there is NO enclosing class
         throw(
             Alerts.compile(
                 "No enclosing class",
                 "You are attempting an operation that requires an enclosing class"
             ).mishap()
         );
     }
 
     /**
      * Returns a string containing the required format control codes for the
      * specified interpolation map. Any "%" characters in the input string will
      * be translated to "%%", while a "%p" will be inserted at each
      * interpolation point in the string.
      *
      * @param w the input string to prepare for interpolation
      * @param interpolationMapping  the map of positions in the input string to
      * their respective interpolation values
      * @return  a copy of the input string with "%" replaced by "%%" and a "%p"
      * inserted for each interpolation point
      */
     private String insertPercentPee( final String w, final IMap< Integer, CharSequence > interpolationMapping ) {
         final StringBuffer b = new StringBuffer();
         for ( int i = 0; i < w.length(); i++ ) {
             final CharSequence cs = interpolationMapping.get( new Integer( i ) );
             if ( cs != null ) {
                 b.append( "%p" );
             }
             if ( i >= 0 ) {
                 final char ch = w.charAt( i );
                 if ( ch == '%' ) {
                     b.append( "%%" );
                 } else {
                     b.append( ch );
                 }
             }
         }
         if ( interpolationMapping.get( new Integer( w.length() ) ) != null ) {
             b.append( "%p" );
         }
         return b.toString();
     }
 
     /**
      * @see org.millscript.millscript.syntax.Parser#makeInterpolatedExpr()
      */
     public Expr makeInterpolatedExpr() {
         String s = this.getStringNoQuotes();
         // Insert "%p" in all the relevant places, including
         // changing existing "%" to "%%".
         final String wpp = this.insertPercentPee( s, interpolationMap );
         // Start with the control string as the first argument
         Expr sofar = new ConstantExpr( wpp );
         // Now add a list for each interpoalated section
         for ( MapIterator< Integer, CharSequence > it = interpolationMap.iterator( true ); it.hasNext(); ) {
             final CharSequence cs = it.nextValue();
             sofar = CommaExpr.make(
                 sofar,
                 new ListExpr(
                     this.parseCharSequence( cs )
                 )
             );
         }
         // Return an application of the format function with the
         // comment as it's first argument and parsed interpolated
         // section. e.g.
         // format( wpp, { e }, { e } )
         // so "hello \( "there" ) \( 1,2,3 )" would become
         // format( "hello %p %p", { "there" }, { 1, 2, 3 } );
         return new ApplyExpr(
             new NameExpr( "format" ),
             sofar
         );
     }
 
     /**
      * Parses the specified character sequence, returning the expression for
      * the parsed sequence.
      *
      * @param cs    the character sequence to parse
      * @return  an Expr for the parsed expression
      */
     private Expr parseCharSequence( final CharSequence cs ) {
         final String interp = cs.toString();
         // TODO - It would be great to be able to pass in the current line
         // number, and a better origin message.
         final Parser p = new ParserImpl( "Interpolated String", new StringReader( interp ), true, this.config );
         final Expr e = p.readStmnts();
         if ( p.peekToken() != TokenType.EOF ) {
             throw(
                 Alerts.parse(
                     "Invalid interpolation expression",
                     null
                 ).culprit( "interpolated", interp ).mishap()
             );
         }
         return e;
     }
 
     /**
      * Convenience method for inserting entries in the symbol table.
      *
      * @param s symbol
      * @param t Syntax for symbol
      */
     protected static void put( final String s, final Syntax t ) {
         TABLE.insert( s.intern(), t );
     }
 
     /**
      * @see org.millscript.millscript.syntax.Parser#readAttributeName()
      */
     public String readAttributeName() {
         if ( nextToken() == TokenType.NAME ) {
             return getAttributeName();
         } else {
             throw(
                 Alerts.parse(
                     "Attribute name expected",
                     null
                 ).culprit( "found", getErrorString() ).mishap()
             );
         }
     }
 
     /**
      * @see org.millscript.millscript.syntax.Parser#readBlock()
      */
     public Expr readBlock() {
         return new Block( readStmnts() );
     }
 
     /**
      * @see org.millscript.millscript.syntax.Parser#readBlockTo(java.lang.String)
      */
     public Expr readBlockTo( final String sym ) {
         return new Block( readStmntsTo( sym ) );
     }
 
     /**
      * @see org.millscript.millscript.syntax.Parser#readExpr()
      */
     public Expr readExpr() {
         return readExprPrec( 0 );
     }
 
     /**
      * @see org.millscript.millscript.syntax.Parser#readExprComma()
      */
     public Expr readExprComma() {
         return readExprPrec( COMMA_PREC1 );
     }
 
     /**
      * @see org.millscript.millscript.syntax.Parser#readExprPrec(int)
      */
     public Expr readExprPrec( final int prec ) {
         Expr e = readOptExprPrec( prec );
         if ( e == null ) {
             throw(
                 Alerts.parse(
                     "Missing expression",
                     "An expression is required here"
                 ).mishap()
             );
         }
         return e;
     }
 
     /**
      * @see org.millscript.millscript.syntax.Parser#readExprTo(java.lang.String)
      */
     public Expr readExprTo( final String sym ) {
         Expr e = readExpr();
         mustRead( sym );
         return e;
     }
 
     /**
      * @see org.millscript.millscript.syntax.Parser#readName()
      */
     public NameExpr readName() {
         String name = readSymbol();
         Syntax syn = TABLE.get( name );
         if ( syn != null ) {
             //    Ooops - we wanted a plain word.
             throw(
                 Alerts.parse(
                     "Identifier needed",
                     null
                 ).culprit( "found", name ).mishap()
             );
         } else {
             return new NameExpr( name );
         }
     }
 
     /**
      * @see org.millscript.millscript.syntax.Parser#readOptExpr()
      */
     public Expr readOptExpr() {
         return readOptExprPrec( 0 );
     }
 
     /**
      * @see org.millscript.millscript.syntax.Parser#readOptExprPrec(int)
      */
     public Expr readOptExprPrec( final int prec ) {
         //    Record position in file.
         String og = getOrigin();
         int ln = getLineNumber();
 
         try {
             //    Phase 1: read primary.
             Expr e = readOptPrimary();
 
             //    EOF allowed here.
             if ( e == null ) {
                 return null;
             }
 
             //    Phase 2: read postfix/infix expressions.
             for (;;) {
                 TokenType tt = peekToken();
                 if ( tt == TokenType.NAME ) {
                     String sym = getName();
                     Syntax s = TABLE.get( sym );
                     //    First check whether the next symbol is marked as postfixable.
                     if ( s == null || !( s instanceof PostfixSyntaxInterface ) ) {
                         return annotate( e, og, ln );
                     }
                     int q = ((PostfixSyntaxInterface)s).getPrecedence();
                     //    Now check whether it binder as tightly (or more tightly) than the
                     //    current precedence level.
                     if ( q < prec ) {
                         return annotate( e, og, ln );
                     }
                     //    OK, we accept it as a legitimate continuation.
                     dropToken();
                     //    Run the postfix factory interface.
                     e = ((PostfixSyntaxInterface)s).postfix( sym, q, e, this );
                 } else if ( tt == TokenType.INTEGER && getInt() < 0 ) {
                     //    We have the yukky case of E-7 i.e. a general
                     //    expression followed by a small negative number.
                     int num = getInt();
                     dropToken();
                     e =
                         new ApplyExpr(
                             new NameExpr( "-".intern() ),
                             CommaExpr.make( e, new ConstantExpr( IntegerTools.make( -num ) ) )
                          );
                 } else {
                     return annotate( e, og, ln );
                 }
             }
         } catch ( Alert ex ) {
             throw ex.origin( this ).remishap();
         }
     }
 
     /**
      * @see org.millscript.millscript.syntax.Parser#readOptPrimary()
      */
     public Expr readOptPrimary() {
         TokenType tt = peekToken();
         if ( tt == TokenType.EOF ) {
             return null;
         } else if ( tt == TokenType.STRING ) {
             dropToken();
             char ch = getQuoteChar();
             // We have a branch here to support constant and interpolated
             // strings
             if ( this.interpolationMap.isEmtpy() ) {
                 // This is NOT an interpolated string, so we must construct a
                 // constant value
                 if ( checkWhere( 'c' ) ) {
                     // We're inside an XML comment, so we must get the parsed string
                     // which contains the comment and the trailing "-->".
                     return new ConstantExpr( new XmlComment( getStringNoQuotes( 0, 3 ) ) );
                 } else if ( ch == '"' || ch == '#' ) {
                     return new ConstantExpr( getStringNoQuotes().intern() );
                 } else if ( ch == '`' ) {
                     return new ConstantExpr( Atom.make( getStringNoQuotes() ) );
                 } else if ( ch == '\'' ) {
                     String s = getStringNoQuotes();
                     Expr sofar = new SkipExpr();
                     for ( int i = 0; i < s.length(); i++ ) {
                         char c = s.charAt( i );
                         sofar = (
                             CommaExpr.make(
                                 sofar,
                                 new ConstantExpr( new Character( c ) )
                             )
                         );
                     }
                     return sofar;
                 } else {
                     throw(
                         Alerts.fault( "Impossible character quote" ).mishap()
                     );
                 }
             } else {
                 // This IS an interpolated string, so we have to construct an
                 // apply expression. i.e. not a constant
                 if ( checkWhere( 'c' ) ) {
                     // We're inside an XML comment, so we must get the parsed string
                     // which contains the comment and the trailing "-->".
                     String s = this.getStringNoQuotes( 0, 3 );
                     // Insert "%p" in all the relevant places, including
                     // changing existing "%" to "%%".
                     final String wpp = this.insertPercentPee( s, interpolationMap );
                     // We start with an XMLComment as the first argument
                     Expr sofar = new ConstantExpr( new XmlComment( wpp ) );
                     // Now add a list for each interpoalated section
                     for ( MapIterator< Integer, CharSequence > it = interpolationMap.iterator( true ); it.hasNext(); ) {
                         final CharSequence cs = it.nextValue();
                         sofar = CommaExpr.make( sofar, new ListExpr( this.parseCharSequence( cs ) ) );
                     }
                     // Return an application of the format function with the
                     // comment as it's first argument and parsed interpolated
                     // section
                     return new ApplyExpr(
                         new NameExpr( "format" ),
                         sofar
                     );
                 } else if ( ch == '"' || ch == '#' ) {
                     return this.makeInterpolatedExpr();
                 } else if ( ch == '`' ) {
                     return new ApplyExpr(
                         new NameExpr( "newSymbol" ),
                         this.makeInterpolatedExpr()
                     );
                 } else if ( ch == '\'' ) {
                     return new ApplyExpr(
                         new NameExpr( "explode" ),
                         this.makeInterpolatedExpr()
                     );
                 } else {
                     throw(
                         Alerts.fault( "Impossible character quote" ).mishap()
                     );
                 }
             }
         } else if ( tt == TokenType.TRADITIONAL_REGEX ) {
             // A traditional regular expression. We just need to make a
             // constant expression containing the compiled pattern.
             dropToken();
             return new ConstantExpr( this.makePattern() );
         } else if ( tt == TokenType.INTEGER ) {
             dropToken();
             return new ConstantExpr( IntegerTools.make( getInt() ) );
         } else if ( tt == TokenType.NAME ) {
             String sym = getName();
             Syntax syntax = TABLE.get( sym );
             if ( syntax == null ) {
                 dropToken();
                 NameExpr name = new NameExpr( sym );
                 if ( tryRead( "::" ) ) {
                     NameExpr newname = readName();
                     newname.setNickname( name.getName() );
                     return newname;
                 }
                 return name;
             } else if ( syntax instanceof PrefixSyntaxInterface ) {
                 dropToken();
                 return ((PrefixSyntaxInterface)syntax).prefix( sym, this );
             } else {
                 return null;
             }
         } else {
             throw(
                 Alerts.fault( "Invalid token type " + tt ).mishap()
             );
         }
     }
 
     /**
      * @see org.millscript.millscript.syntax.Parser#readPrimary()
      */
     public Expr readPrimary() {
         Expr e = readOptPrimary();
         if ( e == null ) {
             if ( peekToken() == TokenType.EOF ) {
                 throw(
                     Alerts.parse(
                         "Unexpected end of input while reading Primary",
                         null
                     ).mishap()
                 );
             } else {
                 throw(
                     Alerts.parse(
                         "Unexpected token while reading Simple expression",
                         null
                     ).culprit( "token", getErrorString() ).mishap()
                 );
             }
         }
         return e;
     }
 
     /**
      * @see org.millscript.millscript.syntax.Parser#readStmnts()
      */
     public Expr readStmnts() {
         Expr x = new SkipExpr();
         for (;;) {
             Expr y = readOptExprPrec( 0 );
             if ( y == null ) {
                 return x;
             } else {
                 x = CommaExpr.make( CheckNoneExpr.make( x ), y );
             }
             if ( !tryRead( ";" ) ) {
                 return x;
             }
         }
     }
 
     /**
      * @see org.millscript.millscript.syntax.Parser#readStmntsTo(java.lang.String)
      */
     public Expr readStmntsTo( final String sym ) {
         Expr e = readStmnts();
         mustRead( sym );
         return e;
     }
 
     /**
      * @see org.millscript.millscript.syntax.Parser#readSymbol()
      */
     public String readSymbol() {
         TokenType tt = nextToken();
         if ( tt == TokenType.NAME ) {
             return getName();
         } else if ( tt == TokenType.EOF ) {
             //    Ooops - we did not want the end of file.
             throw(
                 Alerts.parse(
                     "Unexpected end of file",
                     null
                 ).mishap()
             );
         } else {
             //    Ooops - we wanted an identifier.
             throw(
                 Alerts.parse(
                     "Identifier needed",
                     null
                 ).culprit( "found", getErrorString() ).mishap()
             );
         }
     }
 
     /**
      * @see org.millscript.millscript.syntax.Parser#readTagName()
      */
     public String readTagName() {
         if ( nextToken() == TokenType.NAME ) {
             return getTagName();
         } else {
             throw(
                 Alerts.parse(
                     "Tag name expected",
                     null
                 ).culprit( "found", getErrorString() ).mishap()
             );
         }
     }
 
 }