replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

General support utilities like a program options class and a StringMap 

class for mapping strings to arbitrary things.

llvm-svn: 228
This commit is contained in:
Vikram S. Adve 2001-07-21 12:40:18 +00:00
parent ad5ac0fab4
commit 1f3de470af
4 changed files with 429 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

151
llvm/include/llvm/Support/ProgramOption.h Normal file
View File

@ -0,0 +1,151 @@
// $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
//************************** System Include Files **************************/
#include <string>
//*************************** User Include Files ***************************/
#include "llvm/Support/Unique.h"
#include "llvm/Support/StringUtils.h"
//********************** Local Variable Definitions ************************/
class ProgramOption: public Unique {
public:
/*ctor*/ ProgramOption (const char* _argString,
const char* _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 char* optarg) = 0;
// Returns the value associated with the option as a human-readable
// string. The memory returned is allocated via `malloc'.
virtual char* GetTextValue () const = 0;
// Inline accessor functions for common option information
//
bool OptionSpecified () const { return optionSpecified; }
const char* ArgString () const { return argString.c_str(); }
const char* HelpMesg () const { return helpMesg.c_str(); }
int MinExpectedArgs () const { return minExpectedArgs; }
protected:
bool optionSpecified;
string argString;
string helpMesg;
int minExpectedArgs;
};
//**************************************************************************/
class StringOption : public ProgramOption {
public:
/*ctor*/ StringOption (const char* argString,
const char* helpMesg,
const char* 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 char* optarg);
const char* Value () const { return value.c_str(); }
virtual char* GetTextValue () const { return strdup(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:
/*ctor*/ FlagOption (const char* argString,
const char* helpMesg,
bool initValue = false);
/*dtor*/ virtual ~FlagOption () {}
virtual int EvalOpt (const char* optarg);
bool Value () const { return value; }
virtual char* GetTextValue () const { return strdup(
value ? "true" : "false");}
private:
bool value;
};
//**************************************************************************/
class RealValuedOption : public ProgramOption {
public:
/*ctor*/ RealValuedOption(const char* argString,
const char* helpMesg,
double initValue = 0.0);
/*dtor*/ virtual ~RealValuedOption() {}
virtual int EvalOpt (const char* optarg);
double Value () const { return value; }
virtual char* GetTextValue () const;
private:
double value;
};
//**************************************************************************/
class IntegerValuedOption : public RealValuedOption {
public:
/*ctor*/ IntegerValuedOption(const char* argString,
const char* helpMesg,
int initValue = 0);
/*ctor*/ virtual ~IntegerValuedOption() {}
int Value () const;
virtual char* GetTextValue () const;
};
//**************************************************************************/
#endif

147
llvm/include/llvm/Support/ProgramOptions.h Normal file
View File

@ -0,0 +1,147 @@
// $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
//************************** System Include Files **************************/
#include <iostream.h>
//*************************** User Include Files ***************************/
#include "llvm/Support/Unique.h"
#include "llvm/Support/StringUtils.h"
//************************ Forward Declarations ****************************/
class ProgramOption;
//************************* Main Driver Routine ****************************/
//---------------------------------------------------------------------------
//
// 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.
//--------------------------------------------------------------------
const char* StringOptionValue(const char* optionString) const;
bool FlagOptionValue (const char* optionString) const;
double RealOptionValue (const char* optionString) const;
int IntOptionValue (const char* optionString) const;
bool OptionSpecified (const char* 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<char*> 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 char* optString) {
ProgramOption** poPtr = optionRegistry.query(optString);
return poPtr? *poPtr : NULL;
}
inline const ProgramOption* OptionHandler(const char* optString) const {
const ProgramOption* const* poPtr = optionRegistry.query(optString);
return poPtr? *poPtr : NULL;
}
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:
StringMap<ProgramOption*> optionRegistry;
int argc;
const char** argv;
const char** envp;
int argsConsumed;
};
//**************************************************************************/
#endif

75
llvm/include/llvm/Support/StringUtils.h Normal file
View File

@ -0,0 +1,75 @@
// $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
//************************** System Include Files **************************/
#include <string>
#include <hash_map>
//*************************** User Include Files ***************************/
#include "llvm/Support/Unique.h"
class ProgramOption;
//************************ Forward Declarations ****************************/
//***************************** String Functions ****************************/
struct eqstr
{
bool operator()(const char* s1, const char* s2) const
{
return strcmp(s1, s2) == 0;
}
};
//***************************** String Classes *****************************/
template <class DataType>
class StringMap:
public hash_map<const char*, DataType, hash<const char*>, eqstr>
{
public:
typedef hash_map<const char*, DataType, hash<const char*>, eqstr>::iterator
iterator;
typedef hash_map<const char*, DataType, hash<const char*>, eqstr>::const_iterator
const_iterator;
public:
DataType* query(const char* _key)
{
hash_map<const char*, DataType, hash<const char*>, eqstr>::iterator
hashPair = this->find(_key);
return (hashPair == this->end())? NULL : & (*hashPair).second;
}
const DataType* query(const char* _key) const
{
hash_map<const char*, DataType, hash<const char*>, eqstr>::const_iterator
hashPair = this->find(_key);
return (hashPair == this->end())? NULL : & (*hashPair).second;
}
};
//**************************************************************************/
#endif

56
llvm/include/llvm/Support/Unique.h Normal file
View File

@ -0,0 +1,56 @@
//***************************************************************************
// class Unique:
// Mixin class for classes that should never be copied.
//
// Purpose:
// This mixin disables both the copy constructor and the
// assignment operator. It also provides a default equality operator.
//
// History:
// 09/24/96 - vadve - Created (adapted from dHPF).
//
//***************************************************************************
#ifndef UNIQUE_H
#define UNIQUE_H
#include <assert.h>
class Unique
{
protected:
/*ctor*/ Unique () {}
/*dtor*/ virtual ~Unique () {}
public:
virtual bool operator== (const Unique& u1) const;
virtual bool operator!= (const Unique& u1) const;
private:
//
// Disable the copy constructor and the assignment operator
// by making them both private:
//
/*ctor*/ Unique (Unique&) { assert(0); }
virtual Unique& operator= (const Unique& u1) { assert(0);
return *this; }
};
// Unique object equality.
inline bool
Unique::operator==(const Unique& u2) const
{
return (bool) (this == &u2);
}
// Unique object inequality.
inline bool
Unique::operator!=(const Unique& u2) const
{
return (bool) !(this == &u2);
}
#endif