/*
* 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
* `/<arg> [<qualifiers>]' or `-<arg> [<qualifiers>]' where <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