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" 20431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner#include "llvm/ADT/ArrayRef.h" 2167aead68beae1fca4c53e92a1682364ba8cb497dChris Lattner#include "llvm/ADT/SmallPtrSet.h" 22970e7dff5ba2bd8c5613c43e3b215ca940a378e9Chris Lattner#include "llvm/ADT/SmallString.h" 2367aead68beae1fca4c53e92a1682364ba8cb497dChris Lattner#include "llvm/ADT/StringMap.h" 24a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner#include "llvm/ADT/Twine.h" 25ca179340ce51ca394a836444d4dd1974ce18e1a4Chris Lattner#include "llvm/Config/config.h" 26431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner#include "llvm/Support/ConvertUTF.h" 27d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Support/Debug.h" 28d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Support/ErrorHandling.h" 29d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Support/Host.h" 30d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Support/ManagedStatic.h" 31d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Support/MemoryBuffer.h" 32d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Support/Path.h" 33d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Support/raw_ostream.h" 342d6a2360036cf511af0a06f9720e6a1752779d1cBrian Gaeke#include <cerrno> 35ca179340ce51ca394a836444d4dd1974ce18e1a4Chris Lattner#include <cstdlib> 36b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick#include <map> 37cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines#include <system_error> 382cdd21c2e4d855500dfb53f77aa74da53ccf9de6Chris Lattnerusing namespace llvm; 39dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattnerusing namespace cl; 40dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 41dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines#define DEBUG_TYPE "commandline" 42dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 437422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner//===----------------------------------------------------------------------===// 447422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner// Template instantiations and anchors. 457422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner// 46b3587cfb3bd2de1675836eca8802661d32d6eb4dDouglas Gregornamespace llvm { namespace cl { 477422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class basic_parser<bool>); 4881da02b553b86868637f27b89c6e919c31ed5b51Dale JohannesenTEMPLATE_INSTANTIATION(class basic_parser<boolOrDefault>); 497422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class basic_parser<int>); 507422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class basic_parser<unsigned>); 51b3514569d078065ced56562e01fd5a39e01543daBenjamin KramerTEMPLATE_INSTANTIATION(class basic_parser<unsigned long long>); 527422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class basic_parser<double>); 537422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class basic_parser<float>); 547422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class basic_parser<std::string>); 55b587f9662a7b6f00f9ce48ddf2dea1a4fb18a6dbBill WendlingTEMPLATE_INSTANTIATION(class basic_parser<char>); 567422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner 577422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class opt<unsigned>); 587422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class opt<int>); 597422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class opt<std::string>); 60b587f9662a7b6f00f9ce48ddf2dea1a4fb18a6dbBill WendlingTEMPLATE_INSTANTIATION(class opt<char>); 617422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class opt<bool>); 62b3587cfb3bd2de1675836eca8802661d32d6eb4dDouglas Gregor} } // end namespace llvm::cl 637422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner 64354362524a72b3fa43a6c09380b7ae3b2380cbbaJuergen Ributzka// Pin the vtables to this file. 65354362524a72b3fa43a6c09380b7ae3b2380cbbaJuergen Ributzkavoid GenericOptionValue::anchor() {} 660becc96b243da058f6d8901128b173d192db5148David Blaikievoid OptionValue<boolOrDefault>::anchor() {} 670becc96b243da058f6d8901128b173d192db5148David Blaikievoid OptionValue<std::string>::anchor() {} 687422a761008ef63152417c5e69ddc31252fb6b10Chris Lattnervoid Option::anchor() {} 697422a761008ef63152417c5e69ddc31252fb6b10Chris Lattnervoid basic_parser_impl::anchor() {} 707422a761008ef63152417c5e69ddc31252fb6b10Chris Lattnervoid parser<bool>::anchor() {} 7181da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesenvoid parser<boolOrDefault>::anchor() {} 727422a761008ef63152417c5e69ddc31252fb6b10Chris Lattnervoid parser<int>::anchor() {} 737422a761008ef63152417c5e69ddc31252fb6b10Chris Lattnervoid parser<unsigned>::anchor() {} 74b3514569d078065ced56562e01fd5a39e01543daBenjamin Kramervoid parser<unsigned long long>::anchor() {} 757422a761008ef63152417c5e69ddc31252fb6b10Chris Lattnervoid parser<double>::anchor() {} 767422a761008ef63152417c5e69ddc31252fb6b10Chris Lattnervoid parser<float>::anchor() {} 777422a761008ef63152417c5e69ddc31252fb6b10Chris Lattnervoid parser<std::string>::anchor() {} 78b587f9662a7b6f00f9ce48ddf2dea1a4fb18a6dbBill Wendlingvoid parser<char>::anchor() {} 79354362524a72b3fa43a6c09380b7ae3b2380cbbaJuergen Ributzkavoid StringSaver::anchor() {} 807422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner 817422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner//===----------------------------------------------------------------------===// 827422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner 83efa3da5593117eab5209c9197cad5ca42213c12eChris Lattner// Globals for name and overview of program. Program name is not a string to 84efa3da5593117eab5209c9197cad5ca42213c12eChris Lattner// avoid static ctor/dtor issues. 85efa3da5593117eab5209c9197cad5ca42213c12eChris Lattnerstatic char ProgramName[80] = "<premain>"; 86dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hinesstatic const char *ProgramOverview = nullptr; 87e1cc150a8e6b451e42b04b04ffb41596e01bbef5Reid Spencer 88c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner// This collects additional help to be printed. 8990aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattnerstatic ManagedStatic<std::vector<const char*> > MoreHelp; 90c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner 9190aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattnerextrahelp::extrahelp(const char *Help) 92c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner : morehelp(Help) { 9390aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner MoreHelp->push_back(Help); 94c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner} 95c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner 9669d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattnerstatic bool OptionListChanged = false; 9769d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattner 9869d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattner// MarkOptionsChanged - Internal helper function. 9969d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattnervoid cl::MarkOptionsChanged() { 10069d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattner OptionListChanged = true; 10169d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattner} 10269d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattner 1039878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner/// RegisteredOptionList - This is the list of the command line options that 1049878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner/// have statically constructed themselves. 105dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hinesstatic Option *RegisteredOptionList = nullptr; 1069878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner 1079878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattnervoid Option::addArgument() { 108dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines assert(!NextRegistered && "argument multiply registered!"); 109beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 1109878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner NextRegistered = RegisteredOptionList; 1119878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner RegisteredOptionList = this; 11269d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattner MarkOptionsChanged(); 1139878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner} 1149878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner 11536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hinesvoid Option::removeArgument() { 116dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines assert(NextRegistered && "argument never registered"); 11736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines assert(RegisteredOptionList == this && "argument is not the last registered"); 11836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines RegisteredOptionList = NextRegistered; 11936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines MarkOptionsChanged(); 12036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines} 12136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 122b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick// This collects the different option categories that have been registered. 123b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Tricktypedef SmallPtrSet<OptionCategory*,16> OptionCatSet; 124b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trickstatic ManagedStatic<OptionCatSet> RegisteredOptionCategories; 125b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick 126b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick// Initialise the general option category. 127b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew TrickOptionCategory llvm::cl::GeneralCategory("General options"); 128b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick 12936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hinesvoid OptionCategory::registerCategory() { 13036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines assert(std::count_if(RegisteredOptionCategories->begin(), 13136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines RegisteredOptionCategories->end(), 13236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines [this](const OptionCategory *Category) { 13336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return getName() == Category->getName(); 13436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines }) == 0 && "Duplicate option categories"); 13536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 136b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick RegisteredOptionCategories->insert(this); 137b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick} 13869d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattner 139331de23705a719514e37c211f327379688f81b0dChris Lattner//===----------------------------------------------------------------------===// 1407422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner// Basic, shared command line option processing machinery. 141331de23705a719514e37c211f327379688f81b0dChris Lattner// 142331de23705a719514e37c211f327379688f81b0dChris Lattner 1439878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner/// GetOptionInfo - Scan the list of registered options, turning them into data 1449878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner/// structures that are easier to handle. 14549b301c40a0a1172dbdd7b55bbaee83eed57aab4Chris Lattnerstatic void GetOptionInfo(SmallVectorImpl<Option*> &PositionalOpts, 14649b301c40a0a1172dbdd7b55bbaee83eed57aab4Chris Lattner SmallVectorImpl<Option*> &SinkOpts, 147461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer StringMap<Option*> &OptionsMap) { 148cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines bool HadErrors = false; 1491908aea3a64fa89a907317849cbff73789cdb89aChris Lattner SmallVector<const char*, 16> OptionNames; 150dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Option *CAOpt = nullptr; // The ConsumeAfter option if it exists. 1519878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner for (Option *O = RegisteredOptionList; O; O = O->getNextRegisteredOption()) { 1529878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner // If this option wants to handle multiple option names, get the full set. 1539878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner // This handles enum options like "-O1 -O2" etc. 1549878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner O->getExtraOptionNames(OptionNames); 1559878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner if (O->ArgStr[0]) 1569878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner OptionNames.push_back(O->ArgStr); 157beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 1589878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner // Handle named options. 15934cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng for (size_t i = 0, e = OptionNames.size(); i != e; ++i) { 1609878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner // Add argument to the argument map! 161461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer if (OptionsMap.GetOrCreateValue(OptionNames[i], O).second != O) { 162cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines errs() << ProgramName << ": CommandLine Error: Option '" 163cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines << OptionNames[i] << "' registered more than once!\n"; 164cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines HadErrors = true; 1659878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner } 1669878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner } 167beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 1689878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner OptionNames.clear(); 169beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 1709878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner // Remember information about positional options. 1719878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner if (O->getFormattingFlag() == cl::Positional) 1729878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner PositionalOpts.push_back(O); 17361e015fe7426ca97c3c7afb583f04f5f93050370Dan Gohman else if (O->getMiscFlags() & cl::Sink) // Remember sink options 174d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov SinkOpts.push_back(O); 1759878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner else if (O->getNumOccurrencesFlag() == cl::ConsumeAfter) { 176cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines if (CAOpt) { 1779878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner O->error("Cannot specify more than one option with cl::ConsumeAfter!"); 178cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines HadErrors = true; 179cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines } 180ee2b32082eff7366621ed2ab119deb96b7c26cecChris Lattner CAOpt = O; 1819878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner } 182e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner } 183beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 184ee2b32082eff7366621ed2ab119deb96b7c26cecChris Lattner if (CAOpt) 185ee2b32082eff7366621ed2ab119deb96b7c26cecChris Lattner PositionalOpts.push_back(CAOpt); 186beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 187ee2b32082eff7366621ed2ab119deb96b7c26cecChris Lattner // Make sure that they are in order of registration not backwards. 188ee2b32082eff7366621ed2ab119deb96b7c26cecChris Lattner std::reverse(PositionalOpts.begin(), PositionalOpts.end()); 189cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines 190cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines // Fail hard if there were errors. These are strictly unrecoverable and 191cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines // indicate serious issues such as conflicting option names or an incorrectly 192cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines // linked LLVM distribution. 193cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines if (HadErrors) 194cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines report_fatal_error("inconsistency in registered CommandLine options"); 195e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner} 196e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner 1979878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner 198af035f3460f7d758f73987c3f692faf8d6cae062Chris Lattner/// LookupOption - Lookup the option specified by the specified option on the 199af035f3460f7d758f73987c3f692faf8d6cae062Chris Lattner/// command line. If there is a value specified (after an equal sign) return 200b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner/// that as well. This assumes that leading dashes have already been stripped. 2018a7a05814c70d84eace161d3eed07f5b5cfdd8d6Chris Lattnerstatic Option *LookupOption(StringRef &Arg, StringRef &Value, 2028a7a05814c70d84eace161d3eed07f5b5cfdd8d6Chris Lattner const StringMap<Option*> &OptionsMap) { 2038a7a05814c70d84eace161d3eed07f5b5cfdd8d6Chris Lattner // Reject all dashes. 204dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (Arg.empty()) return nullptr; 205eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 2068a7a05814c70d84eace161d3eed07f5b5cfdd8d6Chris Lattner size_t EqualPos = Arg.find('='); 207eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 2084e247ec4952db1e39b4cc074a38b9f1d52cdaa28Chris Lattner // If we have an equals sign, remember the value. 209b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner if (EqualPos == StringRef::npos) { 210b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner // Look up the option. 211b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner StringMap<Option*>::const_iterator I = OptionsMap.find(Arg); 212dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return I != OptionsMap.end() ? I->second : nullptr; 2138a7a05814c70d84eace161d3eed07f5b5cfdd8d6Chris Lattner } 214beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 215b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner // If the argument before the = is a valid option name, we match. If not, 216b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner // return Arg unmolested. 217b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner StringMap<Option*>::const_iterator I = 218b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner OptionsMap.find(Arg.substr(0, EqualPos)); 219dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (I == OptionsMap.end()) return nullptr; 220eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 221b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner Value = Arg.substr(EqualPos+1); 222b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner Arg = Arg.substr(0, EqualPos); 223b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner return I->second; 224dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 225dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 226f4fb66acae1ae9a296c091a7a857c1d01953b444Daniel Dunbar/// LookupNearestOption - Lookup the closest match to the option specified by 227f4fb66acae1ae9a296c091a7a857c1d01953b444Daniel Dunbar/// the specified option on the command line. If there is a value specified 228f4fb66acae1ae9a296c091a7a857c1d01953b444Daniel Dunbar/// (after an equal sign) return that as well. This assumes that leading dashes 229f4fb66acae1ae9a296c091a7a857c1d01953b444Daniel Dunbar/// have already been stripped. 230f4fb66acae1ae9a296c091a7a857c1d01953b444Daniel Dunbarstatic Option *LookupNearestOption(StringRef Arg, 231c98d82a7f0a2a0a8b939c611954d59bab677bfe7Daniel Dunbar const StringMap<Option*> &OptionsMap, 23295d206a9c7218deca9dd6c3f24513596f1226879Nick Lewycky std::string &NearestString) { 233f4fb66acae1ae9a296c091a7a857c1d01953b444Daniel Dunbar // Reject all dashes. 234dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (Arg.empty()) return nullptr; 235f4fb66acae1ae9a296c091a7a857c1d01953b444Daniel Dunbar 236f4fb66acae1ae9a296c091a7a857c1d01953b444Daniel Dunbar // Split on any equal sign. 23795d206a9c7218deca9dd6c3f24513596f1226879Nick Lewycky std::pair<StringRef, StringRef> SplitArg = Arg.split('='); 23895d206a9c7218deca9dd6c3f24513596f1226879Nick Lewycky StringRef &LHS = SplitArg.first; // LHS == Arg when no '=' is present. 23995d206a9c7218deca9dd6c3f24513596f1226879Nick Lewycky StringRef &RHS = SplitArg.second; 240f4fb66acae1ae9a296c091a7a857c1d01953b444Daniel Dunbar 241f4fb66acae1ae9a296c091a7a857c1d01953b444Daniel Dunbar // Find the closest match. 242dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Option *Best = nullptr; 243f4fb66acae1ae9a296c091a7a857c1d01953b444Daniel Dunbar unsigned BestDistance = 0; 244f4fb66acae1ae9a296c091a7a857c1d01953b444Daniel Dunbar for (StringMap<Option*>::const_iterator it = OptionsMap.begin(), 245f4fb66acae1ae9a296c091a7a857c1d01953b444Daniel Dunbar ie = OptionsMap.end(); it != ie; ++it) { 246c98d82a7f0a2a0a8b939c611954d59bab677bfe7Daniel Dunbar Option *O = it->second; 247c98d82a7f0a2a0a8b939c611954d59bab677bfe7Daniel Dunbar SmallVector<const char*, 16> OptionNames; 248c98d82a7f0a2a0a8b939c611954d59bab677bfe7Daniel Dunbar O->getExtraOptionNames(OptionNames); 249c98d82a7f0a2a0a8b939c611954d59bab677bfe7Daniel Dunbar if (O->ArgStr[0]) 250c98d82a7f0a2a0a8b939c611954d59bab677bfe7Daniel Dunbar OptionNames.push_back(O->ArgStr); 251c98d82a7f0a2a0a8b939c611954d59bab677bfe7Daniel Dunbar 25295d206a9c7218deca9dd6c3f24513596f1226879Nick Lewycky bool PermitValue = O->getValueExpectedFlag() != cl::ValueDisallowed; 25395d206a9c7218deca9dd6c3f24513596f1226879Nick Lewycky StringRef Flag = PermitValue ? LHS : Arg; 254c98d82a7f0a2a0a8b939c611954d59bab677bfe7Daniel Dunbar for (size_t i = 0, e = OptionNames.size(); i != e; ++i) { 255c98d82a7f0a2a0a8b939c611954d59bab677bfe7Daniel Dunbar StringRef Name = OptionNames[i]; 256c98d82a7f0a2a0a8b939c611954d59bab677bfe7Daniel Dunbar unsigned Distance = StringRef(Name).edit_distance( 25795d206a9c7218deca9dd6c3f24513596f1226879Nick Lewycky Flag, /*AllowReplacements=*/true, /*MaxEditDistance=*/BestDistance); 258c98d82a7f0a2a0a8b939c611954d59bab677bfe7Daniel Dunbar if (!Best || Distance < BestDistance) { 259c98d82a7f0a2a0a8b939c611954d59bab677bfe7Daniel Dunbar Best = O; 260c98d82a7f0a2a0a8b939c611954d59bab677bfe7Daniel Dunbar BestDistance = Distance; 2612127c9b93a5fd5f04ffaced84bde0696bd57fce6Bill Wendling if (RHS.empty() || !PermitValue) 2622127c9b93a5fd5f04ffaced84bde0696bd57fce6Bill Wendling NearestString = OptionNames[i]; 2632127c9b93a5fd5f04ffaced84bde0696bd57fce6Bill Wendling else 2642127c9b93a5fd5f04ffaced84bde0696bd57fce6Bill Wendling NearestString = std::string(OptionNames[i]) + "=" + RHS.str(); 265c98d82a7f0a2a0a8b939c611954d59bab677bfe7Daniel Dunbar } 266f4fb66acae1ae9a296c091a7a857c1d01953b444Daniel Dunbar } 267f4fb66acae1ae9a296c091a7a857c1d01953b444Daniel Dunbar } 268f4fb66acae1ae9a296c091a7a857c1d01953b444Daniel Dunbar 269f4fb66acae1ae9a296c091a7a857c1d01953b444Daniel Dunbar return Best; 270f4fb66acae1ae9a296c091a7a857c1d01953b444Daniel Dunbar} 271f4fb66acae1ae9a296c091a7a857c1d01953b444Daniel Dunbar 27236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines/// CommaSeparateAndAddOccurrence - A wrapper around Handler->addOccurrence() 27336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines/// that does special handling of cl::CommaSeparated options. 27436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hinesstatic bool CommaSeparateAndAddOccurrence(Option *Handler, unsigned pos, 27536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines StringRef ArgName, StringRef Value, 27636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines bool MultiArg = false) { 27737628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov // Check to see if this option accepts a comma separated list of values. If 27837628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov // it does, we have to split up the value into multiple values. 27937628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov if (Handler->getMiscFlags() & CommaSeparated) { 28037628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov StringRef Val(Value); 28137628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov StringRef::size_type Pos = Val.find(','); 28237628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov 28337628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov while (Pos != StringRef::npos) { 28437628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov // Process the portion before the comma. 28537628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov if (Handler->addOccurrence(pos, ArgName, Val.substr(0, Pos), MultiArg)) 28637628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov return true; 28737628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov // Erase the portion before the comma, AND the comma. 28837628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov Val = Val.substr(Pos+1); 28937628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov Value.substr(Pos+1); // Increment the original value pointer as well. 29037628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov // Check for another comma. 29137628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov Pos = Val.find(','); 29237628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov } 29337628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov 29437628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov Value = Val; 29537628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov } 296b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner 29737628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov if (Handler->addOccurrence(pos, ArgName, Value, MultiArg)) 29837628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov return true; 29937628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov 30037628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov return false; 30137628e009827420d56cdf9b26c5104abd726e53bMikhail Glushenkov} 302b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner 303341620b2762e604fbf8c75913a1cc5b9c9297b7dChris Lattner/// ProvideOption - For Value, this differentiates between an empty value ("") 304341620b2762e604fbf8c75913a1cc5b9c9297b7dChris Lattner/// and a null value (StringRef()). The later is accepted for arguments that 305341620b2762e604fbf8c75913a1cc5b9c9297b7dChris Lattner/// don't allow a value (-foo) the former is rejected (-foo=). 30699c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattnerstatic inline bool ProvideOption(Option *Handler, StringRef ArgName, 307ebba0558c84b67f73989e174e4512f5af0c06cb1David Blaikie StringRef Value, int argc, 308ebba0558c84b67f73989e174e4512f5af0c06cb1David Blaikie const char *const *argv, int &i) { 3097059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov // Is this a multi-argument option? 3107059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov unsigned NumAdditionalVals = Handler->getNumAdditionalVals(); 3117059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov 312caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner // Enforce value requirements 313caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner switch (Handler->getValueExpectedFlag()) { 314caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner case ValueRequired: 315dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!Value.data()) { // No value specified? 316ba11229f52743ac70f01d4f62d1e04dd093de4e0Chris Lattner if (i+1 >= argc) 317e6864c1d355c4ec1156b956c1dd548682ad3e6b1Benjamin Kramer return Handler->error("requires a value!"); 318ba11229f52743ac70f01d4f62d1e04dd093de4e0Chris Lattner // Steal the next argument, like for '-o filename' 319ba11229f52743ac70f01d4f62d1e04dd093de4e0Chris Lattner Value = argv[++i]; 320caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner } 321caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner break; 322caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner case ValueDisallowed: 3237059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov if (NumAdditionalVals > 0) 324e6864c1d355c4ec1156b956c1dd548682ad3e6b1Benjamin Kramer return Handler->error("multi-valued option specified" 325ba11229f52743ac70f01d4f62d1e04dd093de4e0Chris Lattner " with ValueDisallowed modifier!"); 3267059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov 327341620b2762e604fbf8c75913a1cc5b9c9297b7dChris Lattner if (Value.data()) 328e6864c1d355c4ec1156b956c1dd548682ad3e6b1Benjamin Kramer return Handler->error("does not allow a value! '" + 329a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner Twine(Value) + "' specified."); 330caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner break; 331f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman case ValueOptional: 332e1cc150a8e6b451e42b04b04ffb41596e01bbef5Reid Spencer break; 333caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner } 334caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner 3357059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov // If this isn't a multi-arg option, just run the handler. 336a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner if (NumAdditionalVals == 0) 33736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return CommaSeparateAndAddOccurrence(Handler, i, ArgName, Value); 338a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner 3397059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov // If it is, run the handle several times. 340a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner bool MultiArg = false; 3417059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov 342341620b2762e604fbf8c75913a1cc5b9c9297b7dChris Lattner if (Value.data()) { 34336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (CommaSeparateAndAddOccurrence(Handler, i, ArgName, Value, MultiArg)) 344a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner return true; 345a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner --NumAdditionalVals; 346a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner MultiArg = true; 347a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner } 3487059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov 349a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner while (NumAdditionalVals > 0) { 350a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner if (i+1 >= argc) 351a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner return Handler->error("not enough values!"); 352a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner Value = argv[++i]; 353eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 35436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (CommaSeparateAndAddOccurrence(Handler, i, ArgName, Value, MultiArg)) 355a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner return true; 356a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner MultiArg = true; 357a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner --NumAdditionalVals; 3587059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov } 359a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner return false; 360caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner} 361caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner 362ba11229f52743ac70f01d4f62d1e04dd093de4e0Chris Lattnerstatic bool ProvidePositionalOption(Option *Handler, StringRef Arg, int i) { 3631e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer int Dummy = i; 364dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return ProvideOption(Handler, Handler->ArgStr, Arg, 0, nullptr, Dummy); 365331de23705a719514e37c211f327379688f81b0dChris Lattner} 366331de23705a719514e37c211f327379688f81b0dChris Lattner 367331de23705a719514e37c211f327379688f81b0dChris Lattner 368331de23705a719514e37c211f327379688f81b0dChris Lattner// Option predicates... 369331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic inline bool isGrouping(const Option *O) { 370331de23705a719514e37c211f327379688f81b0dChris Lattner return O->getFormattingFlag() == cl::Grouping; 371331de23705a719514e37c211f327379688f81b0dChris Lattner} 372331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic inline bool isPrefixedOrGrouping(const Option *O) { 373331de23705a719514e37c211f327379688f81b0dChris Lattner return isGrouping(O) || O->getFormattingFlag() == cl::Prefix; 374331de23705a719514e37c211f327379688f81b0dChris Lattner} 375331de23705a719514e37c211f327379688f81b0dChris Lattner 376331de23705a719514e37c211f327379688f81b0dChris Lattner// getOptionPred - Check to see if there are any options that satisfy the 377331de23705a719514e37c211f327379688f81b0dChris Lattner// specified predicate with names that are the prefixes in Name. This is 378331de23705a719514e37c211f327379688f81b0dChris Lattner// checked by progressively stripping characters off of the name, checking to 379331de23705a719514e37c211f327379688f81b0dChris Lattner// see if there options that satisfy the predicate. If we find one, return it, 380331de23705a719514e37c211f327379688f81b0dChris Lattner// otherwise return null. 381f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner// 38299c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattnerstatic Option *getOptionPred(StringRef Name, size_t &Length, 3839878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner bool (*Pred)(const Option*), 384b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner const StringMap<Option*> &OptionsMap) { 385f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 386b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner StringMap<Option*>::const_iterator OMI = OptionsMap.find(Name); 387f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner 388b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner // Loop while we haven't found an option and Name still has at least two 389b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner // characters in it (so that the next iteration will not be the empty 390b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner // string. 391b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner while (OMI == OptionsMap.end() && Name.size() > 1) { 39299c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattner Name = Name.substr(0, Name.size()-1); // Chop off the last character. 3939878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner OMI = OptionsMap.find(Name); 394b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner } 395331de23705a719514e37c211f327379688f81b0dChris Lattner 3969878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner if (OMI != OptionsMap.end() && Pred(OMI->second)) { 39799c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattner Length = Name.size(); 3989878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner return OMI->second; // Found one! 399f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner } 400dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; // No option found! 401331de23705a719514e37c211f327379688f81b0dChris Lattner} 402f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner 403b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner/// HandlePrefixedOrGroupedOption - The specified argument string (which started 404b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner/// with at least one '-') does not fully match an available option. Check to 405b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner/// see if this is a prefix or grouped option. If so, split arg into output an 406b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner/// Arg/Value pair and return the Option to parse it with. 407b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattnerstatic Option *HandlePrefixedOrGroupedOption(StringRef &Arg, StringRef &Value, 408b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner bool &ErrorParsing, 409b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner const StringMap<Option*> &OptionsMap) { 410dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (Arg.size() == 1) return nullptr; 411b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner 412b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner // Do the lookup! 413b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner size_t Length = 0; 414b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner Option *PGOpt = getOptionPred(Arg, Length, isPrefixedOrGrouping, OptionsMap); 415dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!PGOpt) return nullptr; 416eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 417b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner // If the option is a prefixed option, then the value is simply the 418b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner // rest of the name... so fall through to later processing, by 419b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner // setting up the argument name flags and value fields. 420b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner if (PGOpt->getFormattingFlag() == cl::Prefix) { 421b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner Value = Arg.substr(Length); 422b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner Arg = Arg.substr(0, Length); 423b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner assert(OptionsMap.count(Arg) && OptionsMap.find(Arg)->second == PGOpt); 424b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner return PGOpt; 425b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner } 426eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 427b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner // This must be a grouped option... handle them now. Grouping options can't 428b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner // have values. 429b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner assert(isGrouping(PGOpt) && "Broken getOptionPred!"); 430eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 431b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner do { 432b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner // Move current arg name out of Arg into OneArgName. 433b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner StringRef OneArgName = Arg.substr(0, Length); 434b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner Arg = Arg.substr(Length); 435eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 436b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner // Because ValueRequired is an invalid flag for grouped arguments, 437b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner // we don't need to pass argc/argv in. 438b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner assert(PGOpt->getValueExpectedFlag() != cl::ValueRequired && 439b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner "Option can not be cl::Grouping AND cl::ValueRequired!"); 4401fa8b00b30e3e9ea3ea86ccb819bb9eb11117e6dDuncan Sands int Dummy = 0; 441b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner ErrorParsing |= ProvideOption(PGOpt, OneArgName, 442dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines StringRef(), 0, nullptr, Dummy); 443eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 444b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner // Get the next grouping option. 445b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner PGOpt = getOptionPred(Arg, Length, isGrouping, OptionsMap); 446b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner } while (PGOpt && Length != Arg.size()); 447eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 448b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner // Return the last option with Arg cut down to just the last one. 449b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner return PGOpt; 450b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner} 451b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner 452b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner 453b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner 454331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic bool RequiresValue(const Option *O) { 455dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman return O->getNumOccurrencesFlag() == cl::Required || 456dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman O->getNumOccurrencesFlag() == cl::OneOrMore; 457331de23705a719514e37c211f327379688f81b0dChris Lattner} 458331de23705a719514e37c211f327379688f81b0dChris Lattner 459331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic bool EatsUnboundedNumberOfValues(const Option *O) { 460dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman return O->getNumOccurrencesFlag() == cl::ZeroOrMore || 461dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman O->getNumOccurrencesFlag() == cl::OneOrMore; 462f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner} 463caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner 464431b0a7646105c53c607cbf0015c615269bc5f11Reid Klecknerstatic bool isWhitespace(char C) { 465431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner return strchr(" \t\n\r\f\v", C); 466431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner} 467431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner 468431b0a7646105c53c607cbf0015c615269bc5f11Reid Klecknerstatic bool isQuote(char C) { 469431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner return C == '\"' || C == '\''; 470431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner} 471431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner 472431b0a7646105c53c607cbf0015c615269bc5f11Reid Klecknerstatic bool isGNUSpecial(char C) { 473431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner return strchr("\\\"\' ", C); 474431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner} 475431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner 476431b0a7646105c53c607cbf0015c615269bc5f11Reid Klecknervoid cl::TokenizeGNUCommandLine(StringRef Src, StringSaver &Saver, 477431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner SmallVectorImpl<const char *> &NewArgv) { 478431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner SmallString<128> Token; 479431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner for (size_t I = 0, E = Src.size(); I != E; ++I) { 480431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner // Consume runs of whitespace. 481431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner if (Token.empty()) { 482431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner while (I != E && isWhitespace(Src[I])) 483431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner ++I; 484431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner if (I == E) break; 485431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner } 486431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner 487431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner // Backslashes can escape backslashes, spaces, and other quotes. Otherwise 488431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner // they are literal. This makes it much easier to read Windows file paths. 489431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner if (I + 1 < E && Src[I] == '\\' && isGNUSpecial(Src[I + 1])) { 490431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner ++I; // Skip the escape. 491431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner Token.push_back(Src[I]); 49263e944b05e75bc026cb3a0bb0697f364682fc794Chris Lattner continue; 49306b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke } 494eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 495431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner // Consume a quoted string. 496431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner if (isQuote(Src[I])) { 497431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner char Quote = Src[I++]; 498431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner while (I != E && Src[I] != Quote) { 499431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner // Backslashes are literal, unless they escape a special character. 500431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner if (Src[I] == '\\' && I + 1 != E && isGNUSpecial(Src[I + 1])) 501431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner ++I; 502431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner Token.push_back(Src[I]); 503431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner ++I; 504431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner } 505431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner if (I == E) break; 506431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner continue; 507431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner } 508eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 509431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner // End the token if this is whitespace. 510431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner if (isWhitespace(Src[I])) { 511431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner if (!Token.empty()) 512431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner NewArgv.push_back(Saver.SaveString(Token.c_str())); 513431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner Token.clear(); 514431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner continue; 515431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner } 516eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 517431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner // This is a normal character. Append it. 518431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner Token.push_back(Src[I]); 51906b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke } 520431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner 521431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner // Append the last token after hitting EOF with no whitespace. 522431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner if (!Token.empty()) 523431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner NewArgv.push_back(Saver.SaveString(Token.c_str())); 524431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner} 525431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner 526264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama/// Backslashes are interpreted in a rather complicated way in the Windows-style 527264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama/// command line, because backslashes are used both to separate path and to 528264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama/// escape double quote. This method consumes runs of backslashes as well as the 529264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama/// following double quote if it's escaped. 530264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama/// 531264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama/// * If an even number of backslashes is followed by a double quote, one 532264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama/// backslash is output for every pair of backslashes, and the last double 533264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama/// quote remains unconsumed. The double quote will later be interpreted as 534264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama/// the start or end of a quoted string in the main loop outside of this 535264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama/// function. 536264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama/// 537264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama/// * If an odd number of backslashes is followed by a double quote, one 538264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama/// backslash is output for every pair of backslashes, and a double quote is 539264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama/// output for the last pair of backslash-double quote. The double quote is 540264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama/// consumed in this case. 541264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama/// 542264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama/// * Otherwise, backslashes are interpreted literally. 543264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyamastatic size_t parseBackslash(StringRef Src, size_t I, SmallString<128> &Token) { 544264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama size_t E = Src.size(); 545264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama int BackslashCount = 0; 546264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama // Skip the backslashes. 547264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama do { 548264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama ++I; 549264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama ++BackslashCount; 550264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama } while (I != E && Src[I] == '\\'); 551264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama 552264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama bool FollowedByDoubleQuote = (I != E && Src[I] == '"'); 553264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama if (FollowedByDoubleQuote) { 554264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama Token.append(BackslashCount / 2, '\\'); 555264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama if (BackslashCount % 2 == 0) 556264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama return I - 1; 557264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama Token.push_back('"'); 558264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama return I; 559264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama } 560264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama Token.append(BackslashCount, '\\'); 561264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama return I - 1; 562264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama} 563264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama 564431b0a7646105c53c607cbf0015c615269bc5f11Reid Klecknervoid cl::TokenizeWindowsCommandLine(StringRef Src, StringSaver &Saver, 565431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner SmallVectorImpl<const char *> &NewArgv) { 566264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama SmallString<128> Token; 567264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama 568264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama // This is a small state machine to consume characters until it reaches the 569264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama // end of the source string. 570264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama enum { INIT, UNQUOTED, QUOTED } State = INIT; 571264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama for (size_t I = 0, E = Src.size(); I != E; ++I) { 572264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama // INIT state indicates that the current input index is at the start of 573264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama // the string or between tokens. 574264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama if (State == INIT) { 575264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama if (isWhitespace(Src[I])) 576264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama continue; 577264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama if (Src[I] == '"') { 578264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama State = QUOTED; 579264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama continue; 580264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama } 581264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama if (Src[I] == '\\') { 582264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama I = parseBackslash(Src, I, Token); 583264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama State = UNQUOTED; 584264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama continue; 585264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama } 586264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama Token.push_back(Src[I]); 587264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama State = UNQUOTED; 588264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama continue; 589264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama } 590264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama 591264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama // UNQUOTED state means that it's reading a token not quoted by double 592264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama // quotes. 593264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama if (State == UNQUOTED) { 594264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama // Whitespace means the end of the token. 595264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama if (isWhitespace(Src[I])) { 596264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama NewArgv.push_back(Saver.SaveString(Token.c_str())); 597264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama Token.clear(); 598264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama State = INIT; 599264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama continue; 600264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama } 601264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama if (Src[I] == '"') { 602264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama State = QUOTED; 603264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama continue; 604264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama } 605264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama if (Src[I] == '\\') { 606264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama I = parseBackslash(Src, I, Token); 607264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama continue; 608264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama } 609264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama Token.push_back(Src[I]); 610264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama continue; 611264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama } 612264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama 613264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama // QUOTED state means that it's reading a token quoted by double quotes. 614264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama if (State == QUOTED) { 615264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama if (Src[I] == '"') { 616264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama State = UNQUOTED; 617264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama continue; 618264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama } 619264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama if (Src[I] == '\\') { 620264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama I = parseBackslash(Src, I, Token); 621264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama continue; 622264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama } 623264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama Token.push_back(Src[I]); 624264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama } 625264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama } 626264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama // Append the last token after hitting EOF with no whitespace. 627264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama if (!Token.empty()) 628264e92d6db46083f9f46484ec39e99f18d35d370Rui Ueyama NewArgv.push_back(Saver.SaveString(Token.c_str())); 629431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner} 630431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner 631431b0a7646105c53c607cbf0015c615269bc5f11Reid Klecknerstatic bool ExpandResponseFile(const char *FName, StringSaver &Saver, 632431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner TokenizerCallback Tokenizer, 633431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner SmallVectorImpl<const char *> &NewArgv) { 634cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines ErrorOr<std::unique_ptr<MemoryBuffer>> MemBufOrErr = 635cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines MemoryBuffer::getFile(FName); 636cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines if (!MemBufOrErr) 637431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner return false; 638cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines std::unique_ptr<MemoryBuffer> MemBuf = std::move(MemBufOrErr.get()); 639431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner StringRef Str(MemBuf->getBufferStart(), MemBuf->getBufferSize()); 640431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner 641431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner // If we have a UTF-16 byte order mark, convert to UTF-8 for parsing. 642431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner ArrayRef<char> BufRef(MemBuf->getBufferStart(), MemBuf->getBufferEnd()); 643431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner std::string UTF8Buf; 644431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner if (hasUTF16ByteOrderMark(BufRef)) { 645431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner if (!convertUTF16ToUTF8String(BufRef, UTF8Buf)) 646431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner return false; 647431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner Str = StringRef(UTF8Buf); 648431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner } 649431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner 650431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner // Tokenize the contents into NewArgv. 651431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner Tokenizer(Str, Saver, NewArgv); 652431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner 653431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner return true; 654431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner} 655431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner 656431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner/// \brief Expand response files on a command line recursively using the given 657431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner/// StringSaver and tokenization strategy. 658431b0a7646105c53c607cbf0015c615269bc5f11Reid Klecknerbool cl::ExpandResponseFiles(StringSaver &Saver, TokenizerCallback Tokenizer, 659431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner SmallVectorImpl<const char *> &Argv) { 660431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner unsigned RspFiles = 0; 66136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines bool AllExpanded = true; 662431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner 663431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner // Don't cache Argv.size() because it can change. 664431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner for (unsigned I = 0; I != Argv.size(); ) { 665431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner const char *Arg = Argv[I]; 666431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner if (Arg[0] != '@') { 667431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner ++I; 668431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner continue; 669431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner } 670431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner 671431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner // If we have too many response files, leave some unexpanded. This avoids 672431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner // crashing on self-referential response files. 673431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner if (RspFiles++ > 20) 674431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner return false; 675431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner 676431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner // Replace this response file argument with the tokenization of its 677431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner // contents. Nested response files are expanded in subsequent iterations. 678431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner // FIXME: If a nested response file uses a relative path, is it relative to 679431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner // the cwd of the process or the response file? 680431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner SmallVector<const char *, 0> ExpandedArgv; 681431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner if (!ExpandResponseFile(Arg + 1, Saver, Tokenizer, ExpandedArgv)) { 68236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // We couldn't read this file, so we leave it in the argument stream and 68336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // move on. 684431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner AllExpanded = false; 68536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines ++I; 686431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner continue; 687431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner } 688431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner Argv.erase(Argv.begin() + I); 689431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner Argv.insert(Argv.begin() + I, ExpandedArgv.begin(), ExpandedArgv.end()); 690431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner } 691431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner return AllExpanded; 692431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner} 693431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner 694431b0a7646105c53c607cbf0015c615269bc5f11Reid Klecknernamespace { 695431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner class StrDupSaver : public StringSaver { 6961e3c0a4c77611f99f1e482de256c59358a902b63Rafael Espindola std::vector<char*> Dups; 6971e3c0a4c77611f99f1e482de256c59358a902b63Rafael Espindola public: 6981e3c0a4c77611f99f1e482de256c59358a902b63Rafael Espindola ~StrDupSaver() { 6991e3c0a4c77611f99f1e482de256c59358a902b63Rafael Espindola for (std::vector<char *>::iterator I = Dups.begin(), E = Dups.end(); 7001e3c0a4c77611f99f1e482de256c59358a902b63Rafael Espindola I != E; ++I) { 7011e3c0a4c77611f99f1e482de256c59358a902b63Rafael Espindola char *Dup = *I; 7021e3c0a4c77611f99f1e482de256c59358a902b63Rafael Espindola free(Dup); 7031e3c0a4c77611f99f1e482de256c59358a902b63Rafael Espindola } 7041e3c0a4c77611f99f1e482de256c59358a902b63Rafael Espindola } 70536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const char *SaveString(const char *Str) override { 7061e3c0a4c77611f99f1e482de256c59358a902b63Rafael Espindola char *Dup = strdup(Str); 7071e3c0a4c77611f99f1e482de256c59358a902b63Rafael Espindola Dups.push_back(Dup); 7081e3c0a4c77611f99f1e482de256c59358a902b63Rafael Espindola return Dup; 709431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner } 710431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner }; 71106b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke} 71206b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke 71306b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// ParseEnvironmentOptions - An alternative entry point to the 71406b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// CommandLine library, which allows you to read the program's name 71506b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// from the caller (as PROGNAME) and its command-line arguments from 71606b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// an environment variable (whose name is given in ENVVAR). 71706b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// 718bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattnervoid cl::ParseEnvironmentOptions(const char *progName, const char *envVar, 719b4e971f376f15325d6918d7fae0c28c8dad5a78cRafael Espindola const char *Overview) { 720c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Check args. 721bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner assert(progName && "Program name not specified"); 722bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner assert(envVar && "Environment variable name missing"); 723f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 72406b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke // Get the environment variable they want us to parse options out of. 725232885873fb0081acc1420ab83b14ab6f8eba280Chris Lattner const char *envValue = getenv(envVar); 726c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke if (!envValue) 72706b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke return; 728c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke 729c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Get program's "name", which we wouldn't know without the caller 730c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // telling us. 731431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner SmallVector<const char *, 20> newArgv; 7321e3c0a4c77611f99f1e482de256c59358a902b63Rafael Espindola StrDupSaver Saver; 7331e3c0a4c77611f99f1e482de256c59358a902b63Rafael Espindola newArgv.push_back(Saver.SaveString(progName)); 73406b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke 73506b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke // Parse the value of the environment variable into a "command line" 73606b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke // and hand it off to ParseCommandLineOptions(). 737431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner TokenizeGNUCommandLine(envValue, Saver, newArgv); 73834cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng int newArgc = static_cast<int>(newArgv.size()); 739b4e971f376f15325d6918d7fae0c28c8dad5a78cRafael Espindola ParseCommandLineOptions(newArgc, &newArgv[0], Overview); 740beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov} 741beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 742ebba0558c84b67f73989e174e4512f5af0c06cb1David Blaikievoid cl::ParseCommandLineOptions(int argc, const char * const *argv, 743b4e971f376f15325d6918d7fae0c28c8dad5a78cRafael Espindola const char *Overview) { 7449878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner // Process all registered options. 74549b301c40a0a1172dbdd7b55bbaee83eed57aab4Chris Lattner SmallVector<Option*, 4> PositionalOpts; 74649b301c40a0a1172dbdd7b55bbaee83eed57aab4Chris Lattner SmallVector<Option*, 4> SinkOpts; 747461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer StringMap<Option*> Opts; 748d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov GetOptionInfo(PositionalOpts, SinkOpts, Opts); 749beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 7509878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner assert((!Opts.empty() || !PositionalOpts.empty()) && 7519878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner "No options specified!"); 752beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 753beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov // Expand response files. 754431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner SmallVector<const char *, 20> newArgv; 755431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner for (int i = 0; i != argc; ++i) 7561e3c0a4c77611f99f1e482de256c59358a902b63Rafael Espindola newArgv.push_back(argv[i]); 757431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner StrDupSaver Saver; 758431b0a7646105c53c607cbf0015c615269bc5f11Reid Kleckner ExpandResponseFiles(Saver, TokenizeGNUCommandLine, newArgv); 759b4e971f376f15325d6918d7fae0c28c8dad5a78cRafael Espindola argv = &newArgv[0]; 760b4e971f376f15325d6918d7fae0c28c8dad5a78cRafael Espindola argc = static_cast<int>(newArgv.size()); 761beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 762efa3da5593117eab5209c9197cad5ca42213c12eChris Lattner // Copy the program name into ProgName, making sure not to overflow it. 763dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines StringRef ProgName = sys::path::filename(argv[0]); 76412ea66a7277240c5b045ed14c140f94d453eea0eBenjamin Kramer size_t Len = std::min(ProgName.size(), size_t(79)); 76512ea66a7277240c5b045ed14c140f94d453eea0eBenjamin Kramer memcpy(ProgramName, ProgName.data(), Len); 76612ea66a7277240c5b045ed14c140f94d453eea0eBenjamin Kramer ProgramName[Len] = '\0'; 767beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 768dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner ProgramOverview = Overview; 769dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner bool ErrorParsing = false; 770dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 771331de23705a719514e37c211f327379688f81b0dChris Lattner // Check out the positional arguments to collect information about them. 772331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned NumPositionalRequired = 0; 773beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 774de0132453e2939488c2d69290bfdfb2cde94a0afChris Lattner // Determine whether or not there are an unlimited number of positionals 775de0132453e2939488c2d69290bfdfb2cde94a0afChris Lattner bool HasUnlimitedPositionals = false; 776beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 777dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Option *ConsumeAfterOpt = nullptr; 778331de23705a719514e37c211f327379688f81b0dChris Lattner if (!PositionalOpts.empty()) { 779dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman if (PositionalOpts[0]->getNumOccurrencesFlag() == cl::ConsumeAfter) { 780331de23705a719514e37c211f327379688f81b0dChris Lattner assert(PositionalOpts.size() > 1 && 781331de23705a719514e37c211f327379688f81b0dChris Lattner "Cannot specify cl::ConsumeAfter without a positional argument!"); 782331de23705a719514e37c211f327379688f81b0dChris Lattner ConsumeAfterOpt = PositionalOpts[0]; 783331de23705a719514e37c211f327379688f81b0dChris Lattner } 784331de23705a719514e37c211f327379688f81b0dChris Lattner 785331de23705a719514e37c211f327379688f81b0dChris Lattner // Calculate how many positional values are _required_. 786331de23705a719514e37c211f327379688f81b0dChris Lattner bool UnboundedFound = false; 787dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines for (size_t i = ConsumeAfterOpt ? 1 : 0, e = PositionalOpts.size(); 788331de23705a719514e37c211f327379688f81b0dChris Lattner i != e; ++i) { 789331de23705a719514e37c211f327379688f81b0dChris Lattner Option *Opt = PositionalOpts[i]; 790331de23705a719514e37c211f327379688f81b0dChris Lattner if (RequiresValue(Opt)) 791331de23705a719514e37c211f327379688f81b0dChris Lattner ++NumPositionalRequired; 792331de23705a719514e37c211f327379688f81b0dChris Lattner else if (ConsumeAfterOpt) { 793331de23705a719514e37c211f327379688f81b0dChris Lattner // ConsumeAfter cannot be combined with "optional" positional options 79454ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner // unless there is only one positional argument... 79554ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner if (PositionalOpts.size() > 2) 79654ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner ErrorParsing |= 797e6864c1d355c4ec1156b956c1dd548682ad3e6b1Benjamin Kramer Opt->error("error - this positional option will never be matched, " 79854ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner "because it does not Require a value, and a " 79954ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner "cl::ConsumeAfter option is active!"); 8009cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner } else if (UnboundedFound && !Opt->ArgStr[0]) { 8019cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // This option does not "require" a value... Make sure this option is 8029cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // not specified after an option that eats all extra arguments, or this 8039cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // one will never get any! 804331de23705a719514e37c211f327379688f81b0dChris Lattner // 805e6864c1d355c4ec1156b956c1dd548682ad3e6b1Benjamin Kramer ErrorParsing |= Opt->error("error - option can never match, because " 806331de23705a719514e37c211f327379688f81b0dChris Lattner "another positional argument will match an " 807331de23705a719514e37c211f327379688f81b0dChris Lattner "unbounded number of values, and this option" 808331de23705a719514e37c211f327379688f81b0dChris Lattner " does not require a value!"); 809331de23705a719514e37c211f327379688f81b0dChris Lattner } 810331de23705a719514e37c211f327379688f81b0dChris Lattner UnboundedFound |= EatsUnboundedNumberOfValues(Opt); 811331de23705a719514e37c211f327379688f81b0dChris Lattner } 81221e1a79a31fe45fcd861d64118a60c1fcfad618aChris Lattner HasUnlimitedPositionals = UnboundedFound || ConsumeAfterOpt; 813331de23705a719514e37c211f327379688f81b0dChris Lattner } 814331de23705a719514e37c211f327379688f81b0dChris Lattner 8151e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer // PositionalVals - A vector of "positional" arguments we accumulate into 816ba11229f52743ac70f01d4f62d1e04dd093de4e0Chris Lattner // the process at the end. 817331de23705a719514e37c211f327379688f81b0dChris Lattner // 818ba11229f52743ac70f01d4f62d1e04dd093de4e0Chris Lattner SmallVector<std::pair<StringRef,unsigned>, 4> PositionalVals; 819331de23705a719514e37c211f327379688f81b0dChris Lattner 8209cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // If the program has named positional arguments, and the name has been run 8219cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // across, keep track of which positional argument was named. Otherwise put 8229cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // the positional args into the PositionalVals list... 823dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Option *ActivePositionalArg = nullptr; 8249cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner 825dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Loop over all of the arguments... processing them. 826331de23705a719514e37c211f327379688f81b0dChris Lattner bool DashDashFound = false; // Have we read '--'? 827dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner for (int i = 1; i < argc; ++i) { 828dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Option *Handler = nullptr; 829dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Option *NearestHandler = nullptr; 83095d206a9c7218deca9dd6c3f24513596f1226879Nick Lewycky std::string NearestHandlerString; 8314e247ec4952db1e39b4cc074a38b9f1d52cdaa28Chris Lattner StringRef Value; 8328a7a05814c70d84eace161d3eed07f5b5cfdd8d6Chris Lattner StringRef ArgName = ""; 833331de23705a719514e37c211f327379688f81b0dChris Lattner 83469d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattner // If the option list changed, this means that some command line 835159b0a43408e2521110e22e445ec126aaab16788Chris Lattner // option has just been registered or deregistered. This can occur in 836159b0a43408e2521110e22e445ec126aaab16788Chris Lattner // response to things like -load, etc. If this happens, rescan the options. 83769d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattner if (OptionListChanged) { 838159b0a43408e2521110e22e445ec126aaab16788Chris Lattner PositionalOpts.clear(); 839d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov SinkOpts.clear(); 840159b0a43408e2521110e22e445ec126aaab16788Chris Lattner Opts.clear(); 841d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov GetOptionInfo(PositionalOpts, SinkOpts, Opts); 84269d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattner OptionListChanged = false; 843159b0a43408e2521110e22e445ec126aaab16788Chris Lattner } 844beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 845331de23705a719514e37c211f327379688f81b0dChris Lattner // Check to see if this is a positional argument. This argument is 846331de23705a719514e37c211f327379688f81b0dChris Lattner // considered to be positional if it doesn't start with '-', if it is "-" 8471115e0483fc6da16d52382f159005baddf028063Misha Brukman // itself, or if we have seen "--" already. 848331de23705a719514e37c211f327379688f81b0dChris Lattner // 849331de23705a719514e37c211f327379688f81b0dChris Lattner if (argv[i][0] != '-' || argv[i][1] == 0 || DashDashFound) { 850331de23705a719514e37c211f327379688f81b0dChris Lattner // Positional argument! 8519cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (ActivePositionalArg) { 8521e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ProvidePositionalOption(ActivePositionalArg, argv[i], i); 8539cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner continue; // We are done! 85499c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattner } 855eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 85699c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattner if (!PositionalOpts.empty()) { 8571e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals.push_back(std::make_pair(argv[i],i)); 858331de23705a719514e37c211f327379688f81b0dChris Lattner 859331de23705a719514e37c211f327379688f81b0dChris Lattner // All of the positional arguments have been fulfulled, give the rest to 860331de23705a719514e37c211f327379688f81b0dChris Lattner // the consume after option... if it's specified... 861331de23705a719514e37c211f327379688f81b0dChris Lattner // 862dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (PositionalVals.size() >= NumPositionalRequired && ConsumeAfterOpt) { 863331de23705a719514e37c211f327379688f81b0dChris Lattner for (++i; i < argc; ++i) 8641e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals.push_back(std::make_pair(argv[i],i)); 865331de23705a719514e37c211f327379688f81b0dChris Lattner break; // Handle outside of the argument processing loop... 866331de23705a719514e37c211f327379688f81b0dChris Lattner } 867331de23705a719514e37c211f327379688f81b0dChris Lattner 868331de23705a719514e37c211f327379688f81b0dChris Lattner // Delay processing positional arguments until the end... 869331de23705a719514e37c211f327379688f81b0dChris Lattner continue; 870331de23705a719514e37c211f327379688f81b0dChris Lattner } 871bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner } else if (argv[i][0] == '-' && argv[i][1] == '-' && argv[i][2] == 0 && 872bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner !DashDashFound) { 873bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner DashDashFound = true; // This is the mythical "--"? 874bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner continue; // Don't try to process it as an argument itself. 875bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner } else if (ActivePositionalArg && 876bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner (ActivePositionalArg->getMiscFlags() & PositionalEatsArgs)) { 877bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner // If there is a positional argument eating options, check to see if this 878bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner // option is another positional argument. If so, treat it as an argument, 879bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner // otherwise feed it to the eating positional. 880dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner ArgName = argv[i]+1; 881b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner // Eat leading dashes. 882b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner while (!ArgName.empty() && ArgName[0] == '-') 883b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner ArgName = ArgName.substr(1); 884eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 8859878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner Handler = LookupOption(ArgName, Value, Opts); 886bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner if (!Handler || Handler->getFormattingFlag() != cl::Positional) { 8871e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ProvidePositionalOption(ActivePositionalArg, argv[i], i); 888bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner continue; // We are done! 889331de23705a719514e37c211f327379688f81b0dChris Lattner } 890331de23705a719514e37c211f327379688f81b0dChris Lattner 89199c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattner } else { // We start with a '-', must be an argument. 892bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner ArgName = argv[i]+1; 893b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner // Eat leading dashes. 894b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner while (!ArgName.empty() && ArgName[0] == '-') 895b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner ArgName = ArgName.substr(1); 896eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 8979878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner Handler = LookupOption(ArgName, Value, Opts); 898331de23705a719514e37c211f327379688f81b0dChris Lattner 899bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner // Check to see if this "option" is really a prefixed or grouped argument. 900dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!Handler) 901b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner Handler = HandlePrefixedOrGroupedOption(ArgName, Value, 902b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner ErrorParsing, Opts); 903f4fb66acae1ae9a296c091a7a857c1d01953b444Daniel Dunbar 904f4fb66acae1ae9a296c091a7a857c1d01953b444Daniel Dunbar // Otherwise, look for the closest available option to report to the user 905f4fb66acae1ae9a296c091a7a857c1d01953b444Daniel Dunbar // in the upcoming error. 906dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!Handler && SinkOpts.empty()) 907c98d82a7f0a2a0a8b939c611954d59bab677bfe7Daniel Dunbar NearestHandler = LookupNearestOption(ArgName, Opts, 908c98d82a7f0a2a0a8b939c611954d59bab677bfe7Daniel Dunbar NearestHandlerString); 909dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 910dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 911dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!Handler) { 912d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov if (SinkOpts.empty()) { 913d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer errs() << ProgramName << ": Unknown command line argument '" 9147e7ae5ad692760aa8d97477f061a05b10948cf57Duncan Sands << argv[i] << "'. Try: '" << argv[0] << " -help'\n"; 915f4fb66acae1ae9a296c091a7a857c1d01953b444Daniel Dunbar 916c98d82a7f0a2a0a8b939c611954d59bab677bfe7Daniel Dunbar if (NearestHandler) { 917c98d82a7f0a2a0a8b939c611954d59bab677bfe7Daniel Dunbar // If we know a near match, report it as well. 918c98d82a7f0a2a0a8b939c611954d59bab677bfe7Daniel Dunbar errs() << ProgramName << ": Did you mean '-" 919c98d82a7f0a2a0a8b939c611954d59bab677bfe7Daniel Dunbar << NearestHandlerString << "'?\n"; 920c98d82a7f0a2a0a8b939c611954d59bab677bfe7Daniel Dunbar } 921f4fb66acae1ae9a296c091a7a857c1d01953b444Daniel Dunbar 922d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov ErrorParsing = true; 923d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov } else { 92449b301c40a0a1172dbdd7b55bbaee83eed57aab4Chris Lattner for (SmallVectorImpl<Option*>::iterator I = SinkOpts.begin(), 925d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov E = SinkOpts.end(); I != E ; ++I) 926d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov (*I)->addOccurrence(i, "", argv[i]); 927d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov } 928dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner continue; 929dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 930dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 9319cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // If this is a named positional argument, just remember that it is the 9329cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // active one... 9339cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (Handler->getFormattingFlag() == cl::Positional) 9349cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner ActivePositionalArg = Handler; 935341620b2762e604fbf8c75913a1cc5b9c9297b7dChris Lattner else 9364e247ec4952db1e39b4cc074a38b9f1d52cdaa28Chris Lattner ErrorParsing |= ProvideOption(Handler, ArgName, Value, argc, argv, i); 937331de23705a719514e37c211f327379688f81b0dChris Lattner } 938dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 939331de23705a719514e37c211f327379688f81b0dChris Lattner // Check and handle positional arguments now... 940331de23705a719514e37c211f327379688f81b0dChris Lattner if (NumPositionalRequired > PositionalVals.size()) { 941d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer errs() << ProgramName 942e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << ": Not enough positional command line arguments specified!\n" 943e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << "Must specify at least " << NumPositionalRequired 9447e7ae5ad692760aa8d97477f061a05b10948cf57Duncan Sands << " positional arguments: See: " << argv[0] << " -help\n"; 945beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 946331de23705a719514e37c211f327379688f81b0dChris Lattner ErrorParsing = true; 94716e02097d283159c240996185a8b20f4ea46ccfcDan Gohman } else if (!HasUnlimitedPositionals && 94816e02097d283159c240996185a8b20f4ea46ccfcDan Gohman PositionalVals.size() > PositionalOpts.size()) { 949d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer errs() << ProgramName 950e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << ": Too many positional arguments specified!\n" 951e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << "Can specify at most " << PositionalOpts.size() 9527e7ae5ad692760aa8d97477f061a05b10948cf57Duncan Sands << " positional arguments: See: " << argv[0] << " -help\n"; 953de0132453e2939488c2d69290bfdfb2cde94a0afChris Lattner ErrorParsing = true; 954331de23705a719514e37c211f327379688f81b0dChris Lattner 955dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines } else if (!ConsumeAfterOpt) { 956b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner // Positional args have already been handled if ConsumeAfter is specified. 95734cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng unsigned ValNo = 0, NumVals = static_cast<unsigned>(PositionalVals.size()); 95834cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng for (size_t i = 0, e = PositionalOpts.size(); i != e; ++i) { 959331de23705a719514e37c211f327379688f81b0dChris Lattner if (RequiresValue(PositionalOpts[i])) { 960f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman ProvidePositionalOption(PositionalOpts[i], PositionalVals[ValNo].first, 9611e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].second); 9621e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ValNo++; 963331de23705a719514e37c211f327379688f81b0dChris Lattner --NumPositionalRequired; // We fulfilled our duty... 964331de23705a719514e37c211f327379688f81b0dChris Lattner } 965331de23705a719514e37c211f327379688f81b0dChris Lattner 966331de23705a719514e37c211f327379688f81b0dChris Lattner // If we _can_ give this option more arguments, do so now, as long as we 967331de23705a719514e37c211f327379688f81b0dChris Lattner // do not give it values that others need. 'Done' controls whether the 968331de23705a719514e37c211f327379688f81b0dChris Lattner // option even _WANTS_ any more. 969331de23705a719514e37c211f327379688f81b0dChris Lattner // 970dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman bool Done = PositionalOpts[i]->getNumOccurrencesFlag() == cl::Required; 971331de23705a719514e37c211f327379688f81b0dChris Lattner while (NumVals-ValNo > NumPositionalRequired && !Done) { 972dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman switch (PositionalOpts[i]->getNumOccurrencesFlag()) { 973331de23705a719514e37c211f327379688f81b0dChris Lattner case cl::Optional: 974331de23705a719514e37c211f327379688f81b0dChris Lattner Done = true; // Optional arguments want _at most_ one value 975331de23705a719514e37c211f327379688f81b0dChris Lattner // FALL THROUGH 976331de23705a719514e37c211f327379688f81b0dChris Lattner case cl::ZeroOrMore: // Zero or more will take all they can get... 977331de23705a719514e37c211f327379688f81b0dChris Lattner case cl::OneOrMore: // One or more will take all they can get... 9781e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ProvidePositionalOption(PositionalOpts[i], 9791e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].first, 9801e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].second); 9811e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ValNo++; 982331de23705a719514e37c211f327379688f81b0dChris Lattner break; 983331de23705a719514e37c211f327379688f81b0dChris Lattner default: 984c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable("Internal error, unexpected NumOccurrences flag in " 985331de23705a719514e37c211f327379688f81b0dChris Lattner "positional argument processing!"); 986331de23705a719514e37c211f327379688f81b0dChris Lattner } 987331de23705a719514e37c211f327379688f81b0dChris Lattner } 988caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner } 989331de23705a719514e37c211f327379688f81b0dChris Lattner } else { 990331de23705a719514e37c211f327379688f81b0dChris Lattner assert(ConsumeAfterOpt && NumPositionalRequired <= PositionalVals.size()); 991331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned ValNo = 0; 99234cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng for (size_t j = 1, e = PositionalOpts.size(); j != e; ++j) 9931e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer if (RequiresValue(PositionalOpts[j])) { 994faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner ErrorParsing |= ProvidePositionalOption(PositionalOpts[j], 9951e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].first, 9961e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].second); 9971e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ValNo++; 9981e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer } 999faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner 1000faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // Handle the case where there is just one positional option, and it's 1001faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // optional. In this case, we want to give JUST THE FIRST option to the 1002faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // positional option and keep the rest for the consume after. The above 1003faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // loop would have assigned no values to positional options in this case. 1004faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // 10051e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer if (PositionalOpts.size() == 2 && ValNo == 0 && !PositionalVals.empty()) { 1006faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner ErrorParsing |= ProvidePositionalOption(PositionalOpts[1], 10071e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].first, 10081e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].second); 10091e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ValNo++; 10101e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer } 1011f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 1012331de23705a719514e37c211f327379688f81b0dChris Lattner // Handle over all of the rest of the arguments to the 1013331de23705a719514e37c211f327379688f81b0dChris Lattner // cl::ConsumeAfter command line option... 1014331de23705a719514e37c211f327379688f81b0dChris Lattner for (; ValNo != PositionalVals.size(); ++ValNo) 1015331de23705a719514e37c211f327379688f81b0dChris Lattner ErrorParsing |= ProvidePositionalOption(ConsumeAfterOpt, 10161e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].first, 10171e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].second); 1018dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 1019dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1020dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner // Loop over args and make sure all required args are specified! 1021461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer for (StringMap<Option*>::iterator I = Opts.begin(), 1022b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman E = Opts.end(); I != E; ++I) { 1023dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman switch (I->second->getNumOccurrencesFlag()) { 1024dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner case Required: 1025dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner case OneOrMore: 1026dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman if (I->second->getNumOccurrences() == 0) { 1027e6864c1d355c4ec1156b956c1dd548682ad3e6b1Benjamin Kramer I->second->error("must be specified at least once!"); 1028f038acbee21cfed998451aedd00a81901d299516Chris Lattner ErrorParsing = true; 1029f038acbee21cfed998451aedd00a81901d299516Chris Lattner } 1030dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner // Fall through 1031dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner default: 1032dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner break; 1033dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner } 1034dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner } 1035dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1036a962b40f0bcaee07296836e175112602c58e439fRafael Espindola // Now that we know if -debug is specified, we can use it. 1037a962b40f0bcaee07296836e175112602c58e439fRafael Espindola // Note that if ReadResponseFiles == true, this must be done before the 1038a962b40f0bcaee07296836e175112602c58e439fRafael Espindola // memory allocated for the expanded command line is free()d below. 1039a962b40f0bcaee07296836e175112602c58e439fRafael Espindola DEBUG(dbgs() << "Args: "; 1040a962b40f0bcaee07296836e175112602c58e439fRafael Espindola for (int i = 0; i < argc; ++i) 1041a962b40f0bcaee07296836e175112602c58e439fRafael Espindola dbgs() << argv[i] << ' '; 1042a962b40f0bcaee07296836e175112602c58e439fRafael Espindola dbgs() << '\n'; 1043a962b40f0bcaee07296836e175112602c58e439fRafael Espindola ); 1044a962b40f0bcaee07296836e175112602c58e439fRafael Espindola 1045331de23705a719514e37c211f327379688f81b0dChris Lattner // Free all of the memory allocated to the map. Command line options may only 1046331de23705a719514e37c211f327379688f81b0dChris Lattner // be processed once! 104790aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner Opts.clear(); 1048331de23705a719514e37c211f327379688f81b0dChris Lattner PositionalOpts.clear(); 104990aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner MoreHelp->clear(); 1050dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1051dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // If we had an error processing our arguments, don't let the program execute 1052dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner if (ErrorParsing) exit(1); 1053dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 1054dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1055dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner//===----------------------------------------------------------------------===// 1056dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// Option Base class implementation 1057dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 1058dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 105999c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattnerbool Option::error(const Twine &Message, StringRef ArgName) { 1060dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!ArgName.data()) ArgName = ArgStr; 106199c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattner if (ArgName.empty()) 1062d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer errs() << HelpStr; // Be nice for positional arguments 1063331de23705a719514e37c211f327379688f81b0dChris Lattner else 1064d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer errs() << ProgramName << ": for the -" << ArgName; 1065beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 1066d227a3fb1af350ad32b06cd9b2357f7084e46dcbBenjamin Kramer errs() << " option: " << Message << "\n"; 1067dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return true; 1068dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 1069dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 107099c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattnerbool Option::addOccurrence(unsigned pos, StringRef ArgName, 1071a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner StringRef Value, bool MultiArg) { 10727059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov if (!MultiArg) 10737059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov NumOccurrences++; // Increment the number of times we have been seen 1074dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1075dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman switch (getNumOccurrencesFlag()) { 1076dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner case Optional: 1077dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman if (NumOccurrences > 1) 1078e6864c1d355c4ec1156b956c1dd548682ad3e6b1Benjamin Kramer return error("may only occur zero or one times!", ArgName); 1079dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner break; 1080dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner case Required: 1081dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman if (NumOccurrences > 1) 1082e6864c1d355c4ec1156b956c1dd548682ad3e6b1Benjamin Kramer return error("must occur exactly one time!", ArgName); 1083dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Fall through 1084dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner case OneOrMore: 1085caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner case ZeroOrMore: 1086caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner case ConsumeAfter: break; 1087dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 1088dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 10891e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer return handleOccurrence(pos, ArgName, Value); 1090dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 1091dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1092331de23705a719514e37c211f327379688f81b0dChris Lattner 1093331de23705a719514e37c211f327379688f81b0dChris Lattner// getValueStr - Get the value description string, using "DefaultMsg" if nothing 1094331de23705a719514e37c211f327379688f81b0dChris Lattner// has been specified yet. 1095331de23705a719514e37c211f327379688f81b0dChris Lattner// 1096331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic const char *getValueStr(const Option &O, const char *DefaultMsg) { 1097331de23705a719514e37c211f327379688f81b0dChris Lattner if (O.ValueStr[0] == 0) return DefaultMsg; 1098331de23705a719514e37c211f327379688f81b0dChris Lattner return O.ValueStr; 1099331de23705a719514e37c211f327379688f81b0dChris Lattner} 1100331de23705a719514e37c211f327379688f81b0dChris Lattner 1101331de23705a719514e37c211f327379688f81b0dChris Lattner//===----------------------------------------------------------------------===// 1102331de23705a719514e37c211f327379688f81b0dChris Lattner// cl::alias class implementation 1103331de23705a719514e37c211f327379688f81b0dChris Lattner// 1104331de23705a719514e37c211f327379688f81b0dChris Lattner 1105dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// Return the width of the option tag for printing... 110634cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Chengsize_t alias::getOptionWidth() const { 1107dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return std::strlen(ArgStr)+6; 1108dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 1109dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 11102e24e19cacacd4eea346b914124ffc3acadbd72eAlexander Kornienkostatic void printHelpStr(StringRef HelpStr, size_t Indent, 11112e24e19cacacd4eea346b914124ffc3acadbd72eAlexander Kornienko size_t FirstLineIndentedBy) { 11122e24e19cacacd4eea346b914124ffc3acadbd72eAlexander Kornienko std::pair<StringRef, StringRef> Split = HelpStr.split('\n'); 11132e24e19cacacd4eea346b914124ffc3acadbd72eAlexander Kornienko outs().indent(Indent - FirstLineIndentedBy) << " - " << Split.first << "\n"; 11142e24e19cacacd4eea346b914124ffc3acadbd72eAlexander Kornienko while (!Split.second.empty()) { 11152e24e19cacacd4eea346b914124ffc3acadbd72eAlexander Kornienko Split = Split.second.split('\n'); 11162e24e19cacacd4eea346b914124ffc3acadbd72eAlexander Kornienko outs().indent(Indent) << Split.first << "\n"; 11172e24e19cacacd4eea346b914124ffc3acadbd72eAlexander Kornienko } 11182e24e19cacacd4eea346b914124ffc3acadbd72eAlexander Kornienko} 11192e24e19cacacd4eea346b914124ffc3acadbd72eAlexander Kornienko 1120a0de843535627977d107bbe84e4ad20cd2a5060aChris Lattner// Print out the option for the alias. 112134cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Chengvoid alias::printOptionInfo(size_t GlobalWidth) const { 1122ff276b40f0bfd72938f964061c13ed18be7c008fEvan Cheng outs() << " -" << ArgStr; 11232e24e19cacacd4eea346b914124ffc3acadbd72eAlexander Kornienko printHelpStr(HelpStr, GlobalWidth, std::strlen(ArgStr) + 6); 1124dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 1125dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1126dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner//===----------------------------------------------------------------------===// 1127331de23705a719514e37c211f327379688f81b0dChris Lattner// Parser Implementation code... 1128dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 1129dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 11309b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// basic_parser implementation 11319b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// 11329b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 11339b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// Return the width of the option tag for printing... 113434cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Chengsize_t basic_parser_impl::getOptionWidth(const Option &O) const { 113534cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng size_t Len = std::strlen(O.ArgStr); 11369b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner if (const char *ValName = getValueName()) 11379b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner Len += std::strlen(getValueStr(O, ValName))+3; 11389b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 11399b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner return Len + 6; 11409b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner} 11419b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 1142f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman// printOptionInfo - Print out information about this option. The 11439b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// to-be-maintained width is specified. 11449b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// 11459b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattnervoid basic_parser_impl::printOptionInfo(const Option &O, 114634cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng size_t GlobalWidth) const { 1147d9ea85ab01fb0f2929ed50223d3758dceea8bcbdChris Lattner outs() << " -" << O.ArgStr; 11489b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 11499b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner if (const char *ValName = getValueName()) 1150d9ea85ab01fb0f2929ed50223d3758dceea8bcbdChris Lattner outs() << "=<" << getValueStr(O, ValName) << '>'; 11519b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 11522e24e19cacacd4eea346b914124ffc3acadbd72eAlexander Kornienko printHelpStr(O.HelpStr, GlobalWidth, getOptionWidth(O)); 11539b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner} 11549b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 1155ce96902d88d473697f05c0465952dae374be564eAndrew Trickvoid basic_parser_impl::printOptionName(const Option &O, 1156ce96902d88d473697f05c0465952dae374be564eAndrew Trick size_t GlobalWidth) const { 1157ce96902d88d473697f05c0465952dae374be564eAndrew Trick outs() << " -" << O.ArgStr; 1158ce96902d88d473697f05c0465952dae374be564eAndrew Trick outs().indent(GlobalWidth-std::strlen(O.ArgStr)); 1159ce96902d88d473697f05c0465952dae374be564eAndrew Trick} 11609b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 11619b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 1162331de23705a719514e37c211f327379688f81b0dChris Lattner// parser<bool> implementation 1163331de23705a719514e37c211f327379688f81b0dChris Lattner// 116499c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattnerbool parser<bool>::parse(Option &O, StringRef ArgName, 1165a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner StringRef Arg, bool &Value) { 1166f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman if (Arg == "" || Arg == "true" || Arg == "TRUE" || Arg == "True" || 1167dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner Arg == "1") { 1168dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner Value = true; 1169a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner return false; 1170a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner } 1171eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 1172a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner if (Arg == "false" || Arg == "FALSE" || Arg == "False" || Arg == "0") { 1173dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner Value = false; 1174a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner return false; 1175dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 1176a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner return O.error("'" + Arg + 1177a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner "' is invalid value for boolean argument! Try 0 or 1"); 1178dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 1179dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 118081da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen// parser<boolOrDefault> implementation 118181da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen// 118299c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattnerbool parser<boolOrDefault>::parse(Option &O, StringRef ArgName, 1183a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner StringRef Arg, boolOrDefault &Value) { 118481da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen if (Arg == "" || Arg == "true" || Arg == "TRUE" || Arg == "True" || 118581da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen Arg == "1") { 118681da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen Value = BOU_TRUE; 1187a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner return false; 1188a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner } 1189a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner if (Arg == "false" || Arg == "FALSE" || Arg == "False" || Arg == "0") { 119081da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen Value = BOU_FALSE; 1191a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner return false; 119281da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen } 1193eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 1194a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner return O.error("'" + Arg + 1195a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner "' is invalid value for boolean argument! Try 0 or 1"); 119681da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen} 119781da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen 1198331de23705a719514e37c211f327379688f81b0dChris Lattner// parser<int> implementation 1199dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 120099c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattnerbool parser<int>::parse(Option &O, StringRef ArgName, 1201a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner StringRef Arg, int &Value) { 1202970e7dff5ba2bd8c5613c43e3b215ca940a378e9Chris Lattner if (Arg.getAsInteger(0, Value)) 1203e6864c1d355c4ec1156b956c1dd548682ad3e6b1Benjamin Kramer return O.error("'" + Arg + "' value invalid for integer argument!"); 1204331de23705a719514e37c211f327379688f81b0dChris Lattner return false; 1205dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 1206dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1207d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner// parser<unsigned> implementation 1208d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner// 120999c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattnerbool parser<unsigned>::parse(Option &O, StringRef ArgName, 1210a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner StringRef Arg, unsigned &Value) { 1211970e7dff5ba2bd8c5613c43e3b215ca940a378e9Chris Lattner 1212970e7dff5ba2bd8c5613c43e3b215ca940a378e9Chris Lattner if (Arg.getAsInteger(0, Value)) 1213e6864c1d355c4ec1156b956c1dd548682ad3e6b1Benjamin Kramer return O.error("'" + Arg + "' value invalid for uint argument!"); 1214d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner return false; 1215d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner} 1216d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner 1217b3514569d078065ced56562e01fd5a39e01543daBenjamin Kramer// parser<unsigned long long> implementation 1218b3514569d078065ced56562e01fd5a39e01543daBenjamin Kramer// 1219b3514569d078065ced56562e01fd5a39e01543daBenjamin Kramerbool parser<unsigned long long>::parse(Option &O, StringRef ArgName, 1220b3514569d078065ced56562e01fd5a39e01543daBenjamin Kramer StringRef Arg, unsigned long long &Value){ 1221b3514569d078065ced56562e01fd5a39e01543daBenjamin Kramer 1222b3514569d078065ced56562e01fd5a39e01543daBenjamin Kramer if (Arg.getAsInteger(0, Value)) 1223b3514569d078065ced56562e01fd5a39e01543daBenjamin Kramer return O.error("'" + Arg + "' value invalid for uint argument!"); 1224b3514569d078065ced56562e01fd5a39e01543daBenjamin Kramer return false; 1225b3514569d078065ced56562e01fd5a39e01543daBenjamin Kramer} 1226b3514569d078065ced56562e01fd5a39e01543daBenjamin Kramer 12279b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// parser<double>/parser<float> implementation 1228331de23705a719514e37c211f327379688f81b0dChris Lattner// 1229a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattnerstatic bool parseDouble(Option &O, StringRef Arg, double &Value) { 1230970e7dff5ba2bd8c5613c43e3b215ca940a378e9Chris Lattner SmallString<32> TmpStr(Arg.begin(), Arg.end()); 1231970e7dff5ba2bd8c5613c43e3b215ca940a378e9Chris Lattner const char *ArgStart = TmpStr.c_str(); 1232331de23705a719514e37c211f327379688f81b0dChris Lattner char *End; 1233331de23705a719514e37c211f327379688f81b0dChris Lattner Value = strtod(ArgStart, &End); 1234f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman if (*End != 0) 1235e6864c1d355c4ec1156b956c1dd548682ad3e6b1Benjamin Kramer return O.error("'" + Arg + "' value invalid for floating point argument!"); 1236dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return false; 1237dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 1238dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 123999c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattnerbool parser<double>::parse(Option &O, StringRef ArgName, 1240a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner StringRef Arg, double &Val) { 12419b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner return parseDouble(O, Arg, Val); 1242dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 1243dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 124499c5c7b7df4fe44d54cd680e7878c44789e6e057Chris Lattnerbool parser<float>::parse(Option &O, StringRef ArgName, 1245a460beb5cdc1cf05da3b22a39fd2b3107ea2e2feChris Lattner StringRef Arg, float &Val) { 12469b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner double dVal; 12479b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner if (parseDouble(O, Arg, dVal)) 12489b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner return true; 12499b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner Val = (float)dVal; 12509b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner return false; 1251dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 1252dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1253dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1254dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1255331de23705a719514e37c211f327379688f81b0dChris Lattner// generic_parser_base implementation 1256dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 1257dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1258aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner// findOption - Return the option number corresponding to the specified 1259aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner// argument string. If the option is not found, getNumOptions() is returned. 1260aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner// 1261aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattnerunsigned generic_parser_base::findOption(const char *Name) { 1262461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer unsigned e = getNumOptions(); 1263aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner 1264461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer for (unsigned i = 0; i != e; ++i) { 1265461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer if (strcmp(getOption(i), Name) == 0) 1266aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner return i; 1267461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer } 1268aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner return e; 1269aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner} 1270aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner 1271aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner 1272dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// Return the width of the option tag for printing... 127334cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Chengsize_t generic_parser_base::getOptionWidth(const Option &O) const { 1274331de23705a719514e37c211f327379688f81b0dChris Lattner if (O.hasArgStr()) { 127534cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng size_t Size = std::strlen(O.ArgStr)+6; 1276331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = getNumOptions(); i != e; ++i) 127734cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng Size = std::max(Size, std::strlen(getOption(i))+8); 1278331de23705a719514e37c211f327379688f81b0dChris Lattner return Size; 1279331de23705a719514e37c211f327379688f81b0dChris Lattner } else { 128034cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng size_t BaseSize = 0; 1281331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = getNumOptions(); i != e; ++i) 128234cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng BaseSize = std::max(BaseSize, std::strlen(getOption(i))+8); 1283331de23705a719514e37c211f327379688f81b0dChris Lattner return BaseSize; 1284331de23705a719514e37c211f327379688f81b0dChris Lattner } 1285dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 1286dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1287f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman// printOptionInfo - Print out information about this option. The 1288dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// to-be-maintained width is specified. 1289dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 1290331de23705a719514e37c211f327379688f81b0dChris Lattnervoid generic_parser_base::printOptionInfo(const Option &O, 129134cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng size_t GlobalWidth) const { 1292331de23705a719514e37c211f327379688f81b0dChris Lattner if (O.hasArgStr()) { 1293b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner outs() << " -" << O.ArgStr; 12942e24e19cacacd4eea346b914124ffc3acadbd72eAlexander Kornienko printHelpStr(O.HelpStr, GlobalWidth, std::strlen(O.ArgStr) + 6); 1295331de23705a719514e37c211f327379688f81b0dChris Lattner 1296331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = getNumOptions(); i != e; ++i) { 129734cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng size_t NumSpaces = GlobalWidth-strlen(getOption(i))-8; 1298b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner outs() << " =" << getOption(i); 1299b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner outs().indent(NumSpaces) << " - " << getDescription(i) << '\n'; 1300331de23705a719514e37c211f327379688f81b0dChris Lattner } 1301331de23705a719514e37c211f327379688f81b0dChris Lattner } else { 1302331de23705a719514e37c211f327379688f81b0dChris Lattner if (O.HelpStr[0]) 1303b168737a7479bc5c1cfdf62f8cc0f9ad652c2676Chris Lattner outs() << " " << O.HelpStr << '\n'; 1304331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = getNumOptions(); i != e; ++i) { 13052e24e19cacacd4eea346b914124ffc3acadbd72eAlexander Kornienko const char *Option = getOption(i); 13062e24e19cacacd4eea346b914124ffc3acadbd72eAlexander Kornienko outs() << " -" << Option; 13072e24e19cacacd4eea346b914124ffc3acadbd72eAlexander Kornienko printHelpStr(getDescription(i), GlobalWidth, std::strlen(Option) + 8); 1308331de23705a719514e37c211f327379688f81b0dChris Lattner } 1309dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 1310dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 1311dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1312ce96902d88d473697f05c0465952dae374be564eAndrew Trickstatic const size_t MaxOptWidth = 8; // arbitrary spacing for printOptionDiff 1313ce96902d88d473697f05c0465952dae374be564eAndrew Trick 1314ce96902d88d473697f05c0465952dae374be564eAndrew Trick// printGenericOptionDiff - Print the value of this option and it's default. 1315ce96902d88d473697f05c0465952dae374be564eAndrew Trick// 1316ce96902d88d473697f05c0465952dae374be564eAndrew Trick// "Generic" options have each value mapped to a name. 1317ce96902d88d473697f05c0465952dae374be564eAndrew Trickvoid generic_parser_base:: 1318ce96902d88d473697f05c0465952dae374be564eAndrew TrickprintGenericOptionDiff(const Option &O, const GenericOptionValue &Value, 1319ce96902d88d473697f05c0465952dae374be564eAndrew Trick const GenericOptionValue &Default, 1320ce96902d88d473697f05c0465952dae374be564eAndrew Trick size_t GlobalWidth) const { 1321ce96902d88d473697f05c0465952dae374be564eAndrew Trick outs() << " -" << O.ArgStr; 1322ce96902d88d473697f05c0465952dae374be564eAndrew Trick outs().indent(GlobalWidth-std::strlen(O.ArgStr)); 1323ce96902d88d473697f05c0465952dae374be564eAndrew Trick 1324ce96902d88d473697f05c0465952dae374be564eAndrew Trick unsigned NumOpts = getNumOptions(); 1325ce96902d88d473697f05c0465952dae374be564eAndrew Trick for (unsigned i = 0; i != NumOpts; ++i) { 1326ce96902d88d473697f05c0465952dae374be564eAndrew Trick if (Value.compare(getOptionValue(i))) 1327ce96902d88d473697f05c0465952dae374be564eAndrew Trick continue; 1328ce96902d88d473697f05c0465952dae374be564eAndrew Trick 1329ce96902d88d473697f05c0465952dae374be564eAndrew Trick outs() << "= " << getOption(i); 1330ce96902d88d473697f05c0465952dae374be564eAndrew Trick size_t L = std::strlen(getOption(i)); 1331ce96902d88d473697f05c0465952dae374be564eAndrew Trick size_t NumSpaces = MaxOptWidth > L ? MaxOptWidth - L : 0; 1332ce96902d88d473697f05c0465952dae374be564eAndrew Trick outs().indent(NumSpaces) << " (default: "; 1333ce96902d88d473697f05c0465952dae374be564eAndrew Trick for (unsigned j = 0; j != NumOpts; ++j) { 1334ce96902d88d473697f05c0465952dae374be564eAndrew Trick if (Default.compare(getOptionValue(j))) 1335ce96902d88d473697f05c0465952dae374be564eAndrew Trick continue; 1336ce96902d88d473697f05c0465952dae374be564eAndrew Trick outs() << getOption(j); 1337ce96902d88d473697f05c0465952dae374be564eAndrew Trick break; 1338ce96902d88d473697f05c0465952dae374be564eAndrew Trick } 1339ce96902d88d473697f05c0465952dae374be564eAndrew Trick outs() << ")\n"; 1340ce96902d88d473697f05c0465952dae374be564eAndrew Trick return; 1341ce96902d88d473697f05c0465952dae374be564eAndrew Trick } 1342ce96902d88d473697f05c0465952dae374be564eAndrew Trick outs() << "= *unknown option value*\n"; 1343ce96902d88d473697f05c0465952dae374be564eAndrew Trick} 1344ce96902d88d473697f05c0465952dae374be564eAndrew Trick 1345ce96902d88d473697f05c0465952dae374be564eAndrew Trick// printOptionDiff - Specializations for printing basic value types. 1346ce96902d88d473697f05c0465952dae374be564eAndrew Trick// 1347ce96902d88d473697f05c0465952dae374be564eAndrew Trick#define PRINT_OPT_DIFF(T) \ 1348ce96902d88d473697f05c0465952dae374be564eAndrew Trick void parser<T>:: \ 1349ce96902d88d473697f05c0465952dae374be564eAndrew Trick printOptionDiff(const Option &O, T V, OptionValue<T> D, \ 1350ce96902d88d473697f05c0465952dae374be564eAndrew Trick size_t GlobalWidth) const { \ 1351ce96902d88d473697f05c0465952dae374be564eAndrew Trick printOptionName(O, GlobalWidth); \ 1352ce96902d88d473697f05c0465952dae374be564eAndrew Trick std::string Str; \ 1353ce96902d88d473697f05c0465952dae374be564eAndrew Trick { \ 1354ce96902d88d473697f05c0465952dae374be564eAndrew Trick raw_string_ostream SS(Str); \ 1355ce96902d88d473697f05c0465952dae374be564eAndrew Trick SS << V; \ 1356ce96902d88d473697f05c0465952dae374be564eAndrew Trick } \ 1357ce96902d88d473697f05c0465952dae374be564eAndrew Trick outs() << "= " << Str; \ 1358ce96902d88d473697f05c0465952dae374be564eAndrew Trick size_t NumSpaces = MaxOptWidth > Str.size() ? MaxOptWidth - Str.size() : 0;\ 1359ce96902d88d473697f05c0465952dae374be564eAndrew Trick outs().indent(NumSpaces) << " (default: "; \ 1360ce96902d88d473697f05c0465952dae374be564eAndrew Trick if (D.hasValue()) \ 1361ce96902d88d473697f05c0465952dae374be564eAndrew Trick outs() << D.getValue(); \ 1362ce96902d88d473697f05c0465952dae374be564eAndrew Trick else \ 1363ce96902d88d473697f05c0465952dae374be564eAndrew Trick outs() << "*no default*"; \ 1364ce96902d88d473697f05c0465952dae374be564eAndrew Trick outs() << ")\n"; \ 1365ce96902d88d473697f05c0465952dae374be564eAndrew Trick } \ 1366ce96902d88d473697f05c0465952dae374be564eAndrew Trick 1367090771fa26086a72d814f7d47235deb22dac1b05Frits van BommelPRINT_OPT_DIFF(bool) 1368090771fa26086a72d814f7d47235deb22dac1b05Frits van BommelPRINT_OPT_DIFF(boolOrDefault) 1369090771fa26086a72d814f7d47235deb22dac1b05Frits van BommelPRINT_OPT_DIFF(int) 1370090771fa26086a72d814f7d47235deb22dac1b05Frits van BommelPRINT_OPT_DIFF(unsigned) 1371b3514569d078065ced56562e01fd5a39e01543daBenjamin KramerPRINT_OPT_DIFF(unsigned long long) 1372090771fa26086a72d814f7d47235deb22dac1b05Frits van BommelPRINT_OPT_DIFF(double) 1373090771fa26086a72d814f7d47235deb22dac1b05Frits van BommelPRINT_OPT_DIFF(float) 1374090771fa26086a72d814f7d47235deb22dac1b05Frits van BommelPRINT_OPT_DIFF(char) 1375ce96902d88d473697f05c0465952dae374be564eAndrew Trick 1376ce96902d88d473697f05c0465952dae374be564eAndrew Trickvoid parser<std::string>:: 1377ce96902d88d473697f05c0465952dae374be564eAndrew TrickprintOptionDiff(const Option &O, StringRef V, OptionValue<std::string> D, 1378ce96902d88d473697f05c0465952dae374be564eAndrew Trick size_t GlobalWidth) const { 1379ce96902d88d473697f05c0465952dae374be564eAndrew Trick printOptionName(O, GlobalWidth); 1380ce96902d88d473697f05c0465952dae374be564eAndrew Trick outs() << "= " << V; 1381ce96902d88d473697f05c0465952dae374be564eAndrew Trick size_t NumSpaces = MaxOptWidth > V.size() ? MaxOptWidth - V.size() : 0; 1382ce96902d88d473697f05c0465952dae374be564eAndrew Trick outs().indent(NumSpaces) << " (default: "; 1383ce96902d88d473697f05c0465952dae374be564eAndrew Trick if (D.hasValue()) 1384ce96902d88d473697f05c0465952dae374be564eAndrew Trick outs() << D.getValue(); 1385ce96902d88d473697f05c0465952dae374be564eAndrew Trick else 1386ce96902d88d473697f05c0465952dae374be564eAndrew Trick outs() << "*no default*"; 1387ce96902d88d473697f05c0465952dae374be564eAndrew Trick outs() << ")\n"; 1388ce96902d88d473697f05c0465952dae374be564eAndrew Trick} 1389ce96902d88d473697f05c0465952dae374be564eAndrew Trick 1390ce96902d88d473697f05c0465952dae374be564eAndrew Trick// Print a placeholder for options that don't yet support printOptionDiff(). 1391ce96902d88d473697f05c0465952dae374be564eAndrew Trickvoid basic_parser_impl:: 1392ce96902d88d473697f05c0465952dae374be564eAndrew TrickprintOptionNoValue(const Option &O, size_t GlobalWidth) const { 1393ce96902d88d473697f05c0465952dae374be564eAndrew Trick printOptionName(O, GlobalWidth); 1394ce96902d88d473697f05c0465952dae374be564eAndrew Trick outs() << "= *cannot print option value*\n"; 1395ce96902d88d473697f05c0465952dae374be564eAndrew Trick} 1396dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1397dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner//===----------------------------------------------------------------------===// 13987e7ae5ad692760aa8d97477f061a05b10948cf57Duncan Sands// -help and -help-hidden option implementation 1399dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 1400ad0846bd8be0a86e0277e1890fd280c9868f830aReid Spencer 14010fd48b1f1ce923828460fe097faa968b3ea28cb7Chris Lattnerstatic int OptNameCompare(const void *LHS, const void *RHS) { 14020fd48b1f1ce923828460fe097faa968b3ea28cb7Chris Lattner typedef std::pair<const char *, Option*> pair_ty; 1403eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 1404e840fef4c2cac5f85d17a1bffe3f0ac14724d115Duncan Sands return strcmp(((const pair_ty*)LHS)->first, ((const pair_ty*)RHS)->first); 14050fd48b1f1ce923828460fe097faa968b3ea28cb7Chris Lattner} 14060fd48b1f1ce923828460fe097faa968b3ea28cb7Chris Lattner 1407ce96902d88d473697f05c0465952dae374be564eAndrew Trick// Copy Options into a vector so we can sort them as we like. 1408ce96902d88d473697f05c0465952dae374be564eAndrew Trickstatic void 1409ce96902d88d473697f05c0465952dae374be564eAndrew TricksortOpts(StringMap<Option*> &OptMap, 1410ce96902d88d473697f05c0465952dae374be564eAndrew Trick SmallVectorImpl< std::pair<const char *, Option*> > &Opts, 1411ce96902d88d473697f05c0465952dae374be564eAndrew Trick bool ShowHidden) { 1412ce96902d88d473697f05c0465952dae374be564eAndrew Trick SmallPtrSet<Option*, 128> OptionSet; // Duplicate option detection. 1413ce96902d88d473697f05c0465952dae374be564eAndrew Trick 1414ce96902d88d473697f05c0465952dae374be564eAndrew Trick for (StringMap<Option*>::iterator I = OptMap.begin(), E = OptMap.end(); 1415ce96902d88d473697f05c0465952dae374be564eAndrew Trick I != E; ++I) { 1416ce96902d88d473697f05c0465952dae374be564eAndrew Trick // Ignore really-hidden options. 1417ce96902d88d473697f05c0465952dae374be564eAndrew Trick if (I->second->getOptionHiddenFlag() == ReallyHidden) 1418ce96902d88d473697f05c0465952dae374be564eAndrew Trick continue; 1419ce96902d88d473697f05c0465952dae374be564eAndrew Trick 1420ce96902d88d473697f05c0465952dae374be564eAndrew Trick // Unless showhidden is set, ignore hidden flags. 1421ce96902d88d473697f05c0465952dae374be564eAndrew Trick if (I->second->getOptionHiddenFlag() == Hidden && !ShowHidden) 1422ce96902d88d473697f05c0465952dae374be564eAndrew Trick continue; 1423ce96902d88d473697f05c0465952dae374be564eAndrew Trick 1424ce96902d88d473697f05c0465952dae374be564eAndrew Trick // If we've already seen this option, don't add it to the list again. 1425ce96902d88d473697f05c0465952dae374be564eAndrew Trick if (!OptionSet.insert(I->second)) 1426ce96902d88d473697f05c0465952dae374be564eAndrew Trick continue; 1427ce96902d88d473697f05c0465952dae374be564eAndrew Trick 1428ce96902d88d473697f05c0465952dae374be564eAndrew Trick Opts.push_back(std::pair<const char *, Option*>(I->getKey().data(), 1429ce96902d88d473697f05c0465952dae374be564eAndrew Trick I->second)); 1430ce96902d88d473697f05c0465952dae374be564eAndrew Trick } 1431ce96902d88d473697f05c0465952dae374be564eAndrew Trick 1432ce96902d88d473697f05c0465952dae374be564eAndrew Trick // Sort the options list alphabetically. 1433ce96902d88d473697f05c0465952dae374be564eAndrew Trick qsort(Opts.data(), Opts.size(), sizeof(Opts[0]), OptNameCompare); 1434ce96902d88d473697f05c0465952dae374be564eAndrew Trick} 1435ce96902d88d473697f05c0465952dae374be564eAndrew Trick 1436dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattnernamespace { 1437dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1438331de23705a719514e37c211f327379688f81b0dChris Lattnerclass HelpPrinter { 1439b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trickprotected: 1440dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner const bool ShowHidden; 1441b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick typedef SmallVector<std::pair<const char *, Option*>,128> StrOptionPairVector; 1442b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick // Print the options. Opts is assumed to be alphabetically sorted. 1443b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick virtual void printOptions(StrOptionPairVector &Opts, size_t MaxArgLen) { 1444b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick for (size_t i = 0, e = Opts.size(); i != e; ++i) 1445b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick Opts[i].second->printOptionInfo(MaxArgLen); 1446b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick } 1447dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1448331de23705a719514e37c211f327379688f81b0dChris Lattnerpublic: 1449ddde2082db45078dadb14c887aeb3cb63d1eace2Craig Topper explicit HelpPrinter(bool showHidden) : ShowHidden(showHidden) {} 1450b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick virtual ~HelpPrinter() {} 1451331de23705a719514e37c211f327379688f81b0dChris Lattner 1452b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick // Invoke the printer. 1453331de23705a719514e37c211f327379688f81b0dChris Lattner void operator=(bool Value) { 1454331de23705a719514e37c211f327379688f81b0dChris Lattner if (Value == false) return; 1455331de23705a719514e37c211f327379688f81b0dChris Lattner 14569878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner // Get all the options. 145749b301c40a0a1172dbdd7b55bbaee83eed57aab4Chris Lattner SmallVector<Option*, 4> PositionalOpts; 145849b301c40a0a1172dbdd7b55bbaee83eed57aab4Chris Lattner SmallVector<Option*, 4> SinkOpts; 1459461c87655b89fd44604bf705b68e7541d2b721a7Benjamin Kramer StringMap<Option*> OptMap; 1460d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov GetOptionInfo(PositionalOpts, SinkOpts, OptMap); 1461beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 1462b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick StrOptionPairVector Opts; 1463ce96902d88d473697f05c0465952dae374be564eAndrew Trick sortOpts(OptMap, Opts, ShowHidden); 1464dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1465dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner if (ProgramOverview) 1466d9ea85ab01fb0f2929ed50223d3758dceea8bcbdChris Lattner outs() << "OVERVIEW: " << ProgramOverview << "\n"; 1467dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1468d9ea85ab01fb0f2929ed50223d3758dceea8bcbdChris Lattner outs() << "USAGE: " << ProgramName << " [options]"; 1469331de23705a719514e37c211f327379688f81b0dChris Lattner 147090aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner // Print out the positional options. 1471dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Option *CAOpt = nullptr; // The cl::ConsumeAfter option, if it exists... 1472beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov if (!PositionalOpts.empty() && 14739878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner PositionalOpts[0]->getNumOccurrencesFlag() == ConsumeAfter) 14749878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner CAOpt = PositionalOpts[0]; 14759878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner 1476dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines for (size_t i = CAOpt != nullptr, e = PositionalOpts.size(); i != e; ++i) { 14779878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner if (PositionalOpts[i]->ArgStr[0]) 1478d9ea85ab01fb0f2929ed50223d3758dceea8bcbdChris Lattner outs() << " --" << PositionalOpts[i]->ArgStr; 1479d9ea85ab01fb0f2929ed50223d3758dceea8bcbdChris Lattner outs() << " " << PositionalOpts[i]->HelpStr; 14809cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner } 1481331de23705a719514e37c211f327379688f81b0dChris Lattner 1482331de23705a719514e37c211f327379688f81b0dChris Lattner // Print the consume after option info if it exists... 1483d9ea85ab01fb0f2929ed50223d3758dceea8bcbdChris Lattner if (CAOpt) outs() << " " << CAOpt->HelpStr; 1484331de23705a719514e37c211f327379688f81b0dChris Lattner 1485d9ea85ab01fb0f2929ed50223d3758dceea8bcbdChris Lattner outs() << "\n\n"; 1486dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1487dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Compute the maximum argument length... 1488ddde2082db45078dadb14c887aeb3cb63d1eace2Craig Topper size_t MaxArgLen = 0; 148934cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng for (size_t i = 0, e = Opts.size(); i != e; ++i) 14900fd48b1f1ce923828460fe097faa968b3ea28cb7Chris Lattner MaxArgLen = std::max(MaxArgLen, Opts[i].second->getOptionWidth()); 1491dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1492d9ea85ab01fb0f2929ed50223d3758dceea8bcbdChris Lattner outs() << "OPTIONS:\n"; 1493b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick printOptions(Opts, MaxArgLen); 1494dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1495c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner // Print any extra help the user has declared. 149690aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner for (std::vector<const char *>::iterator I = MoreHelp->begin(), 1497b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick E = MoreHelp->end(); 1498b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick I != E; ++I) 1499d9ea85ab01fb0f2929ed50223d3758dceea8bcbdChris Lattner outs() << *I; 150090aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner MoreHelp->clear(); 1501ad0846bd8be0a86e0277e1890fd280c9868f830aReid Spencer 15029bbba091396922093687d11a181e5886c42c5dfdReid Spencer // Halt the program since help information was printed 150336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines exit(0); 1504dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 1505331de23705a719514e37c211f327379688f81b0dChris Lattner}; 1506b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick 1507b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trickclass CategorizedHelpPrinter : public HelpPrinter { 1508b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trickpublic: 1509b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick explicit CategorizedHelpPrinter(bool showHidden) : HelpPrinter(showHidden) {} 1510b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick 1511b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick // Helper function for printOptions(). 1512b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick // It shall return true if A's name should be lexographically 1513b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick // ordered before B's name. It returns false otherwise. 1514b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick static bool OptionCategoryCompare(OptionCategory *A, OptionCategory *B) { 151536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return strcmp(A->getName(), B->getName()) < 0; 1516b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick } 1517b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick 1518b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick // Make sure we inherit our base class's operator=() 1519b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick using HelpPrinter::operator= ; 1520b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick 1521b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trickprotected: 152236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines void printOptions(StrOptionPairVector &Opts, size_t MaxArgLen) override { 1523b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick std::vector<OptionCategory *> SortedCategories; 1524b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick std::map<OptionCategory *, std::vector<Option *> > CategorizedOptions; 1525b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick 152636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // Collect registered option categories into vector in preparation for 1527b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick // sorting. 1528b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick for (OptionCatSet::const_iterator I = RegisteredOptionCategories->begin(), 1529b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick E = RegisteredOptionCategories->end(); 153036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines I != E; ++I) { 1531b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick SortedCategories.push_back(*I); 153236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } 1533b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick 1534b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick // Sort the different option categories alphabetically. 1535b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick assert(SortedCategories.size() > 0 && "No option categories registered!"); 1536b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick std::sort(SortedCategories.begin(), SortedCategories.end(), 1537b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick OptionCategoryCompare); 1538b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick 1539b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick // Create map to empty vectors. 1540b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick for (std::vector<OptionCategory *>::const_iterator 1541b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick I = SortedCategories.begin(), 1542b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick E = SortedCategories.end(); 1543b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick I != E; ++I) 1544b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick CategorizedOptions[*I] = std::vector<Option *>(); 1545b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick 1546b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick // Walk through pre-sorted options and assign into categories. 1547b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick // Because the options are already alphabetically sorted the 1548b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick // options within categories will also be alphabetically sorted. 1549b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick for (size_t I = 0, E = Opts.size(); I != E; ++I) { 1550b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick Option *Opt = Opts[I].second; 1551b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick assert(CategorizedOptions.count(Opt->Category) > 0 && 1552b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick "Option has an unregistered category"); 1553b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick CategorizedOptions[Opt->Category].push_back(Opt); 1554b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick } 1555b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick 1556b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick // Now do printing. 1557b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick for (std::vector<OptionCategory *>::const_iterator 1558b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick Category = SortedCategories.begin(), 1559b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick E = SortedCategories.end(); 1560b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick Category != E; ++Category) { 1561b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick // Hide empty categories for -help, but show for -help-hidden. 1562b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick bool IsEmptyCategory = CategorizedOptions[*Category].size() == 0; 1563b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick if (!ShowHidden && IsEmptyCategory) 1564b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick continue; 1565b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick 1566b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick // Print category information. 1567b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick outs() << "\n"; 1568b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick outs() << (*Category)->getName() << ":\n"; 1569b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick 1570b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick // Check if description is set. 1571dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if ((*Category)->getDescription() != nullptr) 1572b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick outs() << (*Category)->getDescription() << "\n\n"; 1573b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick else 1574b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick outs() << "\n"; 1575b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick 1576b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick // When using -help-hidden explicitly state if the category has no 1577b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick // options associated with it. 1578b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick if (IsEmptyCategory) { 1579b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick outs() << " This option category has no options.\n"; 1580b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick continue; 1581b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick } 1582b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick // Loop over the options in the category and print. 1583b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick for (std::vector<Option *>::const_iterator 1584b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick Opt = CategorizedOptions[*Category].begin(), 1585b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick E = CategorizedOptions[*Category].end(); 1586b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick Opt != E; ++Opt) 1587b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick (*Opt)->printOptionInfo(MaxArgLen); 1588b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick } 1589b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick } 1590b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick}; 1591b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick 1592b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick// This wraps the Uncategorizing and Categorizing printers and decides 1593b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick// at run time which should be invoked. 1594b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trickclass HelpPrinterWrapper { 1595b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trickprivate: 1596b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick HelpPrinter &UncategorizedPrinter; 1597b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick CategorizedHelpPrinter &CategorizedPrinter; 1598b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick 1599b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trickpublic: 1600b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick explicit HelpPrinterWrapper(HelpPrinter &UncategorizedPrinter, 1601b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick CategorizedHelpPrinter &CategorizedPrinter) : 1602b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick UncategorizedPrinter(UncategorizedPrinter), 1603b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick CategorizedPrinter(CategorizedPrinter) { } 1604b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick 1605b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick // Invoke the printer. 1606b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick void operator=(bool Value); 1607b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick}; 1608b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick 1609500d8bff2077ac327deec076fc8793e740b358c0Chris Lattner} // End anonymous namespace 1610dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1611b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick// Declare the four HelpPrinter instances that are used to print out help, or 1612b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick// help-hidden as an uncategorized list or in categories. 1613b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trickstatic HelpPrinter UncategorizedNormalPrinter(false); 1614b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trickstatic HelpPrinter UncategorizedHiddenPrinter(true); 1615b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trickstatic CategorizedHelpPrinter CategorizedNormalPrinter(false); 1616b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trickstatic CategorizedHelpPrinter CategorizedHiddenPrinter(true); 1617b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick 1618331de23705a719514e37c211f327379688f81b0dChris Lattner 1619b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick// Declare HelpPrinter wrappers that will decide whether or not to invoke 1620b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick// a categorizing help printer 1621b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trickstatic HelpPrinterWrapper WrappedNormalPrinter(UncategorizedNormalPrinter, 1622b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick CategorizedNormalPrinter); 1623b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trickstatic HelpPrinterWrapper WrappedHiddenPrinter(UncategorizedHiddenPrinter, 1624b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick CategorizedHiddenPrinter); 1625b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick 1626b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick// Define uncategorized help printers. 1627b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick// -help-list is hidden by default because if Option categories are being used 1628b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick// then -help behaves the same as -help-list. 1629500d8bff2077ac327deec076fc8793e740b358c0Chris Lattnerstatic cl::opt<HelpPrinter, true, parser<bool> > 1630b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew TrickHLOp("help-list", 1631b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick cl::desc("Display list of available options (-help-list-hidden for more)"), 1632b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick cl::location(UncategorizedNormalPrinter), cl::Hidden, cl::ValueDisallowed); 1633dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1634500d8bff2077ac327deec076fc8793e740b358c0Chris Lattnerstatic cl::opt<HelpPrinter, true, parser<bool> > 1635b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew TrickHLHOp("help-list-hidden", 1636b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick cl::desc("Display list of all available options"), 1637b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick cl::location(UncategorizedHiddenPrinter), cl::Hidden, cl::ValueDisallowed); 1638b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick 1639b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick// Define uncategorized/categorized help printers. These printers change their 1640b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick// behaviour at runtime depending on whether one or more Option categories have 1641b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick// been declared. 1642b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trickstatic cl::opt<HelpPrinterWrapper, true, parser<bool> > 1643b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew TrickHOp("help", cl::desc("Display available options (-help-hidden for more)"), 1644b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick cl::location(WrappedNormalPrinter), cl::ValueDisallowed); 1645b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick 1646b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trickstatic cl::opt<HelpPrinterWrapper, true, parser<bool> > 16474bf7afcc271138512c38ab2e4a348e2fe6164140Chris LattnerHHOp("help-hidden", cl::desc("Display all available options"), 1648b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick cl::location(WrappedHiddenPrinter), cl::Hidden, cl::ValueDisallowed); 1649b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick 1650b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick 1651dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1652ce96902d88d473697f05c0465952dae374be564eAndrew Trickstatic cl::opt<bool> 1653ce96902d88d473697f05c0465952dae374be564eAndrew TrickPrintOptions("print-options", 1654ce96902d88d473697f05c0465952dae374be564eAndrew Trick cl::desc("Print non-default options after command line parsing"), 1655ce96902d88d473697f05c0465952dae374be564eAndrew Trick cl::Hidden, cl::init(false)); 1656ce96902d88d473697f05c0465952dae374be564eAndrew Trick 1657ce96902d88d473697f05c0465952dae374be564eAndrew Trickstatic cl::opt<bool> 1658ce96902d88d473697f05c0465952dae374be564eAndrew TrickPrintAllOptions("print-all-options", 1659ce96902d88d473697f05c0465952dae374be564eAndrew Trick cl::desc("Print all option values after command line parsing"), 1660ce96902d88d473697f05c0465952dae374be564eAndrew Trick cl::Hidden, cl::init(false)); 1661ce96902d88d473697f05c0465952dae374be564eAndrew Trick 1662b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trickvoid HelpPrinterWrapper::operator=(bool Value) { 1663b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick if (Value == false) 1664b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick return; 1665b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick 1666b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick // Decide which printer to invoke. If more than one option category is 1667b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick // registered then it is useful to show the categorized help instead of 1668b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick // uncategorized help. 1669b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick if (RegisteredOptionCategories->size() > 1) { 1670b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick // unhide -help-list option so user can have uncategorized output if they 1671b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick // want it. 1672b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick HLOp.setHiddenFlag(NotHidden); 1673b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick 1674b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick CategorizedPrinter = true; // Invoke categorized printer 1675b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick } 1676b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick else 1677b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick UncategorizedPrinter = true; // Invoke uncategorized printer 1678b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick} 1679b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick 1680ce96902d88d473697f05c0465952dae374be564eAndrew Trick// Print the value of each option. 1681ce96902d88d473697f05c0465952dae374be564eAndrew Trickvoid cl::PrintOptionValues() { 1682ce96902d88d473697f05c0465952dae374be564eAndrew Trick if (!PrintOptions && !PrintAllOptions) return; 1683ce96902d88d473697f05c0465952dae374be564eAndrew Trick 1684ce96902d88d473697f05c0465952dae374be564eAndrew Trick // Get all the options. 1685ce96902d88d473697f05c0465952dae374be564eAndrew Trick SmallVector<Option*, 4> PositionalOpts; 1686ce96902d88d473697f05c0465952dae374be564eAndrew Trick SmallVector<Option*, 4> SinkOpts; 1687ce96902d88d473697f05c0465952dae374be564eAndrew Trick StringMap<Option*> OptMap; 1688ce96902d88d473697f05c0465952dae374be564eAndrew Trick GetOptionInfo(PositionalOpts, SinkOpts, OptMap); 1689ce96902d88d473697f05c0465952dae374be564eAndrew Trick 1690ce96902d88d473697f05c0465952dae374be564eAndrew Trick SmallVector<std::pair<const char *, Option*>, 128> Opts; 1691ce96902d88d473697f05c0465952dae374be564eAndrew Trick sortOpts(OptMap, Opts, /*ShowHidden*/true); 1692ce96902d88d473697f05c0465952dae374be564eAndrew Trick 1693ce96902d88d473697f05c0465952dae374be564eAndrew Trick // Compute the maximum argument length... 1694ce96902d88d473697f05c0465952dae374be564eAndrew Trick size_t MaxArgLen = 0; 1695ce96902d88d473697f05c0465952dae374be564eAndrew Trick for (size_t i = 0, e = Opts.size(); i != e; ++i) 1696ce96902d88d473697f05c0465952dae374be564eAndrew Trick MaxArgLen = std::max(MaxArgLen, Opts[i].second->getOptionWidth()); 1697ce96902d88d473697f05c0465952dae374be564eAndrew Trick 1698ce96902d88d473697f05c0465952dae374be564eAndrew Trick for (size_t i = 0, e = Opts.size(); i != e; ++i) 1699ce96902d88d473697f05c0465952dae374be564eAndrew Trick Opts[i].second->printOptionValue(MaxArgLen, PrintAllOptions); 1700ce96902d88d473697f05c0465952dae374be564eAndrew Trick} 1701ce96902d88d473697f05c0465952dae374be564eAndrew Trick 1702dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hinesstatic void (*OverrideVersionPrinter)() = nullptr; 1703515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer 1704dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hinesstatic std::vector<void (*)()>* ExtraVersionPrinters = nullptr; 17056d51d26a2479069f85a7676f664d6f998fc49a16Chandler Carruth 1706500d8bff2077ac327deec076fc8793e740b358c0Chris Lattnernamespace { 1707515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencerclass VersionPrinter { 1708515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencerpublic: 1709aed293dfba04b07a867491c11dfff4bf3eb6bdddDevang Patel void print() { 171049b301c40a0a1172dbdd7b55bbaee83eed57aab4Chris Lattner raw_ostream &OS = outs(); 1711c48d4dc8a9371690f73d2d05d2297f1e1a19c952Jim Grosbach OS << "LLVM (http://llvm.org/):\n" 171249b301c40a0a1172dbdd7b55bbaee83eed57aab4Chris Lattner << " " << PACKAGE_NAME << " version " << PACKAGE_VERSION; 17133fc2f4e83f3317f592c06e2ae7d9f1832210decbChris Lattner#ifdef LLVM_VERSION_INFO 1714cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines OS << " " << LLVM_VERSION_INFO; 17153fc2f4e83f3317f592c06e2ae7d9f1832210decbChris Lattner#endif 171649b301c40a0a1172dbdd7b55bbaee83eed57aab4Chris Lattner OS << "\n "; 17173fc2f4e83f3317f592c06e2ae7d9f1832210decbChris Lattner#ifndef __OPTIMIZE__ 171849b301c40a0a1172dbdd7b55bbaee83eed57aab4Chris Lattner OS << "DEBUG build"; 1719515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer#else 172049b301c40a0a1172dbdd7b55bbaee83eed57aab4Chris Lattner OS << "Optimized build"; 17213fc2f4e83f3317f592c06e2ae7d9f1832210decbChris Lattner#endif 17223fc2f4e83f3317f592c06e2ae7d9f1832210decbChris Lattner#ifndef NDEBUG 172349b301c40a0a1172dbdd7b55bbaee83eed57aab4Chris Lattner OS << " with assertions"; 1724515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer#endif 1725ba43e0785b7449501f019b9aa4433881dd05bb6aDaniel Dunbar std::string CPU = sys::getHostCPUName(); 1726110e7bb25cab03b6f7051a336233699f3e3ec1e3Benjamin Kramer if (CPU == "generic") CPU = "(unknown)"; 172749b301c40a0a1172dbdd7b55bbaee83eed57aab4Chris Lattner OS << ".\n" 1728dd464df687faf544e83684d0c0e4da87c05f8bfeDaniel Dunbar#if (ENABLE_TIMESTAMPS == 1) 172949b301c40a0a1172dbdd7b55bbaee83eed57aab4Chris Lattner << " Built " << __DATE__ << " (" << __TIME__ << ").\n" 1730dd464df687faf544e83684d0c0e4da87c05f8bfeDaniel Dunbar#endif 17310173864d8a87d9243d304fbf91b556e20b5a32fcSebastian Pop << " Default target: " << sys::getDefaultTargetTriple() << '\n' 17324039313b4c9796d194d90f88675ceb47a183696eChandler Carruth << " Host CPU: " << CPU << '\n'; 1733aed293dfba04b07a867491c11dfff4bf3eb6bdddDevang Patel } 1734aed293dfba04b07a867491c11dfff4bf3eb6bdddDevang Patel void operator=(bool OptionWasSpecified) { 1735043b8b5bb2a54133549fbf08e78345a5d086328aChris Lattner if (!OptionWasSpecified) return; 1736eeebecfcb4156319899c8dc63cd28c05f313538bMikhail Glushenkov 1737dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (OverrideVersionPrinter != nullptr) { 17386d51d26a2479069f85a7676f664d6f998fc49a16Chandler Carruth (*OverrideVersionPrinter)(); 173936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines exit(0); 1740515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer } 17416d51d26a2479069f85a7676f664d6f998fc49a16Chandler Carruth print(); 17426d51d26a2479069f85a7676f664d6f998fc49a16Chandler Carruth 17436d51d26a2479069f85a7676f664d6f998fc49a16Chandler Carruth // Iterate over any registered extra printers and call them to add further 17446d51d26a2479069f85a7676f664d6f998fc49a16Chandler Carruth // information. 1745dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (ExtraVersionPrinters != nullptr) { 17464039313b4c9796d194d90f88675ceb47a183696eChandler Carruth outs() << '\n'; 17476d51d26a2479069f85a7676f664d6f998fc49a16Chandler Carruth for (std::vector<void (*)()>::iterator I = ExtraVersionPrinters->begin(), 17486d51d26a2479069f85a7676f664d6f998fc49a16Chandler Carruth E = ExtraVersionPrinters->end(); 17496d51d26a2479069f85a7676f664d6f998fc49a16Chandler Carruth I != E; ++I) 17506d51d26a2479069f85a7676f664d6f998fc49a16Chandler Carruth (*I)(); 17516d51d26a2479069f85a7676f664d6f998fc49a16Chandler Carruth } 17526d51d26a2479069f85a7676f664d6f998fc49a16Chandler Carruth 175336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines exit(0); 1754515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer } 1755515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer}; 1756500d8bff2077ac327deec076fc8793e740b358c0Chris Lattner} // End anonymous namespace 1757515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer 1758515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer 175969105f33c190621a6b1ad61f925b1a9e6b0512afReid Spencer// Define the --version option that prints out the LLVM version for the tool 1760500d8bff2077ac327deec076fc8793e740b358c0Chris Lattnerstatic VersionPrinter VersionPrinterInstance; 1761500d8bff2077ac327deec076fc8793e740b358c0Chris Lattner 1762500d8bff2077ac327deec076fc8793e740b358c0Chris Lattnerstatic cl::opt<VersionPrinter, true, parser<bool> > 17634bf7afcc271138512c38ab2e4a348e2fe6164140Chris LattnerVersOp("version", cl::desc("Display the version of this program"), 176469105f33c190621a6b1ad61f925b1a9e6b0512afReid Spencer cl::location(VersionPrinterInstance), cl::ValueDisallowed); 176569105f33c190621a6b1ad61f925b1a9e6b0512afReid Spencer 17669bbba091396922093687d11a181e5886c42c5dfdReid Spencer// Utility function for printing the help message. 1767b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trickvoid cl::PrintHelpMessage(bool Hidden, bool Categorized) { 1768b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick // This looks weird, but it actually prints the help message. The Printers are 1769b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick // types of HelpPrinter and the help gets printed when its operator= is 1770b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick // invoked. That's because the "normal" usages of the help printer is to be 1771b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick // assigned true/false depending on whether -help or -help-hidden was given or 1772b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick // not. Since we're circumventing that we have to make it look like -help or 1773b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick // -help-hidden were given, so we assign true. 1774b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick 1775b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick if (!Hidden && !Categorized) 1776b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick UncategorizedNormalPrinter = true; 1777b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick else if (!Hidden && Categorized) 1778b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick CategorizedNormalPrinter = true; 1779b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick else if (Hidden && !Categorized) 1780b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick UncategorizedHiddenPrinter = true; 1781b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick else 1782b7ad33b7195cb99b0cbb1c5308324d328650ca45Andrew Trick CategorizedHiddenPrinter = true; 17839bbba091396922093687d11a181e5886c42c5dfdReid Spencer} 1784515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer 1785aed293dfba04b07a867491c11dfff4bf3eb6bdddDevang Patel/// Utility function for printing version number. 1786aed293dfba04b07a867491c11dfff4bf3eb6bdddDevang Patelvoid cl::PrintVersionMessage() { 1787aed293dfba04b07a867491c11dfff4bf3eb6bdddDevang Patel VersionPrinterInstance.print(); 1788aed293dfba04b07a867491c11dfff4bf3eb6bdddDevang Patel} 1789aed293dfba04b07a867491c11dfff4bf3eb6bdddDevang Patel 1790515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencervoid cl::SetVersionPrinter(void (*func)()) { 1791515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer OverrideVersionPrinter = func; 1792515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer} 17936d51d26a2479069f85a7676f664d6f998fc49a16Chandler Carruth 17946d51d26a2479069f85a7676f664d6f998fc49a16Chandler Carruthvoid cl::AddExtraVersionPrinter(void (*func)()) { 1795dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!ExtraVersionPrinters) 17966d51d26a2479069f85a7676f664d6f998fc49a16Chandler Carruth ExtraVersionPrinters = new std::vector<void (*)()>; 17976d51d26a2479069f85a7676f664d6f998fc49a16Chandler Carruth 17986d51d26a2479069f85a7676f664d6f998fc49a16Chandler Carruth ExtraVersionPrinters->push_back(func); 17996d51d26a2479069f85a7676f664d6f998fc49a16Chandler Carruth} 180061e01721978af4c2979c4b9153e56e72eb6389fbAndrew Trick 180161e01721978af4c2979c4b9153e56e72eb6389fbAndrew Trickvoid cl::getRegisteredOptions(StringMap<Option*> &Map) 180261e01721978af4c2979c4b9153e56e72eb6389fbAndrew Trick{ 180361e01721978af4c2979c4b9153e56e72eb6389fbAndrew Trick // Get all the options. 180461e01721978af4c2979c4b9153e56e72eb6389fbAndrew Trick SmallVector<Option*, 4> PositionalOpts; //NOT USED 180561e01721978af4c2979c4b9153e56e72eb6389fbAndrew Trick SmallVector<Option*, 4> SinkOpts; //NOT USED 180661e01721978af4c2979c4b9153e56e72eb6389fbAndrew Trick assert(Map.size() == 0 && "StringMap must be empty"); 180761e01721978af4c2979c4b9153e56e72eb6389fbAndrew Trick GetOptionInfo(PositionalOpts, SinkOpts, Map); 180861e01721978af4c2979c4b9153e56e72eb6389fbAndrew Trick return; 180961e01721978af4c2979c4b9153e56e72eb6389fbAndrew Trick} 1810