/*
 * Copyright (c) 1999, 2007, Oracle and/or its affiliates. All rights reserved.
 * 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
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * 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.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */
/*
 * 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:
// -F46082.51<daz> Remove -stateful option. "Stateful interfaces" obsolete.
// -D58319<daz> Add -version option.  Note that this may occur as the last
//  argument on the command-line.
// -F60858.1<daz> Add -corba [level] option.  Accept IDL upto this level, and
//  behave in a "proprietary manner" otherwise.
// -D62023<daz> Add -noWarn option to supress warnings.

import java.io.DataInputStream;
import java.io.IOException;
import java.util.Hashtable;
import java.util.Properties;
import java.util.Vector;
import java.util.StringTokenizer;
import java.lang.reflect.Modifier;
import java.lang.reflect.Field;

import com.sun.tools.corba.se.idl.som.cff.FileLocator;

/**
 * This class is responsible for parsing the command line arguments to the
 * compiler.  To add new arguments to the compiler, this class must be extended
 * and the parseOtherArgs method overridden.
 **/
public class Arguments
{
  /**
   * Method parseOtherArgs() is called when the framework detects arguments
   * which are unknown to it.  The default implementation of this method simply
   * throws an InvalidArgument exception.  Any overriding implementation
   * must check the arguments passed to it for validity and process the
   * arguments appropriately.  If it detects an invalid argument, it should
   * throw an InvalidArgument exception.  Arguments MUST be of the form
   * {@code '/<arg> [<qualifiers>]'} or {@code '-<arg> [<qualifiers>]'} where {@code <qualifiers>}
   * is optional (for example, -iC:\includes, 'C:\includes' is the qualifier
   * for the argument 'i').
   * @param args The arguments which are unknown by the framework.
   * @param properties Environment-style properties collected from the
   * file idl.config.
   * @exception idl.InvalidArgument if the argument is unknown.
   **/
  protected void parseOtherArgs (String[] args, Properties properties) throws InvalidArgument
  {
    if (args.length > 0)
      throw new InvalidArgument (args[0]);
  } // parseOtherArgs


    protected void setDebugFlags( String args )
    {
        StringTokenizer st = new StringTokenizer( args, "," ) ;
        while (st.hasMoreTokens()) {
            String token = st.nextToken() ;

            // If there is a public boolean data member in this class
            // named token + "DebugFlag", set it to true.
            try {
                Field fld = this.getClass().getField( token + "DebugFlag" ) ;
                int mod = fld.getModifiers() ;
                if (Modifier.isPublic( mod ) && !Modifier.isStatic( mod ))
                    if (fld.getType() == boolean.class)
                        fld.setBoolean( this, true ) ;
            } catch (Exception exc) {
                // ignore it
            }
        }
    }

    /**
    * Collect the command-line parameters.
    **/
    void parseArgs (String[] args) throws InvalidArgument {
        Vector unknownArgs = new Vector ();
        int    i           = 0;

        try {
            // Process command line parameters
            for (i = 0; i < args.length - 1; ++i) {
                String lcArg = args[i].toLowerCase ();
                if (lcArg.charAt (0) != '-' && lcArg.charAt (0) != '/')
                    throw new InvalidArgument (args[i]);
                if (lcArg.charAt (0) == '-' ) {
                    lcArg = lcArg.substring (1);
                }

                // Include path
                if (lcArg.equals ("i")) {
                    includePaths.addElement (args[++i]);
                } else if (lcArg.startsWith ("i")) {
                    includePaths.addElement (args[i].substring (2));
                } else if (lcArg.equals ("v") || lcArg.equals ("verbose")) {
                    // Verbose mode
                    verbose = true;
                } else if (lcArg.equals ("d")) {
                    // Define symbol
                    definedSymbols.put (args[++i], "");
                } else if (lcArg.equals( "debug" )) {
                    // Turn on debug flags
                    setDebugFlags( args[++i] ) ;
                } else if (lcArg.startsWith ("d")) {
                    definedSymbols.put (args[i].substring (2), "");
                } else if (lcArg.equals ("emitall")) {
                    // Emit bindings for included sources
                    emitAll = true;
                } else if (lcArg.equals ("keep")) {
                    // Keep old files
                    keepOldFiles = true;
                } else if (lcArg.equals ("nowarn")) {
                    // <d62023> Suppress warnings
                    noWarn = true;
                } else if (lcArg.equals ("trace")) {
                    // Allow tracing.
                    Runtime.getRuntime ().traceMethodCalls (true);
                }
                // <f46082.51> Remove -stateful feature.
                //else if (lcArg.equals ("stateful"))
                //{
                //  Emit stateful bindings.
                //  parseStateful = true;
                //}
                // CPPModule
                else if ( lcArg.equals ("cppmodule")) {
                    cppModule = true;
                } else if (lcArg.equals ("version"))  {
                    // Version
                    versionRequest = true;
                } else if (lcArg.equals ("corba"))  {
                    // CORBA level
                    if (i + 1 >= args.length)
                        throw new InvalidArgument (args[i]);
                    String level = args[++i];
                    if (level.charAt (0) == '-')
                        throw new InvalidArgument (args[i - 1]);
                    try {
                        corbaLevel = new Float (level).floatValue ();
                    } catch (NumberFormatException e) {
                        throw new InvalidArgument (args[i]);
                    }
                } else {
                    unknownArgs.addElement (args[i]);
                    ++i;
                    while (i < (args.length - 1) &&
                        args[i].charAt (0) != '-' &&
                        args[i].charAt (0) != '/') {
                        unknownArgs.addElement (args[i++]);
                    }
                    --i;
                }
            }
        } catch (ArrayIndexOutOfBoundsException e) {
            // If there is any array indexing problem, it is probably
            // because the qualifier on the last argument is missing.
            // Report that this last argument is invalid.
            throw new InvalidArgument (args[args.length - 1]);
        }

        // <d57319>
        // The last argument is the file argument or "-version", which may
        // be specified without a file argument.
        if (i == args.length - 1) {
            if (args[i].toLowerCase ().equals ("-version"))
                versionRequest = true;
            else
                file = args[i];
        } else
            throw new InvalidArgument ();

        // Get and process the idl.config file.
        Properties props = new Properties ();
        try {
          DataInputStream stream = FileLocator.locateFileInClassPath ("idl.config");
          props.load (stream);
          addIncludePaths (props);
        } catch (IOException e) {
        }

        // Call parseOtherArgs.  By default, if there are unknown args,
        // InvalidArgument is called.  A call to parseOtherArgs is useful
        // only when this framework has been extended.
        String[] otherArgs;
        if (unknownArgs.size () > 0) {
            otherArgs = new String[unknownArgs.size ()];
            unknownArgs.copyInto (otherArgs);
        } else
            otherArgs = new String[0];

        parseOtherArgs (otherArgs, props);
    } // parseArgs

  /**
   *
   **/
  private void addIncludePaths (Properties props)
  {
    String paths = props.getProperty ("includes");
    if (paths != null)
    {
      String separator = System.getProperty ("path.separator");
      int end = -separator.length (); // so the first pass paths == original paths
      do
      {
        paths = paths.substring (end + separator.length ());
        end = paths.indexOf (separator);
        if (end < 0)
          end = paths.length ();
        includePaths.addElement (paths.substring (0, end));
      }
      while (end != paths.length ());
    }
  } // addIncludePaths

  /**
   * The name of the IDL file.
   **/
  public String file = null;

  /**
   * True if the user wishes to see processing remarks.
   **/
  public boolean verbose = false;

  /**
   * If this is true, then existing files should not be overwritten
   * by the compiler.
   **/
  public boolean keepOldFiles = false;

  /**
   * If this is true, then the types in all included files are also emitted.
   **/
  public boolean emitAll = false;

  // <f46082.51> Remove -stateful feature.
  ///**
  // * If this is true, then stateful interfaces (for the Objects-by-Value
  // * proposal) are allowed.  This is not yet a standard, so it must
  // * explicitly be called for by setting the -stateful argument to the
  // * compiler.  If -stateful does not appear on the command line, then
  // * the IDL will be parsed according to the standards.
  // **/
  //public boolean   parseStateful  = false;
  /**
   * A list of strings, each of which is a path from which included files
   * are found.
   **/
  public Vector includePaths = new Vector ();

  /**
   * A table of defined symbols.  The key is the symbol name; the value
   * (if any) is the replacement value for the symbol.
   **/
  public Hashtable definedSymbols = new Hashtable ();

  /**
   * (f46082.46.01) True if new module entries are created for each
   * re-opened module.
   **/
  public boolean cppModule = false;

  /**
   * -version option.
   **/
  public boolean versionRequest = false;  // <D58319>

  // <f60858.1> Specify the maximal level of the CORBA spec. the parser
  // will support.
  //
  // NOTE: For BOSS 3.0, specify at 2.2.  Raise to greater value in future
  //       releases.
  /**
   * -corba [level] option, where [level] is a floating-point number indicating
   * the maximal level of CORBA IDL the parser framework can accept.
   **/
  public float corbaLevel = 2.2f;
  // <d62023>
  /**
   * -noWarn option.  Suppress warnings when true.
   **/
  public boolean noWarn = false;  // Issue warnings by default.

    // Currently defined debug flags.  Any additions must be called xxxDebugFlag.
    // All debug flags must be public boolean types.
    // These are set by passing the flag -ORBDebug x,y,z in the ORB init args.
    // Note that x,y,z must not contain spaces.
    public boolean scannerDebugFlag = false ;
    public boolean tokenDebugFlag = false ;

} // class Arguments