diff options
Diffstat (limited to 'include/llvm')
| -rw-r--r-- | include/llvm/Assembly/Parser.h | 11 | ||||
| -rw-r--r-- | include/llvm/CodeGen/InstrSelection.h | 5 | ||||
| -rw-r--r-- | include/llvm/Support/ProgramOption.h | 142 | ||||
| -rw-r--r-- | include/llvm/Support/ProgramOptions.h | 145 | ||||
| -rw-r--r-- | include/llvm/Tools/CommandLine.h | 370 |
5 files changed, 270 insertions, 403 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 |