CommandLine.cpp revision 341620b2762e604fbf8c75913a1cc5b9c9297b7d
1dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner//===-- CommandLine.cpp - Command line parser implementation --------------===// 2f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman// 3b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// The LLVM Compiler Infrastructure 4b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// 54ee451de366474b9c228b4e5fa573795a715216dChris Lattner// This file is distributed under the University of Illinois Open Source 64ee451de366474b9c228b4e5fa573795a715216dChris Lattner// 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/Support/CommandLine.h" 207d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin#include "llvm/Support/ErrorHandling.h" 21beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov#include "llvm/Support/MemoryBuffer.h" 2290aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner#include "llvm/Support/ManagedStatic.h" 23ca179340ce51ca394a836444d4dd1974ce18e1a4Chris Lattner#include "llvm/Support/raw_ostream.h" 24603bea32743dc9914a1d32ae36fc64fe497af801Daniel Dunbar#include "llvm/Target/TargetRegistry.h" 256552478ee74abe6851cebc5762a1dbe6982bb122Daniel Dunbar#include "llvm/System/Host.h" 266f4c60770cfe6c485cdcb1397df59d2c7778cbc9Reid Spencer#include "llvm/System/Path.h" 27ca179340ce51ca394a836444d4dd1974ce18e1a4Chris Lattner#include "llvm/ADT/OwningPtr.h" 28461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer#include "llvm/ADT/StringMap.h" 29970e7dff5ba2bd8c5613c43e3b215ca940a378e9Chris Lattner#include "llvm/ADT/SmallString.h" 30a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner#include "llvm/ADT/Twine.h" 31ca179340ce51ca394a836444d4dd1974ce18e1a4Chris Lattner#include "llvm/Config/config.h" 32dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner#include <set> 332d6a2360036cf511af0a06f9720e6a1752779d1cBrian Gaeke#include <cerrno> 34ca179340ce51ca394a836444d4dd1974ce18e1a4Chris Lattner#include <cstdlib> 352cdd21c2e4d855500dfb53f77aa74da53ccf9de6Chris Lattnerusing namespace llvm; 36dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattnerusing namespace cl; 37dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 387422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner//===----------------------------------------------------------------------===// 397422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner// Template instantiations and anchors. 407422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner// 417422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class basic_parser<bool>); 4281da02b553b86868637f27b89c6e919c31ed5b51Dale JohannesenTEMPLATE_INSTANTIATION(class basic_parser<boolOrDefault>); 437422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class basic_parser<int>); 447422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class basic_parser<unsigned>); 457422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class basic_parser<double>); 467422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class basic_parser<float>); 477422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class basic_parser<std::string>); 48b587f9662a7b6f00f9ce48ddf2dea1a4fb18a6dbBill WendlingTEMPLATE_INSTANTIATION(class basic_parser<char>); 497422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner 507422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class opt<unsigned>); 517422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class opt<int>); 527422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class opt<std::string>); 53b587f9662a7b6f00f9ce48ddf2dea1a4fb18a6dbBill WendlingTEMPLATE_INSTANTIATION(class opt<char>); 547422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class opt<bool>); 557422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner 567422a761008ef63152417c5e69ddc31252fb6b10Chris Lattnervoid Option::anchor() {} 577422a761008ef63152417c5e69ddc31252fb6b10Chris Lattnervoid basic_parser_impl::anchor() {} 587422a761008ef63152417c5e69ddc31252fb6b10Chris Lattnervoid parser<bool>::anchor() {} 5981da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesenvoid parser<boolOrDefault>::anchor() {} 607422a761008ef63152417c5e69ddc31252fb6b10Chris Lattnervoid parser<int>::anchor() {} 617422a761008ef63152417c5e69ddc31252fb6b10Chris Lattnervoid parser<unsigned>::anchor() {} 627422a761008ef63152417c5e69ddc31252fb6b10Chris Lattnervoid parser<double>::anchor() {} 637422a761008ef63152417c5e69ddc31252fb6b10Chris Lattnervoid parser<float>::anchor() {} 647422a761008ef63152417c5e69ddc31252fb6b10Chris Lattnervoid parser<std::string>::anchor() {} 65b587f9662a7b6f00f9ce48ddf2dea1a4fb18a6dbBill Wendlingvoid parser<char>::anchor() {} 667422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner 677422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner//===----------------------------------------------------------------------===// 687422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner 69efa3da5593117eab5209c9197cad5ca42213c12eChris Lattner// Globals for name and overview of program. Program name is not a string to 70efa3da5593117eab5209c9197cad5ca42213c12eChris Lattner// avoid static ctor/dtor issues. 71efa3da5593117eab5209c9197cad5ca42213c12eChris Lattnerstatic char ProgramName[80] = "<premain>"; 72e1cc150a8e6b451e42b04b04ffb41596e01bbef5Reid Spencerstatic const char *ProgramOverview = 0; 73e1cc150a8e6b451e42b04b04ffb41596e01bbef5Reid Spencer 74c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner// This collects additional help to be printed. 7590aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattnerstatic ManagedStatic<std::vector<const char*> > MoreHelp; 76c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner 7790aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattnerextrahelp::extrahelp(const char *Help) 78c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner : morehelp(Help) { 7990aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner MoreHelp->push_back(Help); 80c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner} 81c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner 8269d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattnerstatic bool OptionListChanged = false; 8369d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattner 8469d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattner// MarkOptionsChanged - Internal helper function. 8569d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattnervoid cl::MarkOptionsChanged() { 8669d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattner OptionListChanged = true; 8769d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattner} 8869d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattner 899878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner/// RegisteredOptionList - This is the list of the command line options that 909878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner/// have statically constructed themselves. 919878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattnerstatic Option *RegisteredOptionList = 0; 929878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner 939878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattnervoid Option::addArgument() { 949878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner assert(NextRegistered == 0 && "argument multiply registered!"); 95beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 969878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner NextRegistered = RegisteredOptionList; 979878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner RegisteredOptionList = this; 9869d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattner MarkOptionsChanged(); 999878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner} 1009878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner 10169d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattner 102331de23705a719514e37c211f327379688f81b0dChris Lattner//===----------------------------------------------------------------------===// 1037422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner// Basic, shared command line option processing machinery. 104331de23705a719514e37c211f327379688f81b0dChris Lattner// 105331de23705a719514e37c211f327379688f81b0dChris Lattner 1069878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner/// GetOptionInfo - Scan the list of registered options, turning them into data 1079878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner/// structures that are easier to handle. 1089878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattnerstatic void GetOptionInfo(std::vector<Option*> &PositionalOpts, 109d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov std::vector<Option*> &SinkOpts, 110461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer StringMap<Option*> &OptionsMap) { 1119878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner std::vector<const char*> OptionNames; 112ee2b32082eff7366621ed2ab119deb96b7c26cecChris Lattner Option *CAOpt = 0; // The ConsumeAfter option if it exists. 1139878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner for (Option *O = RegisteredOptionList; O; O = O->getNextRegisteredOption()) { 1149878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner // If this option wants to handle multiple option names, get the full set. 1159878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner // This handles enum options like "-O1 -O2" etc. 1169878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner O->getExtraOptionNames(OptionNames); 1179878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner if (O->ArgStr[0]) 1189878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner OptionNames.push_back(O->ArgStr); 119beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 1209878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner // Handle named options. 12134cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng for (size_t i = 0, e = OptionNames.size(); i != e; ++i) { 1229878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner // Add argument to the argument map! 123461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer if (OptionsMap.GetOrCreateValue(OptionNames[i], O).second != O) { 124d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer errs() << ProgramName << ": CommandLine Error: Argument '" 12533540adca55b95a5fdbb0dc783ded319a90b4bc1Matthijs Kooijman << OptionNames[i] << "' defined more than once!\n"; 1269878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner } 1279878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner } 128beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 1299878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner OptionNames.clear(); 130beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 1319878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner // Remember information about positional options. 1329878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner if (O->getFormattingFlag() == cl::Positional) 1339878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner PositionalOpts.push_back(O); 13461e015fe7426ca97c3c7afb583f04f5f93050370Dan Gohman else if (O->getMiscFlags() & cl::Sink) // Remember sink options 135d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov SinkOpts.push_back(O); 1369878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner else if (O->getNumOccurrencesFlag() == cl::ConsumeAfter) { 137ee2b32082eff7366621ed2ab119deb96b7c26cecChris Lattner if (CAOpt) 1389878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner O->error("Cannot specify more than one option with cl::ConsumeAfter!"); 139ee2b32082eff7366621ed2ab119deb96b7c26cecChris Lattner CAOpt = O; 1409878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner } 141e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner } 142beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 143ee2b32082eff7366621ed2ab119deb96b7c26cecChris Lattner if (CAOpt) 144ee2b32082eff7366621ed2ab119deb96b7c26cecChris Lattner PositionalOpts.push_back(CAOpt); 145beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 146ee2b32082eff7366621ed2ab119deb96b7c26cecChris Lattner // Make sure that they are in order of registration not backwards. 147ee2b32082eff7366621ed2ab119deb96b7c26cecChris Lattner std::reverse(PositionalOpts.begin(), PositionalOpts.end()); 148e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner} 149e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner 1509878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner 151af035f3460f7d758f73987c3f692faf8d6cae062Chris Lattner/// LookupOption - Lookup the option specified by the specified option on the 152af035f3460f7d758f73987c3f692faf8d6cae062Chris Lattner/// command line. If there is a value specified (after an equal sign) return 153af035f3460f7d758f73987c3f692faf8d6cae062Chris Lattner/// that as well. 1549878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattnerstatic Option *LookupOption(const char *&Arg, const char *&Value, 155461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer StringMap<Option*> &OptionsMap) { 156af035f3460f7d758f73987c3f692faf8d6cae062Chris Lattner while (*Arg == '-') ++Arg; // Eat leading dashes 157beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 158af035f3460f7d758f73987c3f692faf8d6cae062Chris Lattner const char *ArgEnd = Arg; 159af035f3460f7d758f73987c3f692faf8d6cae062Chris Lattner while (*ArgEnd && *ArgEnd != '=') 160af035f3460f7d758f73987c3f692faf8d6cae062Chris Lattner ++ArgEnd; // Scan till end of argument name. 161beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 162af035f3460f7d758f73987c3f692faf8d6cae062Chris Lattner if (*ArgEnd == '=') // If we have an equals sign... 163af035f3460f7d758f73987c3f692faf8d6cae062Chris Lattner Value = ArgEnd+1; // Get the value, not the equals 164beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 165beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 166af035f3460f7d758f73987c3f692faf8d6cae062Chris Lattner if (*Arg == 0) return 0; 167beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 168af035f3460f7d758f73987c3f692faf8d6cae062Chris Lattner // Look up the option. 169461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer StringMap<Option*>::iterator I = 170461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer OptionsMap.find(llvm::StringRef(Arg, ArgEnd-Arg)); 1719878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner return I != OptionsMap.end() ? I->second : 0; 172dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 173dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 174341620b2762e604fbf8c75913a1cc5b9c9297b7dChris Lattner/// ProvideOption - For Value, this differentiates between an empty value ("") 175341620b2762e604fbf8c75913a1cc5b9c9297b7dChris Lattner/// and a null value (StringRef()). The later is accepted for arguments that 176341620b2762e604fbf8c75913a1cc5b9c9297b7dChris Lattner/// don't allow a value (-foo) the former is rejected (-foo=). 17799c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattnerstatic inline bool ProvideOption(Option *Handler, StringRef ArgName, 178341620b2762e604fbf8c75913a1cc5b9c9297b7dChris Lattner StringRef Value, int argc, char **argv, 179caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner int &i) { 1807059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov // Is this a multi-argument option? 1817059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov unsigned NumAdditionalVals = Handler->getNumAdditionalVals(); 1827059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov 183caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner // Enforce value requirements 184caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner switch (Handler->getValueExpectedFlag()) { 185caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner case ValueRequired: 186341620b2762e604fbf8c75913a1cc5b9c9297b7dChris Lattner if (Value.data() == 0) { // No value specified? 187ba11229f52743ac70f01d4f62d1e04dd093de4e0Chris Lattner if (i+1 >= argc) 188e6864c1d355c4ec1156b956c1dd548682ad3e6b1Benjamin Kramer return Handler->error("requires a value!"); 189ba11229f52743ac70f01d4f62d1e04dd093de4e0Chris Lattner // Steal the next argument, like for '-o filename' 190ba11229f52743ac70f01d4f62d1e04dd093de4e0Chris Lattner Value = argv[++i]; 191caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner } 192caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner break; 193caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner case ValueDisallowed: 1947059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov if (NumAdditionalVals > 0) 195e6864c1d355c4ec1156b956c1dd548682ad3e6b1Benjamin Kramer return Handler->error("multi-valued option specified" 196ba11229f52743ac70f01d4f62d1e04dd093de4e0Chris Lattner " with ValueDisallowed modifier!"); 1977059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov 198341620b2762e604fbf8c75913a1cc5b9c9297b7dChris Lattner if (Value.data()) 199e6864c1d355c4ec1156b956c1dd548682ad3e6b1Benjamin Kramer return Handler->error("does not allow a value! '" + 200a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner Twine(Value) + "' specified."); 201caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner break; 202f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman case ValueOptional: 203e1cc150a8e6b451e42b04b04ffb41596e01bbef5Reid Spencer break; 204ba11229f52743ac70f01d4f62d1e04dd093de4e0Chris Lattner 205f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman default: 206d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer errs() << ProgramName 207e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << ": Bad ValueMask flag! CommandLine usage error:" 208e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << Handler->getValueExpectedFlag() << "\n"; 209c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable(0); 210caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner } 211caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner 2127059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov // If this isn't a multi-arg option, just run the handler. 213a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner if (NumAdditionalVals == 0) 214341620b2762e604fbf8c75913a1cc5b9c9297b7dChris Lattner return Handler->addOccurrence(i, ArgName, Value); 215a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner 2167059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov // If it is, run the handle several times. 217a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner bool MultiArg = false; 2187059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov 219341620b2762e604fbf8c75913a1cc5b9c9297b7dChris Lattner if (Value.data()) { 220a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner if (Handler->addOccurrence(i, ArgName, Value, MultiArg)) 221a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner return true; 222a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner --NumAdditionalVals; 223a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner MultiArg = true; 224a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner } 2257059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov 226a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner while (NumAdditionalVals > 0) { 227a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner if (i+1 >= argc) 228a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner return Handler->error("not enough values!"); 229a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner Value = argv[++i]; 230a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner 231a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner if (Handler->addOccurrence(i, ArgName, Value, MultiArg)) 232a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner return true; 233a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner MultiArg = true; 234a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner --NumAdditionalVals; 2357059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov } 236a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner return false; 237caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner} 238caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner 239ba11229f52743ac70f01d4f62d1e04dd093de4e0Chris Lattnerstatic bool ProvidePositionalOption(Option *Handler, StringRef Arg, int i) { 2401e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer int Dummy = i; 241341620b2762e604fbf8c75913a1cc5b9c9297b7dChris Lattner return ProvideOption(Handler, Handler->ArgStr, Arg, 0, 0, Dummy); 242331de23705a719514e37c211f327379688f81b0dChris Lattner} 243331de23705a719514e37c211f327379688f81b0dChris Lattner 244331de23705a719514e37c211f327379688f81b0dChris Lattner 245331de23705a719514e37c211f327379688f81b0dChris Lattner// Option predicates... 246331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic inline bool isGrouping(const Option *O) { 247331de23705a719514e37c211f327379688f81b0dChris Lattner return O->getFormattingFlag() == cl::Grouping; 248331de23705a719514e37c211f327379688f81b0dChris Lattner} 249331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic inline bool isPrefixedOrGrouping(const Option *O) { 250331de23705a719514e37c211f327379688f81b0dChris Lattner return isGrouping(O) || O->getFormattingFlag() == cl::Prefix; 251331de23705a719514e37c211f327379688f81b0dChris Lattner} 252331de23705a719514e37c211f327379688f81b0dChris Lattner 253331de23705a719514e37c211f327379688f81b0dChris Lattner// getOptionPred - Check to see if there are any options that satisfy the 254331de23705a719514e37c211f327379688f81b0dChris Lattner// specified predicate with names that are the prefixes in Name. This is 255331de23705a719514e37c211f327379688f81b0dChris Lattner// checked by progressively stripping characters off of the name, checking to 256331de23705a719514e37c211f327379688f81b0dChris Lattner// see if there options that satisfy the predicate. If we find one, return it, 257331de23705a719514e37c211f327379688f81b0dChris Lattner// otherwise return null. 258f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner// 25999c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattnerstatic Option *getOptionPred(StringRef Name, size_t &Length, 2609878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner bool (*Pred)(const Option*), 261461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer StringMap<Option*> &OptionsMap) { 262f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 263461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer StringMap<Option*>::iterator OMI = OptionsMap.find(Name); 2649878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner if (OMI != OptionsMap.end() && Pred(OMI->second)) { 26599c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattner Length = Name.size(); 2669878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner return OMI->second; 267331de23705a719514e37c211f327379688f81b0dChris Lattner } 268f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner 269331de23705a719514e37c211f327379688f81b0dChris Lattner if (Name.size() == 1) return 0; 270331de23705a719514e37c211f327379688f81b0dChris Lattner do { 27199c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattner Name = Name.substr(0, Name.size()-1); // Chop off the last character. 2729878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner OMI = OptionsMap.find(Name); 273331de23705a719514e37c211f327379688f81b0dChris Lattner 274331de23705a719514e37c211f327379688f81b0dChris Lattner // Loop while we haven't found an option and Name still has at least two 275331de23705a719514e37c211f327379688f81b0dChris Lattner // characters in it (so that the next iteration will not be the empty 27699c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattner // string. 2779878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner } while ((OMI == OptionsMap.end() || !Pred(OMI->second)) && Name.size() > 1); 278331de23705a719514e37c211f327379688f81b0dChris Lattner 2799878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner if (OMI != OptionsMap.end() && Pred(OMI->second)) { 28099c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattner Length = Name.size(); 2819878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner return OMI->second; // Found one! 282f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner } 283331de23705a719514e37c211f327379688f81b0dChris Lattner return 0; // No option found! 284331de23705a719514e37c211f327379688f81b0dChris Lattner} 285f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner 286331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic bool RequiresValue(const Option *O) { 287dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman return O->getNumOccurrencesFlag() == cl::Required || 288dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman O->getNumOccurrencesFlag() == cl::OneOrMore; 289331de23705a719514e37c211f327379688f81b0dChris Lattner} 290331de23705a719514e37c211f327379688f81b0dChris Lattner 291331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic bool EatsUnboundedNumberOfValues(const Option *O) { 292dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman return O->getNumOccurrencesFlag() == cl::ZeroOrMore || 293dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman O->getNumOccurrencesFlag() == cl::OneOrMore; 294f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner} 295caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner 296c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke/// ParseCStringVector - Break INPUT up wherever one or more 297c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke/// whitespace characters are found, and store the resulting tokens in 298c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke/// OUTPUT. The tokens stored in OUTPUT are dynamically allocated 299fb2674d0de83cbf3b79c269bc694f612de148950Chris Lattner/// using strdup(), so it is the caller's responsibility to free() 300c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke/// them later. 30106b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// 302b7b71a37a1bb88ef88c387f8a31bfc10dd816e83Chris Lattnerstatic void ParseCStringVector(std::vector<char *> &OutputVector, 303b7b71a37a1bb88ef88c387f8a31bfc10dd816e83Chris Lattner const char *Input) { 304c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Characters which will be treated as token separators: 305b7b71a37a1bb88ef88c387f8a31bfc10dd816e83Chris Lattner StringRef Delims = " \v\f\t\r\n"; 306b7b71a37a1bb88ef88c387f8a31bfc10dd816e83Chris Lattner 307b7b71a37a1bb88ef88c387f8a31bfc10dd816e83Chris Lattner StringRef WorkStr(Input); 308b7b71a37a1bb88ef88c387f8a31bfc10dd816e83Chris Lattner while (!WorkStr.empty()) { 309b7b71a37a1bb88ef88c387f8a31bfc10dd816e83Chris Lattner // If the first character is a delimiter, strip them off. 310b7b71a37a1bb88ef88c387f8a31bfc10dd816e83Chris Lattner if (Delims.find(WorkStr[0]) != StringRef::npos) { 311b7b71a37a1bb88ef88c387f8a31bfc10dd816e83Chris Lattner size_t Pos = WorkStr.find_first_not_of(Delims); 312b7b71a37a1bb88ef88c387f8a31bfc10dd816e83Chris Lattner if (Pos == StringRef::npos) Pos = WorkStr.size(); 313b7b71a37a1bb88ef88c387f8a31bfc10dd816e83Chris Lattner WorkStr = WorkStr.substr(Pos); 314b7b71a37a1bb88ef88c387f8a31bfc10dd816e83Chris Lattner continue; 31506b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke } 316b7b71a37a1bb88ef88c387f8a31bfc10dd816e83Chris Lattner 317b7b71a37a1bb88ef88c387f8a31bfc10dd816e83Chris Lattner // Find position of first delimiter. 318b7b71a37a1bb88ef88c387f8a31bfc10dd816e83Chris Lattner size_t Pos = WorkStr.find_first_of(Delims); 319b7b71a37a1bb88ef88c387f8a31bfc10dd816e83Chris Lattner if (Pos == StringRef::npos) Pos = WorkStr.size(); 320b7b71a37a1bb88ef88c387f8a31bfc10dd816e83Chris Lattner 321b7b71a37a1bb88ef88c387f8a31bfc10dd816e83Chris Lattner // Everything from 0 to Pos is the next word to copy. 322b7b71a37a1bb88ef88c387f8a31bfc10dd816e83Chris Lattner char *NewStr = (char*)malloc(Pos+1); 323b7b71a37a1bb88ef88c387f8a31bfc10dd816e83Chris Lattner memcpy(NewStr, WorkStr.data(), Pos); 324b7b71a37a1bb88ef88c387f8a31bfc10dd816e83Chris Lattner NewStr[Pos] = 0; 325b7b71a37a1bb88ef88c387f8a31bfc10dd816e83Chris Lattner OutputVector.push_back(NewStr); 32606b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke } 32706b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke} 32806b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke 32906b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// ParseEnvironmentOptions - An alternative entry point to the 33006b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// CommandLine library, which allows you to read the program's name 33106b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// from the caller (as PROGNAME) and its command-line arguments from 33206b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// an environment variable (whose name is given in ENVVAR). 33306b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// 334bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattnervoid cl::ParseEnvironmentOptions(const char *progName, const char *envVar, 335beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov const char *Overview, bool ReadResponseFiles) { 336c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Check args. 337bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner assert(progName && "Program name not specified"); 338bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner assert(envVar && "Environment variable name missing"); 339f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 34006b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke // Get the environment variable they want us to parse options out of. 341232885873fb0081acc1420ab83b14ab6f8eba280Chris Lattner const char *envValue = getenv(envVar); 342c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke if (!envValue) 34306b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke return; 344c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke 345c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Get program's "name", which we wouldn't know without the caller 346c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // telling us. 347232885873fb0081acc1420ab83b14ab6f8eba280Chris Lattner std::vector<char*> newArgv; 348232885873fb0081acc1420ab83b14ab6f8eba280Chris Lattner newArgv.push_back(strdup(progName)); 34906b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke 35006b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke // Parse the value of the environment variable into a "command line" 35106b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke // and hand it off to ParseCommandLineOptions(). 352232885873fb0081acc1420ab83b14ab6f8eba280Chris Lattner ParseCStringVector(newArgv, envValue); 35334cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng int newArgc = static_cast<int>(newArgv.size()); 354beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov ParseCommandLineOptions(newArgc, &newArgv[0], Overview, ReadResponseFiles); 355c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke 356c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Free all the strdup()ed strings. 357232885873fb0081acc1420ab83b14ab6f8eba280Chris Lattner for (std::vector<char*>::iterator i = newArgv.begin(), e = newArgv.end(); 358232885873fb0081acc1420ab83b14ab6f8eba280Chris Lattner i != e; ++i) 359fb2674d0de83cbf3b79c269bc694f612de148950Chris Lattner free(*i); 36006b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke} 36106b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke 362beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 363beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov/// ExpandResponseFiles - Copy the contents of argv into newArgv, 364beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov/// substituting the contents of the response files for the arguments 365beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov/// of type @file. 366beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkovstatic void ExpandResponseFiles(int argc, char** argv, 367beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov std::vector<char*>& newArgv) { 368beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov for (int i = 1; i != argc; ++i) { 369beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov char* arg = argv[i]; 370beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 371beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov if (arg[0] == '@') { 372beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 373beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov sys::PathWithStatus respFile(++arg); 374beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 375beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov // Check that the response file is not empty (mmap'ing empty 376beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov // files can be problematic). 377beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov const sys::FileStatus *FileStat = respFile.getFileStatus(); 3781421b7bc23f39e57052a51f4647512936f45b12fMikhail Glushenkov if (FileStat && FileStat->getSize() != 0) { 3791421b7bc23f39e57052a51f4647512936f45b12fMikhail Glushenkov 3801421b7bc23f39e57052a51f4647512936f45b12fMikhail Glushenkov // Mmap the response file into memory. 3811421b7bc23f39e57052a51f4647512936f45b12fMikhail Glushenkov OwningPtr<MemoryBuffer> 3821421b7bc23f39e57052a51f4647512936f45b12fMikhail Glushenkov respFilePtr(MemoryBuffer::getFile(respFile.c_str())); 3831421b7bc23f39e57052a51f4647512936f45b12fMikhail Glushenkov 3841421b7bc23f39e57052a51f4647512936f45b12fMikhail Glushenkov // If we could open the file, parse its contents, otherwise 3851421b7bc23f39e57052a51f4647512936f45b12fMikhail Glushenkov // pass the @file option verbatim. 3866c55b1ca7b72c90ce93ca25bc35aefef7d7deda4Mikhail Glushenkov 3876c55b1ca7b72c90ce93ca25bc35aefef7d7deda4Mikhail Glushenkov // TODO: we should also support recursive loading of response files, 3886c55b1ca7b72c90ce93ca25bc35aefef7d7deda4Mikhail Glushenkov // since this is how gcc behaves. (From their man page: "The file may 3896c55b1ca7b72c90ce93ca25bc35aefef7d7deda4Mikhail Glushenkov // itself contain additional @file options; any such options will be 3906c55b1ca7b72c90ce93ca25bc35aefef7d7deda4Mikhail Glushenkov // processed recursively.") 3916c55b1ca7b72c90ce93ca25bc35aefef7d7deda4Mikhail Glushenkov 3921421b7bc23f39e57052a51f4647512936f45b12fMikhail Glushenkov if (respFilePtr != 0) { 3931421b7bc23f39e57052a51f4647512936f45b12fMikhail Glushenkov ParseCStringVector(newArgv, respFilePtr->getBufferStart()); 3941421b7bc23f39e57052a51f4647512936f45b12fMikhail Glushenkov continue; 3951421b7bc23f39e57052a51f4647512936f45b12fMikhail Glushenkov } 3961421b7bc23f39e57052a51f4647512936f45b12fMikhail Glushenkov } 397beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov } 3981421b7bc23f39e57052a51f4647512936f45b12fMikhail Glushenkov newArgv.push_back(strdup(arg)); 399beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov } 400beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov} 401beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 4029a5263241d40d493445d7f386b4d76be088c3ac1Dan Gohmanvoid cl::ParseCommandLineOptions(int argc, char **argv, 403beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov const char *Overview, bool ReadResponseFiles) { 4049878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner // Process all registered options. 4059878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner std::vector<Option*> PositionalOpts; 406d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov std::vector<Option*> SinkOpts; 407461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer StringMap<Option*> Opts; 408d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov GetOptionInfo(PositionalOpts, SinkOpts, Opts); 409beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 4109878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner assert((!Opts.empty() || !PositionalOpts.empty()) && 4119878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner "No options specified!"); 412beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 413beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov // Expand response files. 414beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov std::vector<char*> newArgv; 415beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov if (ReadResponseFiles) { 416beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov newArgv.push_back(strdup(argv[0])); 417beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov ExpandResponseFiles(argc, argv, newArgv); 418beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov argv = &newArgv[0]; 41934cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng argc = static_cast<int>(newArgv.size()); 420beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov } 421beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 422efa3da5593117eab5209c9197cad5ca42213c12eChris Lattner // Copy the program name into ProgName, making sure not to overflow it. 423efa3da5593117eab5209c9197cad5ca42213c12eChris Lattner std::string ProgName = sys::Path(argv[0]).getLast(); 424efa3da5593117eab5209c9197cad5ca42213c12eChris Lattner if (ProgName.size() > 79) ProgName.resize(79); 425efa3da5593117eab5209c9197cad5ca42213c12eChris Lattner strcpy(ProgramName, ProgName.c_str()); 426beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 427dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner ProgramOverview = Overview; 428dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner bool ErrorParsing = false; 429dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 430331de23705a719514e37c211f327379688f81b0dChris Lattner // Check out the positional arguments to collect information about them. 431331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned NumPositionalRequired = 0; 432beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 433de0132453e2939488c2d69290bfdfb2cde94a0afChris Lattner // Determine whether or not there are an unlimited number of positionals 434de0132453e2939488c2d69290bfdfb2cde94a0afChris Lattner bool HasUnlimitedPositionals = false; 435beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 436331de23705a719514e37c211f327379688f81b0dChris Lattner Option *ConsumeAfterOpt = 0; 437331de23705a719514e37c211f327379688f81b0dChris Lattner if (!PositionalOpts.empty()) { 438dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman if (PositionalOpts[0]->getNumOccurrencesFlag() == cl::ConsumeAfter) { 439331de23705a719514e37c211f327379688f81b0dChris Lattner assert(PositionalOpts.size() > 1 && 440331de23705a719514e37c211f327379688f81b0dChris Lattner "Cannot specify cl::ConsumeAfter without a positional argument!"); 441331de23705a719514e37c211f327379688f81b0dChris Lattner ConsumeAfterOpt = PositionalOpts[0]; 442331de23705a719514e37c211f327379688f81b0dChris Lattner } 443331de23705a719514e37c211f327379688f81b0dChris Lattner 444331de23705a719514e37c211f327379688f81b0dChris Lattner // Calculate how many positional values are _required_. 445331de23705a719514e37c211f327379688f81b0dChris Lattner bool UnboundedFound = false; 44634cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng for (size_t i = ConsumeAfterOpt != 0, e = PositionalOpts.size(); 447331de23705a719514e37c211f327379688f81b0dChris Lattner i != e; ++i) { 448331de23705a719514e37c211f327379688f81b0dChris Lattner Option *Opt = PositionalOpts[i]; 449331de23705a719514e37c211f327379688f81b0dChris Lattner if (RequiresValue(Opt)) 450331de23705a719514e37c211f327379688f81b0dChris Lattner ++NumPositionalRequired; 451331de23705a719514e37c211f327379688f81b0dChris Lattner else if (ConsumeAfterOpt) { 452331de23705a719514e37c211f327379688f81b0dChris Lattner // ConsumeAfter cannot be combined with "optional" positional options 45354ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner // unless there is only one positional argument... 45454ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner if (PositionalOpts.size() > 2) 45554ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner ErrorParsing |= 456e6864c1d355c4ec1156b956c1dd548682ad3e6b1Benjamin Kramer Opt->error("error - this positional option will never be matched, " 45754ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner "because it does not Require a value, and a " 45854ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner "cl::ConsumeAfter option is active!"); 4599cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner } else if (UnboundedFound && !Opt->ArgStr[0]) { 4609cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // This option does not "require" a value... Make sure this option is 4619cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // not specified after an option that eats all extra arguments, or this 4629cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // one will never get any! 463331de23705a719514e37c211f327379688f81b0dChris Lattner // 464e6864c1d355c4ec1156b956c1dd548682ad3e6b1Benjamin Kramer ErrorParsing |= Opt->error("error - option can never match, because " 465331de23705a719514e37c211f327379688f81b0dChris Lattner "another positional argument will match an " 466331de23705a719514e37c211f327379688f81b0dChris Lattner "unbounded number of values, and this option" 467331de23705a719514e37c211f327379688f81b0dChris Lattner " does not require a value!"); 468331de23705a719514e37c211f327379688f81b0dChris Lattner } 469331de23705a719514e37c211f327379688f81b0dChris Lattner UnboundedFound |= EatsUnboundedNumberOfValues(Opt); 470331de23705a719514e37c211f327379688f81b0dChris Lattner } 47121e1a79a31fe45fcd861d64118a60c1fcfad618aChris Lattner HasUnlimitedPositionals = UnboundedFound || ConsumeAfterOpt; 472331de23705a719514e37c211f327379688f81b0dChris Lattner } 473331de23705a719514e37c211f327379688f81b0dChris Lattner 4741e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer // PositionalVals - A vector of "positional" arguments we accumulate into 475ba11229f52743ac70f01d4f62d1e04dd093de4e0Chris Lattner // the process at the end. 476331de23705a719514e37c211f327379688f81b0dChris Lattner // 477ba11229f52743ac70f01d4f62d1e04dd093de4e0Chris Lattner SmallVector<std::pair<StringRef,unsigned>, 4> PositionalVals; 478331de23705a719514e37c211f327379688f81b0dChris Lattner 4799cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // If the program has named positional arguments, and the name has been run 4809cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // across, keep track of which positional argument was named. Otherwise put 4819cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // the positional args into the PositionalVals list... 4829cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner Option *ActivePositionalArg = 0; 4839cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner 484dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Loop over all of the arguments... processing them. 485331de23705a719514e37c211f327379688f81b0dChris Lattner bool DashDashFound = false; // Have we read '--'? 486dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner for (int i = 1; i < argc; ++i) { 487dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner Option *Handler = 0; 4886d5857e139df71410e98ccf6cd0e783f90a9fc16Chris Lattner const char *Value = 0; 489dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner const char *ArgName = ""; 490331de23705a719514e37c211f327379688f81b0dChris Lattner 49169d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattner // If the option list changed, this means that some command line 492159b0a43408e2521110e22e445ec126aaab16788Chris Lattner // option has just been registered or deregistered. This can occur in 493159b0a43408e2521110e22e445ec126aaab16788Chris Lattner // response to things like -load, etc. If this happens, rescan the options. 49469d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattner if (OptionListChanged) { 495159b0a43408e2521110e22e445ec126aaab16788Chris Lattner PositionalOpts.clear(); 496d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov SinkOpts.clear(); 497159b0a43408e2521110e22e445ec126aaab16788Chris Lattner Opts.clear(); 498d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov GetOptionInfo(PositionalOpts, SinkOpts, Opts); 49969d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattner OptionListChanged = false; 500159b0a43408e2521110e22e445ec126aaab16788Chris Lattner } 501beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 502331de23705a719514e37c211f327379688f81b0dChris Lattner // Check to see if this is a positional argument. This argument is 503331de23705a719514e37c211f327379688f81b0dChris Lattner // considered to be positional if it doesn't start with '-', if it is "-" 5041115e0483fc6da16d52382f159005baddf028063Misha Brukman // itself, or if we have seen "--" already. 505331de23705a719514e37c211f327379688f81b0dChris Lattner // 506331de23705a719514e37c211f327379688f81b0dChris Lattner if (argv[i][0] != '-' || argv[i][1] == 0 || DashDashFound) { 507331de23705a719514e37c211f327379688f81b0dChris Lattner // Positional argument! 5089cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (ActivePositionalArg) { 5091e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ProvidePositionalOption(ActivePositionalArg, argv[i], i); 5109cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner continue; // We are done! 51199c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattner } 51299c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattner 51399c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattner if (!PositionalOpts.empty()) { 5141e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals.push_back(std::make_pair(argv[i],i)); 515331de23705a719514e37c211f327379688f81b0dChris Lattner 516331de23705a719514e37c211f327379688f81b0dChris Lattner // All of the positional arguments have been fulfulled, give the rest to 517331de23705a719514e37c211f327379688f81b0dChris Lattner // the consume after option... if it's specified... 518331de23705a719514e37c211f327379688f81b0dChris Lattner // 519f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman if (PositionalVals.size() >= NumPositionalRequired && 520331de23705a719514e37c211f327379688f81b0dChris Lattner ConsumeAfterOpt != 0) { 521331de23705a719514e37c211f327379688f81b0dChris Lattner for (++i; i < argc; ++i) 5221e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals.push_back(std::make_pair(argv[i],i)); 523331de23705a719514e37c211f327379688f81b0dChris Lattner break; // Handle outside of the argument processing loop... 524331de23705a719514e37c211f327379688f81b0dChris Lattner } 525331de23705a719514e37c211f327379688f81b0dChris Lattner 526331de23705a719514e37c211f327379688f81b0dChris Lattner // Delay processing positional arguments until the end... 527331de23705a719514e37c211f327379688f81b0dChris Lattner continue; 528331de23705a719514e37c211f327379688f81b0dChris Lattner } 529bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner } else if (argv[i][0] == '-' && argv[i][1] == '-' && argv[i][2] == 0 && 530bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner !DashDashFound) { 531bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner DashDashFound = true; // This is the mythical "--"? 532bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner continue; // Don't try to process it as an argument itself. 533bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner } else if (ActivePositionalArg && 534bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner (ActivePositionalArg->getMiscFlags() & PositionalEatsArgs)) { 535bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner // If there is a positional argument eating options, check to see if this 536bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner // option is another positional argument. If so, treat it as an argument, 537bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner // otherwise feed it to the eating positional. 538dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner ArgName = argv[i]+1; 5399878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner Handler = LookupOption(ArgName, Value, Opts); 540bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner if (!Handler || Handler->getFormattingFlag() != cl::Positional) { 5411e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ProvidePositionalOption(ActivePositionalArg, argv[i], i); 542bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner continue; // We are done! 543331de23705a719514e37c211f327379688f81b0dChris Lattner } 544331de23705a719514e37c211f327379688f81b0dChris Lattner 54599c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattner } else { // We start with a '-', must be an argument. 546bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner ArgName = argv[i]+1; 5479878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner Handler = LookupOption(ArgName, Value, Opts); 548331de23705a719514e37c211f327379688f81b0dChris Lattner 549bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner // Check to see if this "option" is really a prefixed or grouped argument. 5505f8448f79c2876466d586f2e1caec89e6f070623Reid Spencer if (Handler == 0) { 55199c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattner StringRef RealName(ArgName); 552bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner if (RealName.size() > 1) { 55334cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng size_t Length = 0; 5549878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner Option *PGOpt = getOptionPred(RealName, Length, isPrefixedOrGrouping, 5559878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner Opts); 556f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 557331de23705a719514e37c211f327379688f81b0dChris Lattner // If the option is a prefixed option, then the value is simply the 558331de23705a719514e37c211f327379688f81b0dChris Lattner // rest of the name... so fall through to later processing, by 559331de23705a719514e37c211f327379688f81b0dChris Lattner // setting up the argument name flags and value fields. 560331de23705a719514e37c211f327379688f81b0dChris Lattner // 561331de23705a719514e37c211f327379688f81b0dChris Lattner if (PGOpt && PGOpt->getFormattingFlag() == cl::Prefix) { 562bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner Value = ArgName+Length; 56399c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattner assert(Opts.count(StringRef(ArgName, Length)) && 56499c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattner Opts[StringRef(ArgName, Length)] == PGOpt); 565bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner Handler = PGOpt; 566331de23705a719514e37c211f327379688f81b0dChris Lattner } else if (PGOpt) { 567bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner // This must be a grouped option... handle them now. 568331de23705a719514e37c211f327379688f81b0dChris Lattner assert(isGrouping(PGOpt) && "Broken getOptionPred!"); 569f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 570331de23705a719514e37c211f327379688f81b0dChris Lattner do { 57199c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattner // Move current arg name out of RealName into RealArgName. 57299c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattner StringRef RealArgName = RealName.substr(0, Length); 57399c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattner RealName = RealName.substr(Length); 574f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 575b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman // Because ValueRequired is an invalid flag for grouped arguments, 57699c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattner // we don't need to pass argc/argv in. 577b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman // 578331de23705a719514e37c211f327379688f81b0dChris Lattner assert(PGOpt->getValueExpectedFlag() != cl::ValueRequired && 579331de23705a719514e37c211f327379688f81b0dChris Lattner "Option can not be cl::Grouping AND cl::ValueRequired!"); 580331de23705a719514e37c211f327379688f81b0dChris Lattner int Dummy; 58199c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattner ErrorParsing |= ProvideOption(PGOpt, RealArgName, 582341620b2762e604fbf8c75913a1cc5b9c9297b7dChris Lattner StringRef(), 0, 0, Dummy); 583f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 58499c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattner // Get the next grouping option. 5859878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner PGOpt = getOptionPred(RealName, Length, isGrouping, Opts); 586bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner } while (PGOpt && Length != RealName.size()); 587f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 588bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner Handler = PGOpt; // Ate all of the options. 589331de23705a719514e37c211f327379688f81b0dChris Lattner } 590b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman } 591dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 592dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 593dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 594dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner if (Handler == 0) { 595d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov if (SinkOpts.empty()) { 596d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer errs() << ProgramName << ": Unknown command line argument '" 597d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov << argv[i] << "'. Try: '" << argv[0] << " --help'\n"; 598d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov ErrorParsing = true; 599d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov } else { 600d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov for (std::vector<Option*>::iterator I = SinkOpts.begin(), 601d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov E = SinkOpts.end(); I != E ; ++I) 602d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov (*I)->addOccurrence(i, "", argv[i]); 603d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov } 604dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner continue; 605dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 606dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 60772fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner // Check to see if this option accepts a comma separated list of values. If 608341620b2762e604fbf8c75913a1cc5b9c9297b7dChris Lattner // it does, we have to split up the value into multiple values. 6096d5857e139df71410e98ccf6cd0e783f90a9fc16Chris Lattner if (Value && Handler->getMiscFlags() & CommaSeparated) { 610341620b2762e604fbf8c75913a1cc5b9c9297b7dChris Lattner StringRef Val(Value); 611341620b2762e604fbf8c75913a1cc5b9c9297b7dChris Lattner StringRef::size_type Pos = Val.find(','); 612341620b2762e604fbf8c75913a1cc5b9c9297b7dChris Lattner 613341620b2762e604fbf8c75913a1cc5b9c9297b7dChris Lattner while (Pos != StringRef::npos) { 614341620b2762e604fbf8c75913a1cc5b9c9297b7dChris Lattner // Process the portion before the comma. 615341620b2762e604fbf8c75913a1cc5b9c9297b7dChris Lattner ErrorParsing |= ProvideOption(Handler, ArgName, Val.substr(0, Pos), 61672fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner argc, argv, i); 617341620b2762e604fbf8c75913a1cc5b9c9297b7dChris Lattner // Erase the portion before the comma, AND the comma. 618341620b2762e604fbf8c75913a1cc5b9c9297b7dChris Lattner Val = Val.substr(Pos+1); 619341620b2762e604fbf8c75913a1cc5b9c9297b7dChris Lattner Value += Pos+1; // Increment the original value pointer as well. 62072fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner 621341620b2762e604fbf8c75913a1cc5b9c9297b7dChris Lattner // Check for another comma. 62272fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner Pos = Val.find(','); 62372fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner } 62472fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner } 6259cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner 6269cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // If this is a named positional argument, just remember that it is the 6279cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // active one... 6289cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (Handler->getFormattingFlag() == cl::Positional) 6299cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner ActivePositionalArg = Handler; 630341620b2762e604fbf8c75913a1cc5b9c9297b7dChris Lattner else if (Value) 6319cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner ErrorParsing |= ProvideOption(Handler, ArgName, Value, argc, argv, i); 632341620b2762e604fbf8c75913a1cc5b9c9297b7dChris Lattner else 633341620b2762e604fbf8c75913a1cc5b9c9297b7dChris Lattner ErrorParsing |= ProvideOption(Handler, ArgName, StringRef(), 634341620b2762e604fbf8c75913a1cc5b9c9297b7dChris Lattner argc, argv, i); 635341620b2762e604fbf8c75913a1cc5b9c9297b7dChris Lattner 636331de23705a719514e37c211f327379688f81b0dChris Lattner } 637dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 638331de23705a719514e37c211f327379688f81b0dChris Lattner // Check and handle positional arguments now... 639331de23705a719514e37c211f327379688f81b0dChris Lattner if (NumPositionalRequired > PositionalVals.size()) { 640d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer errs() << ProgramName 641e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << ": Not enough positional command line arguments specified!\n" 642e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << "Must specify at least " << NumPositionalRequired 643e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << " positional arguments: See: " << argv[0] << " --help\n"; 644beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 645331de23705a719514e37c211f327379688f81b0dChris Lattner ErrorParsing = true; 646de0132453e2939488c2d69290bfdfb2cde94a0afChris Lattner } else if (!HasUnlimitedPositionals 647de0132453e2939488c2d69290bfdfb2cde94a0afChris Lattner && PositionalVals.size() > PositionalOpts.size()) { 648d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer errs() << ProgramName 649e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << ": Too many positional arguments specified!\n" 650e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << "Can specify at most " << PositionalOpts.size() 651e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << " positional arguments: See: " << argv[0] << " --help\n"; 652de0132453e2939488c2d69290bfdfb2cde94a0afChris Lattner ErrorParsing = true; 653331de23705a719514e37c211f327379688f81b0dChris Lattner 654331de23705a719514e37c211f327379688f81b0dChris Lattner } else if (ConsumeAfterOpt == 0) { 655331de23705a719514e37c211f327379688f81b0dChris Lattner // Positional args have already been handled if ConsumeAfter is specified... 65634cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng unsigned ValNo = 0, NumVals = static_cast<unsigned>(PositionalVals.size()); 65734cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng for (size_t i = 0, e = PositionalOpts.size(); i != e; ++i) { 658331de23705a719514e37c211f327379688f81b0dChris Lattner if (RequiresValue(PositionalOpts[i])) { 659f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman ProvidePositionalOption(PositionalOpts[i], PositionalVals[ValNo].first, 6601e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].second); 6611e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ValNo++; 662331de23705a719514e37c211f327379688f81b0dChris Lattner --NumPositionalRequired; // We fulfilled our duty... 663331de23705a719514e37c211f327379688f81b0dChris Lattner } 664331de23705a719514e37c211f327379688f81b0dChris Lattner 665331de23705a719514e37c211f327379688f81b0dChris Lattner // If we _can_ give this option more arguments, do so now, as long as we 666331de23705a719514e37c211f327379688f81b0dChris Lattner // do not give it values that others need. 'Done' controls whether the 667331de23705a719514e37c211f327379688f81b0dChris Lattner // option even _WANTS_ any more. 668331de23705a719514e37c211f327379688f81b0dChris Lattner // 669dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman bool Done = PositionalOpts[i]->getNumOccurrencesFlag() == cl::Required; 670331de23705a719514e37c211f327379688f81b0dChris Lattner while (NumVals-ValNo > NumPositionalRequired && !Done) { 671dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman switch (PositionalOpts[i]->getNumOccurrencesFlag()) { 672331de23705a719514e37c211f327379688f81b0dChris Lattner case cl::Optional: 673331de23705a719514e37c211f327379688f81b0dChris Lattner Done = true; // Optional arguments want _at most_ one value 674331de23705a719514e37c211f327379688f81b0dChris Lattner // FALL THROUGH 675331de23705a719514e37c211f327379688f81b0dChris Lattner case cl::ZeroOrMore: // Zero or more will take all they can get... 676331de23705a719514e37c211f327379688f81b0dChris Lattner case cl::OneOrMore: // One or more will take all they can get... 6771e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ProvidePositionalOption(PositionalOpts[i], 6781e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].first, 6791e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].second); 6801e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ValNo++; 681331de23705a719514e37c211f327379688f81b0dChris Lattner break; 682331de23705a719514e37c211f327379688f81b0dChris Lattner default: 683c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable("Internal error, unexpected NumOccurrences flag in " 684331de23705a719514e37c211f327379688f81b0dChris Lattner "positional argument processing!"); 685331de23705a719514e37c211f327379688f81b0dChris Lattner } 686331de23705a719514e37c211f327379688f81b0dChris Lattner } 687caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner } 688331de23705a719514e37c211f327379688f81b0dChris Lattner } else { 689331de23705a719514e37c211f327379688f81b0dChris Lattner assert(ConsumeAfterOpt && NumPositionalRequired <= PositionalVals.size()); 690331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned ValNo = 0; 69134cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng for (size_t j = 1, e = PositionalOpts.size(); j != e; ++j) 6921e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer if (RequiresValue(PositionalOpts[j])) { 693faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner ErrorParsing |= ProvidePositionalOption(PositionalOpts[j], 6941e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].first, 6951e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].second); 6961e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ValNo++; 6971e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer } 698faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner 699faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // Handle the case where there is just one positional option, and it's 700faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // optional. In this case, we want to give JUST THE FIRST option to the 701faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // positional option and keep the rest for the consume after. The above 702faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // loop would have assigned no values to positional options in this case. 703faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // 7041e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer if (PositionalOpts.size() == 2 && ValNo == 0 && !PositionalVals.empty()) { 705faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner ErrorParsing |= ProvidePositionalOption(PositionalOpts[1], 7061e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].first, 7071e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].second); 7081e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ValNo++; 7091e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer } 710f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 711331de23705a719514e37c211f327379688f81b0dChris Lattner // Handle over all of the rest of the arguments to the 712331de23705a719514e37c211f327379688f81b0dChris Lattner // cl::ConsumeAfter command line option... 713331de23705a719514e37c211f327379688f81b0dChris Lattner for (; ValNo != PositionalVals.size(); ++ValNo) 714331de23705a719514e37c211f327379688f81b0dChris Lattner ErrorParsing |= ProvidePositionalOption(ConsumeAfterOpt, 7151e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].first, 7161e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].second); 717dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 718dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 719dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner // Loop over args and make sure all required args are specified! 720461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer for (StringMap<Option*>::iterator I = Opts.begin(), 721b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman E = Opts.end(); I != E; ++I) { 722dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman switch (I->second->getNumOccurrencesFlag()) { 723dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner case Required: 724dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner case OneOrMore: 725dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman if (I->second->getNumOccurrences() == 0) { 726e6864c1d355c4ec1156b956c1dd548682ad3e6b1Benjamin Kramer I->second->error("must be specified at least once!"); 727f038acbee21cfed998451aedd00a81901d299516Chris Lattner ErrorParsing = true; 728f038acbee21cfed998451aedd00a81901d299516Chris Lattner } 729dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner // Fall through 730dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner default: 731dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner break; 732dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner } 733dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner } 734dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 735331de23705a719514e37c211f327379688f81b0dChris Lattner // Free all of the memory allocated to the map. Command line options may only 736331de23705a719514e37c211f327379688f81b0dChris Lattner // be processed once! 73790aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner Opts.clear(); 738331de23705a719514e37c211f327379688f81b0dChris Lattner PositionalOpts.clear(); 73990aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner MoreHelp->clear(); 740dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 741beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov // Free the memory allocated by ExpandResponseFiles. 742beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov if (ReadResponseFiles) { 743beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov // Free all the strdup()ed strings. 744beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov for (std::vector<char*>::iterator i = newArgv.begin(), e = newArgv.end(); 745beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov i != e; ++i) 746beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov free (*i); 747beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov } 748beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 749dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // If we had an error processing our arguments, don't let the program execute 750dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner if (ErrorParsing) exit(1); 751dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 752dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 753dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner//===----------------------------------------------------------------------===// 754dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// Option Base class implementation 755dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 756dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 75799c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattnerbool Option::error(const Twine &Message, StringRef ArgName) { 75899c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattner if (ArgName.data() == 0) ArgName = ArgStr; 75999c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattner if (ArgName.empty()) 760d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer errs() << HelpStr; // Be nice for positional arguments 761331de23705a719514e37c211f327379688f81b0dChris Lattner else 762d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer errs() << ProgramName << ": for the -" << ArgName; 763beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 764d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer errs() << " option: " << Message << "\n"; 765dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return true; 766dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 767dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 76899c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattnerbool Option::addOccurrence(unsigned pos, StringRef ArgName, 769a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner StringRef Value, bool MultiArg) { 7707059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov if (!MultiArg) 7717059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov NumOccurrences++; // Increment the number of times we have been seen 772dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 773dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman switch (getNumOccurrencesFlag()) { 774dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner case Optional: 775dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman if (NumOccurrences > 1) 776e6864c1d355c4ec1156b956c1dd548682ad3e6b1Benjamin Kramer return error("may only occur zero or one times!", ArgName); 777dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner break; 778dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner case Required: 779dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman if (NumOccurrences > 1) 780e6864c1d355c4ec1156b956c1dd548682ad3e6b1Benjamin Kramer return error("must occur exactly one time!", ArgName); 781dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Fall through 782dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner case OneOrMore: 783caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner case ZeroOrMore: 784caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner case ConsumeAfter: break; 785e6864c1d355c4ec1156b956c1dd548682ad3e6b1Benjamin Kramer default: return error("bad num occurrences flag value!"); 786dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 787dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 7881e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer return handleOccurrence(pos, ArgName, Value); 789dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 790dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 791331de23705a719514e37c211f327379688f81b0dChris Lattner 792331de23705a719514e37c211f327379688f81b0dChris Lattner// getValueStr - Get the value description string, using "DefaultMsg" if nothing 793331de23705a719514e37c211f327379688f81b0dChris Lattner// has been specified yet. 794331de23705a719514e37c211f327379688f81b0dChris Lattner// 795331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic const char *getValueStr(const Option &O, const char *DefaultMsg) { 796331de23705a719514e37c211f327379688f81b0dChris Lattner if (O.ValueStr[0] == 0) return DefaultMsg; 797331de23705a719514e37c211f327379688f81b0dChris Lattner return O.ValueStr; 798331de23705a719514e37c211f327379688f81b0dChris Lattner} 799331de23705a719514e37c211f327379688f81b0dChris Lattner 800331de23705a719514e37c211f327379688f81b0dChris Lattner//===----------------------------------------------------------------------===// 801331de23705a719514e37c211f327379688f81b0dChris Lattner// cl::alias class implementation 802331de23705a719514e37c211f327379688f81b0dChris Lattner// 803331de23705a719514e37c211f327379688f81b0dChris Lattner 804dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// Return the width of the option tag for printing... 80534cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Chengsize_t alias::getOptionWidth() const { 806dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return std::strlen(ArgStr)+6; 807dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 808dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 809a0de843535627977d107bbe84e4ad20cd2a5060aChris Lattner// Print out the option for the alias. 81034cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Chengvoid alias::printOptionInfo(size_t GlobalWidth) const { 81134cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng size_t L = std::strlen(ArgStr); 812d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer errs() << " -" << ArgStr << std::string(GlobalWidth-L-6, ' ') << " - " 813603bea32743dc9914a1d32ae36fc64fe497af801Daniel Dunbar << HelpStr << "\n"; 814dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 815dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 816dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 817331de23705a719514e37c211f327379688f81b0dChris Lattner 818dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner//===----------------------------------------------------------------------===// 819331de23705a719514e37c211f327379688f81b0dChris Lattner// Parser Implementation code... 820dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 821dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 8229b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// basic_parser implementation 8239b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// 8249b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 8259b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// Return the width of the option tag for printing... 82634cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Chengsize_t basic_parser_impl::getOptionWidth(const Option &O) const { 82734cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng size_t Len = std::strlen(O.ArgStr); 8289b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner if (const char *ValName = getValueName()) 8299b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner Len += std::strlen(getValueStr(O, ValName))+3; 8309b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 8319b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner return Len + 6; 8329b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner} 8339b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 834f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman// printOptionInfo - Print out information about this option. The 8359b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// to-be-maintained width is specified. 8369b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// 8379b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattnervoid basic_parser_impl::printOptionInfo(const Option &O, 83834cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng size_t GlobalWidth) const { 839d9ea85ab01fb0f2929ed50223d3758dceea8bcbdChris Lattner outs() << " -" << O.ArgStr; 8409b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 8419b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner if (const char *ValName = getValueName()) 842d9ea85ab01fb0f2929ed50223d3758dceea8bcbdChris Lattner outs() << "=<" << getValueStr(O, ValName) << '>'; 8439b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 844d9ea85ab01fb0f2929ed50223d3758dceea8bcbdChris Lattner outs().indent(GlobalWidth-getOptionWidth(O)) << " - " << O.HelpStr << '\n'; 8459b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner} 8469b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 8479b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 8489b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 8499b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 850331de23705a719514e37c211f327379688f81b0dChris Lattner// parser<bool> implementation 851331de23705a719514e37c211f327379688f81b0dChris Lattner// 85299c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattnerbool parser<bool>::parse(Option &O, StringRef ArgName, 853a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner StringRef Arg, bool &Value) { 854f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman if (Arg == "" || Arg == "true" || Arg == "TRUE" || Arg == "True" || 855dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner Arg == "1") { 856dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner Value = true; 857a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner return false; 858a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner } 859a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner 860a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner if (Arg == "false" || Arg == "FALSE" || Arg == "False" || Arg == "0") { 861dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner Value = false; 862a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner return false; 863dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 864a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner return O.error("'" + Arg + 865a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner "' is invalid value for boolean argument! Try 0 or 1"); 866dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 867dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 86881da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen// parser<boolOrDefault> implementation 86981da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen// 87099c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattnerbool parser<boolOrDefault>::parse(Option &O, StringRef ArgName, 871a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner StringRef Arg, boolOrDefault &Value) { 87281da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen if (Arg == "" || Arg == "true" || Arg == "TRUE" || Arg == "True" || 87381da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen Arg == "1") { 87481da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen Value = BOU_TRUE; 875a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner return false; 876a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner } 877a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner if (Arg == "false" || Arg == "FALSE" || Arg == "False" || Arg == "0") { 87881da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen Value = BOU_FALSE; 879a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner return false; 88081da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen } 881a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner 882a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner return O.error("'" + Arg + 883a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner "' is invalid value for boolean argument! Try 0 or 1"); 88481da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen} 88581da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen 886331de23705a719514e37c211f327379688f81b0dChris Lattner// parser<int> implementation 887dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 88899c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattnerbool parser<int>::parse(Option &O, StringRef ArgName, 889a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner StringRef Arg, int &Value) { 890970e7dff5ba2bd8c5613c43e3b215ca940a378e9Chris Lattner if (Arg.getAsInteger(0, Value)) 891e6864c1d355c4ec1156b956c1dd548682ad3e6b1Benjamin Kramer return O.error("'" + Arg + "' value invalid for integer argument!"); 892331de23705a719514e37c211f327379688f81b0dChris Lattner return false; 893dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 894dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 895d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner// parser<unsigned> implementation 896d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner// 89799c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattnerbool parser<unsigned>::parse(Option &O, StringRef ArgName, 898a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner StringRef Arg, unsigned &Value) { 899970e7dff5ba2bd8c5613c43e3b215ca940a378e9Chris Lattner 900970e7dff5ba2bd8c5613c43e3b215ca940a378e9Chris Lattner if (Arg.getAsInteger(0, Value)) 901e6864c1d355c4ec1156b956c1dd548682ad3e6b1Benjamin Kramer return O.error("'" + Arg + "' value invalid for uint argument!"); 902d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner return false; 903d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner} 904d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner 9059b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// parser<double>/parser<float> implementation 906331de23705a719514e37c211f327379688f81b0dChris Lattner// 907a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattnerstatic bool parseDouble(Option &O, StringRef Arg, double &Value) { 908970e7dff5ba2bd8c5613c43e3b215ca940a378e9Chris Lattner SmallString<32> TmpStr(Arg.begin(), Arg.end()); 909970e7dff5ba2bd8c5613c43e3b215ca940a378e9Chris Lattner const char *ArgStart = TmpStr.c_str(); 910331de23705a719514e37c211f327379688f81b0dChris Lattner char *End; 911331de23705a719514e37c211f327379688f81b0dChris Lattner Value = strtod(ArgStart, &End); 912f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman if (*End != 0) 913e6864c1d355c4ec1156b956c1dd548682ad3e6b1Benjamin Kramer return O.error("'" + Arg + "' value invalid for floating point argument!"); 914dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return false; 915dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 916dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 91799c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattnerbool parser<double>::parse(Option &O, StringRef ArgName, 918a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner StringRef Arg, double &Val) { 9199b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner return parseDouble(O, Arg, Val); 920dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 921dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 92299c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattnerbool parser<float>::parse(Option &O, StringRef ArgName, 923a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner StringRef Arg, float &Val) { 9249b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner double dVal; 9259b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner if (parseDouble(O, Arg, dVal)) 9269b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner return true; 9279b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner Val = (float)dVal; 9289b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner return false; 929dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 930dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 931dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 932dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 933331de23705a719514e37c211f327379688f81b0dChris Lattner// generic_parser_base implementation 934dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 935dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 936aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner// findOption - Return the option number corresponding to the specified 937aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner// argument string. If the option is not found, getNumOptions() is returned. 938aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner// 939aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattnerunsigned generic_parser_base::findOption(const char *Name) { 940461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer unsigned e = getNumOptions(); 941aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner 942461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer for (unsigned i = 0; i != e; ++i) { 943461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer if (strcmp(getOption(i), Name) == 0) 944aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner return i; 945461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer } 946aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner return e; 947aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner} 948aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner 949aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner 950dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// Return the width of the option tag for printing... 95134cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Chengsize_t generic_parser_base::getOptionWidth(const Option &O) const { 952331de23705a719514e37c211f327379688f81b0dChris Lattner if (O.hasArgStr()) { 95334cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng size_t Size = std::strlen(O.ArgStr)+6; 954331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = getNumOptions(); i != e; ++i) 95534cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng Size = std::max(Size, std::strlen(getOption(i))+8); 956331de23705a719514e37c211f327379688f81b0dChris Lattner return Size; 957331de23705a719514e37c211f327379688f81b0dChris Lattner } else { 95834cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng size_t BaseSize = 0; 959331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = getNumOptions(); i != e; ++i) 96034cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng BaseSize = std::max(BaseSize, std::strlen(getOption(i))+8); 961331de23705a719514e37c211f327379688f81b0dChris Lattner return BaseSize; 962331de23705a719514e37c211f327379688f81b0dChris Lattner } 963dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 964dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 965f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman// printOptionInfo - Print out information about this option. The 966dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// to-be-maintained width is specified. 967dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 968331de23705a719514e37c211f327379688f81b0dChris Lattnervoid generic_parser_base::printOptionInfo(const Option &O, 96934cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng size_t GlobalWidth) const { 970331de23705a719514e37c211f327379688f81b0dChris Lattner if (O.hasArgStr()) { 97134cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng size_t L = std::strlen(O.ArgStr); 972d9ea85ab01fb0f2929ed50223d3758dceea8bcbdChris Lattner outs() << " -" << O.ArgStr << std::string(GlobalWidth-L-6, ' ') 973d9ea85ab01fb0f2929ed50223d3758dceea8bcbdChris Lattner << " - " << O.HelpStr << '\n'; 974331de23705a719514e37c211f327379688f81b0dChris Lattner 975331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = getNumOptions(); i != e; ++i) { 97634cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng size_t NumSpaces = GlobalWidth-strlen(getOption(i))-8; 977d9ea85ab01fb0f2929ed50223d3758dceea8bcbdChris Lattner outs() << " =" << getOption(i) << std::string(NumSpaces, ' ') 978d9ea85ab01fb0f2929ed50223d3758dceea8bcbdChris Lattner << " - " << getDescription(i) << '\n'; 979331de23705a719514e37c211f327379688f81b0dChris Lattner } 980331de23705a719514e37c211f327379688f81b0dChris Lattner } else { 981331de23705a719514e37c211f327379688f81b0dChris Lattner if (O.HelpStr[0]) 982d9ea85ab01fb0f2929ed50223d3758dceea8bcbdChris Lattner outs() << " " << O.HelpStr << "\n"; 983331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = getNumOptions(); i != e; ++i) { 98434cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng size_t L = std::strlen(getOption(i)); 985d9ea85ab01fb0f2929ed50223d3758dceea8bcbdChris Lattner outs() << " -" << getOption(i) << std::string(GlobalWidth-L-8, ' ') 986d9ea85ab01fb0f2929ed50223d3758dceea8bcbdChris Lattner << " - " << getDescription(i) << "\n"; 987331de23705a719514e37c211f327379688f81b0dChris Lattner } 988dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 989dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 990dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 991dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 992dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner//===----------------------------------------------------------------------===// 993331de23705a719514e37c211f327379688f81b0dChris Lattner// --help and --help-hidden option implementation 994dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 995ad0846bd8be0a86e0277e1890fd280c9868f830aReid Spencer 996dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattnernamespace { 997dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 998331de23705a719514e37c211f327379688f81b0dChris Lattnerclass HelpPrinter { 99934cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng size_t MaxArgLen; 1000dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner const Option *EmptyArg; 1001dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner const bool ShowHidden; 1002dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1003331de23705a719514e37c211f327379688f81b0dChris Lattner // isHidden/isReallyHidden - Predicates to be used to filter down arg lists. 1004461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer inline static bool isHidden(Option *Opt) { 1005461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer return Opt->getOptionHiddenFlag() >= Hidden; 1006331de23705a719514e37c211f327379688f81b0dChris Lattner } 1007461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer inline static bool isReallyHidden(Option *Opt) { 1008461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer return Opt->getOptionHiddenFlag() == ReallyHidden; 1009331de23705a719514e37c211f327379688f81b0dChris Lattner } 1010331de23705a719514e37c211f327379688f81b0dChris Lattner 1011331de23705a719514e37c211f327379688f81b0dChris Lattnerpublic: 1012950a4c40b823cd4f09dc71be635229246dfd6cacDan Gohman explicit HelpPrinter(bool showHidden) : ShowHidden(showHidden) { 1013331de23705a719514e37c211f327379688f81b0dChris Lattner EmptyArg = 0; 1014331de23705a719514e37c211f327379688f81b0dChris Lattner } 1015331de23705a719514e37c211f327379688f81b0dChris Lattner 1016331de23705a719514e37c211f327379688f81b0dChris Lattner void operator=(bool Value) { 1017331de23705a719514e37c211f327379688f81b0dChris Lattner if (Value == false) return; 1018331de23705a719514e37c211f327379688f81b0dChris Lattner 10199878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner // Get all the options. 10209878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner std::vector<Option*> PositionalOpts; 1021d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov std::vector<Option*> SinkOpts; 1022461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer StringMap<Option*> OptMap; 1023d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov GetOptionInfo(PositionalOpts, SinkOpts, OptMap); 1024beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 1025dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Copy Options into a vector so we can sort them as we like... 1026461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer std::vector<Option*> Opts; 1027461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer for (StringMap<Option*>::iterator I = OptMap.begin(), E = OptMap.end(); 1028461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer I != E; ++I) { 1029461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer Opts.push_back(I->second); 1030461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer } 1031dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1032dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Eliminate Hidden or ReallyHidden arguments, depending on ShowHidden 103390aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner Opts.erase(std::remove_if(Opts.begin(), Opts.end(), 103490aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner std::ptr_fun(ShowHidden ? isReallyHidden : isHidden)), 103590aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner Opts.end()); 1036dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1037dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Eliminate duplicate entries in table (from enum flags options, f.e.) 1038331de23705a719514e37c211f327379688f81b0dChris Lattner { // Give OptionSet a scope 1039331de23705a719514e37c211f327379688f81b0dChris Lattner std::set<Option*> OptionSet; 104090aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner for (unsigned i = 0; i != Opts.size(); ++i) 1041461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer if (OptionSet.count(Opts[i]) == 0) 1042461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer OptionSet.insert(Opts[i]); // Add new entry to set 1043331de23705a719514e37c211f327379688f81b0dChris Lattner else 104490aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner Opts.erase(Opts.begin()+i--); // Erase duplicate 1045331de23705a719514e37c211f327379688f81b0dChris Lattner } 1046dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1047dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner if (ProgramOverview) 1048d9ea85ab01fb0f2929ed50223d3758dceea8bcbdChris Lattner outs() << "OVERVIEW: " << ProgramOverview << "\n"; 1049dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1050d9ea85ab01fb0f2929ed50223d3758dceea8bcbdChris Lattner outs() << "USAGE: " << ProgramName << " [options]"; 1051331de23705a719514e37c211f327379688f81b0dChris Lattner 105290aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner // Print out the positional options. 1053331de23705a719514e37c211f327379688f81b0dChris Lattner Option *CAOpt = 0; // The cl::ConsumeAfter option, if it exists... 1054beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov if (!PositionalOpts.empty() && 10559878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner PositionalOpts[0]->getNumOccurrencesFlag() == ConsumeAfter) 10569878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner CAOpt = PositionalOpts[0]; 10579878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner 105834cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng for (size_t i = CAOpt != 0, e = PositionalOpts.size(); i != e; ++i) { 10599878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner if (PositionalOpts[i]->ArgStr[0]) 1060d9ea85ab01fb0f2929ed50223d3758dceea8bcbdChris Lattner outs() << " --" << PositionalOpts[i]->ArgStr; 1061d9ea85ab01fb0f2929ed50223d3758dceea8bcbdChris Lattner outs() << " " << PositionalOpts[i]->HelpStr; 10629cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner } 1063331de23705a719514e37c211f327379688f81b0dChris Lattner 1064331de23705a719514e37c211f327379688f81b0dChris Lattner // Print the consume after option info if it exists... 1065d9ea85ab01fb0f2929ed50223d3758dceea8bcbdChris Lattner if (CAOpt) outs() << " " << CAOpt->HelpStr; 1066331de23705a719514e37c211f327379688f81b0dChris Lattner 1067d9ea85ab01fb0f2929ed50223d3758dceea8bcbdChris Lattner outs() << "\n\n"; 1068dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1069dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Compute the maximum argument length... 1070dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner MaxArgLen = 0; 107134cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng for (size_t i = 0, e = Opts.size(); i != e; ++i) 1072461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer MaxArgLen = std::max(MaxArgLen, Opts[i]->getOptionWidth()); 1073dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1074d9ea85ab01fb0f2929ed50223d3758dceea8bcbdChris Lattner outs() << "OPTIONS:\n"; 107534cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng for (size_t i = 0, e = Opts.size(); i != e; ++i) 1076461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer Opts[i]->printOptionInfo(MaxArgLen); 1077dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1078c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner // Print any extra help the user has declared. 107990aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner for (std::vector<const char *>::iterator I = MoreHelp->begin(), 108090aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner E = MoreHelp->end(); I != E; ++I) 1081d9ea85ab01fb0f2929ed50223d3758dceea8bcbdChris Lattner outs() << *I; 108290aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner MoreHelp->clear(); 1083ad0846bd8be0a86e0277e1890fd280c9868f830aReid Spencer 10849bbba091396922093687d11a181e5886c42c5dfdReid Spencer // Halt the program since help information was printed 1085331de23705a719514e37c211f327379688f81b0dChris Lattner exit(1); 1086dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 1087331de23705a719514e37c211f327379688f81b0dChris Lattner}; 1088500d8bff2077ac327deec076fc8793e740b358c0Chris Lattner} // End anonymous namespace 1089dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1090331de23705a719514e37c211f327379688f81b0dChris Lattner// Define the two HelpPrinter instances that are used to print out help, or 1091331de23705a719514e37c211f327379688f81b0dChris Lattner// help-hidden... 1092331de23705a719514e37c211f327379688f81b0dChris Lattner// 1093500d8bff2077ac327deec076fc8793e740b358c0Chris Lattnerstatic HelpPrinter NormalPrinter(false); 1094500d8bff2077ac327deec076fc8793e740b358c0Chris Lattnerstatic HelpPrinter HiddenPrinter(true); 1095331de23705a719514e37c211f327379688f81b0dChris Lattner 1096500d8bff2077ac327deec076fc8793e740b358c0Chris Lattnerstatic cl::opt<HelpPrinter, true, parser<bool> > 10974bf7afcc271138512c38ab2e4a348e2fe6164140Chris LattnerHOp("help", cl::desc("Display available options (--help-hidden for more)"), 10989b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner cl::location(NormalPrinter), cl::ValueDisallowed); 1099dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1100500d8bff2077ac327deec076fc8793e740b358c0Chris Lattnerstatic cl::opt<HelpPrinter, true, parser<bool> > 11014bf7afcc271138512c38ab2e4a348e2fe6164140Chris LattnerHHOp("help-hidden", cl::desc("Display all available options"), 11029b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner cl::location(HiddenPrinter), cl::Hidden, cl::ValueDisallowed); 1103dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1104500d8bff2077ac327deec076fc8793e740b358c0Chris Lattnerstatic void (*OverrideVersionPrinter)() = 0; 1105515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer 1106500d8bff2077ac327deec076fc8793e740b358c0Chris Lattnernamespace { 1107515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencerclass VersionPrinter { 1108515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencerpublic: 1109aed293dfba04b07a867491c11dfff4bf3eb6bdddDevang Patel void print() { 1110d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer outs() << "Low Level Virtual Machine (http://llvm.org/):\n" 1111d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer << " " << PACKAGE_NAME << " version " << PACKAGE_VERSION; 11123fc2f4e83f3317f592c06e2ae7d9f1832210decbChris Lattner#ifdef LLVM_VERSION_INFO 1113d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer outs() << LLVM_VERSION_INFO; 11143fc2f4e83f3317f592c06e2ae7d9f1832210decbChris Lattner#endif 1115d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer outs() << "\n "; 11163fc2f4e83f3317f592c06e2ae7d9f1832210decbChris Lattner#ifndef __OPTIMIZE__ 1117d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer outs() << "DEBUG build"; 1118515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer#else 1119d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer outs() << "Optimized build"; 11203fc2f4e83f3317f592c06e2ae7d9f1832210decbChris Lattner#endif 11213fc2f4e83f3317f592c06e2ae7d9f1832210decbChris Lattner#ifndef NDEBUG 1122d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer outs() << " with assertions"; 1123515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer#endif 1124d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer outs() << ".\n" 1125d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer << " Built " << __DATE__ << " (" << __TIME__ << ").\n" 11266552478ee74abe6851cebc5762a1dbe6982bb122Daniel Dunbar << " Host: " << sys::getHostTriple() << "\n" 1127d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer << "\n" 1128d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer << " Registered Targets:\n"; 1129d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer 1130d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer std::vector<std::pair<std::string, const Target*> > Targets; 1131d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer size_t Width = 0; 1132d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer for (TargetRegistry::iterator it = TargetRegistry::begin(), 1133d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer ie = TargetRegistry::end(); it != ie; ++it) { 1134d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer Targets.push_back(std::make_pair(it->getName(), &*it)); 1135d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer Width = std::max(Width, Targets.back().first.length()); 1136d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer } 1137d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer std::sort(Targets.begin(), Targets.end()); 1138603bea32743dc9914a1d32ae36fc64fe497af801Daniel Dunbar 1139d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer for (unsigned i = 0, e = Targets.size(); i != e; ++i) { 1140d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer outs() << " " << Targets[i].first 1141d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer << std::string(Width - Targets[i].first.length(), ' ') << " - " 1142d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer << Targets[i].second->getShortDescription() << "\n"; 1143d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer } 1144d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer if (Targets.empty()) 1145d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer outs() << " (none)\n"; 1146aed293dfba04b07a867491c11dfff4bf3eb6bdddDevang Patel } 1147aed293dfba04b07a867491c11dfff4bf3eb6bdddDevang Patel void operator=(bool OptionWasSpecified) { 1148aed293dfba04b07a867491c11dfff4bf3eb6bdddDevang Patel if (OptionWasSpecified) { 1149aed293dfba04b07a867491c11dfff4bf3eb6bdddDevang Patel if (OverrideVersionPrinter == 0) { 1150aed293dfba04b07a867491c11dfff4bf3eb6bdddDevang Patel print(); 1151515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer exit(1); 1152515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer } else { 1153515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer (*OverrideVersionPrinter)(); 1154515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer exit(1); 1155515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer } 1156515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer } 1157515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer } 1158515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer}; 1159500d8bff2077ac327deec076fc8793e740b358c0Chris Lattner} // End anonymous namespace 1160515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer 1161515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer 116269105f33c190621a6b1ad61f925b1a9e6b0512afReid Spencer// Define the --version option that prints out the LLVM version for the tool 1163500d8bff2077ac327deec076fc8793e740b358c0Chris Lattnerstatic VersionPrinter VersionPrinterInstance; 1164500d8bff2077ac327deec076fc8793e740b358c0Chris Lattner 1165500d8bff2077ac327deec076fc8793e740b358c0Chris Lattnerstatic cl::opt<VersionPrinter, true, parser<bool> > 11664bf7afcc271138512c38ab2e4a348e2fe6164140Chris LattnerVersOp("version", cl::desc("Display the version of this program"), 116769105f33c190621a6b1ad61f925b1a9e6b0512afReid Spencer cl::location(VersionPrinterInstance), cl::ValueDisallowed); 116869105f33c190621a6b1ad61f925b1a9e6b0512afReid Spencer 11699bbba091396922093687d11a181e5886c42c5dfdReid Spencer// Utility function for printing the help message. 11709bbba091396922093687d11a181e5886c42c5dfdReid Spencervoid cl::PrintHelpMessage() { 1171f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman // This looks weird, but it actually prints the help message. The 11725cc498f116cd76235c9c0a2ded46bc29f8fb35e0Reid Spencer // NormalPrinter variable is a HelpPrinter and the help gets printed when 11735cc498f116cd76235c9c0a2ded46bc29f8fb35e0Reid Spencer // its operator= is invoked. That's because the "normal" usages of the 1174f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman // help printer is to be assigned true/false depending on whether the 11755cc498f116cd76235c9c0a2ded46bc29f8fb35e0Reid Spencer // --help option was given or not. Since we're circumventing that we have 11765cc498f116cd76235c9c0a2ded46bc29f8fb35e0Reid Spencer // to make it look like --help was given, so we assign true. 11779bbba091396922093687d11a181e5886c42c5dfdReid Spencer NormalPrinter = true; 11789bbba091396922093687d11a181e5886c42c5dfdReid Spencer} 1179515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer 1180aed293dfba04b07a867491c11dfff4bf3eb6bdddDevang Patel/// Utility function for printing version number. 1181aed293dfba04b07a867491c11dfff4bf3eb6bdddDevang Patelvoid cl::PrintVersionMessage() { 1182aed293dfba04b07a867491c11dfff4bf3eb6bdddDevang Patel VersionPrinterInstance.print(); 1183aed293dfba04b07a867491c11dfff4bf3eb6bdddDevang Patel} 1184aed293dfba04b07a867491c11dfff4bf3eb6bdddDevang Patel 1185515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencervoid cl::SetVersionPrinter(void (*func)()) { 1186515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer OverrideVersionPrinter = func; 1187515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer} 1188