| /* |
| * 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 |