CommandLine.cpp revision a962b40f0bcaee07296836e175112602c58e439f
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" 20bf177ee6fd234dee70ebf6f0ef7c39b55f8ed4f5Sandeep Patel#include "llvm/Support/Debug.h" 217d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin#include "llvm/Support/ErrorHandling.h" 22beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov#include "llvm/Support/MemoryBuffer.h" 2390aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner#include "llvm/Support/ManagedStatic.h" 24ca179340ce51ca394a836444d4dd1974ce18e1a4Chris Lattner#include "llvm/Support/raw_ostream.h" 25603bea32743dc9914a1d32ae36fc64fe497af801Daniel Dunbar#include "llvm/Target/TargetRegistry.h" 266552478ee74abe6851cebc5762a1dbe6982bb122Daniel Dunbar#include "llvm/System/Host.h" 276f4c60770cfe6c485cdcb1397df59d2c7778cbc9Reid Spencer#include "llvm/System/Path.h" 28ca179340ce51ca394a836444d4dd1974ce18e1a4Chris Lattner#include "llvm/ADT/OwningPtr.h" 2967aead68beae1fca4c53e92a1682364ba8cb497dChris Lattner#include "llvm/ADT/SmallPtrSet.h" 30970e7dff5ba2bd8c5613c43e3b215ca940a378e9Chris Lattner#include "llvm/ADT/SmallString.h" 3167aead68beae1fca4c53e92a1682364ba8cb497dChris Lattner#include "llvm/ADT/StringMap.h" 32a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner#include "llvm/ADT/Twine.h" 33ca179340ce51ca394a836444d4dd1974ce18e1a4Chris Lattner#include "llvm/Config/config.h" 342d6a2360036cf511af0a06f9720e6a1752779d1cBrian Gaeke#include <cerrno> 35ca179340ce51ca394a836444d4dd1974ce18e1a4Chris Lattner#include <cstdlib> 362cdd21c2e4d855500dfb53f77aa74da53ccf9de6Chris Lattnerusing namespace llvm; 37dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattnerusing namespace cl; 38dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 397422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner//===----------------------------------------------------------------------===// 407422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner// Template instantiations and anchors. 417422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner// 42b3587cfb3bd2de1675836eca8802661d32d6eb4dDouglas Gregornamespace llvm { namespace cl { 437422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class basic_parser<bool>); 4481da02b553b86868637f27b89c6e919c31ed5b51Dale JohannesenTEMPLATE_INSTANTIATION(class basic_parser<boolOrDefault>); 457422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class basic_parser<int>); 467422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class basic_parser<unsigned>); 477422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class basic_parser<double>); 487422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class basic_parser<float>); 497422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class basic_parser<std::string>); 50b587f9662a7b6f00f9ce48ddf2dea1a4fb18a6dbBill WendlingTEMPLATE_INSTANTIATION(class basic_parser<char>); 517422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner 527422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class opt<unsigned>); 537422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class opt<int>); 547422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class opt<std::string>); 55b587f9662a7b6f00f9ce48ddf2dea1a4fb18a6dbBill WendlingTEMPLATE_INSTANTIATION(class opt<char>); 567422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class opt<bool>); 57b3587cfb3bd2de1675836eca8802661d32d6eb4dDouglas Gregor} } // end namespace llvm::cl 587422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner 597422a761008ef63152417c5e69ddc31252fb6b10Chris Lattnervoid Option::anchor() {} 607422a761008ef63152417c5e69ddc31252fb6b10Chris Lattnervoid basic_parser_impl::anchor() {} 617422a761008ef63152417c5e69ddc31252fb6b10Chris Lattnervoid parser<bool>::anchor() {} 6281da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesenvoid parser<boolOrDefault>::anchor() {} 637422a761008ef63152417c5e69ddc31252fb6b10Chris Lattnervoid parser<int>::anchor() {} 647422a761008ef63152417c5e69ddc31252fb6b10Chris Lattnervoid parser<unsigned>::anchor() {} 657422a761008ef63152417c5e69ddc31252fb6b10Chris Lattnervoid parser<double>::anchor() {} 667422a761008ef63152417c5e69ddc31252fb6b10Chris Lattnervoid parser<float>::anchor() {} 677422a761008ef63152417c5e69ddc31252fb6b10Chris Lattnervoid parser<std::string>::anchor() {} 68b587f9662a7b6f00f9ce48ddf2dea1a4fb18a6dbBill Wendlingvoid parser<char>::anchor() {} 697422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner 707422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner//===----------------------------------------------------------------------===// 717422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner 72efa3da5593117eab5209c9197cad5ca42213c12eChris Lattner// Globals for name and overview of program. Program name is not a string to 73efa3da5593117eab5209c9197cad5ca42213c12eChris Lattner// avoid static ctor/dtor issues. 74efa3da5593117eab5209c9197cad5ca42213c12eChris Lattnerstatic char ProgramName[80] = "<premain>"; 75e1cc150a8e6b451e42b04b04ffb41596e01bbef5Reid Spencerstatic const char *ProgramOverview = 0; 76e1cc150a8e6b451e42b04b04ffb41596e01bbef5Reid Spencer 77c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner// This collects additional help to be printed. 7890aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattnerstatic ManagedStatic<std::vector<const char*> > MoreHelp; 79c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner 8090aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattnerextrahelp::extrahelp(const char *Help) 81c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner : morehelp(Help) { 8290aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner MoreHelp->push_back(Help); 83c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner} 84c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner 8569d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattnerstatic bool OptionListChanged = false; 8669d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattner 8769d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattner// MarkOptionsChanged - Internal helper function. 8869d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattnervoid cl::MarkOptionsChanged() { 8969d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattner OptionListChanged = true; 9069d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattner} 9169d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattner 929878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner/// RegisteredOptionList - This is the list of the command line options that 939878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner/// have statically constructed themselves. 949878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattnerstatic Option *RegisteredOptionList = 0; 959878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner 969878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattnervoid Option::addArgument() { 979878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner assert(NextRegistered == 0 && "argument multiply registered!"); 98beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 999878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner NextRegistered = RegisteredOptionList; 1009878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner RegisteredOptionList = this; 10169d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattner MarkOptionsChanged(); 1029878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner} 1039878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner 10469d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattner 105331de23705a719514e37c211f327379688f81b0dChris Lattner//===----------------------------------------------------------------------===// 1067422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner// Basic, shared command line option processing machinery. 107331de23705a719514e37c211f327379688f81b0dChris Lattner// 108331de23705a719514e37c211f327379688f81b0dChris Lattner 1099878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner/// GetOptionInfo - Scan the list of registered options, turning them into data 1109878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner/// structures that are easier to handle. 11149b301c40a0a1172dbdd7b55bbaee83eed57aab4Chris Lattnerstatic void GetOptionInfo(SmallVectorImpl<Option*> &PositionalOpts, 11249b301c40a0a1172dbdd7b55bbaee83eed57aab4Chris Lattner SmallVectorImpl<Option*> &SinkOpts, 113461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer StringMap<Option*> &OptionsMap) { 1141908aea3a64fa89a907317849cbff73789cdb89aChris Lattner SmallVector<const char*, 16> OptionNames; 115ee2b32082eff7366621ed2ab119deb96b7c26cecChris Lattner Option *CAOpt = 0; // The ConsumeAfter option if it exists. 1169878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner for (Option *O = RegisteredOptionList; O; O = O->getNextRegisteredOption()) { 1179878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner // If this option wants to handle multiple option names, get the full set. 1189878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner // This handles enum options like "-O1 -O2" etc. 1199878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner O->getExtraOptionNames(OptionNames); 1209878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner if (O->ArgStr[0]) 1219878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner OptionNames.push_back(O->ArgStr); 122beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 1239878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner // Handle named options. 12434cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng for (size_t i = 0, e = OptionNames.size(); i != e; ++i) { 1259878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner // Add argument to the argument map! 126461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer if (OptionsMap.GetOrCreateValue(OptionNames[i], O).second != O) { 127d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer errs() << ProgramName << ": CommandLine Error: Argument '" 12833540adca55b95a5fdbb0dc783ded319a90b4bc1Matthijs Kooijman << OptionNames[i] << "' defined more than once!\n"; 1299878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner } 1309878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner } 131beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 1329878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner OptionNames.clear(); 133beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 1349878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner // Remember information about positional options. 1359878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner if (O->getFormattingFlag() == cl::Positional) 1369878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner PositionalOpts.push_back(O); 13761e015fe7426ca97c3c7afb583f04f5f93050370Dan Gohman else if (O->getMiscFlags() & cl::Sink) // Remember sink options 138d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov SinkOpts.push_back(O); 1399878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner else if (O->getNumOccurrencesFlag() == cl::ConsumeAfter) { 140ee2b32082eff7366621ed2ab119deb96b7c26cecChris Lattner if (CAOpt) 1419878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner O->error("Cannot specify more than one option with cl::ConsumeAfter!"); 142ee2b32082eff7366621ed2ab119deb96b7c26cecChris Lattner CAOpt = O; 1439878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner } 144e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner } 145beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 146ee2b32082eff7366621ed2ab119deb96b7c26cecChris Lattner if (CAOpt) 147ee2b32082eff7366621ed2ab119deb96b7c26cecChris Lattner PositionalOpts.push_back(CAOpt); 148beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 149ee2b32082eff7366621ed2ab119deb96b7c26cecChris Lattner // Make sure that they are in order of registration not backwards. 150ee2b32082eff7366621ed2ab119deb96b7c26cecChris Lattner std::reverse(PositionalOpts.begin(), PositionalOpts.end()); 151e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner} 152e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner 1539878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner 154af035f3460f7d758f73987c3f692faf8d6cae062Chris Lattner/// LookupOption - Lookup the option specified by the specified option on the 155af035f3460f7d758f73987c3f692faf8d6cae062Chris Lattner/// command line. If there is a value specified (after an equal sign) return 156b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner/// that as well. This assumes that leading dashes have already been stripped. 1578a7a05814c70d84eace161d3eed07f5b5cfdd8d6Chris Lattnerstatic Option *LookupOption(StringRef &Arg, StringRef &Value, 1588a7a05814c70d84eace161d3eed07f5b5cfdd8d6Chris Lattner const StringMap<Option*> &OptionsMap) { 1598a7a05814c70d84eace161d3eed07f5b5cfdd8d6Chris Lattner // Reject all dashes. 1608a7a05814c70d84eace161d3eed07f5b5cfdd8d6Chris Lattner if (Arg.empty()) return 0; 161eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 1628a7a05814c70d84eace161d3eed07f5b5cfdd8d6Chris Lattner size_t EqualPos = Arg.find('='); 163eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 1644e247ec4952db1e39b4cc074a38b9f1d52cdaa28Chris Lattner // If we have an equals sign, remember the value. 165b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner if (EqualPos == StringRef::npos) { 166b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner // Look up the option. 167b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner StringMap<Option*>::const_iterator I = OptionsMap.find(Arg); 168b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner return I != OptionsMap.end() ? I->second : 0; 1698a7a05814c70d84eace161d3eed07f5b5cfdd8d6Chris Lattner } 170beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 171b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner // If the argument before the = is a valid option name, we match. If not, 172b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner // return Arg unmolested. 173b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner StringMap<Option*>::const_iterator I = 174b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner OptionsMap.find(Arg.substr(0, EqualPos)); 175b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner if (I == OptionsMap.end()) return 0; 176eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 177b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner Value = Arg.substr(EqualPos+1); 178b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner Arg = Arg.substr(0, EqualPos); 179b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner return I->second; 180dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 181dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 18237628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov/// CommaSeparateAndAddOccurence - A wrapper around Handler->addOccurence() that 18337628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov/// does special handling of cl::CommaSeparated options. 18437628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkovstatic bool CommaSeparateAndAddOccurence(Option *Handler, unsigned pos, 18537628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov StringRef ArgName, 18637628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov StringRef Value, bool MultiArg = false) 18737628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov{ 18837628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov // Check to see if this option accepts a comma separated list of values. If 18937628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov // it does, we have to split up the value into multiple values. 19037628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov if (Handler->getMiscFlags() & CommaSeparated) { 19137628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov StringRef Val(Value); 19237628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov StringRef::size_type Pos = Val.find(','); 19337628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov 19437628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov while (Pos != StringRef::npos) { 19537628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov // Process the portion before the comma. 19637628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov if (Handler->addOccurrence(pos, ArgName, Val.substr(0, Pos), MultiArg)) 19737628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov return true; 19837628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov // Erase the portion before the comma, AND the comma. 19937628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov Val = Val.substr(Pos+1); 20037628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov Value.substr(Pos+1); // Increment the original value pointer as well. 20137628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov // Check for another comma. 20237628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov Pos = Val.find(','); 20337628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov } 20437628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov 20537628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov Value = Val; 20637628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov } 207b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner 20837628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov if (Handler->addOccurrence(pos, ArgName, Value, MultiArg)) 20937628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov return true; 21037628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov 21137628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov return false; 21237628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov} 213b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner 214341620b2762e604fbf8c75913a1cc5b9c9297b7dChris Lattner/// ProvideOption - For Value, this differentiates between an empty value ("") 215341620b2762e604fbf8c75913a1cc5b9c9297b7dChris Lattner/// and a null value (StringRef()). The later is accepted for arguments that 216341620b2762e604fbf8c75913a1cc5b9c9297b7dChris Lattner/// don't allow a value (-foo) the former is rejected (-foo=). 21799c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattnerstatic inline bool ProvideOption(Option *Handler, StringRef ArgName, 218341620b2762e604fbf8c75913a1cc5b9c9297b7dChris Lattner StringRef Value, int argc, char **argv, 219caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner int &i) { 2207059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov // Is this a multi-argument option? 2217059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov unsigned NumAdditionalVals = Handler->getNumAdditionalVals(); 2227059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov 223caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner // Enforce value requirements 224caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner switch (Handler->getValueExpectedFlag()) { 225caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner case ValueRequired: 226341620b2762e604fbf8c75913a1cc5b9c9297b7dChris Lattner if (Value.data() == 0) { // No value specified? 227ba11229f52743ac70f01d4f62d1e04dd093de4e0Chris Lattner if (i+1 >= argc) 228e6864c1d355c4ec1156b956c1dd548682ad3e6b1Benjamin Kramer return Handler->error("requires a value!"); 229ba11229f52743ac70f01d4f62d1e04dd093de4e0Chris Lattner // Steal the next argument, like for '-o filename' 230ba11229f52743ac70f01d4f62d1e04dd093de4e0Chris Lattner Value = argv[++i]; 231caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner } 232caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner break; 233caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner case ValueDisallowed: 2347059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov if (NumAdditionalVals > 0) 235e6864c1d355c4ec1156b956c1dd548682ad3e6b1Benjamin Kramer return Handler->error("multi-valued option specified" 236ba11229f52743ac70f01d4f62d1e04dd093de4e0Chris Lattner " with ValueDisallowed modifier!"); 2377059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov 238341620b2762e604fbf8c75913a1cc5b9c9297b7dChris Lattner if (Value.data()) 239e6864c1d355c4ec1156b956c1dd548682ad3e6b1Benjamin Kramer return Handler->error("does not allow a value! '" + 240a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner Twine(Value) + "' specified."); 241caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner break; 242f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman case ValueOptional: 243e1cc150a8e6b451e42b04b04ffb41596e01bbef5Reid Spencer break; 244eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 245f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman default: 246d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer errs() << ProgramName 247e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << ": Bad ValueMask flag! CommandLine usage error:" 248e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << Handler->getValueExpectedFlag() << "\n"; 249c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable(0); 250caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner } 251caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner 2527059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov // If this isn't a multi-arg option, just run the handler. 253a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner if (NumAdditionalVals == 0) 25437628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov return CommaSeparateAndAddOccurence(Handler, i, ArgName, Value); 255a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner 2567059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov // If it is, run the handle several times. 257a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner bool MultiArg = false; 2587059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov 259341620b2762e604fbf8c75913a1cc5b9c9297b7dChris Lattner if (Value.data()) { 26037628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov if (CommaSeparateAndAddOccurence(Handler, i, ArgName, Value, MultiArg)) 261a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner return true; 262a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner --NumAdditionalVals; 263a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner MultiArg = true; 264a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner } 2657059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov 266a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner while (NumAdditionalVals > 0) { 267a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner if (i+1 >= argc) 268a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner return Handler->error("not enough values!"); 269a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner Value = argv[++i]; 270eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 27137628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov if (CommaSeparateAndAddOccurence(Handler, i, ArgName, Value, MultiArg)) 272a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner return true; 273a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner MultiArg = true; 274a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner --NumAdditionalVals; 2757059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov } 276a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner return false; 277caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner} 278caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner 279ba11229f52743ac70f01d4f62d1e04dd093de4e0Chris Lattnerstatic bool ProvidePositionalOption(Option *Handler, StringRef Arg, int i) { 2801e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer int Dummy = i; 281341620b2762e604fbf8c75913a1cc5b9c9297b7dChris Lattner return ProvideOption(Handler, Handler->ArgStr, Arg, 0, 0, Dummy); 282331de23705a719514e37c211f327379688f81b0dChris Lattner} 283331de23705a719514e37c211f327379688f81b0dChris Lattner 284331de23705a719514e37c211f327379688f81b0dChris Lattner 285331de23705a719514e37c211f327379688f81b0dChris Lattner// Option predicates... 286331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic inline bool isGrouping(const Option *O) { 287331de23705a719514e37c211f327379688f81b0dChris Lattner return O->getFormattingFlag() == cl::Grouping; 288331de23705a719514e37c211f327379688f81b0dChris Lattner} 289331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic inline bool isPrefixedOrGrouping(const Option *O) { 290331de23705a719514e37c211f327379688f81b0dChris Lattner return isGrouping(O) || O->getFormattingFlag() == cl::Prefix; 291331de23705a719514e37c211f327379688f81b0dChris Lattner} 292331de23705a719514e37c211f327379688f81b0dChris Lattner 293331de23705a719514e37c211f327379688f81b0dChris Lattner// getOptionPred - Check to see if there are any options that satisfy the 294331de23705a719514e37c211f327379688f81b0dChris Lattner// specified predicate with names that are the prefixes in Name. This is 295331de23705a719514e37c211f327379688f81b0dChris Lattner// checked by progressively stripping characters off of the name, checking to 296331de23705a719514e37c211f327379688f81b0dChris Lattner// see if there options that satisfy the predicate. If we find one, return it, 297331de23705a719514e37c211f327379688f81b0dChris Lattner// otherwise return null. 298f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner// 29999c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattnerstatic Option *getOptionPred(StringRef Name, size_t &Length, 3009878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner bool (*Pred)(const Option*), 301b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner const StringMap<Option*> &OptionsMap) { 302f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 303b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner StringMap<Option*>::const_iterator OMI = OptionsMap.find(Name); 304f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner 305b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner // Loop while we haven't found an option and Name still has at least two 306b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner // characters in it (so that the next iteration will not be the empty 307b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner // string. 308b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner while (OMI == OptionsMap.end() && Name.size() > 1) { 30999c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattner Name = Name.substr(0, Name.size()-1); // Chop off the last character. 3109878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner OMI = OptionsMap.find(Name); 311b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner } 312331de23705a719514e37c211f327379688f81b0dChris Lattner 3139878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner if (OMI != OptionsMap.end() && Pred(OMI->second)) { 31499c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattner Length = Name.size(); 3159878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner return OMI->second; // Found one! 316f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner } 317331de23705a719514e37c211f327379688f81b0dChris Lattner return 0; // No option found! 318331de23705a719514e37c211f327379688f81b0dChris Lattner} 319f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner 320b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner/// HandlePrefixedOrGroupedOption - The specified argument string (which started 321b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner/// with at least one '-') does not fully match an available option. Check to 322b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner/// see if this is a prefix or grouped option. If so, split arg into output an 323b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner/// Arg/Value pair and return the Option to parse it with. 324b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattnerstatic Option *HandlePrefixedOrGroupedOption(StringRef &Arg, StringRef &Value, 325b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner bool &ErrorParsing, 326b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner const StringMap<Option*> &OptionsMap) { 327b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner if (Arg.size() == 1) return 0; 328b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner 329b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner // Do the lookup! 330b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner size_t Length = 0; 331b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner Option *PGOpt = getOptionPred(Arg, Length, isPrefixedOrGrouping, OptionsMap); 332b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner if (PGOpt == 0) return 0; 333eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 334b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner // If the option is a prefixed option, then the value is simply the 335b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner // rest of the name... so fall through to later processing, by 336b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner // setting up the argument name flags and value fields. 337b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner if (PGOpt->getFormattingFlag() == cl::Prefix) { 338b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner Value = Arg.substr(Length); 339b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner Arg = Arg.substr(0, Length); 340b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner assert(OptionsMap.count(Arg) && OptionsMap.find(Arg)->second == PGOpt); 341b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner return PGOpt; 342b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner } 343eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 344b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner // This must be a grouped option... handle them now. Grouping options can't 345b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner // have values. 346b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner assert(isGrouping(PGOpt) && "Broken getOptionPred!"); 347eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 348b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner do { 349b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner // Move current arg name out of Arg into OneArgName. 350b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner StringRef OneArgName = Arg.substr(0, Length); 351b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner Arg = Arg.substr(Length); 352eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 353b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner // Because ValueRequired is an invalid flag for grouped arguments, 354b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner // we don't need to pass argc/argv in. 355b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner assert(PGOpt->getValueExpectedFlag() != cl::ValueRequired && 356b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner "Option can not be cl::Grouping AND cl::ValueRequired!"); 3571fa8b00b30e3e9ea3ea86ccb819bb9eb11117e6dDuncan Sands int Dummy = 0; 358b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner ErrorParsing |= ProvideOption(PGOpt, OneArgName, 359b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner StringRef(), 0, 0, Dummy); 360eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 361b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner // Get the next grouping option. 362b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner PGOpt = getOptionPred(Arg, Length, isGrouping, OptionsMap); 363b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner } while (PGOpt && Length != Arg.size()); 364eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 365b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner // Return the last option with Arg cut down to just the last one. 366b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner return PGOpt; 367b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner} 368b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner 369b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner 370b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner 371331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic bool RequiresValue(const Option *O) { 372dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman return O->getNumOccurrencesFlag() == cl::Required || 373dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman O->getNumOccurrencesFlag() == cl::OneOrMore; 374331de23705a719514e37c211f327379688f81b0dChris Lattner} 375331de23705a719514e37c211f327379688f81b0dChris Lattner 376331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic bool EatsUnboundedNumberOfValues(const Option *O) { 377dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman return O->getNumOccurrencesFlag() == cl::ZeroOrMore || 378dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman O->getNumOccurrencesFlag() == cl::OneOrMore; 379f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner} 380caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner 381c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke/// ParseCStringVector - Break INPUT up wherever one or more 382c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke/// whitespace characters are found, and store the resulting tokens in 383c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke/// OUTPUT. The tokens stored in OUTPUT are dynamically allocated 384fb2674d0de83cbf3b79c269bc694f612de148950Chris Lattner/// using strdup(), so it is the caller's responsibility to free() 385c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke/// them later. 38606b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// 38763e944b05e75bc026cb3a0bb0697f364682fc794Chris Lattnerstatic void ParseCStringVector(std::vector<char *> &OutputVector, 38863e944b05e75bc026cb3a0bb0697f364682fc794Chris Lattner const char *Input) { 389c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Characters which will be treated as token separators: 39063e944b05e75bc026cb3a0bb0697f364682fc794Chris Lattner StringRef Delims = " \v\f\t\r\n"; 39163e944b05e75bc026cb3a0bb0697f364682fc794Chris Lattner 39263e944b05e75bc026cb3a0bb0697f364682fc794Chris Lattner StringRef WorkStr(Input); 39363e944b05e75bc026cb3a0bb0697f364682fc794Chris Lattner while (!WorkStr.empty()) { 39463e944b05e75bc026cb3a0bb0697f364682fc794Chris Lattner // If the first character is a delimiter, strip them off. 39563e944b05e75bc026cb3a0bb0697f364682fc794Chris Lattner if (Delims.find(WorkStr[0]) != StringRef::npos) { 39663e944b05e75bc026cb3a0bb0697f364682fc794Chris Lattner size_t Pos = WorkStr.find_first_not_of(Delims); 39763e944b05e75bc026cb3a0bb0697f364682fc794Chris Lattner if (Pos == StringRef::npos) Pos = WorkStr.size(); 39863e944b05e75bc026cb3a0bb0697f364682fc794Chris Lattner WorkStr = WorkStr.substr(Pos); 39963e944b05e75bc026cb3a0bb0697f364682fc794Chris Lattner continue; 40006b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke } 401eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 40263e944b05e75bc026cb3a0bb0697f364682fc794Chris Lattner // Find position of first delimiter. 40363e944b05e75bc026cb3a0bb0697f364682fc794Chris Lattner size_t Pos = WorkStr.find_first_of(Delims); 40463e944b05e75bc026cb3a0bb0697f364682fc794Chris Lattner if (Pos == StringRef::npos) Pos = WorkStr.size(); 405eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 40663e944b05e75bc026cb3a0bb0697f364682fc794Chris Lattner // Everything from 0 to Pos is the next word to copy. 40763e944b05e75bc026cb3a0bb0697f364682fc794Chris Lattner char *NewStr = (char*)malloc(Pos+1); 40863e944b05e75bc026cb3a0bb0697f364682fc794Chris Lattner memcpy(NewStr, WorkStr.data(), Pos); 40963e944b05e75bc026cb3a0bb0697f364682fc794Chris Lattner NewStr[Pos] = 0; 41063e944b05e75bc026cb3a0bb0697f364682fc794Chris Lattner OutputVector.push_back(NewStr); 411eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 41263e944b05e75bc026cb3a0bb0697f364682fc794Chris Lattner WorkStr = WorkStr.substr(Pos); 41306b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke } 41406b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke} 41506b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke 41606b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// ParseEnvironmentOptions - An alternative entry point to the 41706b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// CommandLine library, which allows you to read the program's name 41806b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// from the caller (as PROGNAME) and its command-line arguments from 41906b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// an environment variable (whose name is given in ENVVAR). 42006b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// 421bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattnervoid cl::ParseEnvironmentOptions(const char *progName, const char *envVar, 422beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov const char *Overview, bool ReadResponseFiles) { 423c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Check args. 424bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner assert(progName && "Program name not specified"); 425bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner assert(envVar && "Environment variable name missing"); 426f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 42706b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke // Get the environment variable they want us to parse options out of. 428232885873fb0081acc1420ab83b14ab6f8eba280Chris Lattner const char *envValue = getenv(envVar); 429c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke if (!envValue) 43006b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke return; 431c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke 432c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Get program's "name", which we wouldn't know without the caller 433c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // telling us. 434232885873fb0081acc1420ab83b14ab6f8eba280Chris Lattner std::vector<char*> newArgv; 435232885873fb0081acc1420ab83b14ab6f8eba280Chris Lattner newArgv.push_back(strdup(progName)); 43606b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke 43706b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke // Parse the value of the environment variable into a "command line" 43806b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke // and hand it off to ParseCommandLineOptions(). 439232885873fb0081acc1420ab83b14ab6f8eba280Chris Lattner ParseCStringVector(newArgv, envValue); 44034cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng int newArgc = static_cast<int>(newArgv.size()); 441beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov ParseCommandLineOptions(newArgc, &newArgv[0], Overview, ReadResponseFiles); 442c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke 443c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Free all the strdup()ed strings. 444232885873fb0081acc1420ab83b14ab6f8eba280Chris Lattner for (std::vector<char*>::iterator i = newArgv.begin(), e = newArgv.end(); 445232885873fb0081acc1420ab83b14ab6f8eba280Chris Lattner i != e; ++i) 446fb2674d0de83cbf3b79c269bc694f612de148950Chris Lattner free(*i); 44706b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke} 44806b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke 449beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 450beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov/// ExpandResponseFiles - Copy the contents of argv into newArgv, 451beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov/// substituting the contents of the response files for the arguments 452beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov/// of type @file. 453b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattnerstatic void ExpandResponseFiles(unsigned argc, char** argv, 454beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov std::vector<char*>& newArgv) { 455b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner for (unsigned i = 1; i != argc; ++i) { 456b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner char *arg = argv[i]; 457beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 458beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov if (arg[0] == '@') { 459beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov sys::PathWithStatus respFile(++arg); 460beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 461beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov // Check that the response file is not empty (mmap'ing empty 462beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov // files can be problematic). 463beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov const sys::FileStatus *FileStat = respFile.getFileStatus(); 4641421b7bc23f39e57052a51f4647512936f45b12fMikhail Glushenkov if (FileStat && FileStat->getSize() != 0) { 4651421b7bc23f39e57052a51f4647512936f45b12fMikhail Glushenkov 4661421b7bc23f39e57052a51f4647512936f45b12fMikhail Glushenkov // Mmap the response file into memory. 4671421b7bc23f39e57052a51f4647512936f45b12fMikhail Glushenkov OwningPtr<MemoryBuffer> 4681421b7bc23f39e57052a51f4647512936f45b12fMikhail Glushenkov respFilePtr(MemoryBuffer::getFile(respFile.c_str())); 4691421b7bc23f39e57052a51f4647512936f45b12fMikhail Glushenkov 4701421b7bc23f39e57052a51f4647512936f45b12fMikhail Glushenkov // If we could open the file, parse its contents, otherwise 4711421b7bc23f39e57052a51f4647512936f45b12fMikhail Glushenkov // pass the @file option verbatim. 4726c55b1ca7b72c90ce93ca25bc35aefef7d7deda4Mikhail Glushenkov 4736c55b1ca7b72c90ce93ca25bc35aefef7d7deda4Mikhail Glushenkov // TODO: we should also support recursive loading of response files, 4746c55b1ca7b72c90ce93ca25bc35aefef7d7deda4Mikhail Glushenkov // since this is how gcc behaves. (From their man page: "The file may 4756c55b1ca7b72c90ce93ca25bc35aefef7d7deda4Mikhail Glushenkov // itself contain additional @file options; any such options will be 4766c55b1ca7b72c90ce93ca25bc35aefef7d7deda4Mikhail Glushenkov // processed recursively.") 4776c55b1ca7b72c90ce93ca25bc35aefef7d7deda4Mikhail Glushenkov 4781421b7bc23f39e57052a51f4647512936f45b12fMikhail Glushenkov if (respFilePtr != 0) { 4791421b7bc23f39e57052a51f4647512936f45b12fMikhail Glushenkov ParseCStringVector(newArgv, respFilePtr->getBufferStart()); 4801421b7bc23f39e57052a51f4647512936f45b12fMikhail Glushenkov continue; 4811421b7bc23f39e57052a51f4647512936f45b12fMikhail Glushenkov } 4821421b7bc23f39e57052a51f4647512936f45b12fMikhail Glushenkov } 483beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov } 4841421b7bc23f39e57052a51f4647512936f45b12fMikhail Glushenkov newArgv.push_back(strdup(arg)); 485beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov } 486beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov} 487beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 4889a5263241d40d493445d7f386b4d76be088c3ac1Dan Gohmanvoid cl::ParseCommandLineOptions(int argc, char **argv, 489beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov const char *Overview, bool ReadResponseFiles) { 4909878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner // Process all registered options. 49149b301c40a0a1172dbdd7b55bbaee83eed57aab4Chris Lattner SmallVector<Option*, 4> PositionalOpts; 49249b301c40a0a1172dbdd7b55bbaee83eed57aab4Chris Lattner SmallVector<Option*, 4> SinkOpts; 493461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer StringMap<Option*> Opts; 494d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov GetOptionInfo(PositionalOpts, SinkOpts, Opts); 495beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 4969878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner assert((!Opts.empty() || !PositionalOpts.empty()) && 4979878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner "No options specified!"); 498beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 499beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov // Expand response files. 500beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov std::vector<char*> newArgv; 501beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov if (ReadResponseFiles) { 502beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov newArgv.push_back(strdup(argv[0])); 503beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov ExpandResponseFiles(argc, argv, newArgv); 504beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov argv = &newArgv[0]; 50534cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng argc = static_cast<int>(newArgv.size()); 506beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov } 507beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 508efa3da5593117eab5209c9197cad5ca42213c12eChris Lattner // Copy the program name into ProgName, making sure not to overflow it. 509efa3da5593117eab5209c9197cad5ca42213c12eChris Lattner std::string ProgName = sys::Path(argv[0]).getLast(); 51012ea66a7277240c5b045ed14c140f94d453eea0eBenjamin Kramer size_t Len = std::min(ProgName.size(), size_t(79)); 51112ea66a7277240c5b045ed14c140f94d453eea0eBenjamin Kramer memcpy(ProgramName, ProgName.data(), Len); 51212ea66a7277240c5b045ed14c140f94d453eea0eBenjamin Kramer ProgramName[Len] = '\0'; 513beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 514dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner ProgramOverview = Overview; 515dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner bool ErrorParsing = false; 516dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 517331de23705a719514e37c211f327379688f81b0dChris Lattner // Check out the positional arguments to collect information about them. 518331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned NumPositionalRequired = 0; 519beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 520de0132453e2939488c2d69290bfdfb2cde94a0afChris Lattner // Determine whether or not there are an unlimited number of positionals 521de0132453e2939488c2d69290bfdfb2cde94a0afChris Lattner bool HasUnlimitedPositionals = false; 522beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 523331de23705a719514e37c211f327379688f81b0dChris Lattner Option *ConsumeAfterOpt = 0; 524331de23705a719514e37c211f327379688f81b0dChris Lattner if (!PositionalOpts.empty()) { 525dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman if (PositionalOpts[0]->getNumOccurrencesFlag() == cl::ConsumeAfter) { 526331de23705a719514e37c211f327379688f81b0dChris Lattner assert(PositionalOpts.size() > 1 && 527331de23705a719514e37c211f327379688f81b0dChris Lattner "Cannot specify cl::ConsumeAfter without a positional argument!"); 528331de23705a719514e37c211f327379688f81b0dChris Lattner ConsumeAfterOpt = PositionalOpts[0]; 529331de23705a719514e37c211f327379688f81b0dChris Lattner } 530331de23705a719514e37c211f327379688f81b0dChris Lattner 531331de23705a719514e37c211f327379688f81b0dChris Lattner // Calculate how many positional values are _required_. 532331de23705a719514e37c211f327379688f81b0dChris Lattner bool UnboundedFound = false; 53334cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng for (size_t i = ConsumeAfterOpt != 0, e = PositionalOpts.size(); 534331de23705a719514e37c211f327379688f81b0dChris Lattner i != e; ++i) { 535331de23705a719514e37c211f327379688f81b0dChris Lattner Option *Opt = PositionalOpts[i]; 536331de23705a719514e37c211f327379688f81b0dChris Lattner if (RequiresValue(Opt)) 537331de23705a719514e37c211f327379688f81b0dChris Lattner ++NumPositionalRequired; 538331de23705a719514e37c211f327379688f81b0dChris Lattner else if (ConsumeAfterOpt) { 539331de23705a719514e37c211f327379688f81b0dChris Lattner // ConsumeAfter cannot be combined with "optional" positional options 54054ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner // unless there is only one positional argument... 54154ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner if (PositionalOpts.size() > 2) 54254ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner ErrorParsing |= 543e6864c1d355c4ec1156b956c1dd548682ad3e6b1Benjamin Kramer Opt->error("error - this positional option will never be matched, " 54454ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner "because it does not Require a value, and a " 54554ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner "cl::ConsumeAfter option is active!"); 5469cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner } else if (UnboundedFound && !Opt->ArgStr[0]) { 5479cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // This option does not "require" a value... Make sure this option is 5489cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // not specified after an option that eats all extra arguments, or this 5499cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // one will never get any! 550331de23705a719514e37c211f327379688f81b0dChris Lattner // 551e6864c1d355c4ec1156b956c1dd548682ad3e6b1Benjamin Kramer ErrorParsing |= Opt->error("error - option can never match, because " 552331de23705a719514e37c211f327379688f81b0dChris Lattner "another positional argument will match an " 553331de23705a719514e37c211f327379688f81b0dChris Lattner "unbounded number of values, and this option" 554331de23705a719514e37c211f327379688f81b0dChris Lattner " does not require a value!"); 555331de23705a719514e37c211f327379688f81b0dChris Lattner } 556331de23705a719514e37c211f327379688f81b0dChris Lattner UnboundedFound |= EatsUnboundedNumberOfValues(Opt); 557331de23705a719514e37c211f327379688f81b0dChris Lattner } 55821e1a79a31fe45fcd861d64118a60c1fcfad618aChris Lattner HasUnlimitedPositionals = UnboundedFound || ConsumeAfterOpt; 559331de23705a719514e37c211f327379688f81b0dChris Lattner } 560331de23705a719514e37c211f327379688f81b0dChris Lattner 5611e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer // PositionalVals - A vector of "positional" arguments we accumulate into 562ba11229f52743ac70f01d4f62d1e04dd093de4e0Chris Lattner // the process at the end. 563331de23705a719514e37c211f327379688f81b0dChris Lattner // 564ba11229f52743ac70f01d4f62d1e04dd093de4e0Chris Lattner SmallVector<std::pair<StringRef,unsigned>, 4> PositionalVals; 565331de23705a719514e37c211f327379688f81b0dChris Lattner 5669cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // If the program has named positional arguments, and the name has been run 5679cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // across, keep track of which positional argument was named. Otherwise put 5689cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // the positional args into the PositionalVals list... 5699cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner Option *ActivePositionalArg = 0; 5709cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner 571dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Loop over all of the arguments... processing them. 572331de23705a719514e37c211f327379688f81b0dChris Lattner bool DashDashFound = false; // Have we read '--'? 573dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner for (int i = 1; i < argc; ++i) { 574dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner Option *Handler = 0; 5754e247ec4952db1e39b4cc074a38b9f1d52cdaa28Chris Lattner StringRef Value; 5768a7a05814c70d84eace161d3eed07f5b5cfdd8d6Chris Lattner StringRef ArgName = ""; 577331de23705a719514e37c211f327379688f81b0dChris Lattner 57869d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattner // If the option list changed, this means that some command line 579159b0a43408e2521110e22e445ec126aaab16788Chris Lattner // option has just been registered or deregistered. This can occur in 580159b0a43408e2521110e22e445ec126aaab16788Chris Lattner // response to things like -load, etc. If this happens, rescan the options. 58169d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattner if (OptionListChanged) { 582159b0a43408e2521110e22e445ec126aaab16788Chris Lattner PositionalOpts.clear(); 583d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov SinkOpts.clear(); 584159b0a43408e2521110e22e445ec126aaab16788Chris Lattner Opts.clear(); 585d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov GetOptionInfo(PositionalOpts, SinkOpts, Opts); 58669d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattner OptionListChanged = false; 587159b0a43408e2521110e22e445ec126aaab16788Chris Lattner } 588beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 589331de23705a719514e37c211f327379688f81b0dChris Lattner // Check to see if this is a positional argument. This argument is 590331de23705a719514e37c211f327379688f81b0dChris Lattner // considered to be positional if it doesn't start with '-', if it is "-" 5911115e0483fc6da16d52382f159005baddf028063Misha Brukman // itself, or if we have seen "--" already. 592331de23705a719514e37c211f327379688f81b0dChris Lattner // 593331de23705a719514e37c211f327379688f81b0dChris Lattner if (argv[i][0] != '-' || argv[i][1] == 0 || DashDashFound) { 594331de23705a719514e37c211f327379688f81b0dChris Lattner // Positional argument! 5959cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (ActivePositionalArg) { 5961e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ProvidePositionalOption(ActivePositionalArg, argv[i], i); 5979cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner continue; // We are done! 59899c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattner } 599eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 60099c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattner if (!PositionalOpts.empty()) { 6011e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals.push_back(std::make_pair(argv[i],i)); 602331de23705a719514e37c211f327379688f81b0dChris Lattner 603331de23705a719514e37c211f327379688f81b0dChris Lattner // All of the positional arguments have been fulfulled, give the rest to 604331de23705a719514e37c211f327379688f81b0dChris Lattner // the consume after option... if it's specified... 605331de23705a719514e37c211f327379688f81b0dChris Lattner // 606f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman if (PositionalVals.size() >= NumPositionalRequired && 607331de23705a719514e37c211f327379688f81b0dChris Lattner ConsumeAfterOpt != 0) { 608331de23705a719514e37c211f327379688f81b0dChris Lattner for (++i; i < argc; ++i) 6091e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals.push_back(std::make_pair(argv[i],i)); 610331de23705a719514e37c211f327379688f81b0dChris Lattner break; // Handle outside of the argument processing loop... 611331de23705a719514e37c211f327379688f81b0dChris Lattner } 612331de23705a719514e37c211f327379688f81b0dChris Lattner 613331de23705a719514e37c211f327379688f81b0dChris Lattner // Delay processing positional arguments until the end... 614331de23705a719514e37c211f327379688f81b0dChris Lattner continue; 615331de23705a719514e37c211f327379688f81b0dChris Lattner } 616bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner } else if (argv[i][0] == '-' && argv[i][1] == '-' && argv[i][2] == 0 && 617bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner !DashDashFound) { 618bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner DashDashFound = true; // This is the mythical "--"? 619bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner continue; // Don't try to process it as an argument itself. 620bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner } else if (ActivePositionalArg && 621bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner (ActivePositionalArg->getMiscFlags() & PositionalEatsArgs)) { 622bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner // If there is a positional argument eating options, check to see if this 623bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner // option is another positional argument. If so, treat it as an argument, 624bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner // otherwise feed it to the eating positional. 625dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner ArgName = argv[i]+1; 626b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner // Eat leading dashes. 627b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner while (!ArgName.empty() && ArgName[0] == '-') 628b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner ArgName = ArgName.substr(1); 629eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 6309878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner Handler = LookupOption(ArgName, Value, Opts); 631bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner if (!Handler || Handler->getFormattingFlag() != cl::Positional) { 6321e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ProvidePositionalOption(ActivePositionalArg, argv[i], i); 633bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner continue; // We are done! 634331de23705a719514e37c211f327379688f81b0dChris Lattner } 635331de23705a719514e37c211f327379688f81b0dChris Lattner 63699c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattner } else { // We start with a '-', must be an argument. 637bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner ArgName = argv[i]+1; 638b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner // Eat leading dashes. 639b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner while (!ArgName.empty() && ArgName[0] == '-') 640b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner ArgName = ArgName.substr(1); 641eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 6429878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner Handler = LookupOption(ArgName, Value, Opts); 643331de23705a719514e37c211f327379688f81b0dChris Lattner 644bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner // Check to see if this "option" is really a prefixed or grouped argument. 645b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner if (Handler == 0) 646b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner Handler = HandlePrefixedOrGroupedOption(ArgName, Value, 647b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner ErrorParsing, Opts); 648dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 649dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 650dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner if (Handler == 0) { 651d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov if (SinkOpts.empty()) { 652d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer errs() << ProgramName << ": Unknown command line argument '" 6537e7ae5ad692760aa8d97477f061a05b10948cf57Duncan Sands << argv[i] << "'. Try: '" << argv[0] << " -help'\n"; 654d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov ErrorParsing = true; 655d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov } else { 65649b301c40a0a1172dbdd7b55bbaee83eed57aab4Chris Lattner for (SmallVectorImpl<Option*>::iterator I = SinkOpts.begin(), 657d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov E = SinkOpts.end(); I != E ; ++I) 658d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov (*I)->addOccurrence(i, "", argv[i]); 659d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov } 660dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner continue; 661dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 662dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 6639cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // If this is a named positional argument, just remember that it is the 6649cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // active one... 6659cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (Handler->getFormattingFlag() == cl::Positional) 6669cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner ActivePositionalArg = Handler; 667341620b2762e604fbf8c75913a1cc5b9c9297b7dChris Lattner else 6684e247ec4952db1e39b4cc074a38b9f1d52cdaa28Chris Lattner ErrorParsing |= ProvideOption(Handler, ArgName, Value, argc, argv, i); 669331de23705a719514e37c211f327379688f81b0dChris Lattner } 670dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 671331de23705a719514e37c211f327379688f81b0dChris Lattner // Check and handle positional arguments now... 672331de23705a719514e37c211f327379688f81b0dChris Lattner if (NumPositionalRequired > PositionalVals.size()) { 673d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer errs() << ProgramName 674e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << ": Not enough positional command line arguments specified!\n" 675e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << "Must specify at least " << NumPositionalRequired 6767e7ae5ad692760aa8d97477f061a05b10948cf57Duncan Sands << " positional arguments: See: " << argv[0] << " -help\n"; 677beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 678331de23705a719514e37c211f327379688f81b0dChris Lattner ErrorParsing = true; 67916e02097d283159c240996185a8b20f4ea46ccfcDan Gohman } else if (!HasUnlimitedPositionals && 68016e02097d283159c240996185a8b20f4ea46ccfcDan Gohman PositionalVals.size() > PositionalOpts.size()) { 681d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer errs() << ProgramName 682e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << ": Too many positional arguments specified!\n" 683e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << "Can specify at most " << PositionalOpts.size() 6847e7ae5ad692760aa8d97477f061a05b10948cf57Duncan Sands << " positional arguments: See: " << argv[0] << " -help\n"; 685de0132453e2939488c2d69290bfdfb2cde94a0afChris Lattner ErrorParsing = true; 686331de23705a719514e37c211f327379688f81b0dChris Lattner 687331de23705a719514e37c211f327379688f81b0dChris Lattner } else if (ConsumeAfterOpt == 0) { 688b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner // Positional args have already been handled if ConsumeAfter is specified. 68934cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng unsigned ValNo = 0, NumVals = static_cast<unsigned>(PositionalVals.size()); 69034cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng for (size_t i = 0, e = PositionalOpts.size(); i != e; ++i) { 691331de23705a719514e37c211f327379688f81b0dChris Lattner if (RequiresValue(PositionalOpts[i])) { 692f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman ProvidePositionalOption(PositionalOpts[i], PositionalVals[ValNo].first, 6931e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].second); 6941e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ValNo++; 695331de23705a719514e37c211f327379688f81b0dChris Lattner --NumPositionalRequired; // We fulfilled our duty... 696331de23705a719514e37c211f327379688f81b0dChris Lattner } 697331de23705a719514e37c211f327379688f81b0dChris Lattner 698331de23705a719514e37c211f327379688f81b0dChris Lattner // If we _can_ give this option more arguments, do so now, as long as we 699331de23705a719514e37c211f327379688f81b0dChris Lattner // do not give it values that others need. 'Done' controls whether the 700331de23705a719514e37c211f327379688f81b0dChris Lattner // option even _WANTS_ any more. 701331de23705a719514e37c211f327379688f81b0dChris Lattner // 702dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman bool Done = PositionalOpts[i]->getNumOccurrencesFlag() == cl::Required; 703331de23705a719514e37c211f327379688f81b0dChris Lattner while (NumVals-ValNo > NumPositionalRequired && !Done) { 704dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman switch (PositionalOpts[i]->getNumOccurrencesFlag()) { 705331de23705a719514e37c211f327379688f81b0dChris Lattner case cl::Optional: 706331de23705a719514e37c211f327379688f81b0dChris Lattner Done = true; // Optional arguments want _at most_ one value 707331de23705a719514e37c211f327379688f81b0dChris Lattner // FALL THROUGH 708331de23705a719514e37c211f327379688f81b0dChris Lattner case cl::ZeroOrMore: // Zero or more will take all they can get... 709331de23705a719514e37c211f327379688f81b0dChris Lattner case cl::OneOrMore: // One or more will take all they can get... 7101e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ProvidePositionalOption(PositionalOpts[i], 7111e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].first, 7121e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].second); 7131e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ValNo++; 714331de23705a719514e37c211f327379688f81b0dChris Lattner break; 715331de23705a719514e37c211f327379688f81b0dChris Lattner default: 716c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable("Internal error, unexpected NumOccurrences flag in " 717331de23705a719514e37c211f327379688f81b0dChris Lattner "positional argument processing!"); 718331de23705a719514e37c211f327379688f81b0dChris Lattner } 719331de23705a719514e37c211f327379688f81b0dChris Lattner } 720caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner } 721331de23705a719514e37c211f327379688f81b0dChris Lattner } else { 722331de23705a719514e37c211f327379688f81b0dChris Lattner assert(ConsumeAfterOpt && NumPositionalRequired <= PositionalVals.size()); 723331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned ValNo = 0; 72434cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng for (size_t j = 1, e = PositionalOpts.size(); j != e; ++j) 7251e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer if (RequiresValue(PositionalOpts[j])) { 726faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner ErrorParsing |= ProvidePositionalOption(PositionalOpts[j], 7271e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].first, 7281e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].second); 7291e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ValNo++; 7301e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer } 731faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner 732faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // Handle the case where there is just one positional option, and it's 733faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // optional. In this case, we want to give JUST THE FIRST option to the 734faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // positional option and keep the rest for the consume after. The above 735faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // loop would have assigned no values to positional options in this case. 736faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // 7371e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer if (PositionalOpts.size() == 2 && ValNo == 0 && !PositionalVals.empty()) { 738faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner ErrorParsing |= ProvidePositionalOption(PositionalOpts[1], 7391e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].first, 7401e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].second); 7411e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ValNo++; 7421e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer } 743f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 744331de23705a719514e37c211f327379688f81b0dChris Lattner // Handle over all of the rest of the arguments to the 745331de23705a719514e37c211f327379688f81b0dChris Lattner // cl::ConsumeAfter command line option... 746331de23705a719514e37c211f327379688f81b0dChris Lattner for (; ValNo != PositionalVals.size(); ++ValNo) 747331de23705a719514e37c211f327379688f81b0dChris Lattner ErrorParsing |= ProvidePositionalOption(ConsumeAfterOpt, 7481e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].first, 7491e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].second); 750dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 751dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 752dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner // Loop over args and make sure all required args are specified! 753461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer for (StringMap<Option*>::iterator I = Opts.begin(), 754b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman E = Opts.end(); I != E; ++I) { 755dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman switch (I->second->getNumOccurrencesFlag()) { 756dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner case Required: 757dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner case OneOrMore: 758dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman if (I->second->getNumOccurrences() == 0) { 759e6864c1d355c4ec1156b956c1dd548682ad3e6b1Benjamin Kramer I->second->error("must be specified at least once!"); 760f038acbee21cfed998451aedd00a81901d299516Chris Lattner ErrorParsing = true; 761f038acbee21cfed998451aedd00a81901d299516Chris Lattner } 762dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner // Fall through 763dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner default: 764dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner break; 765dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner } 766dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner } 767dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 768a962b40f0bcaee07296836e175112602c58e439fRafael Espindola // Now that we know if -debug is specified, we can use it. 769a962b40f0bcaee07296836e175112602c58e439fRafael Espindola // Note that if ReadResponseFiles == true, this must be done before the 770a962b40f0bcaee07296836e175112602c58e439fRafael Espindola // memory allocated for the expanded command line is free()d below. 771a962b40f0bcaee07296836e175112602c58e439fRafael Espindola DEBUG(dbgs() << "Args: "; 772a962b40f0bcaee07296836e175112602c58e439fRafael Espindola for (int i = 0; i < argc; ++i) 773a962b40f0bcaee07296836e175112602c58e439fRafael Espindola dbgs() << argv[i] << ' '; 774a962b40f0bcaee07296836e175112602c58e439fRafael Espindola dbgs() << '\n'; 775a962b40f0bcaee07296836e175112602c58e439fRafael Espindola ); 776a962b40f0bcaee07296836e175112602c58e439fRafael Espindola 777331de23705a719514e37c211f327379688f81b0dChris Lattner // Free all of the memory allocated to the map. Command line options may only 778331de23705a719514e37c211f327379688f81b0dChris Lattner // be processed once! 77990aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner Opts.clear(); 780331de23705a719514e37c211f327379688f81b0dChris Lattner PositionalOpts.clear(); 78190aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner MoreHelp->clear(); 782dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 783beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov // Free the memory allocated by ExpandResponseFiles. 784beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov if (ReadResponseFiles) { 785beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov // Free all the strdup()ed strings. 786beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov for (std::vector<char*>::iterator i = newArgv.begin(), e = newArgv.end(); 787beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov i != e; ++i) 788fd40d038b32096d12af83b28e9ccd1ae3837356fChris Lattner free(*i); 789beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov } 790beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 791dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // If we had an error processing our arguments, don't let the program execute 792dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner if (ErrorParsing) exit(1); 793dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 794dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 795dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner//===----------------------------------------------------------------------===// 796dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// Option Base class implementation 797dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 798dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 79999c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattnerbool Option::error(const Twine &Message, StringRef ArgName) { 80099c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattner if (ArgName.data() == 0) ArgName = ArgStr; 80199c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattner if (ArgName.empty()) 802d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer errs() << HelpStr; // Be nice for positional arguments 803331de23705a719514e37c211f327379688f81b0dChris Lattner else 804d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer errs() << ProgramName << ": for the -" << ArgName; 805beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 806d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer errs() << " option: " << Message << "\n"; 807dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return true; 808dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 809dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 81099c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattnerbool Option::addOccurrence(unsigned pos, StringRef ArgName, 811a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner StringRef Value, bool MultiArg) { 8127059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov if (!MultiArg) 8137059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov NumOccurrences++; // Increment the number of times we have been seen 814dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 815dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman switch (getNumOccurrencesFlag()) { 816dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner case Optional: 817dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman if (NumOccurrences > 1) 818e6864c1d355c4ec1156b956c1dd548682ad3e6b1Benjamin Kramer return error("may only occur zero or one times!", ArgName); 819dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner break; 820dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner case Required: 821dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman if (NumOccurrences > 1) 822e6864c1d355c4ec1156b956c1dd548682ad3e6b1Benjamin Kramer return error("must occur exactly one time!", ArgName); 823dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Fall through 824dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner case OneOrMore: 825caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner case ZeroOrMore: 826caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner case ConsumeAfter: break; 827e6864c1d355c4ec1156b956c1dd548682ad3e6b1Benjamin Kramer default: return error("bad num occurrences flag value!"); 828dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 829dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 8301e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer return handleOccurrence(pos, ArgName, Value); 831dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 832dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 833331de23705a719514e37c211f327379688f81b0dChris Lattner 834331de23705a719514e37c211f327379688f81b0dChris Lattner// getValueStr - Get the value description string, using "DefaultMsg" if nothing 835331de23705a719514e37c211f327379688f81b0dChris Lattner// has been specified yet. 836331de23705a719514e37c211f327379688f81b0dChris Lattner// 837331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic const char *getValueStr(const Option &O, const char *DefaultMsg) { 838331de23705a719514e37c211f327379688f81b0dChris Lattner if (O.ValueStr[0] == 0) return DefaultMsg; 839331de23705a719514e37c211f327379688f81b0dChris Lattner return O.ValueStr; 840331de23705a719514e37c211f327379688f81b0dChris Lattner} 841331de23705a719514e37c211f327379688f81b0dChris Lattner 842331de23705a719514e37c211f327379688f81b0dChris Lattner//===----------------------------------------------------------------------===// 843331de23705a719514e37c211f327379688f81b0dChris Lattner// cl::alias class implementation 844331de23705a719514e37c211f327379688f81b0dChris Lattner// 845331de23705a719514e37c211f327379688f81b0dChris Lattner 846dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// Return the width of the option tag for printing... 84734cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Chengsize_t alias::getOptionWidth() const { 848dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return std::strlen(ArgStr)+6; 849dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 850dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 851a0de843535627977d107bbe84e4ad20cd2a5060aChris Lattner// Print out the option for the alias. 85234cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Chengvoid alias::printOptionInfo(size_t GlobalWidth) const { 85334cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng size_t L = std::strlen(ArgStr); 854b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner errs() << " -" << ArgStr; 855b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner errs().indent(GlobalWidth-L-6) << " - " << HelpStr << "\n"; 856dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 857dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 858dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 859331de23705a719514e37c211f327379688f81b0dChris Lattner 860dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner//===----------------------------------------------------------------------===// 861331de23705a719514e37c211f327379688f81b0dChris Lattner// Parser Implementation code... 862dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 863dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 8649b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// basic_parser implementation 8659b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// 8669b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 8679b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// Return the width of the option tag for printing... 86834cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Chengsize_t basic_parser_impl::getOptionWidth(const Option &O) const { 86934cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng size_t Len = std::strlen(O.ArgStr); 8709b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner if (const char *ValName = getValueName()) 8719b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner Len += std::strlen(getValueStr(O, ValName))+3; 8729b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 8739b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner return Len + 6; 8749b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner} 8759b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 876f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman// printOptionInfo - Print out information about this option. The 8779b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// to-be-maintained width is specified. 8789b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// 8799b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattnervoid basic_parser_impl::printOptionInfo(const Option &O, 88034cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng size_t GlobalWidth) const { 881d9ea85ab01fb0f2929ed50223d3758dceea8bcbdChris Lattner outs() << " -" << O.ArgStr; 8829b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 8839b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner if (const char *ValName = getValueName()) 884d9ea85ab01fb0f2929ed50223d3758dceea8bcbdChris Lattner outs() << "=<" << getValueStr(O, ValName) << '>'; 8859b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 886d9ea85ab01fb0f2929ed50223d3758dceea8bcbdChris Lattner outs().indent(GlobalWidth-getOptionWidth(O)) << " - " << O.HelpStr << '\n'; 8879b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner} 8889b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 8899b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 8909b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 8919b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 892331de23705a719514e37c211f327379688f81b0dChris Lattner// parser<bool> implementation 893331de23705a719514e37c211f327379688f81b0dChris Lattner// 89499c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattnerbool parser<bool>::parse(Option &O, StringRef ArgName, 895a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner StringRef Arg, bool &Value) { 896f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman if (Arg == "" || Arg == "true" || Arg == "TRUE" || Arg == "True" || 897dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner Arg == "1") { 898dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner Value = true; 899a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner return false; 900a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner } 901eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 902a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner if (Arg == "false" || Arg == "FALSE" || Arg == "False" || Arg == "0") { 903dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner Value = false; 904a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner return false; 905dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 906a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner return O.error("'" + Arg + 907a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner "' is invalid value for boolean argument! Try 0 or 1"); 908dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 909dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 91081da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen// parser<boolOrDefault> implementation 91181da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen// 91299c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattnerbool parser<boolOrDefault>::parse(Option &O, StringRef ArgName, 913a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner StringRef Arg, boolOrDefault &Value) { 91481da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen if (Arg == "" || Arg == "true" || Arg == "TRUE" || Arg == "True" || 91581da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen Arg == "1") { 91681da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen Value = BOU_TRUE; 917a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner return false; 918a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner } 919a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner if (Arg == "false" || Arg == "FALSE" || Arg == "False" || Arg == "0") { 92081da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen Value = BOU_FALSE; 921a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner return false; 92281da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen } 923eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 924a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner return O.error("'" + Arg + 925a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner "' is invalid value for boolean argument! Try 0 or 1"); 92681da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen} 92781da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen 928331de23705a719514e37c211f327379688f81b0dChris Lattner// parser<int> implementation 929dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 93099c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattnerbool parser<int>::parse(Option &O, StringRef ArgName, 931a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner StringRef Arg, int &Value) { 932970e7dff5ba2bd8c5613c43e3b215ca940a378e9Chris Lattner if (Arg.getAsInteger(0, Value)) 933e6864c1d355c4ec1156b956c1dd548682ad3e6b1Benjamin Kramer return O.error("'" + Arg + "' value invalid for integer argument!"); 934331de23705a719514e37c211f327379688f81b0dChris Lattner return false; 935dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 936dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 937d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner// parser<unsigned> implementation 938d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner// 93999c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattnerbool parser<unsigned>::parse(Option &O, StringRef ArgName, 940a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner StringRef Arg, unsigned &Value) { 941970e7dff5ba2bd8c5613c43e3b215ca940a378e9Chris Lattner 942970e7dff5ba2bd8c5613c43e3b215ca940a378e9Chris Lattner if (Arg.getAsInteger(0, Value)) 943e6864c1d355c4ec1156b956c1dd548682ad3e6b1Benjamin Kramer return O.error("'" + Arg + "' value invalid for uint argument!"); 944d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner return false; 945d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner} 946d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner 9479b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// parser<double>/parser<float> implementation 948331de23705a719514e37c211f327379688f81b0dChris Lattner// 949a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattnerstatic bool parseDouble(Option &O, StringRef Arg, double &Value) { 950970e7dff5ba2bd8c5613c43e3b215ca940a378e9Chris Lattner SmallString<32> TmpStr(Arg.begin(), Arg.end()); 951970e7dff5ba2bd8c5613c43e3b215ca940a378e9Chris Lattner const char *ArgStart = TmpStr.c_str(); 952331de23705a719514e37c211f327379688f81b0dChris Lattner char *End; 953331de23705a719514e37c211f327379688f81b0dChris Lattner Value = strtod(ArgStart, &End); 954f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman if (*End != 0) 955e6864c1d355c4ec1156b956c1dd548682ad3e6b1Benjamin Kramer return O.error("'" + Arg + "' value invalid for floating point argument!"); 956dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return false; 957dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 958dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 95999c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattnerbool parser<double>::parse(Option &O, StringRef ArgName, 960a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner StringRef Arg, double &Val) { 9619b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner return parseDouble(O, Arg, Val); 962dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 963dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 96499c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattnerbool parser<float>::parse(Option &O, StringRef ArgName, 965a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner StringRef Arg, float &Val) { 9669b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner double dVal; 9679b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner if (parseDouble(O, Arg, dVal)) 9689b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner return true; 9699b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner Val = (float)dVal; 9709b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner return false; 971dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 972dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 973dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 974dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 975331de23705a719514e37c211f327379688f81b0dChris Lattner// generic_parser_base implementation 976dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 977dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 978aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner// findOption - Return the option number corresponding to the specified 979aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner// argument string. If the option is not found, getNumOptions() is returned. 980aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner// 981aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattnerunsigned generic_parser_base::findOption(const char *Name) { 982461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer unsigned e = getNumOptions(); 983aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner 984461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer for (unsigned i = 0; i != e; ++i) { 985461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer if (strcmp(getOption(i), Name) == 0) 986aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner return i; 987461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer } 988aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner return e; 989aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner} 990aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner 991aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner 992dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// Return the width of the option tag for printing... 99334cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Chengsize_t generic_parser_base::getOptionWidth(const Option &O) const { 994331de23705a719514e37c211f327379688f81b0dChris Lattner if (O.hasArgStr()) { 99534cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng size_t Size = std::strlen(O.ArgStr)+6; 996331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = getNumOptions(); i != e; ++i) 99734cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng Size = std::max(Size, std::strlen(getOption(i))+8); 998331de23705a719514e37c211f327379688f81b0dChris Lattner return Size; 999331de23705a719514e37c211f327379688f81b0dChris Lattner } else { 100034cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng size_t BaseSize = 0; 1001331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = getNumOptions(); i != e; ++i) 100234cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng BaseSize = std::max(BaseSize, std::strlen(getOption(i))+8); 1003331de23705a719514e37c211f327379688f81b0dChris Lattner return BaseSize; 1004331de23705a719514e37c211f327379688f81b0dChris Lattner } 1005dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 1006dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1007f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman// printOptionInfo - Print out information about this option. The 1008dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// to-be-maintained width is specified. 1009dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 1010331de23705a719514e37c211f327379688f81b0dChris Lattnervoid generic_parser_base::printOptionInfo(const Option &O, 101134cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng size_t GlobalWidth) const { 1012331de23705a719514e37c211f327379688f81b0dChris Lattner if (O.hasArgStr()) { 101334cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng size_t L = std::strlen(O.ArgStr); 1014b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner outs() << " -" << O.ArgStr; 1015b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner outs().indent(GlobalWidth-L-6) << " - " << O.HelpStr << '\n'; 1016331de23705a719514e37c211f327379688f81b0dChris Lattner 1017331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = getNumOptions(); i != e; ++i) { 101834cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng size_t NumSpaces = GlobalWidth-strlen(getOption(i))-8; 1019b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner outs() << " =" << getOption(i); 1020b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner outs().indent(NumSpaces) << " - " << getDescription(i) << '\n'; 1021331de23705a719514e37c211f327379688f81b0dChris Lattner } 1022331de23705a719514e37c211f327379688f81b0dChris Lattner } else { 1023331de23705a719514e37c211f327379688f81b0dChris Lattner if (O.HelpStr[0]) 1024b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner outs() << " " << O.HelpStr << '\n'; 1025331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = getNumOptions(); i != e; ++i) { 102634cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng size_t L = std::strlen(getOption(i)); 1027b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner outs() << " -" << getOption(i); 1028b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner outs().indent(GlobalWidth-L-8) << " - " << getDescription(i) << '\n'; 1029331de23705a719514e37c211f327379688f81b0dChris Lattner } 1030dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 1031dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 1032dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1033dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1034dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner//===----------------------------------------------------------------------===// 10357e7ae5ad692760aa8d97477f061a05b10948cf57Duncan Sands// -help and -help-hidden option implementation 1036dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 1037ad0846bd8be0a86e0277e1890fd280c9868f830aReid Spencer 10380fd48b1f1ce923828460fe097faa968b3ea28cb7Chris Lattnerstatic int OptNameCompare(const void *LHS, const void *RHS) { 10390fd48b1f1ce923828460fe097faa968b3ea28cb7Chris Lattner typedef std::pair<const char *, Option*> pair_ty; 1040eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 10410fd48b1f1ce923828460fe097faa968b3ea28cb7Chris Lattner return strcmp(((pair_ty*)LHS)->first, ((pair_ty*)RHS)->first); 10420fd48b1f1ce923828460fe097faa968b3ea28cb7Chris Lattner} 10430fd48b1f1ce923828460fe097faa968b3ea28cb7Chris Lattner 1044dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattnernamespace { 1045dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1046331de23705a719514e37c211f327379688f81b0dChris Lattnerclass HelpPrinter { 104734cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng size_t MaxArgLen; 1048dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner const Option *EmptyArg; 1049dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner const bool ShowHidden; 1050dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1051331de23705a719514e37c211f327379688f81b0dChris Lattnerpublic: 1052950a4c40b823cd4f09dc71be635229246dfd6cacDan Gohman explicit HelpPrinter(bool showHidden) : ShowHidden(showHidden) { 1053331de23705a719514e37c211f327379688f81b0dChris Lattner EmptyArg = 0; 1054331de23705a719514e37c211f327379688f81b0dChris Lattner } 1055331de23705a719514e37c211f327379688f81b0dChris Lattner 1056331de23705a719514e37c211f327379688f81b0dChris Lattner void operator=(bool Value) { 1057331de23705a719514e37c211f327379688f81b0dChris Lattner if (Value == false) return; 1058331de23705a719514e37c211f327379688f81b0dChris Lattner 10599878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner // Get all the options. 106049b301c40a0a1172dbdd7b55bbaee83eed57aab4Chris Lattner SmallVector<Option*, 4> PositionalOpts; 106149b301c40a0a1172dbdd7b55bbaee83eed57aab4Chris Lattner SmallVector<Option*, 4> SinkOpts; 1062461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer StringMap<Option*> OptMap; 1063d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov GetOptionInfo(PositionalOpts, SinkOpts, OptMap); 1064beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 106567aead68beae1fca4c53e92a1682364ba8cb497dChris Lattner // Copy Options into a vector so we can sort them as we like. 10660fd48b1f1ce923828460fe097faa968b3ea28cb7Chris Lattner SmallVector<std::pair<const char *, Option*>, 128> Opts; 1067d0062c6e7c870da1f5fa7e587be21aa8ac1188fbChris Lattner SmallPtrSet<Option*, 128> OptionSet; // Duplicate option detection. 1068d0062c6e7c870da1f5fa7e587be21aa8ac1188fbChris Lattner 1069461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer for (StringMap<Option*>::iterator I = OptMap.begin(), E = OptMap.end(); 1070461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer I != E; ++I) { 1071081bcb0d41f6300b92967b2758e0ba1f23e38462Chris Lattner // Ignore really-hidden options. 1072081bcb0d41f6300b92967b2758e0ba1f23e38462Chris Lattner if (I->second->getOptionHiddenFlag() == ReallyHidden) 1073081bcb0d41f6300b92967b2758e0ba1f23e38462Chris Lattner continue; 1074eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 1075081bcb0d41f6300b92967b2758e0ba1f23e38462Chris Lattner // Unless showhidden is set, ignore hidden flags. 1076081bcb0d41f6300b92967b2758e0ba1f23e38462Chris Lattner if (I->second->getOptionHiddenFlag() == Hidden && !ShowHidden) 1077081bcb0d41f6300b92967b2758e0ba1f23e38462Chris Lattner continue; 1078eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 1079d0062c6e7c870da1f5fa7e587be21aa8ac1188fbChris Lattner // If we've already seen this option, don't add it to the list again. 10800fd48b1f1ce923828460fe097faa968b3ea28cb7Chris Lattner if (!OptionSet.insert(I->second)) 1081d0062c6e7c870da1f5fa7e587be21aa8ac1188fbChris Lattner continue; 1082dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 10830fd48b1f1ce923828460fe097faa968b3ea28cb7Chris Lattner Opts.push_back(std::pair<const char *, Option*>(I->getKey().data(), 10840fd48b1f1ce923828460fe097faa968b3ea28cb7Chris Lattner I->second)); 1085331de23705a719514e37c211f327379688f81b0dChris Lattner } 1086eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 10870fd48b1f1ce923828460fe097faa968b3ea28cb7Chris Lattner // Sort the options list alphabetically. 10880fd48b1f1ce923828460fe097faa968b3ea28cb7Chris Lattner qsort(Opts.data(), Opts.size(), sizeof(Opts[0]), OptNameCompare); 1089dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1090dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner if (ProgramOverview) 1091d9ea85ab01fb0f2929ed50223d3758dceea8bcbdChris Lattner outs() << "OVERVIEW: " << ProgramOverview << "\n"; 1092dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1093d9ea85ab01fb0f2929ed50223d3758dceea8bcbdChris Lattner outs() << "USAGE: " << ProgramName << " [options]"; 1094331de23705a719514e37c211f327379688f81b0dChris Lattner 109590aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner // Print out the positional options. 1096331de23705a719514e37c211f327379688f81b0dChris Lattner Option *CAOpt = 0; // The cl::ConsumeAfter option, if it exists... 1097beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov if (!PositionalOpts.empty() && 10989878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner PositionalOpts[0]->getNumOccurrencesFlag() == ConsumeAfter) 10999878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner CAOpt = PositionalOpts[0]; 11009878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner 110134cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng for (size_t i = CAOpt != 0, e = PositionalOpts.size(); i != e; ++i) { 11029878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner if (PositionalOpts[i]->ArgStr[0]) 1103d9ea85ab01fb0f2929ed50223d3758dceea8bcbdChris Lattner outs() << " --" << PositionalOpts[i]->ArgStr; 1104d9ea85ab01fb0f2929ed50223d3758dceea8bcbdChris Lattner outs() << " " << PositionalOpts[i]->HelpStr; 11059cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner } 1106331de23705a719514e37c211f327379688f81b0dChris Lattner 1107331de23705a719514e37c211f327379688f81b0dChris Lattner // Print the consume after option info if it exists... 1108d9ea85ab01fb0f2929ed50223d3758dceea8bcbdChris Lattner if (CAOpt) outs() << " " << CAOpt->HelpStr; 1109331de23705a719514e37c211f327379688f81b0dChris Lattner 1110d9ea85ab01fb0f2929ed50223d3758dceea8bcbdChris Lattner outs() << "\n\n"; 1111dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1112dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Compute the maximum argument length... 1113dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner MaxArgLen = 0; 111434cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng for (size_t i = 0, e = Opts.size(); i != e; ++i) 11150fd48b1f1ce923828460fe097faa968b3ea28cb7Chris Lattner MaxArgLen = std::max(MaxArgLen, Opts[i].second->getOptionWidth()); 1116dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1117d9ea85ab01fb0f2929ed50223d3758dceea8bcbdChris Lattner outs() << "OPTIONS:\n"; 111834cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng for (size_t i = 0, e = Opts.size(); i != e; ++i) 11190fd48b1f1ce923828460fe097faa968b3ea28cb7Chris Lattner Opts[i].second->printOptionInfo(MaxArgLen); 1120dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1121c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner // Print any extra help the user has declared. 112290aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner for (std::vector<const char *>::iterator I = MoreHelp->begin(), 112390aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner E = MoreHelp->end(); I != E; ++I) 1124d9ea85ab01fb0f2929ed50223d3758dceea8bcbdChris Lattner outs() << *I; 112590aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner MoreHelp->clear(); 1126ad0846bd8be0a86e0277e1890fd280c9868f830aReid Spencer 11279bbba091396922093687d11a181e5886c42c5dfdReid Spencer // Halt the program since help information was printed 1128331de23705a719514e37c211f327379688f81b0dChris Lattner exit(1); 1129dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 1130331de23705a719514e37c211f327379688f81b0dChris Lattner}; 1131500d8bff2077ac327deec076fc8793e740b358c0Chris Lattner} // End anonymous namespace 1132dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1133331de23705a719514e37c211f327379688f81b0dChris Lattner// Define the two HelpPrinter instances that are used to print out help, or 1134331de23705a719514e37c211f327379688f81b0dChris Lattner// help-hidden... 1135331de23705a719514e37c211f327379688f81b0dChris Lattner// 1136500d8bff2077ac327deec076fc8793e740b358c0Chris Lattnerstatic HelpPrinter NormalPrinter(false); 1137500d8bff2077ac327deec076fc8793e740b358c0Chris Lattnerstatic HelpPrinter HiddenPrinter(true); 1138331de23705a719514e37c211f327379688f81b0dChris Lattner 1139500d8bff2077ac327deec076fc8793e740b358c0Chris Lattnerstatic cl::opt<HelpPrinter, true, parser<bool> > 11407e7ae5ad692760aa8d97477f061a05b10948cf57Duncan SandsHOp("help", cl::desc("Display available options (-help-hidden for more)"), 11419b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner cl::location(NormalPrinter), cl::ValueDisallowed); 1142dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1143500d8bff2077ac327deec076fc8793e740b358c0Chris Lattnerstatic cl::opt<HelpPrinter, true, parser<bool> > 11444bf7afcc271138512c38ab2e4a348e2fe6164140Chris LattnerHHOp("help-hidden", cl::desc("Display all available options"), 11459b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner cl::location(HiddenPrinter), cl::Hidden, cl::ValueDisallowed); 1146dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1147500d8bff2077ac327deec076fc8793e740b358c0Chris Lattnerstatic void (*OverrideVersionPrinter)() = 0; 1148515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer 1149bc2d9d3de51368091601dcd34ae9556d4f9f52c0Chris Lattnerstatic int TargetArraySortFn(const void *LHS, const void *RHS) { 1150bc2d9d3de51368091601dcd34ae9556d4f9f52c0Chris Lattner typedef std::pair<const char *, const Target*> pair_ty; 1151bc2d9d3de51368091601dcd34ae9556d4f9f52c0Chris Lattner return strcmp(((const pair_ty*)LHS)->first, ((const pair_ty*)RHS)->first); 1152bc2d9d3de51368091601dcd34ae9556d4f9f52c0Chris Lattner} 1153bc2d9d3de51368091601dcd34ae9556d4f9f52c0Chris Lattner 1154500d8bff2077ac327deec076fc8793e740b358c0Chris Lattnernamespace { 1155515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencerclass VersionPrinter { 1156515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencerpublic: 1157aed293dfba04b07a867491c11dfff4bf3eb6bdddDevang Patel void print() { 115849b301c40a0a1172dbdd7b55bbaee83eed57aab4Chris Lattner raw_ostream &OS = outs(); 115949b301c40a0a1172dbdd7b55bbaee83eed57aab4Chris Lattner OS << "Low Level Virtual Machine (http://llvm.org/):\n" 116049b301c40a0a1172dbdd7b55bbaee83eed57aab4Chris Lattner << " " << PACKAGE_NAME << " version " << PACKAGE_VERSION; 11613fc2f4e83f3317f592c06e2ae7d9f1832210decbChris Lattner#ifdef LLVM_VERSION_INFO 116249b301c40a0a1172dbdd7b55bbaee83eed57aab4Chris Lattner OS << LLVM_VERSION_INFO; 11633fc2f4e83f3317f592c06e2ae7d9f1832210decbChris Lattner#endif 116449b301c40a0a1172dbdd7b55bbaee83eed57aab4Chris Lattner OS << "\n "; 11653fc2f4e83f3317f592c06e2ae7d9f1832210decbChris Lattner#ifndef __OPTIMIZE__ 116649b301c40a0a1172dbdd7b55bbaee83eed57aab4Chris Lattner OS << "DEBUG build"; 1167515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer#else 116849b301c40a0a1172dbdd7b55bbaee83eed57aab4Chris Lattner OS << "Optimized build"; 11693fc2f4e83f3317f592c06e2ae7d9f1832210decbChris Lattner#endif 11703fc2f4e83f3317f592c06e2ae7d9f1832210decbChris Lattner#ifndef NDEBUG 117149b301c40a0a1172dbdd7b55bbaee83eed57aab4Chris Lattner OS << " with assertions"; 1172515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer#endif 1173ba43e0785b7449501f019b9aa4433881dd05bb6aDaniel Dunbar std::string CPU = sys::getHostCPUName(); 1174110e7bb25cab03b6f7051a336233699f3e3ec1e3Benjamin Kramer if (CPU == "generic") CPU = "(unknown)"; 117549b301c40a0a1172dbdd7b55bbaee83eed57aab4Chris Lattner OS << ".\n" 1176dd464df687faf544e83684d0c0e4da87c05f8bfeDaniel Dunbar#if (ENABLE_TIMESTAMPS == 1) 117749b301c40a0a1172dbdd7b55bbaee83eed57aab4Chris Lattner << " Built " << __DATE__ << " (" << __TIME__ << ").\n" 1178dd464df687faf544e83684d0c0e4da87c05f8bfeDaniel Dunbar#endif 117949b301c40a0a1172dbdd7b55bbaee83eed57aab4Chris Lattner << " Host: " << sys::getHostTriple() << '\n' 1180ba43e0785b7449501f019b9aa4433881dd05bb6aDaniel Dunbar << " Host CPU: " << CPU << '\n' 118149b301c40a0a1172dbdd7b55bbaee83eed57aab4Chris Lattner << '\n' 118249b301c40a0a1172dbdd7b55bbaee83eed57aab4Chris Lattner << " Registered Targets:\n"; 1183d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer 1184bc2d9d3de51368091601dcd34ae9556d4f9f52c0Chris Lattner std::vector<std::pair<const char *, const Target*> > Targets; 1185d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer size_t Width = 0; 1186eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov for (TargetRegistry::iterator it = TargetRegistry::begin(), 1187d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer ie = TargetRegistry::end(); it != ie; ++it) { 1188d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer Targets.push_back(std::make_pair(it->getName(), &*it)); 1189bc2d9d3de51368091601dcd34ae9556d4f9f52c0Chris Lattner Width = std::max(Width, strlen(Targets.back().first)); 1190d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer } 1191bc2d9d3de51368091601dcd34ae9556d4f9f52c0Chris Lattner if (!Targets.empty()) 1192bc2d9d3de51368091601dcd34ae9556d4f9f52c0Chris Lattner qsort(&Targets[0], Targets.size(), sizeof(Targets[0]), 1193bc2d9d3de51368091601dcd34ae9556d4f9f52c0Chris Lattner TargetArraySortFn); 1194603bea32743dc9914a1d32ae36fc64fe497af801Daniel Dunbar 1195d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer for (unsigned i = 0, e = Targets.size(); i != e; ++i) { 119649b301c40a0a1172dbdd7b55bbaee83eed57aab4Chris Lattner OS << " " << Targets[i].first; 119749b301c40a0a1172dbdd7b55bbaee83eed57aab4Chris Lattner OS.indent(Width - strlen(Targets[i].first)) << " - " 1198b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner << Targets[i].second->getShortDescription() << '\n'; 1199d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer } 1200d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer if (Targets.empty()) 120149b301c40a0a1172dbdd7b55bbaee83eed57aab4Chris Lattner OS << " (none)\n"; 1202aed293dfba04b07a867491c11dfff4bf3eb6bdddDevang Patel } 1203aed293dfba04b07a867491c11dfff4bf3eb6bdddDevang Patel void operator=(bool OptionWasSpecified) { 1204043b8b5bb2a54133549fbf08e78345a5d086328aChris Lattner if (!OptionWasSpecified) return; 1205eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 1206043b8b5bb2a54133549fbf08e78345a5d086328aChris Lattner if (OverrideVersionPrinter == 0) { 1207043b8b5bb2a54133549fbf08e78345a5d086328aChris Lattner print(); 1208043b8b5bb2a54133549fbf08e78345a5d086328aChris Lattner exit(1); 1209515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer } 1210043b8b5bb2a54133549fbf08e78345a5d086328aChris Lattner (*OverrideVersionPrinter)(); 1211043b8b5bb2a54133549fbf08e78345a5d086328aChris Lattner exit(1); 1212515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer } 1213515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer}; 1214500d8bff2077ac327deec076fc8793e740b358c0Chris Lattner} // End anonymous namespace 1215515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer 1216515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer 121769105f33c190621a6b1ad61f925b1a9e6b0512afReid Spencer// Define the --version option that prints out the LLVM version for the tool 1218500d8bff2077ac327deec076fc8793e740b358c0Chris Lattnerstatic VersionPrinter VersionPrinterInstance; 1219500d8bff2077ac327deec076fc8793e740b358c0Chris Lattner 1220500d8bff2077ac327deec076fc8793e740b358c0Chris Lattnerstatic cl::opt<VersionPrinter, true, parser<bool> > 12214bf7afcc271138512c38ab2e4a348e2fe6164140Chris LattnerVersOp("version", cl::desc("Display the version of this program"), 122269105f33c190621a6b1ad61f925b1a9e6b0512afReid Spencer cl::location(VersionPrinterInstance), cl::ValueDisallowed); 122369105f33c190621a6b1ad61f925b1a9e6b0512afReid Spencer 12249bbba091396922093687d11a181e5886c42c5dfdReid Spencer// Utility function for printing the help message. 12259bbba091396922093687d11a181e5886c42c5dfdReid Spencervoid cl::PrintHelpMessage() { 1226f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman // This looks weird, but it actually prints the help message. The 12275cc498f116cd76235c9c0a2ded46bc29f8fb35e0Reid Spencer // NormalPrinter variable is a HelpPrinter and the help gets printed when 12285cc498f116cd76235c9c0a2ded46bc29f8fb35e0Reid Spencer // its operator= is invoked. That's because the "normal" usages of the 1229f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman // help printer is to be assigned true/false depending on whether the 12307e7ae5ad692760aa8d97477f061a05b10948cf57Duncan Sands // -help option was given or not. Since we're circumventing that we have 12317e7ae5ad692760aa8d97477f061a05b10948cf57Duncan Sands // to make it look like -help was given, so we assign true. 12329bbba091396922093687d11a181e5886c42c5dfdReid Spencer NormalPrinter = true; 12339bbba091396922093687d11a181e5886c42c5dfdReid Spencer} 1234515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer 1235aed293dfba04b07a867491c11dfff4bf3eb6bdddDevang Patel/// Utility function for printing version number. 1236aed293dfba04b07a867491c11dfff4bf3eb6bdddDevang Patelvoid cl::PrintVersionMessage() { 1237aed293dfba04b07a867491c11dfff4bf3eb6bdddDevang Patel VersionPrinterInstance.print(); 1238aed293dfba04b07a867491c11dfff4bf3eb6bdddDevang Patel} 1239aed293dfba04b07a867491c11dfff4bf3eb6bdddDevang Patel 1240515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencervoid cl::SetVersionPrinter(void (*func)()) { 1241515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer OverrideVersionPrinter = func; 1242515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer} 1243