#include "llvm/Config/config.h"
#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/ManagedStatic.h"
+#include "llvm/Support/Streams.h"
+#include "llvm/System/Path.h"
#include <algorithm>
#include <functional>
#include <map>
+#include <ostream>
#include <set>
-#include <iostream>
#include <cstdlib>
#include <cerrno>
#include <cstring>
using namespace llvm;
-
using namespace cl;
-// Globals for name and overview of program
-static const char *ProgramName = "<unknown>";
+//===----------------------------------------------------------------------===//
+// Template instantiations and anchors.
+//
+TEMPLATE_INSTANTIATION(class basic_parser<bool>);
+TEMPLATE_INSTANTIATION(class basic_parser<int>);
+TEMPLATE_INSTANTIATION(class basic_parser<unsigned>);
+TEMPLATE_INSTANTIATION(class basic_parser<double>);
+TEMPLATE_INSTANTIATION(class basic_parser<float>);
+TEMPLATE_INSTANTIATION(class basic_parser<std::string>);
+
+TEMPLATE_INSTANTIATION(class opt<unsigned>);
+TEMPLATE_INSTANTIATION(class opt<int>);
+TEMPLATE_INSTANTIATION(class opt<std::string>);
+TEMPLATE_INSTANTIATION(class opt<bool>);
+
+void Option::anchor() {}
+void basic_parser_impl::anchor() {}
+void parser<bool>::anchor() {}
+void parser<int>::anchor() {}
+void parser<unsigned>::anchor() {}
+void parser<double>::anchor() {}
+void parser<float>::anchor() {}
+void parser<std::string>::anchor() {}
+
+//===----------------------------------------------------------------------===//
+
+// Globals for name and overview of program. Program name is not a string to
+// avoid static ctor/dtor issues.
+static char ProgramName[80] = "<premain>";
static const char *ProgramOverview = 0;
// This collects additional help to be printed.
-static std::vector<const char*> &MoreHelp() {
- static std::vector<const char*> moreHelp;
- return moreHelp;
-}
+static ManagedStatic<std::vector<const char*> > MoreHelp;
-extrahelp::extrahelp(const char* Help)
+extrahelp::extrahelp(const char *Help)
: morehelp(Help) {
- MoreHelp().push_back(Help);
+ MoreHelp->push_back(Help);
}
//===----------------------------------------------------------------------===//
-// Basic, shared command line option processing machinery...
+// Basic, shared command line option processing machinery.
//
-// Return the global command line option vector. Making it a function scoped
-// static ensures that it will be initialized correctly before its first use.
-//
-static std::map<std::string, Option*> &getOpts() {
- static std::map<std::string, Option*> CommandLineOptions;
- return CommandLineOptions;
-}
+static ManagedStatic<std::map<std::string, Option*> > Options;
+static ManagedStatic<std::vector<Option*> > PositionalOptions;
static Option *getOption(const std::string &Str) {
- std::map<std::string,Option*>::iterator I = getOpts().find(Str);
- return I != getOpts().end() ? I->second : 0;
-}
-
-static std::vector<Option*> &getPositionalOpts() {
- static std::vector<Option*> Positional;
- return Positional;
+ std::map<std::string,Option*>::iterator I = Options->find(Str);
+ return I != Options->end() ? I->second : 0;
}
static void AddArgument(const char *ArgName, Option *Opt) {
if (getOption(ArgName)) {
- std::cerr << ProgramName << ": CommandLine Error: Argument '"
- << ArgName << "' defined more than once!\n";
+ cerr << ProgramName << ": CommandLine Error: Argument '"
+ << ArgName << "' defined more than once!\n";
} else {
// Add argument to the argument map!
- getOpts()[ArgName] = Opt;
+ (*Options)[ArgName] = Opt;
}
}
// options have already been processed and the map has been deleted!
//
static void RemoveArgument(const char *ArgName, Option *Opt) {
- if(getOpts().empty()) return;
+ if (Options->empty()) return;
#ifndef NDEBUG
// This disgusting HACK is brought to you courtesy of GCC 3.3.2, which ICE's
std::string Tmp = ArgName;
assert(getOption(Tmp) == Opt && "Arg not in map!");
#endif
- getOpts().erase(ArgName);
+ Options->erase(ArgName);
}
static inline bool ProvideOption(Option *Handler, const char *ArgName,
case ValueOptional:
break;
default:
- std::cerr << ProgramName
- << ": Bad ValueMask flag! CommandLine usage error:"
- << Handler->getValueExpectedFlag() << "\n";
+ cerr << ProgramName
+ << ": Bad ValueMask flag! CommandLine usage error:"
+ << Handler->getValueExpectedFlag() << "\n";
abort();
break;
}
/// using strdup (), so it is the caller's responsibility to free ()
/// them later.
///
-static void ParseCStringVector (std::vector<char *> &output,
- const char *input) {
+static void ParseCStringVector(std::vector<char *> &output,
+ const char *input) {
// Characters which will be treated as token separators:
static const char *delims = " \v\f\t\r\n";
assert(envVar && "Environment variable name missing");
// Get the environment variable they want us to parse options out of.
- const char *envValue = getenv (envVar);
+ const char *envValue = getenv(envVar);
if (!envValue)
return;
// Get program's "name", which we wouldn't know without the caller
// telling us.
- std::vector<char *> newArgv;
- newArgv.push_back (strdup (progName));
+ std::vector<char*> newArgv;
+ newArgv.push_back(strdup(progName));
// Parse the value of the environment variable into a "command line"
// and hand it off to ParseCommandLineOptions().
- ParseCStringVector (newArgv, envValue);
- int newArgc = newArgv.size ();
- ParseCommandLineOptions (newArgc, &newArgv[0], Overview);
+ ParseCStringVector(newArgv, envValue);
+ int newArgc = newArgv.size();
+ ParseCommandLineOptions(newArgc, &newArgv[0], Overview);
// Free all the strdup()ed strings.
- for (std::vector<char *>::iterator i = newArgv.begin (), e = newArgv.end ();
- i != e; ++i) {
+ for (std::vector<char*>::iterator i = newArgv.begin(), e = newArgv.end();
+ i != e; ++i)
free (*i);
- }
}
/// LookupOption - Lookup the option specified by the specified option on the
if (*Arg == 0) return 0;
// Look up the option.
- std::map<std::string, Option*> &Opts = getOpts();
+ std::map<std::string, Option*> &Opts = *Options;
std::map<std::string, Option*>::iterator I =
Opts.find(std::string(Arg, ArgEnd));
return (I != Opts.end()) ? I->second : 0;
void cl::ParseCommandLineOptions(int &argc, char **argv,
const char *Overview) {
- assert((!getOpts().empty() || !getPositionalOpts().empty()) &&
+ assert((!Options->empty() || !PositionalOptions->empty()) &&
"No options specified, or ParseCommandLineOptions called more"
" than once!");
- ProgramName = argv[0]; // Save this away safe and snug
+ sys::Path progname(argv[0]);
+
+ // Copy the program name into ProgName, making sure not to overflow it.
+ std::string ProgName = sys::Path(argv[0]).getLast();
+ if (ProgName.size() > 79) ProgName.resize(79);
+ strcpy(ProgramName, ProgName.c_str());
+
ProgramOverview = Overview;
bool ErrorParsing = false;
- std::map<std::string, Option*> &Opts = getOpts();
- std::vector<Option*> &PositionalOpts = getPositionalOpts();
+ std::map<std::string, Option*> &Opts = *Options;
+ std::vector<Option*> &PositionalOpts = *PositionalOptions;
// Check out the positional arguments to collect information about them.
unsigned NumPositionalRequired = 0;
}
if (Handler == 0) {
- if (ProgramName)
- std::cerr << ProgramName << ": Unknown command line argument '"
- << argv[i] << "'. Try: '" << argv[0] << " --help'\n";
- else
- std::cerr << "Unknown command line argument '" << argv[i] << "'.\n";
+ cerr << ProgramName << ": Unknown command line argument '"
+ << argv[i] << "'. Try: '" << argv[0] << " --help'\n";
ErrorParsing = true;
continue;
}
// Check and handle positional arguments now...
if (NumPositionalRequired > PositionalVals.size()) {
- if (ProgramName)
- std::cerr << ProgramName
- << ": Not enough positional command line arguments specified!\n"
- << "Must specify at least " << NumPositionalRequired
- << " positional arguments: See: " << argv[0] << " --help\n";
- else
- std::cerr << "Not enough positional command line arguments specified!\n"
- << "Must specify at least " << NumPositionalRequired
- << " positional arguments.";
+ cerr << ProgramName
+ << ": Not enough positional command line arguments specified!\n"
+ << "Must specify at least " << NumPositionalRequired
+ << " positional arguments: See: " << argv[0] << " --help\n";
ErrorParsing = true;
} else if (!HasUnlimitedPositionals
&& PositionalVals.size() > PositionalOpts.size()) {
- if (ProgramName)
- std::cerr << ProgramName
- << ": Too many positional arguments specified!\n"
- << "Can specify at most " << PositionalOpts.size()
- << " positional arguments: See: " << argv[0] << " --help\n";
- else
- std::cerr << "Too many positional arguments specified!\n"
- << "Can specify at most " << PositionalOpts.size()
- << " positional arguments.\n";
+ cerr << ProgramName
+ << ": Too many positional arguments specified!\n"
+ << "Can specify at most " << PositionalOpts.size()
+ << " positional arguments: See: " << argv[0] << " --help\n";
ErrorParsing = true;
} else if (ConsumeAfterOpt == 0) {
// Free all of the memory allocated to the map. Command line options may only
// be processed once!
- getOpts().clear();
+ Opts.clear();
PositionalOpts.clear();
- MoreHelp().clear();
+ MoreHelp->clear();
// If we had an error processing our arguments, don't let the program execute
if (ErrorParsing) exit(1);
bool Option::error(std::string Message, const char *ArgName) {
if (ArgName == 0) ArgName = ArgStr;
if (ArgName[0] == 0)
- std::cerr << HelpStr; // Be nice for positional arguments
+ cerr << HelpStr; // Be nice for positional arguments
else
- std::cerr << ProgramName << ": for the -" << ArgName;
- std::cerr << " option: " << Message << "\n";
+ cerr << ProgramName << ": for the -" << ArgName;
+
+ cerr << " option: " << Message << "\n";
return true;
}
AddArgument(ArgStr, this);
if (getFormattingFlag() == Positional)
- getPositionalOpts().push_back(this);
+ PositionalOptions->push_back(this);
else if (getNumOccurrencesFlag() == ConsumeAfter) {
- if (!getPositionalOpts().empty() &&
- getPositionalOpts().front()->getNumOccurrencesFlag() == ConsumeAfter)
+ if (!PositionalOptions->empty() &&
+ PositionalOptions->front()->getNumOccurrencesFlag() == ConsumeAfter)
error("Cannot specify more than one option with cl::ConsumeAfter!");
- getPositionalOpts().insert(getPositionalOpts().begin(), this);
+ PositionalOptions->insert(PositionalOptions->begin(), this);
}
}
if (getFormattingFlag() == Positional) {
std::vector<Option*>::iterator I =
- std::find(getPositionalOpts().begin(), getPositionalOpts().end(), this);
- assert(I != getPositionalOpts().end() && "Arg not registered!");
- getPositionalOpts().erase(I);
+ std::find(PositionalOptions->begin(), PositionalOptions->end(), this);
+ assert(I != PositionalOptions->end() && "Arg not registered!");
+ PositionalOptions->erase(I);
} else if (getNumOccurrencesFlag() == ConsumeAfter) {
- assert(!getPositionalOpts().empty() && getPositionalOpts()[0] == this &&
+ assert(!PositionalOptions->empty() && (*PositionalOptions)[0] == this &&
"Arg not registered correctly!");
- getPositionalOpts().erase(getPositionalOpts().begin());
+ PositionalOptions->erase(PositionalOptions->begin());
}
}
// Print out the option for the alias.
void alias::printOptionInfo(unsigned GlobalWidth) const {
unsigned L = std::strlen(ArgStr);
- std::cout << " -" << ArgStr << std::string(GlobalWidth-L-6, ' ') << " - "
- << HelpStr << "\n";
+ cout << " -" << ArgStr << std::string(GlobalWidth-L-6, ' ') << " - "
+ << HelpStr << "\n";
}
//
void basic_parser_impl::printOptionInfo(const Option &O,
unsigned GlobalWidth) const {
- std::cout << " -" << O.ArgStr;
+ cout << " -" << O.ArgStr;
if (const char *ValName = getValueName())
- std::cout << "=<" << getValueStr(O, ValName) << ">";
+ cout << "=<" << getValueStr(O, ValName) << ">";
- std::cout << std::string(GlobalWidth-getOptionWidth(O), ' ') << " - "
- << O.HelpStr << "\n";
+ cout << std::string(GlobalWidth-getOptionWidth(O), ' ') << " - "
+ << O.HelpStr << "\n";
}
unsigned GlobalWidth) const {
if (O.hasArgStr()) {
unsigned L = std::strlen(O.ArgStr);
- std::cout << " -" << O.ArgStr << std::string(GlobalWidth-L-6, ' ')
- << " - " << O.HelpStr << "\n";
+ cout << " -" << O.ArgStr << std::string(GlobalWidth-L-6, ' ')
+ << " - " << O.HelpStr << "\n";
for (unsigned i = 0, e = getNumOptions(); i != e; ++i) {
unsigned NumSpaces = GlobalWidth-strlen(getOption(i))-8;
- std::cout << " =" << getOption(i) << std::string(NumSpaces, ' ')
- << " - " << getDescription(i) << "\n";
+ cout << " =" << getOption(i) << std::string(NumSpaces, ' ')
+ << " - " << getDescription(i) << "\n";
}
} else {
if (O.HelpStr[0])
- std::cout << " " << O.HelpStr << "\n";
+ cout << " " << O.HelpStr << "\n";
for (unsigned i = 0, e = getNumOptions(); i != e; ++i) {
unsigned L = std::strlen(getOption(i));
- std::cout << " -" << getOption(i) << std::string(GlobalWidth-L-8, ' ')
- << " - " << getDescription(i) << "\n";
+ cout << " -" << getOption(i) << std::string(GlobalWidth-L-8, ' ')
+ << " - " << getDescription(i) << "\n";
}
}
}
if (Value == false) return;
// Copy Options into a vector so we can sort them as we like...
- std::vector<std::pair<std::string, Option*> > Options;
- copy(getOpts().begin(), getOpts().end(), std::back_inserter(Options));
+ std::vector<std::pair<std::string, Option*> > Opts;
+ copy(Options->begin(), Options->end(), std::back_inserter(Opts));
// Eliminate Hidden or ReallyHidden arguments, depending on ShowHidden
- Options.erase(std::remove_if(Options.begin(), Options.end(),
- std::ptr_fun(ShowHidden ? isReallyHidden : isHidden)),
- Options.end());
+ Opts.erase(std::remove_if(Opts.begin(), Opts.end(),
+ std::ptr_fun(ShowHidden ? isReallyHidden : isHidden)),
+ Opts.end());
// Eliminate duplicate entries in table (from enum flags options, f.e.)
{ // Give OptionSet a scope
std::set<Option*> OptionSet;
- for (unsigned i = 0; i != Options.size(); ++i)
- if (OptionSet.count(Options[i].second) == 0)
- OptionSet.insert(Options[i].second); // Add new entry to set
+ for (unsigned i = 0; i != Opts.size(); ++i)
+ if (OptionSet.count(Opts[i].second) == 0)
+ OptionSet.insert(Opts[i].second); // Add new entry to set
else
- Options.erase(Options.begin()+i--); // Erase duplicate
+ Opts.erase(Opts.begin()+i--); // Erase duplicate
}
if (ProgramOverview)
- std::cout << "OVERVIEW:" << ProgramOverview << "\n";
+ cout << "OVERVIEW:" << ProgramOverview << "\n";
- std::cout << "USAGE: " << ProgramName << " [options]";
+ cout << "USAGE: " << ProgramName << " [options]";
- // Print out the positional options...
- std::vector<Option*> &PosOpts = getPositionalOpts();
+ // Print out the positional options.
+ std::vector<Option*> &PosOpts = *PositionalOptions;
Option *CAOpt = 0; // The cl::ConsumeAfter option, if it exists...
if (!PosOpts.empty() && PosOpts[0]->getNumOccurrencesFlag() == ConsumeAfter)
CAOpt = PosOpts[0];
for (unsigned i = CAOpt != 0, e = PosOpts.size(); i != e; ++i) {
if (PosOpts[i]->ArgStr[0])
- std::cout << " --" << PosOpts[i]->ArgStr;
- std::cout << " " << PosOpts[i]->HelpStr;
+ cout << " --" << PosOpts[i]->ArgStr;
+ cout << " " << PosOpts[i]->HelpStr;
}
// Print the consume after option info if it exists...
- if (CAOpt) std::cout << " " << CAOpt->HelpStr;
+ if (CAOpt) cout << " " << CAOpt->HelpStr;
- std::cout << "\n\n";
+ cout << "\n\n";
// Compute the maximum argument length...
MaxArgLen = 0;
- for (unsigned i = 0, e = Options.size(); i != e; ++i)
- MaxArgLen = std::max(MaxArgLen, Options[i].second->getOptionWidth());
+ for (unsigned i = 0, e = Opts.size(); i != e; ++i)
+ MaxArgLen = std::max(MaxArgLen, Opts[i].second->getOptionWidth());
- std::cout << "OPTIONS:\n";
- for (unsigned i = 0, e = Options.size(); i != e; ++i)
- Options[i].second->printOptionInfo(MaxArgLen);
+ cout << "OPTIONS:\n";
+ for (unsigned i = 0, e = Opts.size(); i != e; ++i)
+ Opts[i].second->printOptionInfo(MaxArgLen);
// Print any extra help the user has declared.
- for (std::vector<const char *>::iterator I = MoreHelp().begin(),
- E = MoreHelp().end(); I != E; ++I)
- std::cout << *I;
- MoreHelp().clear();
+ for (std::vector<const char *>::iterator I = MoreHelp->begin(),
+ E = MoreHelp->end(); I != E; ++I)
+ cout << *I;
+ MoreHelp->clear();
// Halt the program since help information was printed
- getOpts().clear(); // Don't bother making option dtors remove from map.
+ Options->clear(); // Don't bother making option dtors remove from map.
exit(1);
}
};
+} // End anonymous namespace
// Define the two HelpPrinter instances that are used to print out help, or
// help-hidden...
//
-HelpPrinter NormalPrinter(false);
-HelpPrinter HiddenPrinter(true);
+static HelpPrinter NormalPrinter(false);
+static HelpPrinter HiddenPrinter(true);
-cl::opt<HelpPrinter, true, parser<bool> >
+static cl::opt<HelpPrinter, true, parser<bool> >
HOp("help", cl::desc("Display available options (--help-hidden for more)"),
cl::location(NormalPrinter), cl::ValueDisallowed);
-cl::opt<HelpPrinter, true, parser<bool> >
+static cl::opt<HelpPrinter, true, parser<bool> >
HHOp("help-hidden", cl::desc("Display all available options"),
cl::location(HiddenPrinter), cl::Hidden, cl::ValueDisallowed);
-void (*OverrideVersionPrinter)() = 0;
+static void (*OverrideVersionPrinter)() = 0;
+namespace {
class VersionPrinter {
public:
void operator=(bool OptionWasSpecified) {
if (OptionWasSpecified) {
if (OverrideVersionPrinter == 0) {
- std::cout << "Low Level Virtual Machine (" << PACKAGE_NAME << ") "
- << PACKAGE_VERSION << " (see http://llvm.org/)";
-#ifndef NDEBUG
- std::cout << " ASSERTIONS ENABLED\n";
+ cout << "Low Level Virtual Machine (http://llvm.org/):\n";
+ cout << " " << PACKAGE_NAME << " version " << PACKAGE_VERSION;
+#ifdef LLVM_VERSION_INFO
+ cout << LLVM_VERSION_INFO;
+#endif
+ cout << "\n ";
+#ifndef __OPTIMIZE__
+ cout << "DEBUG build";
#else
- std::cout << "\n";
+ cout << "Optimized build";
#endif
- getOpts().clear(); // Don't bother making option dtors remove from map.
+#ifndef NDEBUG
+ cout << " with assertions";
+#endif
+ cout << ".\n";
+ Options->clear(); // Don't bother making option dtors remove from map.
exit(1);
} else {
(*OverrideVersionPrinter)();
}
}
};
+} // End anonymous namespace
// Define the --version option that prints out the LLVM version for the tool
-VersionPrinter VersionPrinterInstance;
-cl::opt<VersionPrinter, true, parser<bool> >
+static VersionPrinter VersionPrinterInstance;
+
+static cl::opt<VersionPrinter, true, parser<bool> >
VersOp("version", cl::desc("Display the version of this program"),
cl::location(VersionPrinterInstance), cl::ValueDisallowed);
-
-} // End anonymous namespace
-
// Utility function for printing the help message.
void cl::PrintHelpMessage() {
// This looks weird, but it actually prints the help message. The