/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * particular file as subject to the "Classpath" exception as provided

 *

 * This code 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

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 */

/*

 * COMPONENT_NAME: idl.parser

 *

 * ORIGINS: 27

 *

 * Licensed Materials - Property of IBM

 * 5639-D57 (C) COPYRIGHT International Business Machines Corp. 1997, 1999

 * RMI-IIOP v1.0

 *

 */

package com.sun.tools.corba.se.idl;

// NOTES:

// -D57110<daz> Allow ID pragma directive to be applied to modules and update

//  feature in accordance to CORBA 2.3.

// -D59165<daz> Enable escaped identifiers when processing pragmas.

// -f60858.1<daz> Support -corba option, level = 2.2: Accept identifiers that

//  collide with keywords, in letter but not case, and issue a warning.

// -d62023 <daz> support -noWarn option; suppress inappropriate warnings when

//  parsing IBM-specific pragmas (#meta <interface_name> abstract).

import java.io.File;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.math.BigInteger;

import java.util.Enumeration;

import java.util.Hashtable;

import java.util.Stack;

import java.util.Vector;

import com.sun.tools.corba.se.idl.RepositoryID;

import com.sun.tools.corba.se.idl.constExpr.*;

/**

 * This class should be extended if new pragmas are desired.  If the

 * preprocessor encounters a pragma name which it doesn't recognize

 * (anything other than ID, prefix, or version), it calls the method

 * otherPragmas.  This is the only method which need be overridden.

 * The Preprocessor base class has a number of utility-like methods

 * which can be used by the overridden otherPragmas method.

 **/

public class Preprocessor

{

  /**

   * Public zero-argument constructor.

   **/

  Preprocessor ()

  {

  } // ctor

  /**

   *

   **/

  void init (Parser p)

  {

    parser  = p;

    symbols = p.symbols;

    macros  = p.macros;

  } // init

  /**

   *

   **/

  protected Object clone ()

  {

    return new Preprocessor ();

  } // clone

  /**

   *

   **/

  Token process (Token t) throws IOException, ParseException

  {

    token   = t;

    scanner = parser.scanner;

    // <f46082.40> Deactivate escaped identifier processing in Scanner while

    // preprocessing.

    //scanner.underscoreOK = true;

    scanner.escapedOK = false;

    try

    {

      switch (token.type)

      {

        case Token.Include:

          include ();

          break;

        case Token.If:

          ifClause ();

          break;

        case Token.Ifdef:

          ifdef (false);

          break;

        case Token.Ifndef:

          ifdef (true);

          break;

        case Token.Else:

          if (alreadyProcessedABranch.empty ())

            throw ParseException.elseNoIf (scanner);

          else if (((Boolean)alreadyProcessedABranch.peek ()).booleanValue ())

            skipToEndif ();

          else

          {

            alreadyProcessedABranch.pop ();

            alreadyProcessedABranch.push (new Boolean (true));

            token = scanner.getToken ();

          }

          break;

        case Token.Elif:

          elif ();

          break;

        case Token.Endif:

          if (alreadyProcessedABranch.empty ())

            throw ParseException.endNoIf (scanner);

          else

          {

            alreadyProcessedABranch.pop ();

            token = scanner.getToken ();

            break;

          }

        case Token.Define:

          define ();

          break;

        case Token.Undef:

          undefine ();

          break;

        case Token.Pragma:

          pragma ();

          break;

        case Token.Unknown:

          if (!parser.noWarn)

            ParseException.warning (scanner, Util.getMessage ("Preprocessor.unknown", token.name));

        case Token.Error:

        case Token.Line:

        case Token.Null:

          // ignore

        default:

          scanner.skipLineComment ();

          token = scanner.getToken ();

      }

    }

    catch (IOException e)

    {

      // <f46082.40> Underscore may now precede any identifier, so underscoreOK

      // is vestigal.  The Preprocessor must reset escapedOK so that Scanner

      // will process escaped identifiers according to specification.

      //scanner.underscoreOK = false;

      scanner.escapedOK = true;

      throw e;

    }

    catch (ParseException e)

    {

      // <f46082.40> See above.

      //scanner.underscoreOK = false;

      scanner.escapedOK = true;

      throw e;

    }

    // <f46082.40> See above.

    //scanner.underscoreOK = false;

    scanner.escapedOK = true;

    return token;

  } // process

  /**

   *

   **/

  private void include () throws IOException, ParseException

  {

    match (Token.Include);

    IncludeEntry include = parser.stFactory.includeEntry (parser.currentModule);

    include.sourceFile (scanner.fileEntry ());

    scanner.fileEntry ().addInclude (include);

    if (token.type == Token.StringLiteral)

      include2 (include);

    else if (token.type == Token.LessThan)

      include3 (include);

    else

    {

      int[] expected = {Token.StringLiteral, Token.LessThan};

      throw ParseException.syntaxError (scanner, expected, token.type);

    }

    if (parser.currentModule instanceof ModuleEntry)

      ((ModuleEntry)parser.currentModule).addContained (include);

    else if (parser.currentModule instanceof InterfaceEntry)

      ((InterfaceEntry)parser.currentModule).addContained (include);

  } // include

  /**

   *

   **/

  private void include2 (IncludeEntry include) throws IOException, ParseException

  {

    include.name ('"' + token.name + '"');

    include4 (include, token.name);

    match (Token.StringLiteral);

  } // include2

  /**

   *

   **/

  private void include3 (IncludeEntry include) throws IOException, ParseException

  {

    if (token.type != Token.LessThan)

      // match will throw an exception

      match (Token.LessThan);

    else

    {

      try

      {

        String includeFile = getUntil ('>');

        token = scanner.getToken ();

        include.name ('<' + includeFile + '>');

        include4 (include, includeFile);

        match (Token.GreaterThan);

      }

      catch (IOException e)

      {

        throw ParseException.syntaxError (scanner, ">", "EOF");

      }

    }

  } // include3

  /**

   *

   **/

  private void include4 (IncludeEntry include, String filename) throws IOException, ParseException

  {

    try

    {

      // If the #include is at the global scope, it is treated as

      // an import statement.  If it is within some other scope, it

      // is treated as a normal #include.

      boolean includeIsImport = parser.currentModule == parser.topLevelModule;

      //daz

      include.absFilename (Util.getAbsolutePath (filename, parser.paths));

      scanner.scanIncludedFile (include, getFilename (filename), includeIsImport);

    }

    catch (IOException e)

    {

      ParseException.generic (scanner, e.toString ());

    }

  } // include4

  /**

   *

   **/

  private void define () throws IOException, ParseException

  {

    match (Token.Define);

    if (token.equals (Token.Identifier))

    {

      String symbol = scanner.getStringToEOL ();

      symbols.put (token.name, symbol.trim ());

      match (Token.Identifier);

    }

    else if (token.equals (Token.MacroIdentifier))

    {

      symbols.put (token.name, '(' + scanner.getStringToEOL () . trim ());

      macros.addElement (token.name);

      match (Token.MacroIdentifier);

    }

    else

      throw ParseException.syntaxError (scanner, Token.Identifier, token.type);

  } // define

  /**

   *

   **/

  private void undefine () throws IOException, ParseException

  {

    match (Token.Undef);

    if (token.equals (Token.Identifier))

    {

      symbols.remove (token.name);

      macros.removeElement (token.name);

      match (Token.Identifier);

    }

    else

      throw ParseException.syntaxError (scanner, Token.Identifier, token.type);

  } // undefine

  /**

   *

   **/

  private void ifClause () throws IOException, ParseException

  {

    match (Token.If);

    constExpr ();

  } // ifClause

  /**

   *

   **/

  private void constExpr () throws IOException, ParseException

  {

    SymtabEntry dummyEntry = new SymtabEntry (parser.currentModule);

    dummyEntry.container (parser.currentModule);

    parser.parsingConditionalExpr = true;

    Expression boolExpr = booleanConstExpr (dummyEntry);

    parser.parsingConditionalExpr = false;

    boolean expr;

    if (boolExpr.value () instanceof Boolean)

      expr = ((Boolean)boolExpr.value ()).booleanValue ();

    else

      expr = ((Number)boolExpr.value ()).longValue () != 0;

    alreadyProcessedABranch.push (new Boolean (expr));

    if (!expr)

      skipToEndiforElse ();

  } // constExpr

  /**

   *

   **/

  Expression booleanConstExpr (SymtabEntry entry) throws IOException, ParseException

  {

    Expression expr = orExpr (null, entry);

    try

    {

      expr.evaluate ();

    }

    catch (EvaluationException e)

    {

      ParseException.evaluationError (scanner, e.toString ());

    }

    return expr;

  } // booleanConstExpr

  /**

   *

   **/

  private Expression orExpr (Expression e, SymtabEntry entry) throws IOException, ParseException

  {

    if (e == null)

      e = andExpr (null, entry);

    else

    {

      BinaryExpr b = (BinaryExpr)e;

      b.right (andExpr (null, entry));

      e.rep (e.rep () + b.right ().rep ());

    }

    if (token.equals (Token.DoubleBar))

    {

      match (token.type);

      BooleanOr or = parser.exprFactory.booleanOr (e, null);

      or.rep (e.rep () + " || ");

      return orExpr (or, entry);

    }

    else

      return e;

  } // orExpr

  /**

   *

   **/

  private Expression andExpr (Expression e, SymtabEntry entry) throws IOException, ParseException

  {

    if (e == null)

      e = notExpr (entry);

    else

    {

      BinaryExpr b = (BinaryExpr)e;

      b.right (notExpr (entry));

      e.rep (e.rep () + b.right ().rep ());

    }

    if (token.equals (Token.DoubleAmpersand))

    {

      match (token.type);

      BooleanAnd and = parser.exprFactory.booleanAnd (e, null);

      and.rep (e.rep () + " && ");

      return andExpr (and, entry);

    }

    else

      return e;

  } // andExpr

  /**

   *

   **/

  private Expression notExpr (/*boolean alreadySawExclamation, */SymtabEntry entry) throws IOException, ParseException

  {

    Expression e;

    if (token.equals (Token.Exclamation))

    {

      match (Token.Exclamation);

      e = parser.exprFactory.booleanNot (definedExpr (entry));

      e.rep ("!" + ((BooleanNot)e).operand ().rep ());

    }

    else

      e = definedExpr (entry);

    return e;

  } // notExpr

  /**

   *

   **/

  private Expression definedExpr (SymtabEntry entry) throws IOException, ParseException

  {

    if (token.equals (Token.Identifier) && token.name.equals ("defined"))

      match (Token.Identifier);

    return equalityExpr (null, entry);

  } // definedExpr

  /**

   *

   **/

  private Expression equalityExpr (Expression e, SymtabEntry entry) throws IOException, ParseException

  {

    if (e == null)

    {

      parser.token = token; // Since parser to parse, give it this token

      e = parser.constExp (entry);

      token = parser.token; // Since parser last parsed, get its token

    }

    else

    {

      BinaryExpr b = (BinaryExpr)e;

      parser.token = token; // Since parser to parse, give it this token

      Expression constExpr = parser.constExp (entry);

      token = parser.token; // Since parser last parsed, get its token

      b.right (constExpr);

      e.rep (e.rep () + b.right ().rep ());

    }

    if (token.equals (Token.DoubleEqual))

    {

      match (token.type);

      Equal eq = parser.exprFactory.equal (e, null);

      eq.rep (e.rep () + " == ");

      return equalityExpr (eq, entry);

    }

    else if (token.equals (Token.NotEqual))

    {

      match (token.type);

      NotEqual n = parser.exprFactory.notEqual (e, null);

      n.rep (e.rep () + " != ");

      return equalityExpr (n, entry);

    }

    else if (token.equals (Token.GreaterThan))

    {

      match (token.type);

      GreaterThan g = parser.exprFactory.greaterThan (e, null);

      g.rep (e.rep () + " > ");

      return equalityExpr (g, entry);

    }

    else if (token.equals (Token.GreaterEqual))

    {

      match (token.type);

      GreaterEqual g = parser.exprFactory.greaterEqual (e, null);

      g.rep (e.rep () + " >= ");

      return equalityExpr (g, entry);

    }

    else if (token.equals (Token.LessThan))

    {

      match (token.type);

      LessThan l = parser.exprFactory.lessThan (e, null);

      l.rep (e.rep () + " < ");

      return equalityExpr (l, entry);

    }

    else if (token.equals (Token.LessEqual))

    {

      match (token.type);

      LessEqual l = parser.exprFactory.lessEqual (e, null);

      l.rep (e.rep () + " <= ");

      return equalityExpr (l, entry);

    }

    else

      return e;

  } // equalityExpr

  /**

   *

   **/

  Expression primaryExpr (SymtabEntry entry) throws IOException, ParseException

  {

    Expression primary = null;

    switch (token.type)

    {

      case Token.Identifier:

        // If an identifier gets this far, it means that no

        // preprocessor variable was defined with that name.

        // Generate a FALSE boolean expr.

        //daz        primary = parser.exprFactory.terminal ("0", new Long (0));

        primary = parser.exprFactory.terminal ("0", BigInteger.valueOf (0));

        token = scanner.getToken ();

        break;

      case Token.BooleanLiteral:

      case Token.CharacterLiteral:

      case Token.IntegerLiteral:

      case Token.FloatingPointLiteral:

      case Token.StringLiteral:

        //daz        primary = parser.literal ();

        primary = parser.literal (entry);

        token = parser.token;

        break;

      case Token.LeftParen:

        match (Token.LeftParen);

        primary = booleanConstExpr (entry);

        match (Token.RightParen);

        primary.rep ('(' + primary.rep () + ')');

        break;

      default:

        int[] expected = {Token.Literal, Token.LeftParen};

        throw ParseException.syntaxError (scanner, expected, token.type);

    }