Large scale changes to implement new command line argument facility

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@272 91177308-0d34-0410-b5e6-96231b3b80d8

32 files changed, 671 insertions, 1366 deletions

diff --git a/include/llvm/Assembly/Parser.h b/include/llvm/Assembly/Parser.h
index 5ac6ec20fa..4dc2bfb059 100644
--- a/include/llvm/Assembly/Parser.h
+++ b/include/llvm/Assembly/Parser.h
@@ -10,14 +10,13 @@
 #include <string>
 
 class Module;
-class ToolCommandLine;
 class ParseException;
 
 
 // The useful interface defined by this file... Parse an ascii file, and return
 // the internal representation in a nice slice'n'dice'able representation.
 //
-Module *ParseAssemblyFile(const ToolCommandLine &Opts) throw (ParseException);
+Module *ParseAssemblyFile(const string &Filename) throw (ParseException);
 
 //===------------------------------------------------------------------------===
 //                              Helper Classes
@@ -28,7 +27,7 @@ Module *ParseAssemblyFile(const ToolCommandLine &Opts) throw (ParseException);
 //
 class ParseException {
 public:
-  ParseException(const ToolCommandLine &Opts, const string &message, 
+  ParseException(const string &filename, const string &message, 
 		 int LineNo = -1, int ColNo = -1);
 
   ParseException(const ParseException &E);
@@ -42,8 +41,8 @@ public:
     return Message;
   }
 
-  inline const ToolCommandLine &getOptions() const {
-    return Opts;                           // Get the options obj used to parse.
+  inline const string &getFilename() const {
+    return Filename;
   }
 
   // getErrorLocation - Return the line and column number of the error in the
@@ -56,7 +55,7 @@ public:
   }
 
 private :
-  const ToolCommandLine &Opts;
+  string Filename;
   string Message;
   int LineNo, ColumnNo;                               // -1 if not relevant
 
diff --git a/include/llvm/CodeGen/InstrSelection.h b/include/llvm/CodeGen/InstrSelection.h
index 0873003baf..e5a93b4727 100644
--- a/include/llvm/CodeGen/InstrSelection.h
+++ b/include/llvm/CodeGen/InstrSelection.h
@@ -22,8 +22,6 @@ class InstructionNode;
 class TmpInstruction;
 class ConstPoolVal;
 
-enum { DEBUG_TREES_NONE = 0, DEBUG_INSTR_TREES = 1, DEBUG_BURG_TREES = 5 };
-
 //---------------------------------------------------------------------------
 // GLOBAL data and an external function that must be implemented
 // for each architecture.
@@ -53,8 +51,7 @@ extern bool	ThisIsAChainRule	(int eruleno);
 //---------------------------------------------------------------------------
 
 bool		SelectInstructionsForMethod	(Method* method,
-						 CompileContext& ccontext,
-						 int DebugLevel);
+						 CompileContext& ccontext);
 
 
 // Debugging function to print the generated instructions
diff --git a/include/llvm/Support/ProgramOption.h b/include/llvm/Support/ProgramOption.h
deleted file mode 100644
index 83eeac60a8..0000000000
--- a/include/llvm/Support/ProgramOption.h
+++ /dev/null
@@ -1,142 +0,0 @@
-// $Id$ -*-c++-*-
-//***************************************************************************
-//
-// File:
-//    ProgramOption.h
-//
-// Purpose:
-//    General representations for a program option.
-//
-// History:
-//    08/08/95 - adve  - created in the dHPF compiler
-//    11/26/96 - adve  - EvalOpt now returns #args consumed, or -1 for error
-//    07/15/01 - vadve - Copied to LLVM system and modified
-//
-//**************************************************************************/
-
-#ifndef LLVM_SUPPORT_PROGRAMOPTION_H
-#define LLVM_SUPPORT_PROGRAMOPTION_H
-
-#include "llvm/Support/Unique.h"
-#include <string>
-
-
-class ProgramOption: public Unique {
-public:
-  /*ctor*/	ProgramOption	(const string &_argString,
-				 const string &_helpMesg,
-				 int _minExpectedArgs = 1)
-			: optionSpecified(false),
-			  argString(_argString),
-			  helpMesg(_helpMesg),
-			  minExpectedArgs(_minExpectedArgs) {}
-    
-  /*dtor*/ virtual ~ProgramOption() {}
-  
-  // Pure virtual function for an option with 0 or more arguments.
-  // `optarg' points to the start of the next word in argv[].
-  // It will be NULL if there are no more words.
-  // The return value indicates the number of words of argv[] that
-  // were consumed by EvalOpt and should be discarded.
-  // A return value of -1 indicates an error.
-  // 
-  virtual int		EvalOpt		(const string &) = 0;
-
-  // Returns the value associated with the option as a human-readable
-  // string.
-  virtual string GetTextValue	() const = 0;
-  
-  // Inline accessor functions for common option information
-  // 
-  bool			OptionSpecified	() const { return optionSpecified; }
-  const string		ArgString	() const { return argString; }
-  const string 		HelpMesg	() const { return helpMesg; }
-  int			MinExpectedArgs	() const { return minExpectedArgs; }
-  
-protected:
-  bool	 optionSpecified;
-  string argString;
-  string helpMesg;
-  int	 minExpectedArgs;
-};
-
-//**************************************************************************/
-
-class StringOption : public ProgramOption {
-public:
-  /*ctor*/		StringOption	(const string &argString,
-					 const string &helpMesg,
-					 const string &initValue = "", 
-					 bool append = false);
-	// append = false:  EvalOpt will overwrite preexisting value 
-	// append = true :  EvalOpt will append <optArg> to value 
-  
-  /*dtor*/ virtual	~StringOption	() {}
-  
-  virtual int		EvalOpt		(const string &optarg);
-  
-  const string &Value() const { return value; }
-  virtual string GetTextValue() const { return value; }
-  
-protected:
-  string value;
-  bool	append; 
-};
-
-//**************************************************************************/
-
-// -<flag_opt>	 sets the flag to TRUE
-// -<flag_opt> 0 sets the flag to FALSE
-// 
-// To provide an actual argument (not option) of "0", mark the
-// end of the options with "--" (see getopt(1)).
-
-class FlagOption : public ProgramOption {
-public:
-  FlagOption(const string &argString, const string &helpMesg,
-	     bool initValue = false);
-    
-  virtual ~FlagOption() {}
-    
-  virtual int		EvalOpt		(const string &optarg);
-    
-  bool			Value		() const { return value; }
-  virtual string GetTextValue() const { return value ? "true" : "false";}
-private:
-  bool value;
-};
-
-//**************************************************************************/
-
-class RealValuedOption : public ProgramOption {
-public:
-  /*ctor*/		RealValuedOption(const string &argString,
-					 const string &helpMesg,
-					 double initValue = 0.0);
-  /*dtor*/ virtual	~RealValuedOption() {}
-    
-  virtual int		EvalOpt		(const string &optarg);
-  
-  double		Value		() const { return value; }
-  virtual string GetTextValue() const;
-    
-private:
-  double value;
-};
-
-//**************************************************************************/
-
-class IntegerValuedOption : public RealValuedOption {
-public:
-  /*ctor*/		IntegerValuedOption(const string &argString,
-					    const string &helpMesg,
-					    int initValue = 0);
-  /*ctor*/ virtual	~IntegerValuedOption() {}
-  
-  int Value() const;
-  virtual string GetTextValue() const;
-};
-
-//**************************************************************************/
-
-#endif
diff --git a/include/llvm/Support/ProgramOptions.h b/include/llvm/Support/ProgramOptions.h
deleted file mode 100644
index 9ebc975c46..0000000000
--- a/include/llvm/Support/ProgramOptions.h
+++ /dev/null
@@ -1,145 +0,0 @@
-// $Id$ -*-c++-*-
-//***************************************************************************
-//
-// File:
-//	ProgramOptions.h
-//
-// Purpose:
-//	A representation of options for any program.
-//
-// History:
-//	08/08/95 - adve  - Created in the dHPF compiler
-//      10/10/96 - mpal, dbaker - converted to const member functions.
-//      10/19/96 - meven - slightly changed interface to accomodate 
-//                         arguments other than -X type options
-//	07/15/01 - vadve - Copied to LLVM system and modified
-//
-//**************************************************************************/
-
-#ifndef LLVM_SUPPORT_PROGRAMOPTIONS_H
-#define LLVM_SUPPORT_PROGRAMOPTIONS_H
-
-#include "llvm/Support/Unique.h"
-#include <vector>
-#include <hash_map>
-#include <string>
-
-template <> struct hash<string> {
-  size_t operator()(string const &str) const {
-    return hash<char const *>()(str.c_str());
-  }
-};
-
-class ProgramOption;
-
-//---------------------------------------------------------------------------
-//
-//  Class: ProgramOptions
-//
-//  Base Classes: none
-//
-//  Class Data Members:
-//	ProgramOptionsRepr*	Internal representation of program options,
-//				accessible to derived classes.
-//  Purpose:
-//     Base class for representing the set of options for a program.
-//
-//---------------------------------------------------------------------------
-
-class ProgramOptions: public Unique {
-public:
-  /*ctor*/	ProgramOptions	(int _argc,
-				 const char* _argv[],
-				 const char* _envp[]);
-  /*dtor*/	~ProgramOptions	()	{}	
-  
-  //--------------------------------------------------------------------
-  // Retrieving different kinds of arguments.
-  // The required argument is specified by the optionString.
-  //--------------------------------------------------------------------
-    
-  string StringOptionValue(const string &optionString) const;
-  bool		FlagOptionValue	 (const string &optionString) const;
-  double	RealOptionValue	 (const string &optionString) const;
-  int		IntOptionValue	 (const string &optionString) const;
-  
-  bool		OptionSpecified	 (const string &optionString) const;
-    
-  //--------------------------------------------------------------------
-  // The name used to invoke this program.
-  //--------------------------------------------------------------------
-  const char* ProgramName	 () const;
-    
-  //--------------------------------------------------------------------
-  // Access to unparsed arguments
-  //--------------------------------------------------------------------
-  int         NumberOfOtherOptions() const;
-  const char* OtherOption(int i) const;
-
-  //--------------------------------------------------------------------
-  // Access to the original arguments
-  //--------------------------------------------------------------------
-  const char**		GetOriginalArgs() const;
-  void PrintArgs(ostream &out) const;
-
-  //--------------------------------------------------------------------
-  // Derived classes may use PrintOptions in their own PrintUsage() fct 
-  // to print information about optional, required, or additional
-  // arguments 
-  //--------------------------------------------------------------------
-  virtual void PrintOptions    (ostream& stream) const;
-  virtual void Usage           () const;
-
-  //--------------------------------------------------------------------
-  // Generate a human-friendly description of the options actually set.
-  // The vector returned contains a multiple of 3 of entries, entry 3n is
-  // the name of the option, entry 3n + 1 contains the description of
-  // the option and entry 3n + 2 contains the ascii value of the option.
-  // All entries are allocated using malloc and can be freed with 'free'.
-  //--------------------------------------------------------------------
-  virtual vector<string> GetDescription	() const;
-  
-protected:
-  //--------------------------------------------------------------------
-  // Called by the subclass to register each possible option
-  // used by the program.  Assumes ownership of the ProgramOption.
-  //--------------------------------------------------------------------
-  void				Register	(ProgramOption* option);
-
-  //--------------------------------------------------------------------
-  // Parses the options.
-  //--------------------------------------------------------------------
-  void	ParseArgs	(int argc,
-			 const char* argv[],
-			 const char* envp[]);
-  
-  inline ProgramOption* OptionHandler(const string &optString) {
-    hash_map<string, ProgramOption*>::iterator hp = 
-      optionRegistry.find(optString);
-    return (hp != optionRegistry.end()) ? hp->second : 0;
-  }
-  inline const ProgramOption* OptionHandler(const string &optString) const {
-    hash_map<string, ProgramOption*>::const_iterator hp = 
-      optionRegistry.find(optString);
-    return (hp != optionRegistry.end()) ? hp->second : 0;
-  }
-protected:
-  //--------------------------------------------------------------------
-  // Functions that must be overridden by the subclass.
-  //--------------------------------------------------------------------
-  
-  virtual void	ParseExtraArgs	() = 0; // called after successful ParseArgs
-  
-  virtual void	PrintUsage	(ostream& stream) const = 0;
-  
-protected:
-  hash_map<string, ProgramOption*> optionRegistry;
-  int			argc;
-  const char**		argv;
-  const char**		envp;
-  int			argsConsumed;
-};
-
-//**************************************************************************/
-
-#endif
diff --git a/include/llvm/Tools/CommandLine.h b/include/llvm/Tools/CommandLine.h
index 76b4e97989..35d96d4922 100644
--- a/include/llvm/Tools/CommandLine.h
+++ b/include/llvm/Tools/CommandLine.h
@@ -1,12 +1,8 @@
 //===-- llvm/Tools/CommandLine.h - Command line parser for tools -*- C++ -*--=//
 //
 // This class implements a command line argument processor that is useful when
-// creating a tool.
-//
-// This class is defined entirely inline so that you don't have to link to any
-// libraries to use this.
-//
-// TODO: make this extensible by passing in arguments to be read.
+// creating a tool.  It provides a simple, minimalistic interface that is easily
+// extensible and supports nonlocal (library) command line options.
 //
 //===----------------------------------------------------------------------===//
 
@@ -14,113 +10,275 @@
 #define LLVM_TOOLS_COMMANDLINE_H
 
 #include <string>
+#include <vector>
+#include <utility>
+#include <stdarg.h>
+
+namespace cl {   // Short namespace to make usage concise
+
+//===----------------------------------------------------------------------===//
+// ParseCommandLineOptions - Minimalistic command line option processing entry
+//
+void cl::ParseCommandLineOptions(int &argc, char **argv,
+				 const char *Overview = 0);
+
+
+//===----------------------------------------------------------------------===//
+// Global flags permitted to be passed to command line arguments
+
+enum FlagsOptions {
+  NoFlags         = 0x00,      // Marker to make explicit that we have no flags
+
+  // Flags for the number of occurances allowed...
+  Optional        = 0x00,      // Zero or One occurance
+  ZeroOrMore      = 0x01,      // Zero or more occurances allowed
+  Required        = 0x02,      // One occurance required
+  OneOrMore       = 0x03,      // One or more occurances required
+  OccurancesMask  = 0x07,
+
+  // Number of arguments to a value expected...
+  //Optional      = 0x00,      // The value can oppear... or not
+  ValueRequired   = 0x08,      // The value is required to appear!
+  ValueDisallowed = 0x10,      // A value may not be specified (for flags)
+  ValueMask       = 0x18,
+
+  // Control whether -help shows the command line option...
+  Hidden          = 0x20,      // -help doesn't -help-hidden does
+  ReallyHidden    = 0x60,      // Neither -help nor -help-hidden show this arg
+  HiddenMask      = 0x60,
+};
+
+
+//===----------------------------------------------------------------------===//
+// Option Base class
+//
+class Option {
+  friend void cl::ParseCommandLineOptions(int &, char **, const char *Overview);
+
+  // handleOccurances - Overriden by subclasses to handle the value passed into
+  // an argument.  Should return true if there was an error processing the
+  // argument and the program should exit.
+  //
+  virtual bool handleOccurance(const char *ArgName, const string &Arg) = 0;
+
+  int NumOccurances;          // The number of times specified
+public:
+  const char * const ArgStr;  // The argument string itself (ex: "help", "o")
+  const char * const HelpStr; // The descriptive text message for --help
+  const int Flags;            // Flags for the argument
+
+protected:
+  Option(const char *ArgStr, const char *Message, int Flags);
+  Option(int flags) : ArgStr(""), HelpStr(""), Flags(flags) {}
+
+  // Prints option name followed by message.  Always returns true.
+  bool error(string Message, const char *ArgName = 0);
+
+  // addOccurance - Wrapper around handleOccurance that enforces Flags
+  //
+  bool addOccurance(const char *ArgName, const string &Value);
+
+public:
+  // Return the width of the option tag for printing...
+  virtual unsigned getOptionWidth() const;
+
+  // printOptionInfo - Print out information about this option.  The 
+  // to-be-maintained width is specified.
+  //
+  virtual void printOptionInfo(unsigned GlobalWidth) const;
+
+public:
+  inline int getNumOccurances() const { return NumOccurances; }
+  virtual ~Option() {}
+};
+
+
+//===----------------------------------------------------------------------===//
+// Boolean/flag command line option
+//
+class Flag : public Option {
+  bool Value;
+  virtual bool handleOccurance(const char *ArgName, const string &Arg);
+public:
+  inline Flag(const char *ArgStr, const char *Message, int Flags = 0, 
+	      bool DefaultVal = 0) : Option(ArgStr, Message, Flags), 
+				     Value(DefaultVal) {}
+  operator bool() const { return Value; }
+  inline bool getValue() const { return Value; }
+  inline void setValue(bool Val) { Value = Val; }
+};
+
+
+
+//===----------------------------------------------------------------------===//
+// Integer valued command line option
+//
+class Int : public Option {
+  int Value;
+  virtual bool handleOccurance(const char *ArgName, const string &Arg);
+public:
+  inline Int(const char *ArgStr, const char *Help, int Flags = 0,
+	     int DefaultVal = 0) : Option(ArgStr, Help, Flags | ValueRequired),
+				   Value(DefaultVal) {}
+  inline operator int() const { return Value; }
+  inline int getValue() const { return Value; }
+  inline void setValue(int Val) { Value = Val; }
+};
+
 
-class ToolCommandLine {
+//===----------------------------------------------------------------------===//
+// String valued command line option
+//
+class String : public Option {
+  string Value;
+  virtual bool handleOccurance(const char *ArgName, const string &Arg);
+public:
+  inline String(const char *ArgStr, const char *Help, int Flags = 0, 
+		const char *DefaultVal = "") 
+    : Option(ArgStr, Help, Flags | ValueRequired), Value(DefaultVal) {}
+
+  inline const string &getValue() const { return Value; }
+  inline void setValue(const string &Val) { Value = Val; }
+};
+
+
+//===----------------------------------------------------------------------===//
+// Enum valued command line option
+//
+#define clEnumVal(ENUMVAL, DESC) #ENUMVAL, ENUMVAL, DESC
+#define clEnumValN(ENUMVAL, FLAGNAME, DESC) FLAGNAME, ENUMVAL, DESC
+
+// EnumBase - Base class for all enum/varargs related argument types...
+class EnumBase : public Option {
+protected:
+  // Use a vector instead of a map, because the lists should be short,
+  // the overhead is less, and most importantly, it keeps them in the order
+  // inserted so we can print our option out nicely.
+  vector<pair<const char *, pair<int, const char *> > > ValueMap;
+
+  inline EnumBase(const char *ArgStr, const char *Help, int Flags)
+    : Option(ArgStr, Help, Flags) {}
+  inline EnumBase(int Flags) : Option(Flags) {}
+
+  // processValues - Incorporate the specifed varargs arglist into the 
+  // ValueMap.
+  //
+  void processValues(va_list Vals);
+
+  // registerArgs - notify the system about these new arguments
+  void registerArgs();
+
+public:
+  // Turn an enum into the arg name that activates it
+  const char *getArgName(int ID) const;
+  const char *getArgDescription(int ID) const;
+};
+
+class EnumValueBase : public EnumBase {
+protected:
+  int Value;
+  inline EnumValueBase(const char *ArgStr, const char *Help, int Flags)
+    : EnumBase(ArgStr, Help, Flags) {}
+  inline EnumValueBase(int Flags) : EnumBase(Flags) {}
+
+  // handleOccurance - Set Value to the enum value specified by Arg
+  virtual bool handleOccurance(const char *ArgName, const string &Arg);
+
+  // Return the width of the option tag for printing...
+  virtual unsigned getOptionWidth() const;
+
+  // printOptionInfo - Print out information about this option.  The 
+  // to-be-maintained width is specified.
+  //
+  virtual void printOptionInfo(unsigned GlobalWidth) const;
+};
+
+template <class E>  // The enum we are representing
+class Enum : public EnumValueBase {
 public:
-  inline ToolCommandLine(int &argc, char **argv, bool OutputBytecode = true);
-  inline ToolCommandLine(const string &infn, const string &outfn = "-");
-  inline ToolCommandLine(const ToolCommandLine &O);
-  inline ToolCommandLine &operator=(const ToolCommandLine &O);
-
-  inline bool getForce() const { return Force; }
-  inline const string getInputFilename() const { return InputFilename; }
-  inline const string getOutputFilename() const { return OutputFilename; }
-
-private:
-  void calculateOutputFilename(bool OutputBytecode) {
-    OutputFilename = InputFilename;
-    unsigned Len = OutputFilename.length();
-
-    if (Len <= 3) { 
-      OutputFilename += (OutputBytecode ? ".bc" : ".ll"); 
-      return; 
-    }
-
-    if (OutputBytecode) {
-      if (OutputFilename[Len-3] == '.' &&
-	  OutputFilename[Len-2] == 'l' &&
-	  OutputFilename[Len-1] == 'l') {   // .ll -> .bc	  
-	OutputFilename[Len-2] = 'b'; 
-	OutputFilename[Len-1] = 'c';
-      } else {
-	OutputFilename += ".bc";
-      }
-    } else {
-      if (OutputFilename[Len-3] == '.' &&
-	  OutputFilename[Len-2] == 'b' &&
-	  OutputFilename[Len-1] == 'c') {   // .ll -> .bc	  
-	OutputFilename[Len-2] = 'l'; 
-	OutputFilename[Len-1] = 'l';
-      } else {
-	OutputFilename += ".ll";
-      }
-    }
+  inline Enum(const char *ArgStr, int Flags, const char *Help, ...)
+    : EnumValueBase(ArgStr, Help, Flags | ValueRequired) {
+    va_list Values;
+    va_start(Values, Help);
+    processValues(Values);
+    va_end(Values);
+    Value = ValueMap.front().second.first; // Grab default value
   }
 
-private:
-  string InputFilename;           // Filename to read from.  If "-", use stdin.
-  string OutputFilename;          // Filename to write to.   If "-", use stdout.
-  bool   Force;                   // Force output (-f argument)
+  inline E getValue() const { return (E)Value; }
+  inline void setValue(E Val) { Value = (E)Val; }
 };
 
-inline ToolCommandLine::ToolCommandLine(int &argc, char **argv, bool OutBC) 
-  : InputFilename("-"), OutputFilename("-"), Force(false) {
-  bool FoundInputFN  = false;
-  bool FoundOutputFN = false;
-  bool FoundForce    = false;
-
-  for (int i = 1; i < argc; i++) {
-    int RemoveArg = 0;
-    
-    if (argv[i][0] == '-') {
-      if (!FoundInputFN && argv[i][1] == 0) { // Is the current argument '-'
-	InputFilename = argv[i];
-	FoundInputFN = true;
-	RemoveArg = 1;
-      } else if (!FoundOutputFN && (argv[i][1] == 'o' && argv[i][2] == 0)) {
-	// Is the argument -o?
-	if (i+1 < argc) {        // Next arg is output fn
-	  OutputFilename = argv[i+1];
-	  FoundOutputFN = true;
-	  RemoveArg = 2;
-	}
-      } else if (!FoundForce && (argv[i][1] == 'f' && argv[i][2] == 0)) {
-	Force = true;
-	FoundForce = true;
-	RemoveArg = 1;
-      }
-    } else if (!FoundInputFN) {     // Is the current argument '[^-].*'?
-      InputFilename = argv[i];
-      FoundInputFN = true;
-      RemoveArg = 1;
-    }
-					    
-    if (RemoveArg) {
-      argc -= RemoveArg;                           // Shift args over...
-      memmove(argv+i, argv+i+RemoveArg, (argc-i)*sizeof(char*));
-      i--;                                         // Reprocess this argument...
-    }
+
+//===----------------------------------------------------------------------===//
+// Enum flags command line option
+//
+class EnumFlagsBase : public EnumValueBase {
+protected:
+  virtual bool handleOccurance(const char *ArgName, const string &Arg);
+  inline EnumFlagsBase(int Flags) : EnumValueBase(Flags | ValueDisallowed) {}
+
+  // Return the width of the option tag for printing...
+  virtual unsigned getOptionWidth() const;
+
+  // printOptionInfo - Print out information about this option.  The 
+  // to-be-maintained width is specified.
+  //
+  virtual void printOptionInfo(unsigned GlobalWidth) const;
+};
+
+template <class E>  // The enum we are representing
+class EnumFlags : public EnumFlagsBase {
+public:
+  inline EnumFlags(int Flags, ...) : EnumFlagsBase(Flags) {
+    va_list Values;
+    va_start(Values, Flags);
+    processValues(Values);
+    va_end(Values);
+    registerArgs();
+    Value = ValueMap.front().second.first; // Grab default value
+  }
+  inline E getValue() const { return (E)Value; }
+  inline void setValue(E Val) { Value = (E)Val; }
+};
+
+
+//===----------------------------------------------------------------------===//
+// Enum list command line option
+//
+class EnumListBase : public EnumBase {
+protected:
+  vector<int> Values;  // The options specified so far.
+
+  inline EnumListBase(int Flags) 
+    : EnumBase(Flags | ValueDisallowed | ZeroOrMore) {}
+  virtual bool handleOccurance(const char *ArgName, const string &Arg);
+
+  // Return the width of the option tag for printing...
+  virtual unsigned getOptionWidth() const;
+
+  // printOptionInfo - Print out information about this option.  The 
+  // to-be-maintained width is specified.
+  //
+  virtual void printOptionInfo(unsigned GlobalWidth) const;
+public:
+  inline unsigned size() { return Values.size(); }
+};
+
+template <class E>  // The enum we are representing
+class EnumList : public EnumListBase {
+public:
+  inline EnumList(int Flags, ...) : EnumListBase(Flags) {
+    va_list Values;
+    va_start(Values, Flags);
+    processValues(Values);
+    va_end(Values);
+    registerArgs();
   }
+  inline E getValue(unsigned i) const { return (E)Values[i]; }
+  inline E operator[](unsigned i) const { return (E)Values[i]; }
+};
 
-  if (!FoundOutputFN && InputFilename != "-")
-    calculateOutputFilename(OutBC);
-}
-
-inline ToolCommandLine::ToolCommandLine(const string &inf, 
-                                        const string &outf) 
-  : InputFilename(inf), OutputFilename(outf), Force(false) {
-}
-
-inline ToolCommandLine::ToolCommandLine(const ToolCommandLine &Opts) 
-  : InputFilename(Opts.InputFilename), OutputFilename(Opts.OutputFilename),
-    Force(Opts.Force) {
-}
-
-inline ToolCommandLine &ToolCommandLine::operator=(const ToolCommandLine &Opts){
-  InputFilename  = Opts.InputFilename;
-  OutputFilename = Opts.OutputFilename;
-  Force          = Opts.Force;
-  return *this;
-}
+} // End namespace cl
 
 #endif
diff --git a/lib/CodeGen/InstrSelection/InstrSelection.cpp b/lib/CodeGen/InstrSelection/InstrSelection.cpp
index 4843a70dce..0ad1dbdb54 100644
--- a/lib/CodeGen/InstrSelection/InstrSelection.cpp
+++ b/lib/CodeGen/InstrSelection/InstrSelection.cpp
@@ -10,8 +10,6 @@
 //***************************************************************************
 
 
-//*************************** User Include Files ***************************/
-
 #include "llvm/CodeGen/InstrSelection.h"
 #include "llvm/Method.h"
 #include "llvm/BasicBlock.h"
@@ -20,7 +18,20 @@
 #include "llvm/Instruction.h"
 #include