CommandLine.cpp revision 1a097e30d39e60303ae2b19f7a56e813f3e3c18e
1dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner//===-- CommandLine.cpp - Command line parser implementation --------------===// 2f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman// 3b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// The LLVM Compiler Infrastructure 4b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// 5b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// This file was developed by the LLVM research group and is distributed under 6b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// the University of Illinois Open Source License. See LICENSE.TXT for details. 7f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman// 8b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell//===----------------------------------------------------------------------===// 9dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 10dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// This class implements a command line argument processor that is useful when 11dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// creating a tool. It provides a simple, minimalistic interface that is easily 12dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// extensible and supports nonlocal (library) command line options. 13dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 1403fe1bd149b21855098e9cc9f959c8e8ca80693cChris Lattner// Note that rather than trying to figure out what this code does, you could try 1503fe1bd149b21855098e9cc9f959c8e8ca80693cChris Lattner// reading the library documentation located in docs/CommandLine.html 1603fe1bd149b21855098e9cc9f959c8e8ca80693cChris Lattner// 17dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner//===----------------------------------------------------------------------===// 18dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 19551ccae044b0ff658fe629dd67edd5ffe75d10e8Reid Spencer#include "llvm/Config/config.h" 20551ccae044b0ff658fe629dd67edd5ffe75d10e8Reid Spencer#include "llvm/Support/CommandLine.h" 2190aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner#include "llvm/Support/ManagedStatic.h" 22fe6b146dcd09f488b12c7ff888ead9cedc92c2a6Bill Wendling#include "llvm/Support/Streams.h" 236f4c60770cfe6c485cdcb1397df59d2c7778cbc9Reid Spencer#include "llvm/System/Path.h" 24dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner#include <algorithm> 25786e3e22a98ce45782932478f76cf8007fb73ec4Duraid Madina#include <functional> 26dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner#include <map> 271a097e30d39e60303ae2b19f7a56e813f3e3c18eBill Wendling#include <ostream> 28dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner#include <set> 292d6a2360036cf511af0a06f9720e6a1752779d1cBrian Gaeke#include <cstdlib> 302d6a2360036cf511af0a06f9720e6a1752779d1cBrian Gaeke#include <cerrno> 315114004110d771e2cc838be569207784f2519010Chris Lattner#include <cstring> 322cdd21c2e4d855500dfb53f77aa74da53ccf9de6Chris Lattnerusing namespace llvm; 33dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattnerusing namespace cl; 34dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 357422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner//===----------------------------------------------------------------------===// 367422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner// Template instantiations and anchors. 377422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner// 387422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class basic_parser<bool>); 397422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class basic_parser<int>); 407422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class basic_parser<unsigned>); 417422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class basic_parser<double>); 427422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class basic_parser<float>); 437422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class basic_parser<std::string>); 447422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner 457422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class opt<unsigned>); 467422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class opt<int>); 477422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class opt<std::string>); 487422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class opt<bool>); 497422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner 507422a761008ef63152417c5e69ddc31252fb6b10Chris Lattnervoid Option::anchor() {} 517422a761008ef63152417c5e69ddc31252fb6b10Chris Lattnervoid basic_parser_impl::anchor() {} 527422a761008ef63152417c5e69ddc31252fb6b10Chris Lattnervoid parser<bool>::anchor() {} 537422a761008ef63152417c5e69ddc31252fb6b10Chris Lattnervoid parser<int>::anchor() {} 547422a761008ef63152417c5e69ddc31252fb6b10Chris Lattnervoid parser<unsigned>::anchor() {} 557422a761008ef63152417c5e69ddc31252fb6b10Chris Lattnervoid parser<double>::anchor() {} 567422a761008ef63152417c5e69ddc31252fb6b10Chris Lattnervoid parser<float>::anchor() {} 577422a761008ef63152417c5e69ddc31252fb6b10Chris Lattnervoid parser<std::string>::anchor() {} 587422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner 597422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner//===----------------------------------------------------------------------===// 607422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner 61efa3da5593117eab5209c9197cad5ca42213c12eChris Lattner// Globals for name and overview of program. Program name is not a string to 62efa3da5593117eab5209c9197cad5ca42213c12eChris Lattner// avoid static ctor/dtor issues. 63efa3da5593117eab5209c9197cad5ca42213c12eChris Lattnerstatic char ProgramName[80] = "<premain>"; 64e1cc150a8e6b451e42b04b04ffb41596e01bbef5Reid Spencerstatic const char *ProgramOverview = 0; 65e1cc150a8e6b451e42b04b04ffb41596e01bbef5Reid Spencer 66c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner// This collects additional help to be printed. 6790aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattnerstatic ManagedStatic<std::vector<const char*> > MoreHelp; 68c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner 6990aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattnerextrahelp::extrahelp(const char *Help) 70c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner : morehelp(Help) { 7190aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner MoreHelp->push_back(Help); 72c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner} 73c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner 74331de23705a719514e37c211f327379688f81b0dChris Lattner//===----------------------------------------------------------------------===// 757422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner// Basic, shared command line option processing machinery. 76331de23705a719514e37c211f327379688f81b0dChris Lattner// 77331de23705a719514e37c211f327379688f81b0dChris Lattner 7890aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattnerstatic ManagedStatic<std::map<std::string, Option*> > Options; 7990aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattnerstatic ManagedStatic<std::vector<Option*> > PositionalOptions; 80e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner 81ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattnerstatic Option *getOption(const std::string &Str) { 8290aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner std::map<std::string,Option*>::iterator I = Options->find(Str); 8390aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner return I != Options->end() ? I->second : 0; 84331de23705a719514e37c211f327379688f81b0dChris Lattner} 85331de23705a719514e37c211f327379688f81b0dChris Lattner 86e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattnerstatic void AddArgument(const char *ArgName, Option *Opt) { 87e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner if (getOption(ArgName)) { 88e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cerr << ProgramName << ": CommandLine Error: Argument '" 89e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << ArgName << "' defined more than once!\n"; 90dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } else { 91f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner // Add argument to the argument map! 9290aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner (*Options)[ArgName] = Opt; 93e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner } 94e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner} 95e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner 96e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner// RemoveArgument - It's possible that the argument is no longer in the map if 97e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner// options have already been processed and the map has been deleted! 98f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman// 99e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattnerstatic void RemoveArgument(const char *ArgName, Option *Opt) { 10090aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner if (Options->empty()) return; 101c4ae8e903c6abd7e391e8a16f8e850073342ca4dTanya Lattner 102f98cfc716d1916e3400d8980c972f75fe47b9061Chris Lattner#ifndef NDEBUG 103f98cfc716d1916e3400d8980c972f75fe47b9061Chris Lattner // This disgusting HACK is brought to you courtesy of GCC 3.3.2, which ICE's 104f98cfc716d1916e3400d8980c972f75fe47b9061Chris Lattner // If we pass ArgName directly into getOption here. 105f98cfc716d1916e3400d8980c972f75fe47b9061Chris Lattner std::string Tmp = ArgName; 106f98cfc716d1916e3400d8980c972f75fe47b9061Chris Lattner assert(getOption(Tmp) == Opt && "Arg not in map!"); 107f98cfc716d1916e3400d8980c972f75fe47b9061Chris Lattner#endif 10890aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner Options->erase(ArgName); 109dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 110dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 111caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattnerstatic inline bool ProvideOption(Option *Handler, const char *ArgName, 112caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner const char *Value, int argc, char **argv, 113caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner int &i) { 114caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner // Enforce value requirements 115caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner switch (Handler->getValueExpectedFlag()) { 116caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner case ValueRequired: 1176d5857e139df71410e98ccf6cd0e783f90a9fc16Chris Lattner if (Value == 0) { // No value specified? 118caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner if (i+1 < argc) { // Steal the next argument, like for '-o filename' 119caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner Value = argv[++i]; 120caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner } else { 121caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner return Handler->error(" requires a value!"); 122caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner } 123caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner } 124caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner break; 125caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner case ValueDisallowed: 1266d5857e139df71410e98ccf6cd0e783f90a9fc16Chris Lattner if (Value) 127f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman return Handler->error(" does not allow a value! '" + 128ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::string(Value) + "' specified."); 129caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner break; 130f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman case ValueOptional: 131e1cc150a8e6b451e42b04b04ffb41596e01bbef5Reid Spencer break; 132f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman default: 133e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cerr << ProgramName 134e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << ": Bad ValueMask flag! CommandLine usage error:" 135e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << Handler->getValueExpectedFlag() << "\n"; 136e1cc150a8e6b451e42b04b04ffb41596e01bbef5Reid Spencer abort(); 137e1cc150a8e6b451e42b04b04ffb41596e01bbef5Reid Spencer break; 138caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner } 139caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner 140caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner // Run the handler now! 1416d5857e139df71410e98ccf6cd0e783f90a9fc16Chris Lattner return Handler->addOccurrence(i, ArgName, Value ? Value : ""); 142caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner} 143caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner 144f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukmanstatic bool ProvidePositionalOption(Option *Handler, const std::string &Arg, 1451e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer int i) { 1461e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer int Dummy = i; 1479cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner return ProvideOption(Handler, Handler->ArgStr, Arg.c_str(), 0, 0, Dummy); 148331de23705a719514e37c211f327379688f81b0dChris Lattner} 149331de23705a719514e37c211f327379688f81b0dChris Lattner 150331de23705a719514e37c211f327379688f81b0dChris Lattner 151331de23705a719514e37c211f327379688f81b0dChris Lattner// Option predicates... 152331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic inline bool isGrouping(const Option *O) { 153331de23705a719514e37c211f327379688f81b0dChris Lattner return O->getFormattingFlag() == cl::Grouping; 154331de23705a719514e37c211f327379688f81b0dChris Lattner} 155331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic inline bool isPrefixedOrGrouping(const Option *O) { 156331de23705a719514e37c211f327379688f81b0dChris Lattner return isGrouping(O) || O->getFormattingFlag() == cl::Prefix; 157331de23705a719514e37c211f327379688f81b0dChris Lattner} 158331de23705a719514e37c211f327379688f81b0dChris Lattner 159331de23705a719514e37c211f327379688f81b0dChris Lattner// getOptionPred - Check to see if there are any options that satisfy the 160331de23705a719514e37c211f327379688f81b0dChris Lattner// specified predicate with names that are the prefixes in Name. This is 161331de23705a719514e37c211f327379688f81b0dChris Lattner// checked by progressively stripping characters off of the name, checking to 162331de23705a719514e37c211f327379688f81b0dChris Lattner// see if there options that satisfy the predicate. If we find one, return it, 163331de23705a719514e37c211f327379688f81b0dChris Lattner// otherwise return null. 164f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner// 165331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic Option *getOptionPred(std::string Name, unsigned &Length, 166331de23705a719514e37c211f327379688f81b0dChris Lattner bool (*Pred)(const Option*)) { 167f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 168e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner Option *Op = getOption(Name); 169e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner if (Op && Pred(Op)) { 170331de23705a719514e37c211f327379688f81b0dChris Lattner Length = Name.length(); 171e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner return Op; 172331de23705a719514e37c211f327379688f81b0dChris Lattner } 173f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner 174331de23705a719514e37c211f327379688f81b0dChris Lattner if (Name.size() == 1) return 0; 175331de23705a719514e37c211f327379688f81b0dChris Lattner do { 176331de23705a719514e37c211f327379688f81b0dChris Lattner Name.erase(Name.end()-1, Name.end()); // Chop off the last character... 177e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner Op = getOption(Name); 178331de23705a719514e37c211f327379688f81b0dChris Lattner 179331de23705a719514e37c211f327379688f81b0dChris Lattner // Loop while we haven't found an option and Name still has at least two 180331de23705a719514e37c211f327379688f81b0dChris Lattner // characters in it (so that the next iteration will not be the empty 181331de23705a719514e37c211f327379688f81b0dChris Lattner // string... 182e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner } while ((Op == 0 || !Pred(Op)) && Name.size() > 1); 183331de23705a719514e37c211f327379688f81b0dChris Lattner 184e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner if (Op && Pred(Op)) { 185331de23705a719514e37c211f327379688f81b0dChris Lattner Length = Name.length(); 186e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner return Op; // Found one! 187f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner } 188331de23705a719514e37c211f327379688f81b0dChris Lattner return 0; // No option found! 189331de23705a719514e37c211f327379688f81b0dChris Lattner} 190f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner 191331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic bool RequiresValue(const Option *O) { 192dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman return O->getNumOccurrencesFlag() == cl::Required || 193dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman O->getNumOccurrencesFlag() == cl::OneOrMore; 194331de23705a719514e37c211f327379688f81b0dChris Lattner} 195331de23705a719514e37c211f327379688f81b0dChris Lattner 196331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic bool EatsUnboundedNumberOfValues(const Option *O) { 197dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman return O->getNumOccurrencesFlag() == cl::ZeroOrMore || 198dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman O->getNumOccurrencesFlag() == cl::OneOrMore; 199f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner} 200caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner 201c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke/// ParseCStringVector - Break INPUT up wherever one or more 202c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke/// whitespace characters are found, and store the resulting tokens in 203c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke/// OUTPUT. The tokens stored in OUTPUT are dynamically allocated 204c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke/// using strdup (), so it is the caller's responsibility to free () 205c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke/// them later. 20606b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// 207232885873fb0081acc1420ab83b14ab6f8eba280Chris Lattnerstatic void ParseCStringVector(std::vector<char *> &output, 208232885873fb0081acc1420ab83b14ab6f8eba280Chris Lattner const char *input) { 209c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Characters which will be treated as token separators: 210c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke static const char *delims = " \v\f\t\r\n"; 211c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke 21206b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke std::string work (input); 213c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Skip past any delims at head of input string. 214c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke size_t pos = work.find_first_not_of (delims); 215c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // If the string consists entirely of delims, then exit early. 216c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke if (pos == std::string::npos) return; 217c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Otherwise, jump forward to beginning of first word. 21806b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke work = work.substr (pos); 219c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Find position of first delimiter. 22006b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke pos = work.find_first_of (delims); 221c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke 222c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke while (!work.empty() && pos != std::string::npos) { 223c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Everything from 0 to POS is the next word to copy. 224c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke output.push_back (strdup (work.substr (0,pos).c_str ())); 225c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Is there another word in the string? 226c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke size_t nextpos = work.find_first_not_of (delims, pos + 1); 227c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke if (nextpos != std::string::npos) { 228c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Yes? Then remove delims from beginning ... 22906b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke work = work.substr (work.find_first_not_of (delims, pos + 1)); 230c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // and find the end of the word. 23106b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke pos = work.find_first_of (delims); 23206b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke } else { 233c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // No? (Remainder of string is delims.) End the loop. 23406b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke work = ""; 235c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke pos = std::string::npos; 23606b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke } 23706b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke } 23806b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke 239c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // If `input' ended with non-delim char, then we'll get here with 240c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // the last word of `input' in `work'; copy it now. 241c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke if (!work.empty ()) { 242c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke output.push_back (strdup (work.c_str ())); 24306b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke } 24406b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke} 24506b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke 24606b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// ParseEnvironmentOptions - An alternative entry point to the 24706b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// CommandLine library, which allows you to read the program's name 24806b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// from the caller (as PROGNAME) and its command-line arguments from 24906b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// an environment variable (whose name is given in ENVVAR). 25006b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// 251bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattnervoid cl::ParseEnvironmentOptions(const char *progName, const char *envVar, 252bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner const char *Overview) { 253c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Check args. 254bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner assert(progName && "Program name not specified"); 255bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner assert(envVar && "Environment variable name missing"); 256f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 25706b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke // Get the environment variable they want us to parse options out of. 258232885873fb0081acc1420ab83b14ab6f8eba280Chris Lattner const char *envValue = getenv(envVar); 259c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke if (!envValue) 26006b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke return; 261c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke 262c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Get program's "name", which we wouldn't know without the caller 263c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // telling us. 264232885873fb0081acc1420ab83b14ab6f8eba280Chris Lattner std::vector<char*> newArgv; 265232885873fb0081acc1420ab83b14ab6f8eba280Chris Lattner newArgv.push_back(strdup(progName)); 26606b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke 26706b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke // Parse the value of the environment variable into a "command line" 26806b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke // and hand it off to ParseCommandLineOptions(). 269232885873fb0081acc1420ab83b14ab6f8eba280Chris Lattner ParseCStringVector(newArgv, envValue); 270232885873fb0081acc1420ab83b14ab6f8eba280Chris Lattner int newArgc = newArgv.size(); 271232885873fb0081acc1420ab83b14ab6f8eba280Chris Lattner ParseCommandLineOptions(newArgc, &newArgv[0], Overview); 272c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke 273c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Free all the strdup()ed strings. 274232885873fb0081acc1420ab83b14ab6f8eba280Chris Lattner for (std::vector<char*>::iterator i = newArgv.begin(), e = newArgv.end(); 275232885873fb0081acc1420ab83b14ab6f8eba280Chris Lattner i != e; ++i) 276c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke free (*i); 27706b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke} 27806b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke 279bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner/// LookupOption - Lookup the option specified by the specified option on the 280bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner/// command line. If there is a value specified (after an equal sign) return 281bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner/// that as well. 282bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattnerstatic Option *LookupOption(const char *&Arg, const char *&Value) { 283bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner while (*Arg == '-') ++Arg; // Eat leading dashes 284f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 285bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner const char *ArgEnd = Arg; 286bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner while (*ArgEnd && *ArgEnd != '=') 2876d5857e139df71410e98ccf6cd0e783f90a9fc16Chris Lattner ++ArgEnd; // Scan till end of argument name. 2886d5857e139df71410e98ccf6cd0e783f90a9fc16Chris Lattner 2896d5857e139df71410e98ccf6cd0e783f90a9fc16Chris Lattner if (*ArgEnd == '=') // If we have an equals sign... 2906d5857e139df71410e98ccf6cd0e783f90a9fc16Chris Lattner Value = ArgEnd+1; // Get the value, not the equals 291bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner 292f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 293bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner if (*Arg == 0) return 0; 294bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner 295bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner // Look up the option. 29690aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner std::map<std::string, Option*> &Opts = *Options; 297bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner std::map<std::string, Option*>::iterator I = 298bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner Opts.find(std::string(Arg, ArgEnd)); 299bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner return (I != Opts.end()) ? I->second : 0; 300bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner} 301bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner 302dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattnervoid cl::ParseCommandLineOptions(int &argc, char **argv, 3030c0edf8afc35a42b15a24ebb5fa5f3fc674290aeChris Lattner const char *Overview) { 30490aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner assert((!Options->empty() || !PositionalOptions->empty()) && 305331de23705a719514e37c211f327379688f81b0dChris Lattner "No options specified, or ParseCommandLineOptions called more" 306331de23705a719514e37c211f327379688f81b0dChris Lattner " than once!"); 3076f4c60770cfe6c485cdcb1397df59d2c7778cbc9Reid Spencer sys::Path progname(argv[0]); 308efa3da5593117eab5209c9197cad5ca42213c12eChris Lattner 309efa3da5593117eab5209c9197cad5ca42213c12eChris Lattner // Copy the program name into ProgName, making sure not to overflow it. 310efa3da5593117eab5209c9197cad5ca42213c12eChris Lattner std::string ProgName = sys::Path(argv[0]).getLast(); 311efa3da5593117eab5209c9197cad5ca42213c12eChris Lattner if (ProgName.size() > 79) ProgName.resize(79); 312efa3da5593117eab5209c9197cad5ca42213c12eChris Lattner strcpy(ProgramName, ProgName.c_str()); 313efa3da5593117eab5209c9197cad5ca42213c12eChris Lattner 314dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner ProgramOverview = Overview; 315dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner bool ErrorParsing = false; 316dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 31790aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner std::map<std::string, Option*> &Opts = *Options; 31890aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner std::vector<Option*> &PositionalOpts = *PositionalOptions; 319331de23705a719514e37c211f327379688f81b0dChris Lattner 320331de23705a719514e37c211f327379688f81b0dChris Lattner // Check out the positional arguments to collect information about them. 321331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned NumPositionalRequired = 0; 322de0132453e2939488c2d69290bfdfb2cde94a0afChris Lattner 323de0132453e2939488c2d69290bfdfb2cde94a0afChris Lattner // Determine whether or not there are an unlimited number of positionals 324de0132453e2939488c2d69290bfdfb2cde94a0afChris Lattner bool HasUnlimitedPositionals = false; 325de0132453e2939488c2d69290bfdfb2cde94a0afChris Lattner 326331de23705a719514e37c211f327379688f81b0dChris Lattner Option *ConsumeAfterOpt = 0; 327331de23705a719514e37c211f327379688f81b0dChris Lattner if (!PositionalOpts.empty()) { 328dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman if (PositionalOpts[0]->getNumOccurrencesFlag() == cl::ConsumeAfter) { 329331de23705a719514e37c211f327379688f81b0dChris Lattner assert(PositionalOpts.size() > 1 && 330331de23705a719514e37c211f327379688f81b0dChris Lattner "Cannot specify cl::ConsumeAfter without a positional argument!"); 331331de23705a719514e37c211f327379688f81b0dChris Lattner ConsumeAfterOpt = PositionalOpts[0]; 332331de23705a719514e37c211f327379688f81b0dChris Lattner } 333331de23705a719514e37c211f327379688f81b0dChris Lattner 334331de23705a719514e37c211f327379688f81b0dChris Lattner // Calculate how many positional values are _required_. 335331de23705a719514e37c211f327379688f81b0dChris Lattner bool UnboundedFound = false; 336331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = ConsumeAfterOpt != 0, e = PositionalOpts.size(); 337331de23705a719514e37c211f327379688f81b0dChris Lattner i != e; ++i) { 338331de23705a719514e37c211f327379688f81b0dChris Lattner Option *Opt = PositionalOpts[i]; 339331de23705a719514e37c211f327379688f81b0dChris Lattner if (RequiresValue(Opt)) 340331de23705a719514e37c211f327379688f81b0dChris Lattner ++NumPositionalRequired; 341331de23705a719514e37c211f327379688f81b0dChris Lattner else if (ConsumeAfterOpt) { 342331de23705a719514e37c211f327379688f81b0dChris Lattner // ConsumeAfter cannot be combined with "optional" positional options 34354ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner // unless there is only one positional argument... 34454ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner if (PositionalOpts.size() > 2) 34554ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner ErrorParsing |= 34654ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner Opt->error(" error - this positional option will never be matched, " 34754ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner "because it does not Require a value, and a " 34854ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner "cl::ConsumeAfter option is active!"); 3499cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner } else if (UnboundedFound && !Opt->ArgStr[0]) { 3509cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // This option does not "require" a value... Make sure this option is 3519cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // not specified after an option that eats all extra arguments, or this 3529cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // one will never get any! 353331de23705a719514e37c211f327379688f81b0dChris Lattner // 354331de23705a719514e37c211f327379688f81b0dChris Lattner ErrorParsing |= Opt->error(" error - option can never match, because " 355331de23705a719514e37c211f327379688f81b0dChris Lattner "another positional argument will match an " 356331de23705a719514e37c211f327379688f81b0dChris Lattner "unbounded number of values, and this option" 357331de23705a719514e37c211f327379688f81b0dChris Lattner " does not require a value!"); 358331de23705a719514e37c211f327379688f81b0dChris Lattner } 359331de23705a719514e37c211f327379688f81b0dChris Lattner UnboundedFound |= EatsUnboundedNumberOfValues(Opt); 360331de23705a719514e37c211f327379688f81b0dChris Lattner } 36121e1a79a31fe45fcd861d64118a60c1fcfad618aChris Lattner HasUnlimitedPositionals = UnboundedFound || ConsumeAfterOpt; 362331de23705a719514e37c211f327379688f81b0dChris Lattner } 363331de23705a719514e37c211f327379688f81b0dChris Lattner 3641e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer // PositionalVals - A vector of "positional" arguments we accumulate into 3651e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer // the process at the end... 366331de23705a719514e37c211f327379688f81b0dChris Lattner // 3671e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer std::vector<std::pair<std::string,unsigned> > PositionalVals; 368331de23705a719514e37c211f327379688f81b0dChris Lattner 3699cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // If the program has named positional arguments, and the name has been run 3709cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // across, keep track of which positional argument was named. Otherwise put 3719cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // the positional args into the PositionalVals list... 3729cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner Option *ActivePositionalArg = 0; 3739cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner 374dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Loop over all of the arguments... processing them. 375331de23705a719514e37c211f327379688f81b0dChris Lattner bool DashDashFound = false; // Have we read '--'? 376dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner for (int i = 1; i < argc; ++i) { 377dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner Option *Handler = 0; 3786d5857e139df71410e98ccf6cd0e783f90a9fc16Chris Lattner const char *Value = 0; 379dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner const char *ArgName = ""; 380331de23705a719514e37c211f327379688f81b0dChris Lattner 381331de23705a719514e37c211f327379688f81b0dChris Lattner // Check to see if this is a positional argument. This argument is 382331de23705a719514e37c211f327379688f81b0dChris Lattner // considered to be positional if it doesn't start with '-', if it is "-" 3831115e0483fc6da16d52382f159005baddf028063Misha Brukman // itself, or if we have seen "--" already. 384331de23705a719514e37c211f327379688f81b0dChris Lattner // 385331de23705a719514e37c211f327379688f81b0dChris Lattner if (argv[i][0] != '-' || argv[i][1] == 0 || DashDashFound) { 386331de23705a719514e37c211f327379688f81b0dChris Lattner // Positional argument! 3879cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (ActivePositionalArg) { 3881e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ProvidePositionalOption(ActivePositionalArg, argv[i], i); 3899cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner continue; // We are done! 3909cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner } else if (!PositionalOpts.empty()) { 3911e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals.push_back(std::make_pair(argv[i],i)); 392331de23705a719514e37c211f327379688f81b0dChris Lattner 393331de23705a719514e37c211f327379688f81b0dChris Lattner // All of the positional arguments have been fulfulled, give the rest to 394331de23705a719514e37c211f327379688f81b0dChris Lattner // the consume after option... if it's specified... 395331de23705a719514e37c211f327379688f81b0dChris Lattner // 396f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman if (PositionalVals.size() >= NumPositionalRequired && 397331de23705a719514e37c211f327379688f81b0dChris Lattner ConsumeAfterOpt != 0) { 398331de23705a719514e37c211f327379688f81b0dChris Lattner for (++i; i < argc; ++i) 3991e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals.push_back(std::make_pair(argv[i],i)); 400331de23705a719514e37c211f327379688f81b0dChris Lattner break; // Handle outside of the argument processing loop... 401331de23705a719514e37c211f327379688f81b0dChris Lattner } 402331de23705a719514e37c211f327379688f81b0dChris Lattner 403331de23705a719514e37c211f327379688f81b0dChris Lattner // Delay processing positional arguments until the end... 404331de23705a719514e37c211f327379688f81b0dChris Lattner continue; 405331de23705a719514e37c211f327379688f81b0dChris Lattner } 406bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner } else if (argv[i][0] == '-' && argv[i][1] == '-' && argv[i][2] == 0 && 407bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner !DashDashFound) { 408bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner DashDashFound = true; // This is the mythical "--"? 409bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner continue; // Don't try to process it as an argument itself. 410bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner } else if (ActivePositionalArg && 411bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner (ActivePositionalArg->getMiscFlags() & PositionalEatsArgs)) { 412bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner // If there is a positional argument eating options, check to see if this 413bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner // option is another positional argument. If so, treat it as an argument, 414bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner // otherwise feed it to the eating positional. 415dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner ArgName = argv[i]+1; 416bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner Handler = LookupOption(ArgName, Value); 417bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner if (!Handler || Handler->getFormattingFlag() != cl::Positional) { 4181e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ProvidePositionalOption(ActivePositionalArg, argv[i], i); 419bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner continue; // We are done! 420331de23705a719514e37c211f327379688f81b0dChris Lattner } 421331de23705a719514e37c211f327379688f81b0dChris Lattner 422bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner } else { // We start with a '-', must be an argument... 423bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner ArgName = argv[i]+1; 424bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner Handler = LookupOption(ArgName, Value); 425331de23705a719514e37c211f327379688f81b0dChris Lattner 426bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner // Check to see if this "option" is really a prefixed or grouped argument. 4275f8448f79c2876466d586f2e1caec89e6f070623Reid Spencer if (Handler == 0) { 428bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner std::string RealName(ArgName); 429bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner if (RealName.size() > 1) { 430331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned Length = 0; 431331de23705a719514e37c211f327379688f81b0dChris Lattner Option *PGOpt = getOptionPred(RealName, Length, isPrefixedOrGrouping); 432f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 433331de23705a719514e37c211f327379688f81b0dChris Lattner // If the option is a prefixed option, then the value is simply the 434331de23705a719514e37c211f327379688f81b0dChris Lattner // rest of the name... so fall through to later processing, by 435331de23705a719514e37c211f327379688f81b0dChris Lattner // setting up the argument name flags and value fields. 436331de23705a719514e37c211f327379688f81b0dChris Lattner // 437331de23705a719514e37c211f327379688f81b0dChris Lattner if (PGOpt && PGOpt->getFormattingFlag() == cl::Prefix) { 438bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner Value = ArgName+Length; 439bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner assert(Opts.find(std::string(ArgName, Value)) != Opts.end() && 440bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner Opts.find(std::string(ArgName, Value))->second == PGOpt); 441bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner Handler = PGOpt; 442331de23705a719514e37c211f327379688f81b0dChris Lattner } else if (PGOpt) { 443bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner // This must be a grouped option... handle them now. 444331de23705a719514e37c211f327379688f81b0dChris Lattner assert(isGrouping(PGOpt) && "Broken getOptionPred!"); 445f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 446331de23705a719514e37c211f327379688f81b0dChris Lattner do { 447331de23705a719514e37c211f327379688f81b0dChris Lattner // Move current arg name out of RealName into RealArgName... 448bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner std::string RealArgName(RealName.begin(), 449bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner RealName.begin() + Length); 450bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner RealName.erase(RealName.begin(), RealName.begin() + Length); 451f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 452b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman // Because ValueRequired is an invalid flag for grouped arguments, 453b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman // we don't need to pass argc/argv in... 454b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman // 455331de23705a719514e37c211f327379688f81b0dChris Lattner assert(PGOpt->getValueExpectedFlag() != cl::ValueRequired && 456331de23705a719514e37c211f327379688f81b0dChris Lattner "Option can not be cl::Grouping AND cl::ValueRequired!"); 457331de23705a719514e37c211f327379688f81b0dChris Lattner int Dummy; 458bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner ErrorParsing |= ProvideOption(PGOpt, RealArgName.c_str(), 4596d5857e139df71410e98ccf6cd0e783f90a9fc16Chris Lattner 0, 0, 0, Dummy); 460f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 461331de23705a719514e37c211f327379688f81b0dChris Lattner // Get the next grouping option... 462bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner PGOpt = getOptionPred(RealName, Length, isGrouping); 463bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner } while (PGOpt && Length != RealName.size()); 464f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 465bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner Handler = PGOpt; // Ate all of the options. 466331de23705a719514e37c211f327379688f81b0dChris Lattner } 467b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman } 468dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 469dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 470dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 471dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner if (Handler == 0) { 472e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cerr << ProgramName << ": Unknown command line argument '" 473e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << argv[i] << "'. Try: '" << argv[0] << " --help'\n"; 474dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner ErrorParsing = true; 475dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner continue; 476dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 477dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 47872fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner // Check to see if this option accepts a comma separated list of values. If 47972fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner // it does, we have to split up the value into multiple values... 4806d5857e139df71410e98ccf6cd0e783f90a9fc16Chris Lattner if (Value && Handler->getMiscFlags() & CommaSeparated) { 48172fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner std::string Val(Value); 48272fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner std::string::size_type Pos = Val.find(','); 48372fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner 48472fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner while (Pos != std::string::npos) { 48572fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner // Process the portion before the comma... 48672fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner ErrorParsing |= ProvideOption(Handler, ArgName, 48772fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner std::string(Val.begin(), 48872fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner Val.begin()+Pos).c_str(), 48972fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner argc, argv, i); 49072fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner // Erase the portion before the comma, AND the comma... 49172fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner Val.erase(Val.begin(), Val.begin()+Pos+1); 49272fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner Value += Pos+1; // Increment the original value pointer as well... 49372fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner 49472fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner // Check for another comma... 49572fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner Pos = Val.find(','); 49672fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner } 49772fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner } 4989cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner 4999cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // If this is a named positional argument, just remember that it is the 5009cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // active one... 5019cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (Handler->getFormattingFlag() == cl::Positional) 5029cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner ActivePositionalArg = Handler; 503f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman else 5049cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner ErrorParsing |= ProvideOption(Handler, ArgName, Value, argc, argv, i); 505331de23705a719514e37c211f327379688f81b0dChris Lattner } 506dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 507331de23705a719514e37c211f327379688f81b0dChris Lattner // Check and handle positional arguments now... 508331de23705a719514e37c211f327379688f81b0dChris Lattner if (NumPositionalRequired > PositionalVals.size()) { 509e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cerr << ProgramName 510e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << ": Not enough positional command line arguments specified!\n" 511e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << "Must specify at least " << NumPositionalRequired 512e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << " positional arguments: See: " << argv[0] << " --help\n"; 51379959d21c7b2fb7bb970949b9a5227036cd50d39Chris Lattner 514331de23705a719514e37c211f327379688f81b0dChris Lattner ErrorParsing = true; 515de0132453e2939488c2d69290bfdfb2cde94a0afChris Lattner } else if (!HasUnlimitedPositionals 516de0132453e2939488c2d69290bfdfb2cde94a0afChris Lattner && PositionalVals.size() > PositionalOpts.size()) { 517e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cerr << ProgramName 518e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << ": Too many positional arguments specified!\n" 519e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << "Can specify at most " << PositionalOpts.size() 520e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << " positional arguments: See: " << argv[0] << " --help\n"; 521de0132453e2939488c2d69290bfdfb2cde94a0afChris Lattner ErrorParsing = true; 522331de23705a719514e37c211f327379688f81b0dChris Lattner 523331de23705a719514e37c211f327379688f81b0dChris Lattner } else if (ConsumeAfterOpt == 0) { 524331de23705a719514e37c211f327379688f81b0dChris Lattner // Positional args have already been handled if ConsumeAfter is specified... 525331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned ValNo = 0, NumVals = PositionalVals.size(); 526331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = PositionalOpts.size(); i != e; ++i) { 527331de23705a719514e37c211f327379688f81b0dChris Lattner if (RequiresValue(PositionalOpts[i])) { 528f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman ProvidePositionalOption(PositionalOpts[i], PositionalVals[ValNo].first, 5291e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].second); 5301e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ValNo++; 531331de23705a719514e37c211f327379688f81b0dChris Lattner --NumPositionalRequired; // We fulfilled our duty... 532331de23705a719514e37c211f327379688f81b0dChris Lattner } 533331de23705a719514e37c211f327379688f81b0dChris Lattner 534331de23705a719514e37c211f327379688f81b0dChris Lattner // If we _can_ give this option more arguments, do so now, as long as we 535331de23705a719514e37c211f327379688f81b0dChris Lattner // do not give it values that others need. 'Done' controls whether the 536331de23705a719514e37c211f327379688f81b0dChris Lattner // option even _WANTS_ any more. 537331de23705a719514e37c211f327379688f81b0dChris Lattner // 538dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman bool Done = PositionalOpts[i]->getNumOccurrencesFlag() == cl::Required; 539331de23705a719514e37c211f327379688f81b0dChris Lattner while (NumVals-ValNo > NumPositionalRequired && !Done) { 540dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman switch (PositionalOpts[i]->getNumOccurrencesFlag()) { 541331de23705a719514e37c211f327379688f81b0dChris Lattner case cl::Optional: 542331de23705a719514e37c211f327379688f81b0dChris Lattner Done = true; // Optional arguments want _at most_ one value 543331de23705a719514e37c211f327379688f81b0dChris Lattner // FALL THROUGH 544331de23705a719514e37c211f327379688f81b0dChris Lattner case cl::ZeroOrMore: // Zero or more will take all they can get... 545331de23705a719514e37c211f327379688f81b0dChris Lattner case cl::OneOrMore: // One or more will take all they can get... 5461e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ProvidePositionalOption(PositionalOpts[i], 5471e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].first, 5481e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].second); 5491e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ValNo++; 550331de23705a719514e37c211f327379688f81b0dChris Lattner break; 551331de23705a719514e37c211f327379688f81b0dChris Lattner default: 552dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman assert(0 && "Internal error, unexpected NumOccurrences flag in " 553331de23705a719514e37c211f327379688f81b0dChris Lattner "positional argument processing!"); 554331de23705a719514e37c211f327379688f81b0dChris Lattner } 555331de23705a719514e37c211f327379688f81b0dChris Lattner } 556caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner } 557331de23705a719514e37c211f327379688f81b0dChris Lattner } else { 558331de23705a719514e37c211f327379688f81b0dChris Lattner assert(ConsumeAfterOpt && NumPositionalRequired <= PositionalVals.size()); 559331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned ValNo = 0; 560331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned j = 1, e = PositionalOpts.size(); j != e; ++j) 5611e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer if (RequiresValue(PositionalOpts[j])) { 562faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner ErrorParsing |= ProvidePositionalOption(PositionalOpts[j], 5631e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].first, 5641e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].second); 5651e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ValNo++; 5661e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer } 567faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner 568faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // Handle the case where there is just one positional option, and it's 569faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // optional. In this case, we want to give JUST THE FIRST option to the 570faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // positional option and keep the rest for the consume after. The above 571faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // loop would have assigned no values to positional options in this case. 572faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // 5731e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer if (PositionalOpts.size() == 2 && ValNo == 0 && !PositionalVals.empty()) { 574faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner ErrorParsing |= ProvidePositionalOption(PositionalOpts[1], 5751e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].first, 5761e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].second); 5771e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ValNo++; 5781e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer } 579f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 580331de23705a719514e37c211f327379688f81b0dChris Lattner // Handle over all of the rest of the arguments to the 581331de23705a719514e37c211f327379688f81b0dChris Lattner // cl::ConsumeAfter command line option... 582331de23705a719514e37c211f327379688f81b0dChris Lattner for (; ValNo != PositionalVals.size(); ++ValNo) 583331de23705a719514e37c211f327379688f81b0dChris Lattner ErrorParsing |= ProvidePositionalOption(ConsumeAfterOpt, 5841e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].first, 5851e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].second); 586dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 587dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 588dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner // Loop over args and make sure all required args are specified! 589f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman for (std::map<std::string, Option*>::iterator I = Opts.begin(), 590b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman E = Opts.end(); I != E; ++I) { 591dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman switch (I->second->getNumOccurrencesFlag()) { 592dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner case Required: 593dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner case OneOrMore: 594dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman if (I->second->getNumOccurrences() == 0) { 595b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman I->second->error(" must be specified at least once!"); 596f038acbee21cfed998451aedd00a81901d299516Chris Lattner ErrorParsing = true; 597f038acbee21cfed998451aedd00a81901d299516Chris Lattner } 598dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner // Fall through 599dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner default: 600dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner break; 601dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner } 602dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner } 603dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 604331de23705a719514e37c211f327379688f81b0dChris Lattner // Free all of the memory allocated to the map. Command line options may only 605331de23705a719514e37c211f327379688f81b0dChris Lattner // be processed once! 60690aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner Opts.clear(); 607331de23705a719514e37c211f327379688f81b0dChris Lattner PositionalOpts.clear(); 60890aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner MoreHelp->clear(); 609dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 610dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // If we had an error processing our arguments, don't let the program execute 611dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner if (ErrorParsing) exit(1); 612dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 613dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 614dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner//===----------------------------------------------------------------------===// 615dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// Option Base class implementation 616dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 617dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 618ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattnerbool Option::error(std::string Message, const char *ArgName) { 619dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner if (ArgName == 0) ArgName = ArgStr; 620331de23705a719514e37c211f327379688f81b0dChris Lattner if (ArgName[0] == 0) 621e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cerr << HelpStr; // Be nice for positional arguments 622331de23705a719514e37c211f327379688f81b0dChris Lattner else 623e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cerr << ProgramName << ": for the -" << ArgName; 624abe0e3e6410ca3f192b6a656cbcd042b05d0a68bJim Laskey 625e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cerr << " option: " << Message << "\n"; 626dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return true; 627dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 628dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 6296d5857e139df71410e98ccf6cd0e783f90a9fc16Chris Lattnerbool Option::addOccurrence(unsigned pos, const char *ArgName, 6306d5857e139df71410e98ccf6cd0e783f90a9fc16Chris Lattner const std::string &Value) { 631dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman NumOccurrences++; // Increment the number of times we have been seen 632dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 633dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman switch (getNumOccurrencesFlag()) { 634dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner case Optional: 635dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman if (NumOccurrences > 1) 636dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return error(": may only occur zero or one times!", ArgName); 637dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner break; 638dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner case Required: 639dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman if (NumOccurrences > 1) 640dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return error(": must occur exactly one time!", ArgName); 641dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Fall through 642dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner case OneOrMore: 643caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner case ZeroOrMore: 644caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner case ConsumeAfter: break; 645b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman default: return error(": bad num occurrences flag value!"); 646dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 647dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 6481e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer return handleOccurrence(pos, ArgName, Value); 649dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 650dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 651331de23705a719514e37c211f327379688f81b0dChris Lattner// addArgument - Tell the system that this Option subclass will handle all 652b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman// occurrences of -ArgStr on the command line. 653331de23705a719514e37c211f327379688f81b0dChris Lattner// 654331de23705a719514e37c211f327379688f81b0dChris Lattnervoid Option::addArgument(const char *ArgStr) { 655331de23705a719514e37c211f327379688f81b0dChris Lattner if (ArgStr[0]) 656331de23705a719514e37c211f327379688f81b0dChris Lattner AddArgument(ArgStr, this); 6579cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner 6589cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (getFormattingFlag() == Positional) 65990aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner PositionalOptions->push_back(this); 660dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman else if (getNumOccurrencesFlag() == ConsumeAfter) { 66190aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner if (!PositionalOptions->empty() && 66290aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner PositionalOptions->front()->getNumOccurrencesFlag() == ConsumeAfter) 6639cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner error("Cannot specify more than one option with cl::ConsumeAfter!"); 66490aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner PositionalOptions->insert(PositionalOptions->begin(), this); 665331de23705a719514e37c211f327379688f81b0dChris Lattner } 666331de23705a719514e37c211f327379688f81b0dChris Lattner} 667331de23705a719514e37c211f327379688f81b0dChris Lattner 668aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattnervoid Option::removeArgument(const char *ArgStr) { 6699cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (ArgStr[0]) 670e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner RemoveArgument(ArgStr, this); 6719cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner 6729cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (getFormattingFlag() == Positional) { 673ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::vector<Option*>::iterator I = 67490aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner std::find(PositionalOptions->begin(), PositionalOptions->end(), this); 67590aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner assert(I != PositionalOptions->end() && "Arg not registered!"); 67690aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner PositionalOptions->erase(I); 677dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman } else if (getNumOccurrencesFlag() == ConsumeAfter) { 67890aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner assert(!PositionalOptions->empty() && (*PositionalOptions)[0] == this && 679aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner "Arg not registered correctly!"); 68090aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner PositionalOptions->erase(PositionalOptions->begin()); 681aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner } 682aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner} 683aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner 684331de23705a719514e37c211f327379688f81b0dChris Lattner 685331de23705a719514e37c211f327379688f81b0dChris Lattner// getValueStr - Get the value description string, using "DefaultMsg" if nothing 686331de23705a719514e37c211f327379688f81b0dChris Lattner// has been specified yet. 687331de23705a719514e37c211f327379688f81b0dChris Lattner// 688331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic const char *getValueStr(const Option &O, const char *DefaultMsg) { 689331de23705a719514e37c211f327379688f81b0dChris Lattner if (O.ValueStr[0] == 0) return DefaultMsg; 690331de23705a719514e37c211f327379688f81b0dChris Lattner return O.ValueStr; 691331de23705a719514e37c211f327379688f81b0dChris Lattner} 692331de23705a719514e37c211f327379688f81b0dChris Lattner 693331de23705a719514e37c211f327379688f81b0dChris Lattner//===----------------------------------------------------------------------===// 694331de23705a719514e37c211f327379688f81b0dChris Lattner// cl::alias class implementation 695331de23705a719514e37c211f327379688f81b0dChris Lattner// 696331de23705a719514e37c211f327379688f81b0dChris Lattner 697dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// Return the width of the option tag for printing... 698331de23705a719514e37c211f327379688f81b0dChris Lattnerunsigned alias::getOptionWidth() const { 699dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return std::strlen(ArgStr)+6; 700dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 701dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 702a0de843535627977d107bbe84e4ad20cd2a5060aChris Lattner// Print out the option for the alias. 703331de23705a719514e37c211f327379688f81b0dChris Lattnervoid alias::printOptionInfo(unsigned GlobalWidth) const { 704dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner unsigned L = std::strlen(ArgStr); 705e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << " -" << ArgStr << std::string(GlobalWidth-L-6, ' ') << " - " 706e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << HelpStr << "\n"; 707dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 708dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 709dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 710331de23705a719514e37c211f327379688f81b0dChris Lattner 711dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner//===----------------------------------------------------------------------===// 712331de23705a719514e37c211f327379688f81b0dChris Lattner// Parser Implementation code... 713dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 714dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 7159b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// basic_parser implementation 7169b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// 7179b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 7189b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// Return the width of the option tag for printing... 7199b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattnerunsigned basic_parser_impl::getOptionWidth(const Option &O) const { 7209b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner unsigned Len = std::strlen(O.ArgStr); 7219b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner if (const char *ValName = getValueName()) 7229b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner Len += std::strlen(getValueStr(O, ValName))+3; 7239b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 7249b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner return Len + 6; 7259b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner} 7269b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 727f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman// printOptionInfo - Print out information about this option. The 7289b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// to-be-maintained width is specified. 7299b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// 7309b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattnervoid basic_parser_impl::printOptionInfo(const Option &O, 7319b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner unsigned GlobalWidth) const { 732e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << " -" << O.ArgStr; 7339b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 7349b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner if (const char *ValName = getValueName()) 735e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << "=<" << getValueStr(O, ValName) << ">"; 7369b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 737e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << std::string(GlobalWidth-getOptionWidth(O), ' ') << " - " 738e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << O.HelpStr << "\n"; 7399b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner} 7409b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 7419b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 7429b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 7439b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 744331de23705a719514e37c211f327379688f81b0dChris Lattner// parser<bool> implementation 745331de23705a719514e37c211f327379688f81b0dChris Lattner// 7469b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattnerbool parser<bool>::parse(Option &O, const char *ArgName, 747ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner const std::string &Arg, bool &Value) { 748f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman if (Arg == "" || Arg == "true" || Arg == "TRUE" || Arg == "True" || 749dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner Arg == "1") { 750dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner Value = true; 751dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } else if (Arg == "false" || Arg == "FALSE" || Arg == "False" || Arg == "0") { 752dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner Value = false; 753dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } else { 754331de23705a719514e37c211f327379688f81b0dChris Lattner return O.error(": '" + Arg + 755331de23705a719514e37c211f327379688f81b0dChris Lattner "' is invalid value for boolean argument! Try 0 or 1"); 756dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 757dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return false; 758dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 759dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 760331de23705a719514e37c211f327379688f81b0dChris Lattner// parser<int> implementation 761dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 7629b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattnerbool parser<int>::parse(Option &O, const char *ArgName, 763ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner const std::string &Arg, int &Value) { 764331de23705a719514e37c211f327379688f81b0dChris Lattner char *End; 765d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner Value = (int)strtol(Arg.c_str(), &End, 0); 766f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman if (*End != 0) 767331de23705a719514e37c211f327379688f81b0dChris Lattner return O.error(": '" + Arg + "' value invalid for integer argument!"); 768331de23705a719514e37c211f327379688f81b0dChris Lattner return false; 769dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 770dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 771d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner// parser<unsigned> implementation 772d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner// 773d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattnerbool parser<unsigned>::parse(Option &O, const char *ArgName, 774d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner const std::string &Arg, unsigned &Value) { 775d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner char *End; 7762d6a2360036cf511af0a06f9720e6a1752779d1cBrian Gaeke errno = 0; 7772d6a2360036cf511af0a06f9720e6a1752779d1cBrian Gaeke unsigned long V = strtoul(Arg.c_str(), &End, 0); 778d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner Value = (unsigned)V; 7792d6a2360036cf511af0a06f9720e6a1752779d1cBrian Gaeke if (((V == ULONG_MAX) && (errno == ERANGE)) 7802d6a2360036cf511af0a06f9720e6a1752779d1cBrian Gaeke || (*End != 0) 7812d6a2360036cf511af0a06f9720e6a1752779d1cBrian Gaeke || (Value != V)) 782d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner return O.error(": '" + Arg + "' value invalid for uint argument!"); 783d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner return false; 784d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner} 785d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner 7869b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// parser<double>/parser<float> implementation 787331de23705a719514e37c211f327379688f81b0dChris Lattner// 788ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattnerstatic bool parseDouble(Option &O, const std::string &Arg, double &Value) { 789331de23705a719514e37c211f327379688f81b0dChris Lattner const char *ArgStart = Arg.c_str(); 790331de23705a719514e37c211f327379688f81b0dChris Lattner char *End; 791331de23705a719514e37c211f327379688f81b0dChris Lattner Value = strtod(ArgStart, &End); 792f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman if (*End != 0) 793331de23705a719514e37c211f327379688f81b0dChris Lattner return O.error(": '" +Arg+ "' value invalid for floating point argument!"); 794dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return false; 795dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 796dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 7979b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattnerbool parser<double>::parse(Option &O, const char *AN, 7989b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner const std::string &Arg, double &Val) { 7999b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner return parseDouble(O, Arg, Val); 800dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 801dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 8029b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattnerbool parser<float>::parse(Option &O, const char *AN, 8039b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner const std::string &Arg, float &Val) { 8049b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner double dVal; 8059b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner if (parseDouble(O, Arg, dVal)) 8069b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner return true; 8079b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner Val = (float)dVal; 8089b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner return false; 809dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 810dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 811dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 812dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 813331de23705a719514e37c211f327379688f81b0dChris Lattner// generic_parser_base implementation 814dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 815dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 816aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner// findOption - Return the option number corresponding to the specified 817aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner// argument string. If the option is not found, getNumOptions() is returned. 818aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner// 819aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattnerunsigned generic_parser_base::findOption(const char *Name) { 820aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner unsigned i = 0, e = getNumOptions(); 821ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::string N(Name); 822aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner 823aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner while (i != e) 824aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner if (getOption(i) == N) 825aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner return i; 826aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner else 827aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner ++i; 828aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner return e; 829aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner} 830aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner 831aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner 832dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// Return the width of the option tag for printing... 833331de23705a719514e37c211f327379688f81b0dChris Lattnerunsigned generic_parser_base::getOptionWidth(const Option &O) const { 834331de23705a719514e37c211f327379688f81b0dChris Lattner if (O.hasArgStr()) { 835331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned Size = std::strlen(O.ArgStr)+6; 836331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = getNumOptions(); i != e; ++i) 837331de23705a719514e37c211f327379688f81b0dChris Lattner Size = std::max(Size, (unsigned)std::strlen(getOption(i))+8); 838331de23705a719514e37c211f327379688f81b0dChris Lattner return Size; 839331de23705a719514e37c211f327379688f81b0dChris Lattner } else { 840331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned BaseSize = 0; 841331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = getNumOptions(); i != e; ++i) 842331de23705a719514e37c211f327379688f81b0dChris Lattner BaseSize = std::max(BaseSize, (unsigned)std::strlen(getOption(i))+8); 843331de23705a719514e37c211f327379688f81b0dChris Lattner return BaseSize; 844331de23705a719514e37c211f327379688f81b0dChris Lattner } 845dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 846dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 847f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman// printOptionInfo - Print out information about this option. The 848dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// to-be-maintained width is specified. 849dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 850331de23705a719514e37c211f327379688f81b0dChris Lattnervoid generic_parser_base::printOptionInfo(const Option &O, 851331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned GlobalWidth) const { 852331de23705a719514e37c211f327379688f81b0dChris Lattner if (O.hasArgStr()) { 853331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned L = std::strlen(O.ArgStr); 854e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << " -" << O.ArgStr << std::string(GlobalWidth-L-6, ' ') 855e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << " - " << O.HelpStr << "\n"; 856331de23705a719514e37c211f327379688f81b0dChris Lattner 857331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = getNumOptions(); i != e; ++i) { 858331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned NumSpaces = GlobalWidth-strlen(getOption(i))-8; 859e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << " =" << getOption(i) << std::string(NumSpaces, ' ') 860e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << " - " << getDescription(i) << "\n"; 861331de23705a719514e37c211f327379688f81b0dChris Lattner } 862331de23705a719514e37c211f327379688f81b0dChris Lattner } else { 863331de23705a719514e37c211f327379688f81b0dChris Lattner if (O.HelpStr[0]) 864e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << " " << O.HelpStr << "\n"; 865331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = getNumOptions(); i != e; ++i) { 866331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned L = std::strlen(getOption(i)); 867e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << " -" << getOption(i) << std::string(GlobalWidth-L-8, ' ') 868e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << " - " << getDescription(i) << "\n"; 869331de23705a719514e37c211f327379688f81b0dChris Lattner } 870dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 871dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 872dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 873dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 874dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner//===----------------------------------------------------------------------===// 875331de23705a719514e37c211f327379688f81b0dChris Lattner// --help and --help-hidden option implementation 876dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 877ad0846bd8be0a86e0277e1890fd280c9868f830aReid Spencer 878dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattnernamespace { 879dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 880331de23705a719514e37c211f327379688f81b0dChris Lattnerclass HelpPrinter { 881dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner unsigned MaxArgLen; 882dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner const Option *EmptyArg; 883dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner const bool ShowHidden; 884dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 885331de23705a719514e37c211f327379688f81b0dChris Lattner // isHidden/isReallyHidden - Predicates to be used to filter down arg lists. 886ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner inline static bool isHidden(std::pair<std::string, Option *> &OptPair) { 887331de23705a719514e37c211f327379688f81b0dChris Lattner return OptPair.second->getOptionHiddenFlag() >= Hidden; 888331de23705a719514e37c211f327379688f81b0dChris Lattner } 889ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner inline static bool isReallyHidden(std::pair<std::string, Option *> &OptPair) { 890331de23705a719514e37c211f327379688f81b0dChris Lattner return OptPair.second->getOptionHiddenFlag() == ReallyHidden; 891331de23705a719514e37c211f327379688f81b0dChris Lattner } 892331de23705a719514e37c211f327379688f81b0dChris Lattner 893331de23705a719514e37c211f327379688f81b0dChris Lattnerpublic: 894331de23705a719514e37c211f327379688f81b0dChris Lattner HelpPrinter(bool showHidden) : ShowHidden(showHidden) { 895331de23705a719514e37c211f327379688f81b0dChris Lattner EmptyArg = 0; 896331de23705a719514e37c211f327379688f81b0dChris Lattner } 897331de23705a719514e37c211f327379688f81b0dChris Lattner 898331de23705a719514e37c211f327379688f81b0dChris Lattner void operator=(bool Value) { 899331de23705a719514e37c211f327379688f81b0dChris Lattner if (Value == false) return; 900331de23705a719514e37c211f327379688f81b0dChris Lattner 901dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Copy Options into a vector so we can sort them as we like... 90290aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner std::vector<std::pair<std::string, Option*> > Opts; 90390aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner copy(Options->begin(), Options->end(), std::back_inserter(Opts)); 904dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 905dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Eliminate Hidden or ReallyHidden arguments, depending on ShowHidden 90690aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner Opts.erase(std::remove_if(Opts.begin(), Opts.end(), 90790aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner std::ptr_fun(ShowHidden ? isReallyHidden : isHidden)), 90890aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner Opts.end()); 909dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 910dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Eliminate duplicate entries in table (from enum flags options, f.e.) 911331de23705a719514e37c211f327379688f81b0dChris Lattner { // Give OptionSet a scope 912331de23705a719514e37c211f327379688f81b0dChris Lattner std::set<Option*> OptionSet; 91390aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner for (unsigned i = 0; i != Opts.size(); ++i) 91490aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner if (OptionSet.count(Opts[i].second) == 0) 91590aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner OptionSet.insert(Opts[i].second); // Add new entry to set 916331de23705a719514e37c211f327379688f81b0dChris Lattner else 91790aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner Opts.erase(Opts.begin()+i--); // Erase duplicate 918331de23705a719514e37c211f327379688f81b0dChris Lattner } 919dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 920dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner if (ProgramOverview) 921e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << "OVERVIEW:" << ProgramOverview << "\n"; 922dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 923e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << "USAGE: " << ProgramName << " [options]"; 924331de23705a719514e37c211f327379688f81b0dChris Lattner 92590aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner // Print out the positional options. 92690aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner std::vector<Option*> &PosOpts = *PositionalOptions; 927331de23705a719514e37c211f327379688f81b0dChris Lattner Option *CAOpt = 0; // The cl::ConsumeAfter option, if it exists... 928dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman if (!PosOpts.empty() && PosOpts[0]->getNumOccurrencesFlag() == ConsumeAfter) 929331de23705a719514e37c211f327379688f81b0dChris Lattner CAOpt = PosOpts[0]; 930331de23705a719514e37c211f327379688f81b0dChris Lattner 9319cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner for (unsigned i = CAOpt != 0, e = PosOpts.size(); i != e; ++i) { 9329cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (PosOpts[i]->ArgStr[0]) 933e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << " --" << PosOpts[i]->ArgStr; 934e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << " " << PosOpts[i]->HelpStr; 9359cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner } 936331de23705a719514e37c211f327379688f81b0dChris Lattner 937331de23705a719514e37c211f327379688f81b0dChris Lattner // Print the consume after option info if it exists... 938e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling if (CAOpt) cout << " " << CAOpt->HelpStr; 939331de23705a719514e37c211f327379688f81b0dChris Lattner 940e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << "\n\n"; 941dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 942dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Compute the maximum argument length... 943dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner MaxArgLen = 0; 94490aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner for (unsigned i = 0, e = Opts.size(); i != e; ++i) 94590aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner MaxArgLen = std::max(MaxArgLen, Opts[i].second->getOptionWidth()); 946dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 947e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << "OPTIONS:\n"; 94890aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner for (unsigned i = 0, e = Opts.size(); i != e; ++i) 94990aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner Opts[i].second->printOptionInfo(MaxArgLen); 950dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 951c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner // Print any extra help the user has declared. 95290aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner for (std::vector<const char *>::iterator I = MoreHelp->begin(), 95390aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner E = MoreHelp->end(); I != E; ++I) 954e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << *I; 95590aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner MoreHelp->clear(); 956ad0846bd8be0a86e0277e1890fd280c9868f830aReid Spencer 9579bbba091396922093687d11a181e5886c42c5dfdReid Spencer // Halt the program since help information was printed 95890aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner Options->clear(); // Don't bother making option dtors remove from map. 959331de23705a719514e37c211f327379688f81b0dChris Lattner exit(1); 960dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 961331de23705a719514e37c211f327379688f81b0dChris Lattner}; 962500d8bff2077ac327deec076fc8793e740b358c0Chris Lattner} // End anonymous namespace 963dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 964331de23705a719514e37c211f327379688f81b0dChris Lattner// Define the two HelpPrinter instances that are used to print out help, or 965331de23705a719514e37c211f327379688f81b0dChris Lattner// help-hidden... 966331de23705a719514e37c211f327379688f81b0dChris Lattner// 967500d8bff2077ac327deec076fc8793e740b358c0Chris Lattnerstatic HelpPrinter NormalPrinter(false); 968500d8bff2077ac327deec076fc8793e740b358c0Chris Lattnerstatic HelpPrinter HiddenPrinter(true); 969331de23705a719514e37c211f327379688f81b0dChris Lattner 970500d8bff2077ac327deec076fc8793e740b358c0Chris Lattnerstatic cl::opt<HelpPrinter, true, parser<bool> > 9714bf7afcc271138512c38ab2e4a348e2fe6164140Chris LattnerHOp("help", cl::desc("Display available options (--help-hidden for more)"), 9729b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner cl::location(NormalPrinter), cl::ValueDisallowed); 973dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 974500d8bff2077ac327deec076fc8793e740b358c0Chris Lattnerstatic cl::opt<HelpPrinter, true, parser<bool> > 9754bf7afcc271138512c38ab2e4a348e2fe6164140Chris LattnerHHOp("help-hidden", cl::desc("Display all available options"), 9769b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner cl::location(HiddenPrinter), cl::Hidden, cl::ValueDisallowed); 977dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 978500d8bff2077ac327deec076fc8793e740b358c0Chris Lattnerstatic void (*OverrideVersionPrinter)() = 0; 979515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer 980500d8bff2077ac327deec076fc8793e740b358c0Chris Lattnernamespace { 981515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencerclass VersionPrinter { 982515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencerpublic: 983515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer void operator=(bool OptionWasSpecified) { 984515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer if (OptionWasSpecified) { 985515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer if (OverrideVersionPrinter == 0) { 986e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << "Low Level Virtual Machine (http://llvm.org/):\n"; 987e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << " " << PACKAGE_NAME << " version " << PACKAGE_VERSION; 9883fc2f4e83f3317f592c06e2ae7d9f1832210decbChris Lattner#ifdef LLVM_VERSION_INFO 989e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << LLVM_VERSION_INFO; 9903fc2f4e83f3317f592c06e2ae7d9f1832210decbChris Lattner#endif 991e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << "\n "; 9923fc2f4e83f3317f592c06e2ae7d9f1832210decbChris Lattner#ifndef __OPTIMIZE__ 993e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << "DEBUG build"; 994515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer#else 995e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << "Optimized build"; 9963fc2f4e83f3317f592c06e2ae7d9f1832210decbChris Lattner#endif 9973fc2f4e83f3317f592c06e2ae7d9f1832210decbChris Lattner#ifndef NDEBUG 998e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << " with assertions"; 999515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer#endif 1000e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << ".\n"; 100190aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner Options->clear(); // Don't bother making option dtors remove from map. 1002515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer exit(1); 1003515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer } else { 1004515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer (*OverrideVersionPrinter)(); 1005515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer exit(1); 1006515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer } 1007515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer } 1008515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer } 1009515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer}; 1010500d8bff2077ac327deec076fc8793e740b358c0Chris Lattner} // End anonymous namespace 1011515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer 1012515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer 101369105f33c190621a6b1ad61f925b1a9e6b0512afReid Spencer// Define the --version option that prints out the LLVM version for the tool 1014500d8bff2077ac327deec076fc8793e740b358c0Chris Lattnerstatic VersionPrinter VersionPrinterInstance; 1015500d8bff2077ac327deec076fc8793e740b358c0Chris Lattner 1016500d8bff2077ac327deec076fc8793e740b358c0Chris Lattnerstatic cl::opt<VersionPrinter, true, parser<bool> > 10174bf7afcc271138512c38ab2e4a348e2fe6164140Chris LattnerVersOp("version", cl::desc("Display the version of this program"), 101869105f33c190621a6b1ad61f925b1a9e6b0512afReid Spencer cl::location(VersionPrinterInstance), cl::ValueDisallowed); 101969105f33c190621a6b1ad61f925b1a9e6b0512afReid Spencer 10209bbba091396922093687d11a181e5886c42c5dfdReid Spencer// Utility function for printing the help message. 10219bbba091396922093687d11a181e5886c42c5dfdReid Spencervoid cl::PrintHelpMessage() { 1022f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman // This looks weird, but it actually prints the help message. The 10235cc498f116cd76235c9c0a2ded46bc29f8fb35e0Reid Spencer // NormalPrinter variable is a HelpPrinter and the help gets printed when 10245cc498f116cd76235c9c0a2ded46bc29f8fb35e0Reid Spencer // its operator= is invoked. That's because the "normal" usages of the 1025f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman // help printer is to be assigned true/false depending on whether the 10265cc498f116cd76235c9c0a2ded46bc29f8fb35e0Reid Spencer // --help option was given or not. Since we're circumventing that we have 10275cc498f116cd76235c9c0a2ded46bc29f8fb35e0Reid Spencer // to make it look like --help was given, so we assign true. 10289bbba091396922093687d11a181e5886c42c5dfdReid Spencer NormalPrinter = true; 10299bbba091396922093687d11a181e5886c42c5dfdReid Spencer} 1030515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer 1031515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencervoid cl::SetVersionPrinter(void (*func)()) { 1032515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer OverrideVersionPrinter = func; 1033515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer} 1034