10b57cec5SDimitry Andric //===-- CommandLine.cpp - Command line parser implementation --------------===// 20b57cec5SDimitry Andric // 30b57cec5SDimitry Andric // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 40b57cec5SDimitry Andric // See https://llvm.org/LICENSE.txt for license information. 50b57cec5SDimitry Andric // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 60b57cec5SDimitry Andric // 70b57cec5SDimitry Andric //===----------------------------------------------------------------------===// 80b57cec5SDimitry Andric // 90b57cec5SDimitry Andric // This class implements a command line argument processor that is useful when 100b57cec5SDimitry Andric // creating a tool. It provides a simple, minimalistic interface that is easily 110b57cec5SDimitry Andric // extensible and supports nonlocal (library) command line options. 120b57cec5SDimitry Andric // 130b57cec5SDimitry Andric // Note that rather than trying to figure out what this code does, you could try 140b57cec5SDimitry Andric // reading the library documentation located in docs/CommandLine.html 150b57cec5SDimitry Andric // 160b57cec5SDimitry Andric //===----------------------------------------------------------------------===// 170b57cec5SDimitry Andric 180b57cec5SDimitry Andric #include "llvm/Support/CommandLine.h" 19fe6060f1SDimitry Andric 20fe6060f1SDimitry Andric #include "DebugOptions.h" 21fe6060f1SDimitry Andric 220b57cec5SDimitry Andric #include "llvm-c/Support.h" 230b57cec5SDimitry Andric #include "llvm/ADT/ArrayRef.h" 2404eeddc0SDimitry Andric #include "llvm/ADT/STLFunctionalExtras.h" 250b57cec5SDimitry Andric #include "llvm/ADT/SmallPtrSet.h" 260b57cec5SDimitry Andric #include "llvm/ADT/SmallString.h" 270b57cec5SDimitry Andric #include "llvm/ADT/StringExtras.h" 280b57cec5SDimitry Andric #include "llvm/ADT/StringMap.h" 29480093f4SDimitry Andric #include "llvm/ADT/StringRef.h" 300b57cec5SDimitry Andric #include "llvm/ADT/Twine.h" 310b57cec5SDimitry Andric #include "llvm/Config/config.h" 320b57cec5SDimitry Andric #include "llvm/Support/ConvertUTF.h" 330b57cec5SDimitry Andric #include "llvm/Support/Debug.h" 34480093f4SDimitry Andric #include "llvm/Support/Error.h" 350b57cec5SDimitry Andric #include "llvm/Support/ErrorHandling.h" 360b57cec5SDimitry Andric #include "llvm/Support/FileSystem.h" 370b57cec5SDimitry Andric #include "llvm/Support/ManagedStatic.h" 380b57cec5SDimitry Andric #include "llvm/Support/MemoryBuffer.h" 390b57cec5SDimitry Andric #include "llvm/Support/Path.h" 400b57cec5SDimitry Andric #include "llvm/Support/Process.h" 410b57cec5SDimitry Andric #include "llvm/Support/StringSaver.h" 42480093f4SDimitry Andric #include "llvm/Support/VirtualFileSystem.h" 430b57cec5SDimitry Andric #include "llvm/Support/raw_ostream.h" 440b57cec5SDimitry Andric #include <cstdlib> 45bdd1243dSDimitry Andric #include <optional> 46480093f4SDimitry Andric #include <string> 470b57cec5SDimitry Andric using namespace llvm; 480b57cec5SDimitry Andric using namespace cl; 490b57cec5SDimitry Andric 500b57cec5SDimitry Andric #define DEBUG_TYPE "commandline" 510b57cec5SDimitry Andric 520b57cec5SDimitry Andric //===----------------------------------------------------------------------===// 530b57cec5SDimitry Andric // Template instantiations and anchors. 540b57cec5SDimitry Andric // 550b57cec5SDimitry Andric namespace llvm { 560b57cec5SDimitry Andric namespace cl { 570b57cec5SDimitry Andric template class basic_parser<bool>; 580b57cec5SDimitry Andric template class basic_parser<boolOrDefault>; 590b57cec5SDimitry Andric template class basic_parser<int>; 60480093f4SDimitry Andric template class basic_parser<long>; 61480093f4SDimitry Andric template class basic_parser<long long>; 620b57cec5SDimitry Andric template class basic_parser<unsigned>; 630b57cec5SDimitry Andric template class basic_parser<unsigned long>; 640b57cec5SDimitry Andric template class basic_parser<unsigned long long>; 650b57cec5SDimitry Andric template class basic_parser<double>; 660b57cec5SDimitry Andric template class basic_parser<float>; 670b57cec5SDimitry Andric template class basic_parser<std::string>; 680b57cec5SDimitry Andric template class basic_parser<char>; 690b57cec5SDimitry Andric 700b57cec5SDimitry Andric template class opt<unsigned>; 710b57cec5SDimitry Andric template class opt<int>; 720b57cec5SDimitry Andric template class opt<std::string>; 730b57cec5SDimitry Andric template class opt<char>; 740b57cec5SDimitry Andric template class opt<bool>; 75fe6060f1SDimitry Andric } // namespace cl 76fe6060f1SDimitry Andric } // namespace llvm 770b57cec5SDimitry Andric 780b57cec5SDimitry Andric // Pin the vtables to this file. 790b57cec5SDimitry Andric void GenericOptionValue::anchor() {} 800b57cec5SDimitry Andric void OptionValue<boolOrDefault>::anchor() {} 810b57cec5SDimitry Andric void OptionValue<std::string>::anchor() {} 820b57cec5SDimitry Andric void Option::anchor() {} 830b57cec5SDimitry Andric void basic_parser_impl::anchor() {} 840b57cec5SDimitry Andric void parser<bool>::anchor() {} 850b57cec5SDimitry Andric void parser<boolOrDefault>::anchor() {} 860b57cec5SDimitry Andric void parser<int>::anchor() {} 87480093f4SDimitry Andric void parser<long>::anchor() {} 88480093f4SDimitry Andric void parser<long long>::anchor() {} 890b57cec5SDimitry Andric void parser<unsigned>::anchor() {} 900b57cec5SDimitry Andric void parser<unsigned long>::anchor() {} 910b57cec5SDimitry Andric void parser<unsigned long long>::anchor() {} 920b57cec5SDimitry Andric void parser<double>::anchor() {} 930b57cec5SDimitry Andric void parser<float>::anchor() {} 940b57cec5SDimitry Andric void parser<std::string>::anchor() {} 950b57cec5SDimitry Andric void parser<char>::anchor() {} 960b57cec5SDimitry Andric 970b57cec5SDimitry Andric //===----------------------------------------------------------------------===// 980b57cec5SDimitry Andric 99480093f4SDimitry Andric const static size_t DefaultPad = 2; 100480093f4SDimitry Andric 1010b57cec5SDimitry Andric static StringRef ArgPrefix = "-"; 1020b57cec5SDimitry Andric static StringRef ArgPrefixLong = "--"; 1030b57cec5SDimitry Andric static StringRef ArgHelpPrefix = " - "; 1040b57cec5SDimitry Andric 105480093f4SDimitry Andric static size_t argPlusPrefixesSize(StringRef ArgName, size_t Pad = DefaultPad) { 1060b57cec5SDimitry Andric size_t Len = ArgName.size(); 1070b57cec5SDimitry Andric if (Len == 1) 108480093f4SDimitry Andric return Len + Pad + ArgPrefix.size() + ArgHelpPrefix.size(); 109480093f4SDimitry Andric return Len + Pad + ArgPrefixLong.size() + ArgHelpPrefix.size(); 1100b57cec5SDimitry Andric } 1110b57cec5SDimitry Andric 112480093f4SDimitry Andric static SmallString<8> argPrefix(StringRef ArgName, size_t Pad = DefaultPad) { 113480093f4SDimitry Andric SmallString<8> Prefix; 114480093f4SDimitry Andric for (size_t I = 0; I < Pad; ++I) { 115480093f4SDimitry Andric Prefix.push_back(' '); 116480093f4SDimitry Andric } 117480093f4SDimitry Andric Prefix.append(ArgName.size() > 1 ? ArgPrefixLong : ArgPrefix); 118480093f4SDimitry Andric return Prefix; 1190b57cec5SDimitry Andric } 1200b57cec5SDimitry Andric 1210b57cec5SDimitry Andric // Option predicates... 1220b57cec5SDimitry Andric static inline bool isGrouping(const Option *O) { 1230b57cec5SDimitry Andric return O->getMiscFlags() & cl::Grouping; 1240b57cec5SDimitry Andric } 1250b57cec5SDimitry Andric static inline bool isPrefixedOrGrouping(const Option *O) { 1260b57cec5SDimitry Andric return isGrouping(O) || O->getFormattingFlag() == cl::Prefix || 1270b57cec5SDimitry Andric O->getFormattingFlag() == cl::AlwaysPrefix; 1280b57cec5SDimitry Andric } 1290b57cec5SDimitry Andric 1300b57cec5SDimitry Andric 1310b57cec5SDimitry Andric namespace { 1320b57cec5SDimitry Andric 1330b57cec5SDimitry Andric class PrintArg { 1340b57cec5SDimitry Andric StringRef ArgName; 135480093f4SDimitry Andric size_t Pad; 1360b57cec5SDimitry Andric public: 137480093f4SDimitry Andric PrintArg(StringRef ArgName, size_t Pad = DefaultPad) : ArgName(ArgName), Pad(Pad) {} 1380b57cec5SDimitry Andric friend raw_ostream &operator<<(raw_ostream &OS, const PrintArg &); 1390b57cec5SDimitry Andric }; 1400b57cec5SDimitry Andric 1410b57cec5SDimitry Andric raw_ostream &operator<<(raw_ostream &OS, const PrintArg& Arg) { 142480093f4SDimitry Andric OS << argPrefix(Arg.ArgName, Arg.Pad) << Arg.ArgName; 1430b57cec5SDimitry Andric return OS; 1440b57cec5SDimitry Andric } 1450b57cec5SDimitry Andric 1460b57cec5SDimitry Andric class CommandLineParser { 1470b57cec5SDimitry Andric public: 1480b57cec5SDimitry Andric // Globals for name and overview of program. Program name is not a string to 1490b57cec5SDimitry Andric // avoid static ctor/dtor issues. 1500b57cec5SDimitry Andric std::string ProgramName; 1510b57cec5SDimitry Andric StringRef ProgramOverview; 1520b57cec5SDimitry Andric 1530b57cec5SDimitry Andric // This collects additional help to be printed. 1540b57cec5SDimitry Andric std::vector<StringRef> MoreHelp; 1550b57cec5SDimitry Andric 1560b57cec5SDimitry Andric // This collects Options added with the cl::DefaultOption flag. Since they can 1570b57cec5SDimitry Andric // be overridden, they are not added to the appropriate SubCommands until 1580b57cec5SDimitry Andric // ParseCommandLineOptions actually runs. 1590b57cec5SDimitry Andric SmallVector<Option*, 4> DefaultOptions; 1600b57cec5SDimitry Andric 1610b57cec5SDimitry Andric // This collects the different option categories that have been registered. 1620b57cec5SDimitry Andric SmallPtrSet<OptionCategory *, 16> RegisteredOptionCategories; 1630b57cec5SDimitry Andric 1640b57cec5SDimitry Andric // This collects the different subcommands that have been registered. 1650b57cec5SDimitry Andric SmallPtrSet<SubCommand *, 4> RegisteredSubCommands; 1660b57cec5SDimitry Andric 16781ad6265SDimitry Andric CommandLineParser() { 168bdd1243dSDimitry Andric registerSubCommand(&SubCommand::getTopLevel()); 169bdd1243dSDimitry Andric registerSubCommand(&SubCommand::getAll()); 1700b57cec5SDimitry Andric } 1710b57cec5SDimitry Andric 1720b57cec5SDimitry Andric void ResetAllOptionOccurrences(); 1730b57cec5SDimitry Andric 1740b57cec5SDimitry Andric bool ParseCommandLineOptions(int argc, const char *const *argv, 1750b57cec5SDimitry Andric StringRef Overview, raw_ostream *Errs = nullptr, 1760b57cec5SDimitry Andric bool LongOptionsUseDoubleDash = false); 1770b57cec5SDimitry Andric 178cb14a3feSDimitry Andric void forEachSubCommand(Option &Opt, function_ref<void(SubCommand &)> Action) { 179cb14a3feSDimitry Andric if (Opt.Subs.empty()) { 180cb14a3feSDimitry Andric Action(SubCommand::getTopLevel()); 181cb14a3feSDimitry Andric return; 182cb14a3feSDimitry Andric } 183cb14a3feSDimitry Andric if (Opt.Subs.size() == 1 && *Opt.Subs.begin() == &SubCommand::getAll()) { 184cb14a3feSDimitry Andric for (auto *SC : RegisteredSubCommands) 185cb14a3feSDimitry Andric Action(*SC); 186cb14a3feSDimitry Andric return; 187cb14a3feSDimitry Andric } 188cb14a3feSDimitry Andric for (auto *SC : Opt.Subs) { 189cb14a3feSDimitry Andric assert(SC != &SubCommand::getAll() && 190cb14a3feSDimitry Andric "SubCommand::getAll() should not be used with other subcommands"); 191cb14a3feSDimitry Andric Action(*SC); 192cb14a3feSDimitry Andric } 193cb14a3feSDimitry Andric } 194cb14a3feSDimitry Andric 1950b57cec5SDimitry Andric void addLiteralOption(Option &Opt, SubCommand *SC, StringRef Name) { 1960b57cec5SDimitry Andric if (Opt.hasArgStr()) 1970b57cec5SDimitry Andric return; 1980b57cec5SDimitry Andric if (!SC->OptionsMap.insert(std::make_pair(Name, &Opt)).second) { 1990b57cec5SDimitry Andric errs() << ProgramName << ": CommandLine Error: Option '" << Name 2000b57cec5SDimitry Andric << "' registered more than once!\n"; 2010b57cec5SDimitry Andric report_fatal_error("inconsistency in registered CommandLine options"); 2020b57cec5SDimitry Andric } 2030b57cec5SDimitry Andric } 2040b57cec5SDimitry Andric 2050b57cec5SDimitry Andric void addLiteralOption(Option &Opt, StringRef Name) { 206cb14a3feSDimitry Andric forEachSubCommand( 207cb14a3feSDimitry Andric Opt, [&](SubCommand &SC) { addLiteralOption(Opt, &SC, Name); }); 2080b57cec5SDimitry Andric } 2090b57cec5SDimitry Andric 2100b57cec5SDimitry Andric void addOption(Option *O, SubCommand *SC) { 2110b57cec5SDimitry Andric bool HadErrors = false; 2120b57cec5SDimitry Andric if (O->hasArgStr()) { 2130b57cec5SDimitry Andric // If it's a DefaultOption, check to make sure it isn't already there. 21406c3fb27SDimitry Andric if (O->isDefaultOption() && SC->OptionsMap.contains(O->ArgStr)) 2150b57cec5SDimitry Andric return; 2160b57cec5SDimitry Andric 2170b57cec5SDimitry Andric // Add argument to the argument map! 2180b57cec5SDimitry Andric if (!SC->OptionsMap.insert(std::make_pair(O->ArgStr, O)).second) { 2190b57cec5SDimitry Andric errs() << ProgramName << ": CommandLine Error: Option '" << O->ArgStr 2200b57cec5SDimitry Andric << "' registered more than once!\n"; 2210b57cec5SDimitry Andric HadErrors = true; 2220b57cec5SDimitry Andric } 2230b57cec5SDimitry Andric } 2240b57cec5SDimitry Andric 2250b57cec5SDimitry Andric // Remember information about positional options. 2260b57cec5SDimitry Andric if (O->getFormattingFlag() == cl::Positional) 2270b57cec5SDimitry Andric SC->PositionalOpts.push_back(O); 2280b57cec5SDimitry Andric else if (O->getMiscFlags() & cl::Sink) // Remember sink options 2290b57cec5SDimitry Andric SC->SinkOpts.push_back(O); 2300b57cec5SDimitry Andric else if (O->getNumOccurrencesFlag() == cl::ConsumeAfter) { 2310b57cec5SDimitry Andric if (SC->ConsumeAfterOpt) { 2320b57cec5SDimitry Andric O->error("Cannot specify more than one option with cl::ConsumeAfter!"); 2330b57cec5SDimitry Andric HadErrors = true; 2340b57cec5SDimitry Andric } 2350b57cec5SDimitry Andric SC->ConsumeAfterOpt = O; 2360b57cec5SDimitry Andric } 2370b57cec5SDimitry Andric 2380b57cec5SDimitry Andric // Fail hard if there were errors. These are strictly unrecoverable and 2390b57cec5SDimitry Andric // indicate serious issues such as conflicting option names or an 2400b57cec5SDimitry Andric // incorrectly 2410b57cec5SDimitry Andric // linked LLVM distribution. 2420b57cec5SDimitry Andric if (HadErrors) 2430b57cec5SDimitry Andric report_fatal_error("inconsistency in registered CommandLine options"); 2440b57cec5SDimitry Andric } 2450b57cec5SDimitry Andric 2460b57cec5SDimitry Andric void addOption(Option *O, bool ProcessDefaultOption = false) { 2470b57cec5SDimitry Andric if (!ProcessDefaultOption && O->isDefaultOption()) { 2480b57cec5SDimitry Andric DefaultOptions.push_back(O); 2490b57cec5SDimitry Andric return; 2500b57cec5SDimitry Andric } 251cb14a3feSDimitry Andric forEachSubCommand(*O, [&](SubCommand &SC) { addOption(O, &SC); }); 2520b57cec5SDimitry Andric } 2530b57cec5SDimitry Andric 2540b57cec5SDimitry Andric void removeOption(Option *O, SubCommand *SC) { 2550b57cec5SDimitry Andric SmallVector<StringRef, 16> OptionNames; 2560b57cec5SDimitry Andric O->getExtraOptionNames(OptionNames); 2570b57cec5SDimitry Andric if (O->hasArgStr()) 2580b57cec5SDimitry Andric OptionNames.push_back(O->ArgStr); 2590b57cec5SDimitry Andric 2600b57cec5SDimitry Andric SubCommand &Sub = *SC; 2610b57cec5SDimitry Andric auto End = Sub.OptionsMap.end(); 2620b57cec5SDimitry Andric for (auto Name : OptionNames) { 2630b57cec5SDimitry Andric auto I = Sub.OptionsMap.find(Name); 2640b57cec5SDimitry Andric if (I != End && I->getValue() == O) 2650b57cec5SDimitry Andric Sub.OptionsMap.erase(I); 2660b57cec5SDimitry Andric } 2670b57cec5SDimitry Andric 2680b57cec5SDimitry Andric if (O->getFormattingFlag() == cl::Positional) 269fe6060f1SDimitry Andric for (auto *Opt = Sub.PositionalOpts.begin(); 2700b57cec5SDimitry Andric Opt != Sub.PositionalOpts.end(); ++Opt) { 2710b57cec5SDimitry Andric if (*Opt == O) { 2720b57cec5SDimitry Andric Sub.PositionalOpts.erase(Opt); 2730b57cec5SDimitry Andric break; 2740b57cec5SDimitry Andric } 2750b57cec5SDimitry Andric } 2760b57cec5SDimitry Andric else if (O->getMiscFlags() & cl::Sink) 277fe6060f1SDimitry Andric for (auto *Opt = Sub.SinkOpts.begin(); Opt != Sub.SinkOpts.end(); ++Opt) { 2780b57cec5SDimitry Andric if (*Opt == O) { 2790b57cec5SDimitry Andric Sub.SinkOpts.erase(Opt); 2800b57cec5SDimitry Andric break; 2810b57cec5SDimitry Andric } 2820b57cec5SDimitry Andric } 2830b57cec5SDimitry Andric else if (O == Sub.ConsumeAfterOpt) 2840b57cec5SDimitry Andric Sub.ConsumeAfterOpt = nullptr; 2850b57cec5SDimitry Andric } 2860b57cec5SDimitry Andric 2870b57cec5SDimitry Andric void removeOption(Option *O) { 288cb14a3feSDimitry Andric forEachSubCommand(*O, [&](SubCommand &SC) { removeOption(O, &SC); }); 2890b57cec5SDimitry Andric } 2900b57cec5SDimitry Andric 2910b57cec5SDimitry Andric bool hasOptions(const SubCommand &Sub) const { 2920b57cec5SDimitry Andric return (!Sub.OptionsMap.empty() || !Sub.PositionalOpts.empty() || 2930b57cec5SDimitry Andric nullptr != Sub.ConsumeAfterOpt); 2940b57cec5SDimitry Andric } 2950b57cec5SDimitry Andric 2960b57cec5SDimitry Andric bool hasOptions() const { 297480093f4SDimitry Andric for (const auto *S : RegisteredSubCommands) { 2980b57cec5SDimitry Andric if (hasOptions(*S)) 2990b57cec5SDimitry Andric return true; 3000b57cec5SDimitry Andric } 3010b57cec5SDimitry Andric return false; 3020b57cec5SDimitry Andric } 3030b57cec5SDimitry Andric 3045f757f3fSDimitry Andric bool hasNamedSubCommands() const { 3055f757f3fSDimitry Andric for (const auto *S : RegisteredSubCommands) 3065f757f3fSDimitry Andric if (!S->getName().empty()) 3075f757f3fSDimitry Andric return true; 3085f757f3fSDimitry Andric return false; 3095f757f3fSDimitry Andric } 3105f757f3fSDimitry Andric 3110b57cec5SDimitry Andric SubCommand *getActiveSubCommand() { return ActiveSubCommand; } 3120b57cec5SDimitry Andric 3130b57cec5SDimitry Andric void updateArgStr(Option *O, StringRef NewName, SubCommand *SC) { 3140b57cec5SDimitry Andric SubCommand &Sub = *SC; 3150b57cec5SDimitry Andric if (!Sub.OptionsMap.insert(std::make_pair(NewName, O)).second) { 3160b57cec5SDimitry Andric errs() << ProgramName << ": CommandLine Error: Option '" << O->ArgStr 3170b57cec5SDimitry Andric << "' registered more than once!\n"; 3180b57cec5SDimitry Andric report_fatal_error("inconsistency in registered CommandLine options"); 3190b57cec5SDimitry Andric } 3200b57cec5SDimitry Andric Sub.OptionsMap.erase(O->ArgStr); 3210b57cec5SDimitry Andric } 3220b57cec5SDimitry Andric 3230b57cec5SDimitry Andric void updateArgStr(Option *O, StringRef NewName) { 324cb14a3feSDimitry Andric forEachSubCommand(*O, 325cb14a3feSDimitry Andric [&](SubCommand &SC) { updateArgStr(O, NewName, &SC); }); 3260b57cec5SDimitry Andric } 3270b57cec5SDimitry Andric 3280b57cec5SDimitry Andric void printOptionValues(); 3290b57cec5SDimitry Andric 3300b57cec5SDimitry Andric void registerCategory(OptionCategory *cat) { 3310b57cec5SDimitry Andric assert(count_if(RegisteredOptionCategories, 3320b57cec5SDimitry Andric [cat](const OptionCategory *Category) { 3330b57cec5SDimitry Andric return cat->getName() == Category->getName(); 3340b57cec5SDimitry Andric }) == 0 && 3350b57cec5SDimitry Andric "Duplicate option categories"); 3360b57cec5SDimitry Andric 3370b57cec5SDimitry Andric RegisteredOptionCategories.insert(cat); 3380b57cec5SDimitry Andric } 3390b57cec5SDimitry Andric 3400b57cec5SDimitry Andric void registerSubCommand(SubCommand *sub) { 3410b57cec5SDimitry Andric assert(count_if(RegisteredSubCommands, 3420b57cec5SDimitry Andric [sub](const SubCommand *Sub) { 3430b57cec5SDimitry Andric return (!sub->getName().empty()) && 3440b57cec5SDimitry Andric (Sub->getName() == sub->getName()); 3450b57cec5SDimitry Andric }) == 0 && 3460b57cec5SDimitry Andric "Duplicate subcommands"); 3470b57cec5SDimitry Andric RegisteredSubCommands.insert(sub); 3480b57cec5SDimitry Andric 3490b57cec5SDimitry Andric // For all options that have been registered for all subcommands, add the 3500b57cec5SDimitry Andric // option to this subcommand now. 351bdd1243dSDimitry Andric if (sub != &SubCommand::getAll()) { 352bdd1243dSDimitry Andric for (auto &E : SubCommand::getAll().OptionsMap) { 3530b57cec5SDimitry Andric Option *O = E.second; 3540b57cec5SDimitry Andric if ((O->isPositional() || O->isSink() || O->isConsumeAfter()) || 3550b57cec5SDimitry Andric O->hasArgStr()) 3560b57cec5SDimitry Andric addOption(O, sub); 3570b57cec5SDimitry Andric else 3580b57cec5SDimitry Andric addLiteralOption(*O, sub, E.first()); 3590b57cec5SDimitry Andric } 3600b57cec5SDimitry Andric } 3610b57cec5SDimitry Andric } 3620b57cec5SDimitry Andric 3630b57cec5SDimitry Andric void unregisterSubCommand(SubCommand *sub) { 3640b57cec5SDimitry Andric RegisteredSubCommands.erase(sub); 3650b57cec5SDimitry Andric } 3660b57cec5SDimitry Andric 3670b57cec5SDimitry Andric iterator_range<typename SmallPtrSet<SubCommand *, 4>::iterator> 3680b57cec5SDimitry Andric getRegisteredSubcommands() { 3690b57cec5SDimitry Andric return make_range(RegisteredSubCommands.begin(), 3700b57cec5SDimitry Andric RegisteredSubCommands.end()); 3710b57cec5SDimitry Andric } 3720b57cec5SDimitry Andric 3730b57cec5SDimitry Andric void reset() { 3740b57cec5SDimitry Andric ActiveSubCommand = nullptr; 3750b57cec5SDimitry Andric ProgramName.clear(); 3760b57cec5SDimitry Andric ProgramOverview = StringRef(); 3770b57cec5SDimitry Andric 3780b57cec5SDimitry Andric MoreHelp.clear(); 3790b57cec5SDimitry Andric RegisteredOptionCategories.clear(); 3800b57cec5SDimitry Andric 3810b57cec5SDimitry Andric ResetAllOptionOccurrences(); 3820b57cec5SDimitry Andric RegisteredSubCommands.clear(); 3830b57cec5SDimitry Andric 384bdd1243dSDimitry Andric SubCommand::getTopLevel().reset(); 385bdd1243dSDimitry Andric SubCommand::getAll().reset(); 386bdd1243dSDimitry Andric registerSubCommand(&SubCommand::getTopLevel()); 387bdd1243dSDimitry Andric registerSubCommand(&SubCommand::getAll()); 3880b57cec5SDimitry Andric 3890b57cec5SDimitry Andric DefaultOptions.clear(); 3900b57cec5SDimitry Andric } 3910b57cec5SDimitry Andric 3920b57cec5SDimitry Andric private: 39381ad6265SDimitry Andric SubCommand *ActiveSubCommand = nullptr; 3940b57cec5SDimitry Andric 3950b57cec5SDimitry Andric Option *LookupOption(SubCommand &Sub, StringRef &Arg, StringRef &Value); 3960b57cec5SDimitry Andric Option *LookupLongOption(SubCommand &Sub, StringRef &Arg, StringRef &Value, 3970b57cec5SDimitry Andric bool LongOptionsUseDoubleDash, bool HaveDoubleDash) { 3980b57cec5SDimitry Andric Option *Opt = LookupOption(Sub, Arg, Value); 3990b57cec5SDimitry Andric if (Opt && LongOptionsUseDoubleDash && !HaveDoubleDash && !isGrouping(Opt)) 4000b57cec5SDimitry Andric return nullptr; 4010b57cec5SDimitry Andric return Opt; 4020b57cec5SDimitry Andric } 4035f757f3fSDimitry Andric SubCommand *LookupSubCommand(StringRef Name, std::string &NearestString); 4040b57cec5SDimitry Andric }; 4050b57cec5SDimitry Andric 4060b57cec5SDimitry Andric } // namespace 4070b57cec5SDimitry Andric 4080b57cec5SDimitry Andric static ManagedStatic<CommandLineParser> GlobalParser; 4090b57cec5SDimitry Andric 4100b57cec5SDimitry Andric void cl::AddLiteralOption(Option &O, StringRef Name) { 4110b57cec5SDimitry Andric GlobalParser->addLiteralOption(O, Name); 4120b57cec5SDimitry Andric } 4130b57cec5SDimitry Andric 4140b57cec5SDimitry Andric extrahelp::extrahelp(StringRef Help) : morehelp(Help) { 4150b57cec5SDimitry Andric GlobalParser->MoreHelp.push_back(Help); 4160b57cec5SDimitry Andric } 4170b57cec5SDimitry Andric 4180b57cec5SDimitry Andric void Option::addArgument() { 4190b57cec5SDimitry Andric GlobalParser->addOption(this); 4200b57cec5SDimitry Andric FullyInitialized = true; 4210b57cec5SDimitry Andric } 4220b57cec5SDimitry Andric 4230b57cec5SDimitry Andric void Option::removeArgument() { GlobalParser->removeOption(this); } 4240b57cec5SDimitry Andric 4250b57cec5SDimitry Andric void Option::setArgStr(StringRef S) { 4260b57cec5SDimitry Andric if (FullyInitialized) 4270b57cec5SDimitry Andric GlobalParser->updateArgStr(this, S); 4280b57cec5SDimitry Andric assert((S.empty() || S[0] != '-') && "Option can't start with '-"); 4290b57cec5SDimitry Andric ArgStr = S; 4300b57cec5SDimitry Andric if (ArgStr.size() == 1) 4310b57cec5SDimitry Andric setMiscFlag(Grouping); 4320b57cec5SDimitry Andric } 4330b57cec5SDimitry Andric 4340b57cec5SDimitry Andric void Option::addCategory(OptionCategory &C) { 4350b57cec5SDimitry Andric assert(!Categories.empty() && "Categories cannot be empty."); 4360b57cec5SDimitry Andric // Maintain backward compatibility by replacing the default GeneralCategory 4370b57cec5SDimitry Andric // if it's still set. Otherwise, just add the new one. The GeneralCategory 4380b57cec5SDimitry Andric // must be explicitly added if you want multiple categories that include it. 439fe6060f1SDimitry Andric if (&C != &getGeneralCategory() && Categories[0] == &getGeneralCategory()) 4400b57cec5SDimitry Andric Categories[0] = &C; 441e8d8bef9SDimitry Andric else if (!is_contained(Categories, &C)) 4420b57cec5SDimitry Andric Categories.push_back(&C); 4430b57cec5SDimitry Andric } 4440b57cec5SDimitry Andric 4450b57cec5SDimitry Andric void Option::reset() { 4460b57cec5SDimitry Andric NumOccurrences = 0; 4470b57cec5SDimitry Andric setDefault(); 4480b57cec5SDimitry Andric if (isDefaultOption()) 4490b57cec5SDimitry Andric removeArgument(); 4500b57cec5SDimitry Andric } 4510b57cec5SDimitry Andric 4520b57cec5SDimitry Andric void OptionCategory::registerCategory() { 4530b57cec5SDimitry Andric GlobalParser->registerCategory(this); 4540b57cec5SDimitry Andric } 4550b57cec5SDimitry Andric 4560b57cec5SDimitry Andric // A special subcommand representing no subcommand. It is particularly important 4570b57cec5SDimitry Andric // that this ManagedStatic uses constant initailization and not dynamic 4580b57cec5SDimitry Andric // initialization because it is referenced from cl::opt constructors, which run 4590b57cec5SDimitry Andric // dynamically in an arbitrary order. 4600b57cec5SDimitry Andric LLVM_REQUIRE_CONSTANT_INITIALIZATION 4610b57cec5SDimitry Andric ManagedStatic<SubCommand> llvm::cl::TopLevelSubCommand; 4620b57cec5SDimitry Andric 4630b57cec5SDimitry Andric // A special subcommand that can be used to put an option into all subcommands. 4640b57cec5SDimitry Andric ManagedStatic<SubCommand> llvm::cl::AllSubCommands; 4650b57cec5SDimitry Andric 466bdd1243dSDimitry Andric SubCommand &SubCommand::getTopLevel() { return *TopLevelSubCommand; } 467bdd1243dSDimitry Andric 468bdd1243dSDimitry Andric SubCommand &SubCommand::getAll() { return *AllSubCommands; } 469bdd1243dSDimitry Andric 4700b57cec5SDimitry Andric void SubCommand::registerSubCommand() { 4710b57cec5SDimitry Andric GlobalParser->registerSubCommand(this); 4720b57cec5SDimitry Andric } 4730b57cec5SDimitry Andric 4740b57cec5SDimitry Andric void SubCommand::unregisterSubCommand() { 4750b57cec5SDimitry Andric GlobalParser->unregisterSubCommand(this); 4760b57cec5SDimitry Andric } 4770b57cec5SDimitry Andric 4780b57cec5SDimitry Andric void SubCommand::reset() { 4790b57cec5SDimitry Andric PositionalOpts.clear(); 4800b57cec5SDimitry Andric SinkOpts.clear(); 4810b57cec5SDimitry Andric OptionsMap.clear(); 4820b57cec5SDimitry Andric 4830b57cec5SDimitry Andric ConsumeAfterOpt = nullptr; 4840b57cec5SDimitry Andric } 4850b57cec5SDimitry Andric 4860b57cec5SDimitry Andric SubCommand::operator bool() const { 4870b57cec5SDimitry Andric return (GlobalParser->getActiveSubCommand() == this); 4880b57cec5SDimitry Andric } 4890b57cec5SDimitry Andric 4900b57cec5SDimitry Andric //===----------------------------------------------------------------------===// 4910b57cec5SDimitry Andric // Basic, shared command line option processing machinery. 4920b57cec5SDimitry Andric // 4930b57cec5SDimitry Andric 4940b57cec5SDimitry Andric /// LookupOption - Lookup the option specified by the specified option on the 4950b57cec5SDimitry Andric /// command line. If there is a value specified (after an equal sign) return 4960b57cec5SDimitry Andric /// that as well. This assumes that leading dashes have already been stripped. 4970b57cec5SDimitry Andric Option *CommandLineParser::LookupOption(SubCommand &Sub, StringRef &Arg, 4980b57cec5SDimitry Andric StringRef &Value) { 4990b57cec5SDimitry Andric // Reject all dashes. 5000b57cec5SDimitry Andric if (Arg.empty()) 5010b57cec5SDimitry Andric return nullptr; 502bdd1243dSDimitry Andric assert(&Sub != &SubCommand::getAll()); 5030b57cec5SDimitry Andric 5040b57cec5SDimitry Andric size_t EqualPos = Arg.find('='); 5050b57cec5SDimitry Andric 5060b57cec5SDimitry Andric // If we have an equals sign, remember the value. 5070b57cec5SDimitry Andric if (EqualPos == StringRef::npos) { 5080b57cec5SDimitry Andric // Look up the option. 509e8d8bef9SDimitry Andric return Sub.OptionsMap.lookup(Arg); 5100b57cec5SDimitry Andric } 5110b57cec5SDimitry Andric 5120b57cec5SDimitry Andric // If the argument before the = is a valid option name and the option allows 5130b57cec5SDimitry Andric // non-prefix form (ie is not AlwaysPrefix), we match. If not, signal match 5140b57cec5SDimitry Andric // failure by returning nullptr. 5150b57cec5SDimitry Andric auto I = Sub.OptionsMap.find(Arg.substr(0, EqualPos)); 5160b57cec5SDimitry Andric if (I == Sub.OptionsMap.end()) 5170b57cec5SDimitry Andric return nullptr; 5180b57cec5SDimitry Andric 519fe6060f1SDimitry Andric auto *O = I->second; 5200b57cec5SDimitry Andric if (O->getFormattingFlag() == cl::AlwaysPrefix) 5210b57cec5SDimitry Andric return nullptr; 5220b57cec5SDimitry Andric 5230b57cec5SDimitry Andric Value = Arg.substr(EqualPos + 1); 5240b57cec5SDimitry Andric Arg = Arg.substr(0, EqualPos); 5250b57cec5SDimitry Andric return I->second; 5260b57cec5SDimitry Andric } 5270b57cec5SDimitry Andric 5285f757f3fSDimitry Andric SubCommand *CommandLineParser::LookupSubCommand(StringRef Name, 5295f757f3fSDimitry Andric std::string &NearestString) { 5300b57cec5SDimitry Andric if (Name.empty()) 531bdd1243dSDimitry Andric return &SubCommand::getTopLevel(); 5325f757f3fSDimitry Andric // Find a subcommand with the edit distance == 1. 5335f757f3fSDimitry Andric SubCommand *NearestMatch = nullptr; 534fe6060f1SDimitry Andric for (auto *S : RegisteredSubCommands) { 535bdd1243dSDimitry Andric if (S == &SubCommand::getAll()) 5360b57cec5SDimitry Andric continue; 5370b57cec5SDimitry Andric if (S->getName().empty()) 5380b57cec5SDimitry Andric continue; 5390b57cec5SDimitry Andric 5400b57cec5SDimitry Andric if (StringRef(S->getName()) == StringRef(Name)) 5410b57cec5SDimitry Andric return S; 5425f757f3fSDimitry Andric 5435f757f3fSDimitry Andric if (!NearestMatch && S->getName().edit_distance(Name) < 2) 5445f757f3fSDimitry Andric NearestMatch = S; 5450b57cec5SDimitry Andric } 5465f757f3fSDimitry Andric 5475f757f3fSDimitry Andric if (NearestMatch) 5485f757f3fSDimitry Andric NearestString = NearestMatch->getName(); 5495f757f3fSDimitry Andric 550bdd1243dSDimitry Andric return &SubCommand::getTopLevel(); 5510b57cec5SDimitry Andric } 5520b57cec5SDimitry Andric 5530b57cec5SDimitry Andric /// LookupNearestOption - Lookup the closest match to the option specified by 5540b57cec5SDimitry Andric /// the specified option on the command line. If there is a value specified 5550b57cec5SDimitry Andric /// (after an equal sign) return that as well. This assumes that leading dashes 5560b57cec5SDimitry Andric /// have already been stripped. 5570b57cec5SDimitry Andric static Option *LookupNearestOption(StringRef Arg, 5580b57cec5SDimitry Andric const StringMap<Option *> &OptionsMap, 5590b57cec5SDimitry Andric std::string &NearestString) { 5600b57cec5SDimitry Andric // Reject all dashes. 5610b57cec5SDimitry Andric if (Arg.empty()) 5620b57cec5SDimitry Andric return nullptr; 5630b57cec5SDimitry Andric 5640b57cec5SDimitry Andric // Split on any equal sign. 5650b57cec5SDimitry Andric std::pair<StringRef, StringRef> SplitArg = Arg.split('='); 5660b57cec5SDimitry Andric StringRef &LHS = SplitArg.first; // LHS == Arg when no '=' is present. 5670b57cec5SDimitry Andric StringRef &RHS = SplitArg.second; 5680b57cec5SDimitry Andric 5690b57cec5SDimitry Andric // Find the closest match. 5700b57cec5SDimitry Andric Option *Best = nullptr; 5710b57cec5SDimitry Andric unsigned BestDistance = 0; 5720b57cec5SDimitry Andric for (StringMap<Option *>::const_iterator it = OptionsMap.begin(), 5730b57cec5SDimitry Andric ie = OptionsMap.end(); 5740b57cec5SDimitry Andric it != ie; ++it) { 5750b57cec5SDimitry Andric Option *O = it->second; 5765ffd83dbSDimitry Andric // Do not suggest really hidden options (not shown in any help). 5775ffd83dbSDimitry Andric if (O->getOptionHiddenFlag() == ReallyHidden) 5785ffd83dbSDimitry Andric continue; 5795ffd83dbSDimitry Andric 5800b57cec5SDimitry Andric SmallVector<StringRef, 16> OptionNames; 5810b57cec5SDimitry Andric O->getExtraOptionNames(OptionNames); 5820b57cec5SDimitry Andric if (O->hasArgStr()) 5830b57cec5SDimitry Andric OptionNames.push_back(O->ArgStr); 5840b57cec5SDimitry Andric 5850b57cec5SDimitry Andric bool PermitValue = O->getValueExpectedFlag() != cl::ValueDisallowed; 5860b57cec5SDimitry Andric StringRef Flag = PermitValue ? LHS : Arg; 587fe6060f1SDimitry Andric for (const auto &Name : OptionNames) { 5880b57cec5SDimitry Andric unsigned Distance = StringRef(Name).edit_distance( 5890b57cec5SDimitry Andric Flag, /*AllowReplacements=*/true, /*MaxEditDistance=*/BestDistance); 5900b57cec5SDimitry Andric if (!Best || Distance < BestDistance) { 5910b57cec5SDimitry Andric Best = O; 5920b57cec5SDimitry Andric BestDistance = Distance; 5930b57cec5SDimitry Andric if (RHS.empty() || !PermitValue) 5945ffd83dbSDimitry Andric NearestString = std::string(Name); 5950b57cec5SDimitry Andric else 5960b57cec5SDimitry Andric NearestString = (Twine(Name) + "=" + RHS).str(); 5970b57cec5SDimitry Andric } 5980b57cec5SDimitry Andric } 5990b57cec5SDimitry Andric } 6000b57cec5SDimitry Andric 6010b57cec5SDimitry Andric return Best; 6020b57cec5SDimitry Andric } 6030b57cec5SDimitry Andric 6040b57cec5SDimitry Andric /// CommaSeparateAndAddOccurrence - A wrapper around Handler->addOccurrence() 6050b57cec5SDimitry Andric /// that does special handling of cl::CommaSeparated options. 6060b57cec5SDimitry Andric static bool CommaSeparateAndAddOccurrence(Option *Handler, unsigned pos, 6070b57cec5SDimitry Andric StringRef ArgName, StringRef Value, 6080b57cec5SDimitry Andric bool MultiArg = false) { 6090b57cec5SDimitry Andric // Check to see if this option accepts a comma separated list of values. If 6100b57cec5SDimitry Andric // it does, we have to split up the value into multiple values. 6110b57cec5SDimitry Andric if (Handler->getMiscFlags() & CommaSeparated) { 6120b57cec5SDimitry Andric StringRef Val(Value); 6130b57cec5SDimitry Andric StringRef::size_type Pos = Val.find(','); 6140b57cec5SDimitry Andric 6150b57cec5SDimitry Andric while (Pos != StringRef::npos) { 6160b57cec5SDimitry Andric // Process the portion before the comma. 6170b57cec5SDimitry Andric if (Handler->addOccurrence(pos, ArgName, Val.substr(0, Pos), MultiArg)) 6180b57cec5SDimitry Andric return true; 6190b57cec5SDimitry Andric // Erase the portion before the comma, AND the comma. 6200b57cec5SDimitry Andric Val = Val.substr(Pos + 1); 6210b57cec5SDimitry Andric // Check for another comma. 6220b57cec5SDimitry Andric Pos = Val.find(','); 6230b57cec5SDimitry Andric } 6240b57cec5SDimitry Andric 6250b57cec5SDimitry Andric Value = Val; 6260b57cec5SDimitry Andric } 6270b57cec5SDimitry Andric 6280b57cec5SDimitry Andric return Handler->addOccurrence(pos, ArgName, Value, MultiArg); 6290b57cec5SDimitry Andric } 6300b57cec5SDimitry Andric 6310b57cec5SDimitry Andric /// ProvideOption - For Value, this differentiates between an empty value ("") 6320b57cec5SDimitry Andric /// and a null value (StringRef()). The later is accepted for arguments that 6330b57cec5SDimitry Andric /// don't allow a value (-foo) the former is rejected (-foo=). 6340b57cec5SDimitry Andric static inline bool ProvideOption(Option *Handler, StringRef ArgName, 6350b57cec5SDimitry Andric StringRef Value, int argc, 6360b57cec5SDimitry Andric const char *const *argv, int &i) { 6370b57cec5SDimitry Andric // Is this a multi-argument option? 6380b57cec5SDimitry Andric unsigned NumAdditionalVals = Handler->getNumAdditionalVals(); 6390b57cec5SDimitry Andric 6400b57cec5SDimitry Andric // Enforce value requirements 6410b57cec5SDimitry Andric switch (Handler->getValueExpectedFlag()) { 6420b57cec5SDimitry Andric case ValueRequired: 6430b57cec5SDimitry Andric if (!Value.data()) { // No value specified? 6440b57cec5SDimitry Andric // If no other argument or the option only supports prefix form, we 6450b57cec5SDimitry Andric // cannot look at the next argument. 6460b57cec5SDimitry Andric if (i + 1 >= argc || Handler->getFormattingFlag() == cl::AlwaysPrefix) 6470b57cec5SDimitry Andric return Handler->error("requires a value!"); 6480b57cec5SDimitry Andric // Steal the next argument, like for '-o filename' 6490b57cec5SDimitry Andric assert(argv && "null check"); 6500b57cec5SDimitry Andric Value = StringRef(argv[++i]); 6510b57cec5SDimitry Andric } 6520b57cec5SDimitry Andric break; 6530b57cec5SDimitry Andric case ValueDisallowed: 6540b57cec5SDimitry Andric if (NumAdditionalVals > 0) 6550b57cec5SDimitry Andric return Handler->error("multi-valued option specified" 6560b57cec5SDimitry Andric " with ValueDisallowed modifier!"); 6570b57cec5SDimitry Andric 6580b57cec5SDimitry Andric if (Value.data()) 6590b57cec5SDimitry Andric return Handler->error("does not allow a value! '" + Twine(Value) + 6600b57cec5SDimitry Andric "' specified."); 6610b57cec5SDimitry Andric break; 6620b57cec5SDimitry Andric case ValueOptional: 6630b57cec5SDimitry Andric break; 6640b57cec5SDimitry Andric } 6650b57cec5SDimitry Andric 6660b57cec5SDimitry Andric // If this isn't a multi-arg option, just run the handler. 6670b57cec5SDimitry Andric if (NumAdditionalVals == 0) 6680b57cec5SDimitry Andric return CommaSeparateAndAddOccurrence(Handler, i, ArgName, Value); 6690b57cec5SDimitry Andric 6700b57cec5SDimitry Andric // If it is, run the handle several times. 6710b57cec5SDimitry Andric bool MultiArg = false; 6720b57cec5SDimitry Andric 6730b57cec5SDimitry Andric if (Value.data()) { 6740b57cec5SDimitry Andric if (CommaSeparateAndAddOccurrence(Handler, i, ArgName, Value, MultiArg)) 6750b57cec5SDimitry Andric return true; 6760b57cec5SDimitry Andric --NumAdditionalVals; 6770b57cec5SDimitry Andric MultiArg = true; 6780b57cec5SDimitry Andric } 6790b57cec5SDimitry Andric 6800b57cec5SDimitry Andric while (NumAdditionalVals > 0) { 6810b57cec5SDimitry Andric if (i + 1 >= argc) 6820b57cec5SDimitry Andric return Handler->error("not enough values!"); 6830b57cec5SDimitry Andric assert(argv && "null check"); 6840b57cec5SDimitry Andric Value = StringRef(argv[++i]); 6850b57cec5SDimitry Andric 6860b57cec5SDimitry Andric if (CommaSeparateAndAddOccurrence(Handler, i, ArgName, Value, MultiArg)) 6870b57cec5SDimitry Andric return true; 6880b57cec5SDimitry Andric MultiArg = true; 6890b57cec5SDimitry Andric --NumAdditionalVals; 6900b57cec5SDimitry Andric } 6910b57cec5SDimitry Andric return false; 6920b57cec5SDimitry Andric } 6930b57cec5SDimitry Andric 6948bcb0991SDimitry Andric bool llvm::cl::ProvidePositionalOption(Option *Handler, StringRef Arg, int i) { 6950b57cec5SDimitry Andric int Dummy = i; 6960b57cec5SDimitry Andric return ProvideOption(Handler, Handler->ArgStr, Arg, 0, nullptr, Dummy); 6970b57cec5SDimitry Andric } 6980b57cec5SDimitry Andric 6990b57cec5SDimitry Andric // getOptionPred - Check to see if there are any options that satisfy the 7000b57cec5SDimitry Andric // specified predicate with names that are the prefixes in Name. This is 7010b57cec5SDimitry Andric // checked by progressively stripping characters off of the name, checking to 7020b57cec5SDimitry Andric // see if there options that satisfy the predicate. If we find one, return it, 7030b57cec5SDimitry Andric // otherwise return null. 7040b57cec5SDimitry Andric // 7050b57cec5SDimitry Andric static Option *getOptionPred(StringRef Name, size_t &Length, 7060b57cec5SDimitry Andric bool (*Pred)(const Option *), 7070b57cec5SDimitry Andric const StringMap<Option *> &OptionsMap) { 7080b57cec5SDimitry Andric StringMap<Option *>::const_iterator OMI = OptionsMap.find(Name); 7090b57cec5SDimitry Andric if (OMI != OptionsMap.end() && !Pred(OMI->getValue())) 7100b57cec5SDimitry Andric OMI = OptionsMap.end(); 7110b57cec5SDimitry Andric 7120b57cec5SDimitry Andric // Loop while we haven't found an option and Name still has at least two 7130b57cec5SDimitry Andric // characters in it (so that the next iteration will not be the empty 7140b57cec5SDimitry Andric // string. 7150b57cec5SDimitry Andric while (OMI == OptionsMap.end() && Name.size() > 1) { 7160b57cec5SDimitry Andric Name = Name.substr(0, Name.size() - 1); // Chop off the last character. 7170b57cec5SDimitry Andric OMI = OptionsMap.find(Name); 7180b57cec5SDimitry Andric if (OMI != OptionsMap.end() && !Pred(OMI->getValue())) 7190b57cec5SDimitry Andric OMI = OptionsMap.end(); 7200b57cec5SDimitry Andric } 7210b57cec5SDimitry Andric 7220b57cec5SDimitry Andric if (OMI != OptionsMap.end() && Pred(OMI->second)) { 7230b57cec5SDimitry Andric Length = Name.size(); 7240b57cec5SDimitry Andric return OMI->second; // Found one! 7250b57cec5SDimitry Andric } 7260b57cec5SDimitry Andric return nullptr; // No option found! 7270b57cec5SDimitry Andric } 7280b57cec5SDimitry Andric 7290b57cec5SDimitry Andric /// HandlePrefixedOrGroupedOption - The specified argument string (which started 7300b57cec5SDimitry Andric /// with at least one '-') does not fully match an available option. Check to 7310b57cec5SDimitry Andric /// see if this is a prefix or grouped option. If so, split arg into output an 7320b57cec5SDimitry Andric /// Arg/Value pair and return the Option to parse it with. 7330b57cec5SDimitry Andric static Option * 7340b57cec5SDimitry Andric HandlePrefixedOrGroupedOption(StringRef &Arg, StringRef &Value, 7350b57cec5SDimitry Andric bool &ErrorParsing, 7360b57cec5SDimitry Andric const StringMap<Option *> &OptionsMap) { 7370b57cec5SDimitry Andric if (Arg.size() == 1) 7380b57cec5SDimitry Andric return nullptr; 7390b57cec5SDimitry Andric 7400b57cec5SDimitry Andric // Do the lookup! 7410b57cec5SDimitry Andric size_t Length = 0; 7420b57cec5SDimitry Andric Option *PGOpt = getOptionPred(Arg, Length, isPrefixedOrGrouping, OptionsMap); 7430b57cec5SDimitry Andric if (!PGOpt) 7440b57cec5SDimitry Andric return nullptr; 7450b57cec5SDimitry Andric 7460b57cec5SDimitry Andric do { 7470b57cec5SDimitry Andric StringRef MaybeValue = 7480b57cec5SDimitry Andric (Length < Arg.size()) ? Arg.substr(Length) : StringRef(); 7490b57cec5SDimitry Andric Arg = Arg.substr(0, Length); 7500b57cec5SDimitry Andric assert(OptionsMap.count(Arg) && OptionsMap.find(Arg)->second == PGOpt); 7510b57cec5SDimitry Andric 7520b57cec5SDimitry Andric // cl::Prefix options do not preserve '=' when used separately. 7530b57cec5SDimitry Andric // The behavior for them with grouped options should be the same. 7540b57cec5SDimitry Andric if (MaybeValue.empty() || PGOpt->getFormattingFlag() == cl::AlwaysPrefix || 7550b57cec5SDimitry Andric (PGOpt->getFormattingFlag() == cl::Prefix && MaybeValue[0] != '=')) { 7560b57cec5SDimitry Andric Value = MaybeValue; 7570b57cec5SDimitry Andric return PGOpt; 7580b57cec5SDimitry Andric } 7590b57cec5SDimitry Andric 7600b57cec5SDimitry Andric if (MaybeValue[0] == '=') { 7610b57cec5SDimitry Andric Value = MaybeValue.substr(1); 7620b57cec5SDimitry Andric return PGOpt; 7630b57cec5SDimitry Andric } 7640b57cec5SDimitry Andric 7650b57cec5SDimitry Andric // This must be a grouped option. 7660b57cec5SDimitry Andric assert(isGrouping(PGOpt) && "Broken getOptionPred!"); 7670b57cec5SDimitry Andric 7680b57cec5SDimitry Andric // Grouping options inside a group can't have values. 7690b57cec5SDimitry Andric if (PGOpt->getValueExpectedFlag() == cl::ValueRequired) { 7700b57cec5SDimitry Andric ErrorParsing |= PGOpt->error("may not occur within a group!"); 7710b57cec5SDimitry Andric return nullptr; 7720b57cec5SDimitry Andric } 7730b57cec5SDimitry Andric 7740b57cec5SDimitry Andric // Because the value for the option is not required, we don't need to pass 7750b57cec5SDimitry Andric // argc/argv in. 7760b57cec5SDimitry Andric int Dummy = 0; 7770b57cec5SDimitry Andric ErrorParsing |= ProvideOption(PGOpt, Arg, StringRef(), 0, nullptr, Dummy); 7780b57cec5SDimitry Andric 7790b57cec5SDimitry Andric // Get the next grouping option. 7800b57cec5SDimitry Andric Arg = MaybeValue; 7810b57cec5SDimitry Andric PGOpt = getOptionPred(Arg, Length, isGrouping, OptionsMap); 7820b57cec5SDimitry Andric } while (PGOpt); 7830b57cec5SDimitry Andric 7840b57cec5SDimitry Andric // We could not find a grouping option in the remainder of Arg. 7850b57cec5SDimitry Andric return nullptr; 7860b57cec5SDimitry Andric } 7870b57cec5SDimitry Andric 7880b57cec5SDimitry Andric static bool RequiresValue(const Option *O) { 7890b57cec5SDimitry Andric return O->getNumOccurrencesFlag() == cl::Required || 7900b57cec5SDimitry Andric O->getNumOccurrencesFlag() == cl::OneOrMore; 7910b57cec5SDimitry Andric } 7920b57cec5SDimitry Andric 7930b57cec5SDimitry Andric static bool EatsUnboundedNumberOfValues(const Option *O) { 7940b57cec5SDimitry Andric return O->getNumOccurrencesFlag() == cl::ZeroOrMore || 7950b57cec5SDimitry Andric O->getNumOccurrencesFlag() == cl::OneOrMore; 7960b57cec5SDimitry Andric } 7970b57cec5SDimitry Andric 7980b57cec5SDimitry Andric static bool isWhitespace(char C) { 7990b57cec5SDimitry Andric return C == ' ' || C == '\t' || C == '\r' || C == '\n'; 8000b57cec5SDimitry Andric } 8010b57cec5SDimitry Andric 8020b57cec5SDimitry Andric static bool isWhitespaceOrNull(char C) { 8030b57cec5SDimitry Andric return isWhitespace(C) || C == '\0'; 8040b57cec5SDimitry Andric } 8050b57cec5SDimitry Andric 8060b57cec5SDimitry Andric static bool isQuote(char C) { return C == '\"' || C == '\''; } 8070b57cec5SDimitry Andric 8080b57cec5SDimitry Andric void cl::TokenizeGNUCommandLine(StringRef Src, StringSaver &Saver, 8090b57cec5SDimitry Andric SmallVectorImpl<const char *> &NewArgv, 8100b57cec5SDimitry Andric bool MarkEOLs) { 8110b57cec5SDimitry Andric SmallString<128> Token; 8120b57cec5SDimitry Andric for (size_t I = 0, E = Src.size(); I != E; ++I) { 8130b57cec5SDimitry Andric // Consume runs of whitespace. 8140b57cec5SDimitry Andric if (Token.empty()) { 8150b57cec5SDimitry Andric while (I != E && isWhitespace(Src[I])) { 816e8d8bef9SDimitry Andric // Mark the end of lines in response files. 8170b57cec5SDimitry Andric if (MarkEOLs && Src[I] == '\n') 8180b57cec5SDimitry Andric NewArgv.push_back(nullptr); 8190b57cec5SDimitry Andric ++I; 8200b57cec5SDimitry Andric } 8210b57cec5SDimitry Andric if (I == E) 8220b57cec5SDimitry Andric break; 8230b57cec5SDimitry Andric } 8240b57cec5SDimitry Andric 8250b57cec5SDimitry Andric char C = Src[I]; 8260b57cec5SDimitry Andric 8270b57cec5SDimitry Andric // Backslash escapes the next character. 8280b57cec5SDimitry Andric if (I + 1 < E && C == '\\') { 8290b57cec5SDimitry Andric ++I; // Skip the escape. 8300b57cec5SDimitry Andric Token.push_back(Src[I]); 8310b57cec5SDimitry Andric continue; 8320b57cec5SDimitry Andric } 8330b57cec5SDimitry Andric 8340b57cec5SDimitry Andric // Consume a quoted string. 8350b57cec5SDimitry Andric if (isQuote(C)) { 8360b57cec5SDimitry Andric ++I; 8370b57cec5SDimitry Andric while (I != E && Src[I] != C) { 8380b57cec5SDimitry Andric // Backslash escapes the next character. 8390b57cec5SDimitry Andric if (Src[I] == '\\' && I + 1 != E) 8400b57cec5SDimitry Andric ++I; 8410b57cec5SDimitry Andric Token.push_back(Src[I]); 8420b57cec5SDimitry Andric ++I; 8430b57cec5SDimitry Andric } 8440b57cec5SDimitry Andric if (I == E) 8450b57cec5SDimitry Andric break; 8460b57cec5SDimitry Andric continue; 8470b57cec5SDimitry Andric } 8480b57cec5SDimitry Andric 8490b57cec5SDimitry Andric // End the token if this is whitespace. 8500b57cec5SDimitry Andric if (isWhitespace(C)) { 8510b57cec5SDimitry Andric if (!Token.empty()) 852fe6060f1SDimitry Andric NewArgv.push_back(Saver.save(Token.str()).data()); 853e8d8bef9SDimitry Andric // Mark the end of lines in response files. 854e8d8bef9SDimitry Andric if (MarkEOLs && C == '\n') 855e8d8bef9SDimitry Andric NewArgv.push_back(nullptr); 8560b57cec5SDimitry Andric Token.clear(); 8570b57cec5SDimitry Andric continue; 8580b57cec5SDimitry Andric } 8590b57cec5SDimitry Andric 8600b57cec5SDimitry Andric // This is a normal character. Append it. 8610b57cec5SDimitry Andric Token.push_back(C); 8620b57cec5SDimitry Andric } 8630b57cec5SDimitry Andric 8640b57cec5SDimitry Andric // Append the last token after hitting EOF with no whitespace. 8650b57cec5SDimitry Andric if (!Token.empty()) 866fe6060f1SDimitry Andric NewArgv.push_back(Saver.save(Token.str()).data()); 8670b57cec5SDimitry Andric } 8680b57cec5SDimitry Andric 8690b57cec5SDimitry Andric /// Backslashes are interpreted in a rather complicated way in the Windows-style 8700b57cec5SDimitry Andric /// command line, because backslashes are used both to separate path and to 8710b57cec5SDimitry Andric /// escape double quote. This method consumes runs of backslashes as well as the 8720b57cec5SDimitry Andric /// following double quote if it's escaped. 8730b57cec5SDimitry Andric /// 8740b57cec5SDimitry Andric /// * If an even number of backslashes is followed by a double quote, one 8750b57cec5SDimitry Andric /// backslash is output for every pair of backslashes, and the last double 8760b57cec5SDimitry Andric /// quote remains unconsumed. The double quote will later be interpreted as 8770b57cec5SDimitry Andric /// the start or end of a quoted string in the main loop outside of this 8780b57cec5SDimitry Andric /// function. 8790b57cec5SDimitry Andric /// 8800b57cec5SDimitry Andric /// * If an odd number of backslashes is followed by a double quote, one 8810b57cec5SDimitry Andric /// backslash is output for every pair of backslashes, and a double quote is 8820b57cec5SDimitry Andric /// output for the last pair of backslash-double quote. The double quote is 8830b57cec5SDimitry Andric /// consumed in this case. 8840b57cec5SDimitry Andric /// 8850b57cec5SDimitry Andric /// * Otherwise, backslashes are interpreted literally. 8860b57cec5SDimitry Andric static size_t parseBackslash(StringRef Src, size_t I, SmallString<128> &Token) { 8870b57cec5SDimitry Andric size_t E = Src.size(); 8880b57cec5SDimitry Andric int BackslashCount = 0; 8890b57cec5SDimitry Andric // Skip the backslashes. 8900b57cec5SDimitry Andric do { 8910b57cec5SDimitry Andric ++I; 8920b57cec5SDimitry Andric ++BackslashCount; 8930b57cec5SDimitry Andric } while (I != E && Src[I] == '\\'); 8940b57cec5SDimitry Andric 8950b57cec5SDimitry Andric bool FollowedByDoubleQuote = (I != E && Src[I] == '"'); 8960b57cec5SDimitry Andric if (FollowedByDoubleQuote) { 8970b57cec5SDimitry Andric Token.append(BackslashCount / 2, '\\'); 8980b57cec5SDimitry Andric if (BackslashCount % 2 == 0) 8990b57cec5SDimitry Andric return I - 1; 9000b57cec5SDimitry Andric Token.push_back('"'); 9010b57cec5SDimitry Andric return I; 9020b57cec5SDimitry Andric } 9030b57cec5SDimitry Andric Token.append(BackslashCount, '\\'); 9040b57cec5SDimitry Andric return I - 1; 9050b57cec5SDimitry Andric } 9060b57cec5SDimitry Andric 90781ad6265SDimitry Andric // Windows treats whitespace, double quotes, and backslashes specially, except 90881ad6265SDimitry Andric // when parsing the first token of a full command line, in which case 90981ad6265SDimitry Andric // backslashes are not special. 9105ffd83dbSDimitry Andric static bool isWindowsSpecialChar(char C) { 9115ffd83dbSDimitry Andric return isWhitespaceOrNull(C) || C == '\\' || C == '\"'; 9125ffd83dbSDimitry Andric } 91381ad6265SDimitry Andric static bool isWindowsSpecialCharInCommandName(char C) { 91481ad6265SDimitry Andric return isWhitespaceOrNull(C) || C == '\"'; 91581ad6265SDimitry Andric } 9165ffd83dbSDimitry Andric 9175ffd83dbSDimitry Andric // Windows tokenization implementation. The implementation is designed to be 9185ffd83dbSDimitry Andric // inlined and specialized for the two user entry points. 91981ad6265SDimitry Andric static inline void tokenizeWindowsCommandLineImpl( 92081ad6265SDimitry Andric StringRef Src, StringSaver &Saver, function_ref<void(StringRef)> AddToken, 92181ad6265SDimitry Andric bool AlwaysCopy, function_ref<void()> MarkEOL, bool InitialCommandName) { 9220b57cec5SDimitry Andric SmallString<128> Token; 9230b57cec5SDimitry Andric 92481ad6265SDimitry Andric // Sometimes, this function will be handling a full command line including an 92581ad6265SDimitry Andric // executable pathname at the start. In that situation, the initial pathname 92681ad6265SDimitry Andric // needs different handling from the following arguments, because when 92781ad6265SDimitry Andric // CreateProcess or cmd.exe scans the pathname, it doesn't treat \ as 92881ad6265SDimitry Andric // escaping the quote character, whereas when libc scans the rest of the 92981ad6265SDimitry Andric // command line, it does. 93081ad6265SDimitry Andric bool CommandName = InitialCommandName; 93181ad6265SDimitry Andric 9325ffd83dbSDimitry Andric // Try to do as much work inside the state machine as possible. 9330b57cec5SDimitry Andric enum { INIT, UNQUOTED, QUOTED } State = INIT; 93481ad6265SDimitry Andric 9355ffd83dbSDimitry Andric for (size_t I = 0, E = Src.size(); I < E; ++I) { 9365ffd83dbSDimitry Andric switch (State) { 9375ffd83dbSDimitry Andric case INIT: { 9385ffd83dbSDimitry Andric assert(Token.empty() && "token should be empty in initial state"); 9395ffd83dbSDimitry Andric // Eat whitespace before a token. 9405ffd83dbSDimitry Andric while (I < E && isWhitespaceOrNull(Src[I])) { 9415ffd83dbSDimitry Andric if (Src[I] == '\n') 9425ffd83dbSDimitry Andric MarkEOL(); 9435ffd83dbSDimitry Andric ++I; 9440b57cec5SDimitry Andric } 9455ffd83dbSDimitry Andric // Stop if this was trailing whitespace. 9465ffd83dbSDimitry Andric if (I >= E) 9475ffd83dbSDimitry Andric break; 9485ffd83dbSDimitry Andric size_t Start = I; 94981ad6265SDimitry Andric if (CommandName) { 95081ad6265SDimitry Andric while (I < E && !isWindowsSpecialCharInCommandName(Src[I])) 95181ad6265SDimitry Andric ++I; 95281ad6265SDimitry Andric } else { 9535ffd83dbSDimitry Andric while (I < E && !isWindowsSpecialChar(Src[I])) 9545ffd83dbSDimitry Andric ++I; 95581ad6265SDimitry Andric } 9565ffd83dbSDimitry Andric StringRef NormalChars = Src.slice(Start, I); 9575ffd83dbSDimitry Andric if (I >= E || isWhitespaceOrNull(Src[I])) { 9585ffd83dbSDimitry Andric // No special characters: slice out the substring and start the next 9595ffd83dbSDimitry Andric // token. Copy the string if the caller asks us to. 9605ffd83dbSDimitry Andric AddToken(AlwaysCopy ? Saver.save(NormalChars) : NormalChars); 96181ad6265SDimitry Andric if (I < E && Src[I] == '\n') { 962e8d8bef9SDimitry Andric MarkEOL(); 96381ad6265SDimitry Andric CommandName = InitialCommandName; 96481ad6265SDimitry Andric } else { 96581ad6265SDimitry Andric CommandName = false; 96681ad6265SDimitry Andric } 9675ffd83dbSDimitry Andric } else if (Src[I] == '\"') { 9685ffd83dbSDimitry Andric Token += NormalChars; 9690b57cec5SDimitry Andric State = QUOTED; 9705ffd83dbSDimitry Andric } else if (Src[I] == '\\') { 97181ad6265SDimitry Andric assert(!CommandName && "or else we'd have treated it as a normal char"); 9725ffd83dbSDimitry Andric Token += NormalChars; 9730b57cec5SDimitry Andric I = parseBackslash(Src, I, Token); 9740b57cec5SDimitry Andric State = UNQUOTED; 9755ffd83dbSDimitry Andric } else { 9765ffd83dbSDimitry Andric llvm_unreachable("unexpected special character"); 9770b57cec5SDimitry Andric } 9785ffd83dbSDimitry Andric break; 9790b57cec5SDimitry Andric } 9800b57cec5SDimitry Andric 9815ffd83dbSDimitry Andric case UNQUOTED: 9825ffd83dbSDimitry Andric if (isWhitespaceOrNull(Src[I])) { 9835ffd83dbSDimitry Andric // Whitespace means the end of the token. If we are in this state, the 9845ffd83dbSDimitry Andric // token must have contained a special character, so we must copy the 9855ffd83dbSDimitry Andric // token. 9865ffd83dbSDimitry Andric AddToken(Saver.save(Token.str())); 9870b57cec5SDimitry Andric Token.clear(); 98881ad6265SDimitry Andric if (Src[I] == '\n') { 98981ad6265SDimitry Andric CommandName = InitialCommandName; 9905ffd83dbSDimitry Andric MarkEOL(); 99181ad6265SDimitry Andric } else { 99281ad6265SDimitry Andric CommandName = false; 99381ad6265SDimitry Andric } 9940b57cec5SDimitry Andric State = INIT; 9955ffd83dbSDimitry Andric } else if (Src[I] == '\"') { 9960b57cec5SDimitry Andric State = QUOTED; 99781ad6265SDimitry Andric } else if (Src[I] == '\\' && !CommandName) { 9980b57cec5SDimitry Andric I = parseBackslash(Src, I, Token); 9995ffd83dbSDimitry Andric } else { 10005ffd83dbSDimitry Andric Token.push_back(Src[I]); 10010b57cec5SDimitry Andric } 10025ffd83dbSDimitry Andric break; 10030b57cec5SDimitry Andric 10045ffd83dbSDimitry Andric case QUOTED: 10055ffd83dbSDimitry Andric if (Src[I] == '\"') { 10060b57cec5SDimitry Andric if (I < (E - 1) && Src[I + 1] == '"') { 10070b57cec5SDimitry Andric // Consecutive double-quotes inside a quoted string implies one 10080b57cec5SDimitry Andric // double-quote. 10090b57cec5SDimitry Andric Token.push_back('"'); 10105ffd83dbSDimitry Andric ++I; 10115ffd83dbSDimitry Andric } else { 10125ffd83dbSDimitry Andric // Otherwise, end the quoted portion and return to the unquoted state. 10130b57cec5SDimitry Andric State = UNQUOTED; 10140b57cec5SDimitry Andric } 101581ad6265SDimitry Andric } else if (Src[I] == '\\' && !CommandName) { 10160b57cec5SDimitry Andric I = parseBackslash(Src, I, Token); 10175ffd83dbSDimitry Andric } else { 10185ffd83dbSDimitry Andric Token.push_back(Src[I]); 10190b57cec5SDimitry Andric } 10205ffd83dbSDimitry Andric break; 10210b57cec5SDimitry Andric } 10220b57cec5SDimitry Andric } 10235ffd83dbSDimitry Andric 102481ad6265SDimitry Andric if (State != INIT) 10255ffd83dbSDimitry Andric AddToken(Saver.save(Token.str())); 10265ffd83dbSDimitry Andric } 10275ffd83dbSDimitry Andric 10285ffd83dbSDimitry Andric void cl::TokenizeWindowsCommandLine(StringRef Src, StringSaver &Saver, 10295ffd83dbSDimitry Andric SmallVectorImpl<const char *> &NewArgv, 10305ffd83dbSDimitry Andric bool MarkEOLs) { 10315ffd83dbSDimitry Andric auto AddToken = [&](StringRef Tok) { NewArgv.push_back(Tok.data()); }; 10325ffd83dbSDimitry Andric auto OnEOL = [&]() { 10330b57cec5SDimitry Andric if (MarkEOLs) 10340b57cec5SDimitry Andric NewArgv.push_back(nullptr); 10355ffd83dbSDimitry Andric }; 10365ffd83dbSDimitry Andric tokenizeWindowsCommandLineImpl(Src, Saver, AddToken, 103781ad6265SDimitry Andric /*AlwaysCopy=*/true, OnEOL, false); 10385ffd83dbSDimitry Andric } 10395ffd83dbSDimitry Andric 10405ffd83dbSDimitry Andric void cl::TokenizeWindowsCommandLineNoCopy(StringRef Src, StringSaver &Saver, 10415ffd83dbSDimitry Andric SmallVectorImpl<StringRef> &NewArgv) { 10425ffd83dbSDimitry Andric auto AddToken = [&](StringRef Tok) { NewArgv.push_back(Tok); }; 10435ffd83dbSDimitry Andric auto OnEOL = []() {}; 10445ffd83dbSDimitry Andric tokenizeWindowsCommandLineImpl(Src, Saver, AddToken, /*AlwaysCopy=*/false, 104581ad6265SDimitry Andric OnEOL, false); 104681ad6265SDimitry Andric } 104781ad6265SDimitry Andric 104881ad6265SDimitry Andric void cl::TokenizeWindowsCommandLineFull(StringRef Src, StringSaver &Saver, 104981ad6265SDimitry Andric SmallVectorImpl<const char *> &NewArgv, 105081ad6265SDimitry Andric bool MarkEOLs) { 105181ad6265SDimitry Andric auto AddToken = [&](StringRef Tok) { NewArgv.push_back(Tok.data()); }; 105281ad6265SDimitry Andric auto OnEOL = [&]() { 105381ad6265SDimitry Andric if (MarkEOLs) 105481ad6265SDimitry Andric NewArgv.push_back(nullptr); 105581ad6265SDimitry Andric }; 105681ad6265SDimitry Andric tokenizeWindowsCommandLineImpl(Src, Saver, AddToken, 105781ad6265SDimitry Andric /*AlwaysCopy=*/true, OnEOL, true); 10580b57cec5SDimitry Andric } 10590b57cec5SDimitry Andric 10600b57cec5SDimitry Andric void cl::tokenizeConfigFile(StringRef Source, StringSaver &Saver, 10610b57cec5SDimitry Andric SmallVectorImpl<const char *> &NewArgv, 10620b57cec5SDimitry Andric bool MarkEOLs) { 10630b57cec5SDimitry Andric for (const char *Cur = Source.begin(); Cur != Source.end();) { 10640b57cec5SDimitry Andric SmallString<128> Line; 10650b57cec5SDimitry Andric // Check for comment line. 10660b57cec5SDimitry Andric if (isWhitespace(*Cur)) { 10670b57cec5SDimitry Andric while (Cur != Source.end() && isWhitespace(*Cur)) 10680b57cec5SDimitry Andric ++Cur; 10690b57cec5SDimitry Andric continue; 10700b57cec5SDimitry Andric } 10710b57cec5SDimitry Andric if (*Cur == '#') { 10720b57cec5SDimitry Andric while (Cur != Source.end() && *Cur != '\n') 10730b57cec5SDimitry Andric ++Cur; 10740b57cec5SDimitry Andric continue; 10750b57cec5SDimitry Andric } 10760b57cec5SDimitry Andric // Find end of the current line. 10770b57cec5SDimitry Andric const char *Start = Cur; 10780b57cec5SDimitry Andric for (const char *End = Source.end(); Cur != End; ++Cur) { 10790b57cec5SDimitry Andric if (*Cur == '\\') { 10800b57cec5SDimitry Andric if (Cur + 1 != End) { 10810b57cec5SDimitry Andric ++Cur; 10820b57cec5SDimitry Andric if (*Cur == '\n' || 10830b57cec5SDimitry Andric (*Cur == '\r' && (Cur + 1 != End) && Cur[1] == '\n')) { 10840b57cec5SDimitry Andric Line.append(Start, Cur - 1); 10850b57cec5SDimitry Andric if (*Cur == '\r') 10860b57cec5SDimitry Andric ++Cur; 10870b57cec5SDimitry Andric Start = Cur + 1; 10880b57cec5SDimitry Andric } 10890b57cec5SDimitry Andric } 10900b57cec5SDimitry Andric } else if (*Cur == '\n') 10910b57cec5SDimitry Andric break; 10920b57cec5SDimitry Andric } 10930b57cec5SDimitry Andric // Tokenize line. 10940b57cec5SDimitry Andric Line.append(Start, Cur); 10950b57cec5SDimitry Andric cl::TokenizeGNUCommandLine(Line, Saver, NewArgv, MarkEOLs); 10960b57cec5SDimitry Andric } 10970b57cec5SDimitry Andric } 10980b57cec5SDimitry Andric 10990b57cec5SDimitry Andric // It is called byte order marker but the UTF-8 BOM is actually not affected 11000b57cec5SDimitry Andric // by the host system's endianness. 11010b57cec5SDimitry Andric static bool hasUTF8ByteOrderMark(ArrayRef<char> S) { 11020b57cec5SDimitry Andric return (S.size() >= 3 && S[0] == '\xef' && S[1] == '\xbb' && S[2] == '\xbf'); 11030b57cec5SDimitry Andric } 11040b57cec5SDimitry Andric 110504eeddc0SDimitry Andric // Substitute <CFGDIR> with the file's base path. 110604eeddc0SDimitry Andric static void ExpandBasePaths(StringRef BasePath, StringSaver &Saver, 110704eeddc0SDimitry Andric const char *&Arg) { 110804eeddc0SDimitry Andric assert(sys::path::is_absolute(BasePath)); 110904eeddc0SDimitry Andric constexpr StringLiteral Token("<CFGDIR>"); 111004eeddc0SDimitry Andric const StringRef ArgString(Arg); 111104eeddc0SDimitry Andric 111204eeddc0SDimitry Andric SmallString<128> ResponseFile; 111304eeddc0SDimitry Andric StringRef::size_type StartPos = 0; 111404eeddc0SDimitry Andric for (StringRef::size_type TokenPos = ArgString.find(Token); 111504eeddc0SDimitry Andric TokenPos != StringRef::npos; 111604eeddc0SDimitry Andric TokenPos = ArgString.find(Token, StartPos)) { 111704eeddc0SDimitry Andric // Token may appear more than once per arg (e.g. comma-separated linker 111804eeddc0SDimitry Andric // args). Support by using path-append on any subsequent appearances. 111904eeddc0SDimitry Andric const StringRef LHS = ArgString.substr(StartPos, TokenPos - StartPos); 112004eeddc0SDimitry Andric if (ResponseFile.empty()) 112104eeddc0SDimitry Andric ResponseFile = LHS; 112204eeddc0SDimitry Andric else 112304eeddc0SDimitry Andric llvm::sys::path::append(ResponseFile, LHS); 112404eeddc0SDimitry Andric ResponseFile.append(BasePath); 112504eeddc0SDimitry Andric StartPos = TokenPos + Token.size(); 112604eeddc0SDimitry Andric } 112704eeddc0SDimitry Andric 112804eeddc0SDimitry Andric if (!ResponseFile.empty()) { 112904eeddc0SDimitry Andric // Path-append the remaining arg substring if at least one token appeared. 113004eeddc0SDimitry Andric const StringRef Remaining = ArgString.substr(StartPos); 113104eeddc0SDimitry Andric if (!Remaining.empty()) 113204eeddc0SDimitry Andric llvm::sys::path::append(ResponseFile, Remaining); 113304eeddc0SDimitry Andric Arg = Saver.save(ResponseFile.str()).data(); 113404eeddc0SDimitry Andric } 113504eeddc0SDimitry Andric } 113604eeddc0SDimitry Andric 1137480093f4SDimitry Andric // FName must be an absolute path. 1138bdd1243dSDimitry Andric Error ExpansionContext::expandResponseFile( 1139bdd1243dSDimitry Andric StringRef FName, SmallVectorImpl<const char *> &NewArgv) { 1140480093f4SDimitry Andric assert(sys::path::is_absolute(FName)); 1141480093f4SDimitry Andric llvm::ErrorOr<std::unique_ptr<MemoryBuffer>> MemBufOrErr = 1142bdd1243dSDimitry Andric FS->getBufferForFile(FName); 1143bdd1243dSDimitry Andric if (!MemBufOrErr) { 1144bdd1243dSDimitry Andric std::error_code EC = MemBufOrErr.getError(); 1145bdd1243dSDimitry Andric return llvm::createStringError(EC, Twine("cannot not open file '") + FName + 1146bdd1243dSDimitry Andric "': " + EC.message()); 1147bdd1243dSDimitry Andric } 11480b57cec5SDimitry Andric MemoryBuffer &MemBuf = *MemBufOrErr.get(); 11490b57cec5SDimitry Andric StringRef Str(MemBuf.getBufferStart(), MemBuf.getBufferSize()); 11500b57cec5SDimitry Andric 11510b57cec5SDimitry Andric // If we have a UTF-16 byte order mark, convert to UTF-8 for parsing. 11520b57cec5SDimitry Andric ArrayRef<char> BufRef(MemBuf.getBufferStart(), MemBuf.getBufferEnd()); 11530b57cec5SDimitry Andric std::string UTF8Buf; 11540b57cec5SDimitry Andric if (hasUTF16ByteOrderMark(BufRef)) { 11550b57cec5SDimitry Andric if (!convertUTF16ToUTF8String(BufRef, UTF8Buf)) 1156480093f4SDimitry Andric return llvm::createStringError(std::errc::illegal_byte_sequence, 1157480093f4SDimitry Andric "Could not convert UTF16 to UTF8"); 11580b57cec5SDimitry Andric Str = StringRef(UTF8Buf); 11590b57cec5SDimitry Andric } 11600b57cec5SDimitry Andric // If we see UTF-8 BOM sequence at the beginning of a file, we shall remove 11610b57cec5SDimitry Andric // these bytes before parsing. 11620b57cec5SDimitry Andric // Reference: http://en.wikipedia.org/wiki/UTF-8#Byte_order_mark 11630b57cec5SDimitry Andric else if (hasUTF8ByteOrderMark(BufRef)) 11640b57cec5SDimitry Andric Str = StringRef(BufRef.data() + 3, BufRef.size() - 3); 11650b57cec5SDimitry Andric 11660b57cec5SDimitry Andric // Tokenize the contents into NewArgv. 11670b57cec5SDimitry Andric Tokenizer(Str, Saver, NewArgv, MarkEOLs); 11680b57cec5SDimitry Andric 1169bdd1243dSDimitry Andric // Expanded file content may require additional transformations, like using 1170bdd1243dSDimitry Andric // absolute paths instead of relative in '@file' constructs or expanding 1171bdd1243dSDimitry Andric // macros. 1172bdd1243dSDimitry Andric if (!RelativeNames && !InConfigFile) 1173480093f4SDimitry Andric return Error::success(); 1174bdd1243dSDimitry Andric 1175bdd1243dSDimitry Andric StringRef BasePath = llvm::sys::path::parent_path(FName); 1176bdd1243dSDimitry Andric for (const char *&Arg : NewArgv) { 117704eeddc0SDimitry Andric if (!Arg) 117804eeddc0SDimitry Andric continue; 117904eeddc0SDimitry Andric 118004eeddc0SDimitry Andric // Substitute <CFGDIR> with the file's base path. 1181bdd1243dSDimitry Andric if (InConfigFile) 118204eeddc0SDimitry Andric ExpandBasePaths(BasePath, Saver, Arg); 118304eeddc0SDimitry Andric 1184bdd1243dSDimitry Andric // Discover the case, when argument should be transformed into '@file' and 1185bdd1243dSDimitry Andric // evaluate 'file' for it. 1186bdd1243dSDimitry Andric StringRef ArgStr(Arg); 1187bdd1243dSDimitry Andric StringRef FileName; 1188bdd1243dSDimitry Andric bool ConfigInclusion = false; 1189bdd1243dSDimitry Andric if (ArgStr.consume_front("@")) { 1190bdd1243dSDimitry Andric FileName = ArgStr; 1191480093f4SDimitry Andric if (!llvm::sys::path::is_relative(FileName)) 1192480093f4SDimitry Andric continue; 1193bdd1243dSDimitry Andric } else if (ArgStr.consume_front("--config=")) { 1194bdd1243dSDimitry Andric FileName = ArgStr; 1195bdd1243dSDimitry Andric ConfigInclusion = true; 1196bdd1243dSDimitry Andric } else { 1197bdd1243dSDimitry Andric continue; 1198bdd1243dSDimitry Andric } 1199480093f4SDimitry Andric 1200bdd1243dSDimitry Andric // Update expansion construct. 1201480093f4SDimitry Andric SmallString<128> ResponseFile; 1202480093f4SDimitry Andric ResponseFile.push_back('@'); 1203bdd1243dSDimitry Andric if (ConfigInclusion && !llvm::sys::path::has_parent_path(FileName)) { 1204bdd1243dSDimitry Andric SmallString<128> FilePath; 1205bdd1243dSDimitry Andric if (!findConfigFile(FileName, FilePath)) 1206bdd1243dSDimitry Andric return createStringError( 1207bdd1243dSDimitry Andric std::make_error_code(std::errc::no_such_file_or_directory), 1208bdd1243dSDimitry Andric "cannot not find configuration file: " + FileName); 1209bdd1243dSDimitry Andric ResponseFile.append(FilePath); 1210bdd1243dSDimitry Andric } else { 1211480093f4SDimitry Andric ResponseFile.append(BasePath); 1212480093f4SDimitry Andric llvm::sys::path::append(ResponseFile, FileName); 1213bdd1243dSDimitry Andric } 121404eeddc0SDimitry Andric Arg = Saver.save(ResponseFile.str()).data(); 1215480093f4SDimitry Andric } 1216480093f4SDimitry Andric return Error::success(); 12170b57cec5SDimitry Andric } 12180b57cec5SDimitry Andric 12190b57cec5SDimitry Andric /// Expand response files on a command line recursively using the given 12200b57cec5SDimitry Andric /// StringSaver and tokenization strategy. 1221bdd1243dSDimitry Andric Error ExpansionContext::expandResponseFiles( 1222bdd1243dSDimitry Andric SmallVectorImpl<const char *> &Argv) { 12230b57cec5SDimitry Andric struct ResponseFileRecord { 1224480093f4SDimitry Andric std::string File; 12250b57cec5SDimitry Andric size_t End; 12260b57cec5SDimitry Andric }; 12270b57cec5SDimitry Andric 12280b57cec5SDimitry Andric // To detect recursive response files, we maintain a stack of files and the 12290b57cec5SDimitry Andric // position of the last argument in the file. This position is updated 12300b57cec5SDimitry Andric // dynamically as we recursively expand files. 12310b57cec5SDimitry Andric SmallVector<ResponseFileRecord, 3> FileStack; 12320b57cec5SDimitry Andric 12330b57cec5SDimitry Andric // Push a dummy entry that represents the initial command line, removing 12340b57cec5SDimitry Andric // the need to check for an empty list. 12350b57cec5SDimitry Andric FileStack.push_back({"", Argv.size()}); 12360b57cec5SDimitry Andric 12370b57cec5SDimitry Andric // Don't cache Argv.size() because it can change. 12380b57cec5SDimitry Andric for (unsigned I = 0; I != Argv.size();) { 12390b57cec5SDimitry Andric while (I == FileStack.back().End) { 12400b57cec5SDimitry Andric // Passing the end of a file's argument list, so we can remove it from the 12410b57cec5SDimitry Andric // stack. 12420b57cec5SDimitry Andric FileStack.pop_back(); 12430b57cec5SDimitry Andric } 12440b57cec5SDimitry Andric 12450b57cec5SDimitry Andric const char *Arg = Argv[I]; 12460b57cec5SDimitry Andric // Check if it is an EOL marker 12470b57cec5SDimitry Andric if (Arg == nullptr) { 12480b57cec5SDimitry Andric ++I; 12490b57cec5SDimitry Andric continue; 12500b57cec5SDimitry Andric } 12510b57cec5SDimitry Andric 12520b57cec5SDimitry Andric if (Arg[0] != '@') { 12530b57cec5SDimitry Andric ++I; 12540b57cec5SDimitry Andric continue; 12550b57cec5SDimitry Andric } 12560b57cec5SDimitry Andric 12570b57cec5SDimitry Andric const char *FName = Arg + 1; 1258480093f4SDimitry Andric // Note that CurrentDir is only used for top-level rsp files, the rest will 1259480093f4SDimitry Andric // always have an absolute path deduced from the containing file. 1260480093f4SDimitry Andric SmallString<128> CurrDir; 1261480093f4SDimitry Andric if (llvm::sys::path::is_relative(FName)) { 1262bdd1243dSDimitry Andric if (CurrentDir.empty()) { 1263bdd1243dSDimitry Andric if (auto CWD = FS->getCurrentWorkingDirectory()) { 1264bdd1243dSDimitry Andric CurrDir = *CWD; 1265bdd1243dSDimitry Andric } else { 1266bdd1243dSDimitry Andric return createStringError( 1267bdd1243dSDimitry Andric CWD.getError(), Twine("cannot get absolute path for: ") + FName); 1268bdd1243dSDimitry Andric } 1269bdd1243dSDimitry Andric } else { 1270bdd1243dSDimitry Andric CurrDir = CurrentDir; 1271bdd1243dSDimitry Andric } 1272480093f4SDimitry Andric llvm::sys::path::append(CurrDir, FName); 1273480093f4SDimitry Andric FName = CurrDir.c_str(); 1274480093f4SDimitry Andric } 1275bdd1243dSDimitry Andric 1276bdd1243dSDimitry Andric ErrorOr<llvm::vfs::Status> Res = FS->status(FName); 1277bdd1243dSDimitry Andric if (!Res || !Res->exists()) { 1278bdd1243dSDimitry Andric std::error_code EC = Res.getError(); 1279bdd1243dSDimitry Andric if (!InConfigFile) { 1280bdd1243dSDimitry Andric // If the specified file does not exist, leave '@file' unexpanded, as 1281bdd1243dSDimitry Andric // libiberty does. 1282bdd1243dSDimitry Andric if (!EC || EC == llvm::errc::no_such_file_or_directory) { 1283bdd1243dSDimitry Andric ++I; 1284bdd1243dSDimitry Andric continue; 1285480093f4SDimitry Andric } 1286480093f4SDimitry Andric } 1287bdd1243dSDimitry Andric if (!EC) 1288bdd1243dSDimitry Andric EC = llvm::errc::no_such_file_or_directory; 1289bdd1243dSDimitry Andric return createStringError(EC, Twine("cannot not open file '") + FName + 1290bdd1243dSDimitry Andric "': " + EC.message()); 1291bdd1243dSDimitry Andric } 1292bdd1243dSDimitry Andric const llvm::vfs::Status &FileStatus = Res.get(); 1293bdd1243dSDimitry Andric 1294bdd1243dSDimitry Andric auto IsEquivalent = 1295bdd1243dSDimitry Andric [FileStatus, this](const ResponseFileRecord &RFile) -> ErrorOr<bool> { 1296bdd1243dSDimitry Andric ErrorOr<llvm::vfs::Status> RHS = FS->status(RFile.File); 1297bdd1243dSDimitry Andric if (!RHS) 1298bdd1243dSDimitry Andric return RHS.getError(); 1299bdd1243dSDimitry Andric return FileStatus.equivalent(*RHS); 13000b57cec5SDimitry Andric }; 13010b57cec5SDimitry Andric 13020b57cec5SDimitry Andric // Check for recursive response files. 1303bdd1243dSDimitry Andric for (const auto &F : drop_begin(FileStack)) { 1304bdd1243dSDimitry Andric if (ErrorOr<bool> R = IsEquivalent(F)) { 1305bdd1243dSDimitry Andric if (R.get()) 1306bdd1243dSDimitry Andric return createStringError( 1307bdd1243dSDimitry Andric R.getError(), Twine("recursive expansion of: '") + F.File + "'"); 1308bdd1243dSDimitry Andric } else { 1309bdd1243dSDimitry Andric return createStringError(R.getError(), 1310bdd1243dSDimitry Andric Twine("cannot open file: ") + F.File); 1311bdd1243dSDimitry Andric } 13120b57cec5SDimitry Andric } 13130b57cec5SDimitry Andric 13140b57cec5SDimitry Andric // Replace this response file argument with the tokenization of its 13150b57cec5SDimitry Andric // contents. Nested response files are expanded in subsequent iterations. 13160b57cec5SDimitry Andric SmallVector<const char *, 0> ExpandedArgv; 1317bdd1243dSDimitry Andric if (Error Err = expandResponseFile(FName, ExpandedArgv)) 1318bdd1243dSDimitry Andric return Err; 13190b57cec5SDimitry Andric 13200b57cec5SDimitry Andric for (ResponseFileRecord &Record : FileStack) { 13210b57cec5SDimitry Andric // Increase the end of all active records by the number of newly expanded 13220b57cec5SDimitry Andric // arguments, minus the response file itself. 13230b57cec5SDimitry Andric Record.End += ExpandedArgv.size() - 1; 13240b57cec5SDimitry Andric } 13250b57cec5SDimitry Andric 13260b57cec5SDimitry Andric FileStack.push_back({FName, I + ExpandedArgv.size()}); 13270b57cec5SDimitry Andric Argv.erase(Argv.begin() + I); 13280b57cec5SDimitry Andric Argv.insert(Argv.begin() + I, ExpandedArgv.begin(), ExpandedArgv.end()); 13290b57cec5SDimitry Andric } 13300b57cec5SDimitry Andric 13310b57cec5SDimitry Andric // If successful, the top of the file stack will mark the end of the Argv 13320b57cec5SDimitry Andric // stream. A failure here indicates a bug in the stack popping logic above. 13330b57cec5SDimitry Andric // Note that FileStack may have more than one element at this point because we 13340b57cec5SDimitry Andric // don't have a chance to pop the stack when encountering recursive files at 13350b57cec5SDimitry Andric // the end of the stream, so seeing that doesn't indicate a bug. 13360b57cec5SDimitry Andric assert(FileStack.size() > 0 && Argv.size() == FileStack.back().End); 1337bdd1243dSDimitry Andric return Error::success(); 1338fe6060f1SDimitry Andric } 1339fe6060f1SDimitry Andric 1340e8d8bef9SDimitry Andric bool cl::expandResponseFiles(int Argc, const char *const *Argv, 1341e8d8bef9SDimitry Andric const char *EnvVar, StringSaver &Saver, 1342e8d8bef9SDimitry Andric SmallVectorImpl<const char *> &NewArgv) { 1343bdd1243dSDimitry Andric #ifdef _WIN32 1344bdd1243dSDimitry Andric auto Tokenize = cl::TokenizeWindowsCommandLine; 1345bdd1243dSDimitry Andric #else 1346bdd1243dSDimitry Andric auto Tokenize = cl::TokenizeGNUCommandLine; 1347bdd1243dSDimitry Andric #endif 1348e8d8bef9SDimitry Andric // The environment variable specifies initial options. 1349e8d8bef9SDimitry Andric if (EnvVar) 1350bdd1243dSDimitry Andric if (std::optional<std::string> EnvValue = sys::Process::GetEnv(EnvVar)) 1351e8d8bef9SDimitry Andric Tokenize(*EnvValue, Saver, NewArgv, /*MarkEOLs=*/false); 1352e8d8bef9SDimitry Andric 1353e8d8bef9SDimitry Andric // Command line options can override the environment variable. 1354e8d8bef9SDimitry Andric NewArgv.append(Argv + 1, Argv + Argc); 1355bdd1243dSDimitry Andric ExpansionContext ECtx(Saver.getAllocator(), Tokenize); 1356bdd1243dSDimitry Andric if (Error Err = ECtx.expandResponseFiles(NewArgv)) { 1357bdd1243dSDimitry Andric errs() << toString(std::move(Err)) << '\n'; 1358bdd1243dSDimitry Andric return false; 1359bdd1243dSDimitry Andric } 1360bdd1243dSDimitry Andric return true; 1361e8d8bef9SDimitry Andric } 1362e8d8bef9SDimitry Andric 1363bdd1243dSDimitry Andric bool cl::ExpandResponseFiles(StringSaver &Saver, TokenizerCallback Tokenizer, 1364bdd1243dSDimitry Andric SmallVectorImpl<const char *> &Argv) { 1365bdd1243dSDimitry Andric ExpansionContext ECtx(Saver.getAllocator(), Tokenizer); 1366bdd1243dSDimitry Andric if (Error Err = ECtx.expandResponseFiles(Argv)) { 1367bdd1243dSDimitry Andric errs() << toString(std::move(Err)) << '\n'; 1368bdd1243dSDimitry Andric return false; 1369bdd1243dSDimitry Andric } 1370bdd1243dSDimitry Andric return true; 1371bdd1243dSDimitry Andric } 1372bdd1243dSDimitry Andric 1373bdd1243dSDimitry Andric ExpansionContext::ExpansionContext(BumpPtrAllocator &A, TokenizerCallback T) 1374bdd1243dSDimitry Andric : Saver(A), Tokenizer(T), FS(vfs::getRealFileSystem().get()) {} 1375bdd1243dSDimitry Andric 1376bdd1243dSDimitry Andric bool ExpansionContext::findConfigFile(StringRef FileName, 1377bdd1243dSDimitry Andric SmallVectorImpl<char> &FilePath) { 1378bdd1243dSDimitry Andric SmallString<128> CfgFilePath; 1379bdd1243dSDimitry Andric const auto FileExists = [this](SmallString<128> Path) -> bool { 1380bdd1243dSDimitry Andric auto Status = FS->status(Path); 1381bdd1243dSDimitry Andric return Status && 1382bdd1243dSDimitry Andric Status->getType() == llvm::sys::fs::file_type::regular_file; 1383bdd1243dSDimitry Andric }; 1384bdd1243dSDimitry Andric 1385bdd1243dSDimitry Andric // If file name contains directory separator, treat it as a path to 1386bdd1243dSDimitry Andric // configuration file. 1387bdd1243dSDimitry Andric if (llvm::sys::path::has_parent_path(FileName)) { 1388bdd1243dSDimitry Andric CfgFilePath = FileName; 1389bdd1243dSDimitry Andric if (llvm::sys::path::is_relative(FileName) && FS->makeAbsolute(CfgFilePath)) 1390bdd1243dSDimitry Andric return false; 1391bdd1243dSDimitry Andric if (!FileExists(CfgFilePath)) 1392bdd1243dSDimitry Andric return false; 1393bdd1243dSDimitry Andric FilePath.assign(CfgFilePath.begin(), CfgFilePath.end()); 1394bdd1243dSDimitry Andric return true; 1395bdd1243dSDimitry Andric } 1396bdd1243dSDimitry Andric 1397bdd1243dSDimitry Andric // Look for the file in search directories. 1398bdd1243dSDimitry Andric for (const StringRef &Dir : SearchDirs) { 1399bdd1243dSDimitry Andric if (Dir.empty()) 1400bdd1243dSDimitry Andric continue; 1401bdd1243dSDimitry Andric CfgFilePath.assign(Dir); 1402bdd1243dSDimitry Andric llvm::sys::path::append(CfgFilePath, FileName); 1403bdd1243dSDimitry Andric llvm::sys::path::native(CfgFilePath); 1404bdd1243dSDimitry Andric if (FileExists(CfgFilePath)) { 1405bdd1243dSDimitry Andric FilePath.assign(CfgFilePath.begin(), CfgFilePath.end()); 1406bdd1243dSDimitry Andric return true; 1407bdd1243dSDimitry Andric } 1408bdd1243dSDimitry Andric } 1409bdd1243dSDimitry Andric 1410bdd1243dSDimitry Andric return false; 1411bdd1243dSDimitry Andric } 1412bdd1243dSDimitry Andric 1413bdd1243dSDimitry Andric Error ExpansionContext::readConfigFile(StringRef CfgFile, 14140b57cec5SDimitry Andric SmallVectorImpl<const char *> &Argv) { 1415480093f4SDimitry Andric SmallString<128> AbsPath; 1416480093f4SDimitry Andric if (sys::path::is_relative(CfgFile)) { 1417bdd1243dSDimitry Andric AbsPath.assign(CfgFile); 1418bdd1243dSDimitry Andric if (std::error_code EC = FS->makeAbsolute(AbsPath)) 1419bdd1243dSDimitry Andric return make_error<StringError>( 1420bdd1243dSDimitry Andric EC, Twine("cannot get absolute path for " + CfgFile)); 1421480093f4SDimitry Andric CfgFile = AbsPath.str(); 1422480093f4SDimitry Andric } 1423bdd1243dSDimitry Andric InConfigFile = true; 1424bdd1243dSDimitry Andric RelativeNames = true; 1425bdd1243dSDimitry Andric if (Error Err = expandResponseFile(CfgFile, Argv)) 1426bdd1243dSDimitry Andric return Err; 1427bdd1243dSDimitry Andric return expandResponseFiles(Argv); 14280b57cec5SDimitry Andric } 14290b57cec5SDimitry Andric 1430fe6060f1SDimitry Andric static void initCommonOptions(); 14310b57cec5SDimitry Andric bool cl::ParseCommandLineOptions(int argc, const char *const *argv, 14320b57cec5SDimitry Andric StringRef Overview, raw_ostream *Errs, 14330b57cec5SDimitry Andric const char *EnvVar, 14340b57cec5SDimitry Andric bool LongOptionsUseDoubleDash) { 1435fe6060f1SDimitry Andric initCommonOptions(); 14360b57cec5SDimitry Andric SmallVector<const char *, 20> NewArgv; 14370b57cec5SDimitry Andric BumpPtrAllocator A; 14380b57cec5SDimitry Andric StringSaver Saver(A); 14390b57cec5SDimitry Andric NewArgv.push_back(argv[0]); 14400b57cec5SDimitry Andric 14410b57cec5SDimitry Andric // Parse options from environment variable. 14420b57cec5SDimitry Andric if (EnvVar) { 1443bdd1243dSDimitry Andric if (std::optional<std::string> EnvValue = 14440b57cec5SDimitry Andric sys::Process::GetEnv(StringRef(EnvVar))) 14450b57cec5SDimitry Andric TokenizeGNUCommandLine(*EnvValue, Saver, NewArgv); 14460b57cec5SDimitry Andric } 14470b57cec5SDimitry Andric 14480b57cec5SDimitry Andric // Append options from command line. 14490b57cec5SDimitry Andric for (int I = 1; I < argc; ++I) 14500b57cec5SDimitry Andric NewArgv.push_back(argv[I]); 14510b57cec5SDimitry Andric int NewArgc = static_cast<int>(NewArgv.size()); 14520b57cec5SDimitry Andric 14530b57cec5SDimitry Andric // Parse all options. 14540b57cec5SDimitry Andric return GlobalParser->ParseCommandLineOptions(NewArgc, &NewArgv[0], Overview, 14550b57cec5SDimitry Andric Errs, LongOptionsUseDoubleDash); 14560b57cec5SDimitry Andric } 14570b57cec5SDimitry Andric 1458349cc55cSDimitry Andric /// Reset all options at least once, so that we can parse different options. 14590b57cec5SDimitry Andric void CommandLineParser::ResetAllOptionOccurrences() { 1460349cc55cSDimitry Andric // Reset all option values to look like they have never been seen before. 1461349cc55cSDimitry Andric // Options might be reset twice (they can be reference in both OptionsMap 1462349cc55cSDimitry Andric // and one of the other members), but that does not harm. 1463fe6060f1SDimitry Andric for (auto *SC : RegisteredSubCommands) { 14640b57cec5SDimitry Andric for (auto &O : SC->OptionsMap) 14650b57cec5SDimitry Andric O.second->reset(); 1466349cc55cSDimitry Andric for (Option *O : SC->PositionalOpts) 1467349cc55cSDimitry Andric O->reset(); 1468349cc55cSDimitry Andric for (Option *O : SC->SinkOpts) 1469349cc55cSDimitry Andric O->reset(); 1470349cc55cSDimitry Andric if (SC->ConsumeAfterOpt) 1471349cc55cSDimitry Andric SC->ConsumeAfterOpt->reset(); 14720b57cec5SDimitry Andric } 14730b57cec5SDimitry Andric } 14740b57cec5SDimitry Andric 14750b57cec5SDimitry Andric bool CommandLineParser::ParseCommandLineOptions(int argc, 14760b57cec5SDimitry Andric const char *const *argv, 14770b57cec5SDimitry Andric StringRef Overview, 14780b57cec5SDimitry Andric raw_ostream *Errs, 14790b57cec5SDimitry Andric bool LongOptionsUseDoubleDash) { 14800b57cec5SDimitry Andric assert(hasOptions() && "No options specified!"); 14810b57cec5SDimitry Andric 14820b57cec5SDimitry Andric ProgramOverview = Overview; 14830b57cec5SDimitry Andric bool IgnoreErrors = Errs; 14840b57cec5SDimitry Andric if (!Errs) 14850b57cec5SDimitry Andric Errs = &errs(); 14860b57cec5SDimitry Andric bool ErrorParsing = false; 14870b57cec5SDimitry Andric 1488bdd1243dSDimitry Andric // Expand response files. 1489bdd1243dSDimitry Andric SmallVector<const char *, 20> newArgv(argv, argv + argc); 1490bdd1243dSDimitry Andric BumpPtrAllocator A; 1491bdd1243dSDimitry Andric #ifdef _WIN32 1492bdd1243dSDimitry Andric auto Tokenize = cl::TokenizeWindowsCommandLine; 1493bdd1243dSDimitry Andric #else 1494bdd1243dSDimitry Andric auto Tokenize = cl::TokenizeGNUCommandLine; 1495bdd1243dSDimitry Andric #endif 1496bdd1243dSDimitry Andric ExpansionContext ECtx(A, Tokenize); 1497bdd1243dSDimitry Andric if (Error Err = ECtx.expandResponseFiles(newArgv)) { 1498bdd1243dSDimitry Andric *Errs << toString(std::move(Err)) << '\n'; 1499bdd1243dSDimitry Andric return false; 1500bdd1243dSDimitry Andric } 1501bdd1243dSDimitry Andric argv = &newArgv[0]; 1502bdd1243dSDimitry Andric argc = static_cast<int>(newArgv.size()); 1503bdd1243dSDimitry Andric 1504bdd1243dSDimitry Andric // Copy the program name into ProgName, making sure not to overflow it. 1505bdd1243dSDimitry Andric ProgramName = std::string(sys::path::filename(StringRef(argv[0]))); 1506bdd1243dSDimitry Andric 15070b57cec5SDimitry Andric // Check out the positional arguments to collect information about them. 15080b57cec5SDimitry Andric unsigned NumPositionalRequired = 0; 15090b57cec5SDimitry Andric 15100b57cec5SDimitry Andric // Determine whether or not there are an unlimited number of positionals 15110b57cec5SDimitry Andric bool HasUnlimitedPositionals = false; 15120b57cec5SDimitry Andric 15130b57cec5SDimitry Andric int FirstArg = 1; 1514bdd1243dSDimitry Andric SubCommand *ChosenSubCommand = &SubCommand::getTopLevel(); 15155f757f3fSDimitry Andric std::string NearestSubCommandString; 15165f757f3fSDimitry Andric bool MaybeNamedSubCommand = 15175f757f3fSDimitry Andric argc >= 2 && argv[FirstArg][0] != '-' && hasNamedSubCommands(); 15185f757f3fSDimitry Andric if (MaybeNamedSubCommand) { 15190b57cec5SDimitry Andric // If the first argument specifies a valid subcommand, start processing 15200b57cec5SDimitry Andric // options from the second argument. 15215f757f3fSDimitry Andric ChosenSubCommand = 15225f757f3fSDimitry Andric LookupSubCommand(StringRef(argv[FirstArg]), NearestSubCommandString); 1523bdd1243dSDimitry Andric if (ChosenSubCommand != &SubCommand::getTopLevel()) 15240b57cec5SDimitry Andric FirstArg = 2; 15250b57cec5SDimitry Andric } 15260b57cec5SDimitry Andric GlobalParser->ActiveSubCommand = ChosenSubCommand; 15270b57cec5SDimitry Andric 15280b57cec5SDimitry Andric assert(ChosenSubCommand); 15290b57cec5SDimitry Andric auto &ConsumeAfterOpt = ChosenSubCommand->ConsumeAfterOpt; 15300b57cec5SDimitry Andric auto &PositionalOpts = ChosenSubCommand->PositionalOpts; 15310b57cec5SDimitry Andric auto &SinkOpts = ChosenSubCommand->SinkOpts; 15320b57cec5SDimitry Andric auto &OptionsMap = ChosenSubCommand->OptionsMap; 15330b57cec5SDimitry Andric 1534fe6060f1SDimitry Andric for (auto *O: DefaultOptions) { 15350b57cec5SDimitry Andric addOption(O, true); 15360b57cec5SDimitry Andric } 15370b57cec5SDimitry Andric 15380b57cec5SDimitry Andric if (ConsumeAfterOpt) { 15390b57cec5SDimitry Andric assert(PositionalOpts.size() > 0 && 15400b57cec5SDimitry Andric "Cannot specify cl::ConsumeAfter without a positional argument!"); 15410b57cec5SDimitry Andric } 15420b57cec5SDimitry Andric if (!PositionalOpts.empty()) { 15430b57cec5SDimitry Andric 15440b57cec5SDimitry Andric // Calculate how many positional values are _required_. 15450b57cec5SDimitry Andric bool UnboundedFound = false; 15460b57cec5SDimitry Andric for (size_t i = 0, e = PositionalOpts.size(); i != e; ++i) { 15470b57cec5SDimitry Andric Option *Opt = PositionalOpts[i]; 15480b57cec5SDimitry Andric if (RequiresValue(Opt)) 15490b57cec5SDimitry Andric ++NumPositionalRequired; 15500b57cec5SDimitry Andric else if (ConsumeAfterOpt) { 15510b57cec5SDimitry Andric // ConsumeAfter cannot be combined with "optional" positional options 15520b57cec5SDimitry Andric // unless there is only one positional argument... 15530b57cec5SDimitry Andric if (PositionalOpts.size() > 1) { 15540b57cec5SDimitry Andric if (!IgnoreErrors) 15550b57cec5SDimitry Andric Opt->error("error - this positional option will never be matched, " 15560b57cec5SDimitry Andric "because it does not Require a value, and a " 15570b57cec5SDimitry Andric "cl::ConsumeAfter option is active!"); 15580b57cec5SDimitry Andric ErrorParsing = true; 15590b57cec5SDimitry Andric } 15600b57cec5SDimitry Andric } else if (UnboundedFound && !Opt->hasArgStr()) { 15610b57cec5SDimitry Andric // This option does not "require" a value... Make sure this option is 15620b57cec5SDimitry Andric // not specified after an option that eats all extra arguments, or this 15630b57cec5SDimitry Andric // one will never get any! 15640b57cec5SDimitry Andric // 15650b57cec5SDimitry Andric if (!IgnoreErrors) 15660b57cec5SDimitry Andric Opt->error("error - option can never match, because " 15670b57cec5SDimitry Andric "another positional argument will match an " 15680b57cec5SDimitry Andric "unbounded number of values, and this option" 15690b57cec5SDimitry Andric " does not require a value!"); 15700b57cec5SDimitry Andric *Errs << ProgramName << ": CommandLine Error: Option '" << Opt->ArgStr 15710b57cec5SDimitry Andric << "' is all messed up!\n"; 15720b57cec5SDimitry Andric *Errs << PositionalOpts.size(); 15730b57cec5SDimitry Andric ErrorParsing = true; 15740b57cec5SDimitry Andric } 15750b57cec5SDimitry Andric UnboundedFound |= EatsUnboundedNumberOfValues(Opt); 15760b57cec5SDimitry Andric } 15770b57cec5SDimitry Andric HasUnlimitedPositionals = UnboundedFound || ConsumeAfterOpt; 15780b57cec5SDimitry Andric } 15790b57cec5SDimitry Andric 15800b57cec5SDimitry Andric // PositionalVals - A vector of "positional" arguments we accumulate into 15810b57cec5SDimitry Andric // the process at the end. 15820b57cec5SDimitry Andric // 15830b57cec5SDimitry Andric SmallVector<std::pair<StringRef, unsigned>, 4> PositionalVals; 15840b57cec5SDimitry Andric 15850b57cec5SDimitry Andric // If the program has named positional arguments, and the name has been run 15860b57cec5SDimitry Andric // across, keep track of which positional argument was named. Otherwise put 15870b57cec5SDimitry Andric // the positional args into the PositionalVals list... 15880b57cec5SDimitry Andric Option *ActivePositionalArg = nullptr; 15890b57cec5SDimitry Andric 15900b57cec5SDimitry Andric // Loop over all of the arguments... processing them. 15910b57cec5SDimitry Andric bool DashDashFound = false; // Have we read '--'? 15920b57cec5SDimitry Andric for (int i = FirstArg; i < argc; ++i) { 15930b57cec5SDimitry Andric Option *Handler = nullptr; 15940b57cec5SDimitry Andric std::string NearestHandlerString; 15950b57cec5SDimitry Andric StringRef Value; 15960b57cec5SDimitry Andric StringRef ArgName = ""; 15970b57cec5SDimitry Andric bool HaveDoubleDash = false; 15980b57cec5SDimitry Andric 15990b57cec5SDimitry Andric // Check to see if this is a positional argument. This argument is 16000b57cec5SDimitry Andric // considered to be positional if it doesn't start with '-', if it is "-" 16010b57cec5SDimitry Andric // itself, or if we have seen "--" already. 16020b57cec5SDimitry Andric // 16030b57cec5SDimitry Andric if (argv[i][0] != '-' || argv[i][1] == 0 || DashDashFound) { 16040b57cec5SDimitry Andric // Positional argument! 16050b57cec5SDimitry Andric if (ActivePositionalArg) { 16060b57cec5SDimitry Andric ProvidePositionalOption(ActivePositionalArg, StringRef(argv[i]), i); 16070b57cec5SDimitry Andric continue; // We are done! 16080b57cec5SDimitry Andric } 16090b57cec5SDimitry Andric 16100b57cec5SDimitry Andric if (!PositionalOpts.empty()) { 16110b57cec5SDimitry Andric PositionalVals.push_back(std::make_pair(StringRef(argv[i]), i)); 16120b57cec5SDimitry Andric 16130b57cec5SDimitry Andric // All of the positional arguments have been fulfulled, give the rest to 16140b57cec5SDimitry Andric // the consume after option... if it's specified... 16150b57cec5SDimitry Andric // 16160b57cec5SDimitry Andric if (PositionalVals.size() >= NumPositionalRequired && ConsumeAfterOpt) { 16170b57cec5SDimitry Andric for (++i; i < argc; ++i) 16180b57cec5SDimitry Andric PositionalVals.push_back(std::make_pair(StringRef(argv[i]), i)); 16190b57cec5SDimitry Andric break; // Handle outside of the argument processing loop... 16200b57cec5SDimitry Andric } 16210b57cec5SDimitry Andric 16220b57cec5SDimitry Andric // Delay processing positional arguments until the end... 16230b57cec5SDimitry Andric continue; 16240b57cec5SDimitry Andric } 16250b57cec5SDimitry Andric } else if (argv[i][0] == '-' && argv[i][1] == '-' && argv[i][2] == 0 && 16260b57cec5SDimitry Andric !DashDashFound) { 16270b57cec5SDimitry Andric DashDashFound = true; // This is the mythical "--"? 16280b57cec5SDimitry Andric continue; // Don't try to process it as an argument itself. 16290b57cec5SDimitry Andric } else if (ActivePositionalArg && 16300b57cec5SDimitry Andric (ActivePositionalArg->getMiscFlags() & PositionalEatsArgs)) { 16310b57cec5SDimitry Andric // If there is a positional argument eating options, check to see if this 16320b57cec5SDimitry Andric // option is another positional argument. If so, treat it as an argument, 16330b57cec5SDimitry Andric // otherwise feed it to the eating positional. 16340b57cec5SDimitry Andric ArgName = StringRef(argv[i] + 1); 16350b57cec5SDimitry Andric // Eat second dash. 16360b57cec5SDimitry Andric if (!ArgName.empty() && ArgName[0] == '-') { 16370b57cec5SDimitry Andric HaveDoubleDash = true; 16380b57cec5SDimitry Andric ArgName = ArgName.substr(1); 16390b57cec5SDimitry Andric } 16400b57cec5SDimitry Andric 16410b57cec5SDimitry Andric Handler = LookupLongOption(*ChosenSubCommand, ArgName, Value, 16420b57cec5SDimitry Andric LongOptionsUseDoubleDash, HaveDoubleDash); 16430b57cec5SDimitry Andric if (!Handler || Handler->getFormattingFlag() != cl::Positional) { 16440b57cec5SDimitry Andric ProvidePositionalOption(ActivePositionalArg, StringRef(argv[i]), i); 16450b57cec5SDimitry Andric continue; // We are done! 16460b57cec5SDimitry Andric } 16470b57cec5SDimitry Andric } else { // We start with a '-', must be an argument. 16480b57cec5SDimitry Andric ArgName = StringRef(argv[i] + 1); 16490b57cec5SDimitry Andric // Eat second dash. 16500b57cec5SDimitry Andric if (!ArgName.empty() && ArgName[0] == '-') { 16510b57cec5SDimitry Andric HaveDoubleDash = true; 16520b57cec5SDimitry Andric ArgName = ArgName.substr(1); 16530b57cec5SDimitry Andric } 16540b57cec5SDimitry Andric 16550b57cec5SDimitry Andric Handler = LookupLongOption(*ChosenSubCommand, ArgName, Value, 16560b57cec5SDimitry Andric LongOptionsUseDoubleDash, HaveDoubleDash); 16570b57cec5SDimitry Andric 16585f757f3fSDimitry Andric // If Handler is not found in a specialized subcommand, look up handler 16595f757f3fSDimitry Andric // in the top-level subcommand. 16605f757f3fSDimitry Andric // cl::opt without cl::sub belongs to top-level subcommand. 16615f757f3fSDimitry Andric if (!Handler && ChosenSubCommand != &SubCommand::getTopLevel()) 16625f757f3fSDimitry Andric Handler = LookupLongOption(SubCommand::getTopLevel(), ArgName, Value, 16635f757f3fSDimitry Andric LongOptionsUseDoubleDash, HaveDoubleDash); 16645f757f3fSDimitry Andric 16650b57cec5SDimitry Andric // Check to see if this "option" is really a prefixed or grouped argument. 16660b57cec5SDimitry Andric if (!Handler && !(LongOptionsUseDoubleDash && HaveDoubleDash)) 16670b57cec5SDimitry Andric Handler = HandlePrefixedOrGroupedOption(ArgName, Value, ErrorParsing, 16680b57cec5SDimitry Andric OptionsMap); 16690b57cec5SDimitry Andric 16700b57cec5SDimitry Andric // Otherwise, look for the closest available option to report to the user 16710b57cec5SDimitry Andric // in the upcoming error. 16720b57cec5SDimitry Andric if (!Handler && SinkOpts.empty()) 16730b57cec5SDimitry Andric LookupNearestOption(ArgName, OptionsMap, NearestHandlerString); 16740b57cec5SDimitry Andric } 16750b57cec5SDimitry Andric 16760b57cec5SDimitry Andric if (!Handler) { 16775f757f3fSDimitry Andric if (!SinkOpts.empty()) { 16780eae32dcSDimitry Andric for (Option *SinkOpt : SinkOpts) 16790eae32dcSDimitry Andric SinkOpt->addOccurrence(i, "", StringRef(argv[i])); 16805f757f3fSDimitry Andric continue; 16810b57cec5SDimitry Andric } 16825f757f3fSDimitry Andric 16835f757f3fSDimitry Andric auto ReportUnknownArgument = [&](bool IsArg, 16845f757f3fSDimitry Andric StringRef NearestArgumentName) { 16855f757f3fSDimitry Andric *Errs << ProgramName << ": Unknown " 16865f757f3fSDimitry Andric << (IsArg ? "command line argument" : "subcommand") << " '" 16875f757f3fSDimitry Andric << argv[i] << "'. Try: '" << argv[0] << " --help'\n"; 16885f757f3fSDimitry Andric 16895f757f3fSDimitry Andric if (NearestArgumentName.empty()) 16905f757f3fSDimitry Andric return; 16915f757f3fSDimitry Andric 16925f757f3fSDimitry Andric *Errs << ProgramName << ": Did you mean '"; 16935f757f3fSDimitry Andric if (IsArg) 16945f757f3fSDimitry Andric *Errs << PrintArg(NearestArgumentName, 0); 16955f757f3fSDimitry Andric else 16965f757f3fSDimitry Andric *Errs << NearestArgumentName; 16975f757f3fSDimitry Andric *Errs << "'?\n"; 16985f757f3fSDimitry Andric }; 16995f757f3fSDimitry Andric 17005f757f3fSDimitry Andric if (i > 1 || !MaybeNamedSubCommand) 17015f757f3fSDimitry Andric ReportUnknownArgument(/*IsArg=*/true, NearestHandlerString); 17025f757f3fSDimitry Andric else 17035f757f3fSDimitry Andric ReportUnknownArgument(/*IsArg=*/false, NearestSubCommandString); 17045f757f3fSDimitry Andric 17055f757f3fSDimitry Andric ErrorParsing = true; 17060b57cec5SDimitry Andric continue; 17070b57cec5SDimitry Andric } 17080b57cec5SDimitry Andric 17090b57cec5SDimitry Andric // If this is a named positional argument, just remember that it is the 17100b57cec5SDimitry Andric // active one... 17110b57cec5SDimitry Andric if (Handler->getFormattingFlag() == cl::Positional) { 17120b57cec5SDimitry Andric if ((Handler->getMiscFlags() & PositionalEatsArgs) && !Value.empty()) { 17130b57cec5SDimitry Andric Handler->error("This argument does not take a value.\n" 17140b57cec5SDimitry Andric "\tInstead, it consumes any positional arguments until " 17150b57cec5SDimitry Andric "the next recognized option.", *Errs); 17160b57cec5SDimitry Andric ErrorParsing = true; 17170b57cec5SDimitry Andric } 17180b57cec5SDimitry Andric ActivePositionalArg = Handler; 17190b57cec5SDimitry Andric } 17200b57cec5SDimitry Andric else 17210b57cec5SDimitry Andric ErrorParsing |= ProvideOption(Handler, ArgName, Value, argc, argv, i); 17220b57cec5SDimitry Andric } 17230b57cec5SDimitry Andric 17240b57cec5SDimitry Andric // Check and handle positional arguments now... 17250b57cec5SDimitry Andric if (NumPositionalRequired > PositionalVals.size()) { 17260b57cec5SDimitry Andric *Errs << ProgramName 17270b57cec5SDimitry Andric << ": Not enough positional command line arguments specified!\n" 17280b57cec5SDimitry Andric << "Must specify at least " << NumPositionalRequired 17290b57cec5SDimitry Andric << " positional argument" << (NumPositionalRequired > 1 ? "s" : "") 17300b57cec5SDimitry Andric << ": See: " << argv[0] << " --help\n"; 17310b57cec5SDimitry Andric 17320b57cec5SDimitry Andric ErrorParsing = true; 17330b57cec5SDimitry Andric } else if (!HasUnlimitedPositionals && 17340b57cec5SDimitry Andric PositionalVals.size() > PositionalOpts.size()) { 17350b57cec5SDimitry Andric *Errs << ProgramName << ": Too many positional arguments specified!\n" 17360b57cec5SDimitry Andric << "Can specify at most " << PositionalOpts.size() 17370b57cec5SDimitry Andric << " positional arguments: See: " << argv[0] << " --help\n"; 17380b57cec5SDimitry Andric ErrorParsing = true; 17390b57cec5SDimitry Andric 17400b57cec5SDimitry Andric } else if (!ConsumeAfterOpt) { 17410b57cec5SDimitry Andric // Positional args have already been handled if ConsumeAfter is specified. 17420b57cec5SDimitry Andric unsigned ValNo = 0, NumVals = static_cast<unsigned>(PositionalVals.size()); 17430b57cec5SDimitry Andric for (size_t i = 0, e = PositionalOpts.size(); i != e; ++i) { 17440b57cec5SDimitry Andric if (RequiresValue(PositionalOpts[i])) { 17450b57cec5SDimitry Andric ProvidePositionalOption(PositionalOpts[i], PositionalVals[ValNo].first, 17460b57cec5SDimitry Andric PositionalVals[ValNo].second); 17470b57cec5SDimitry Andric ValNo++; 17480b57cec5SDimitry Andric --NumPositionalRequired; // We fulfilled our duty... 17490b57cec5SDimitry Andric } 17500b57cec5SDimitry Andric 17510b57cec5SDimitry Andric // If we _can_ give this option more arguments, do so now, as long as we 17520b57cec5SDimitry Andric // do not give it values that others need. 'Done' controls whether the 17530b57cec5SDimitry Andric // option even _WANTS_ any more. 17540b57cec5SDimitry Andric // 17550b57cec5SDimitry Andric bool Done = PositionalOpts[i]->getNumOccurrencesFlag() == cl::Required; 17560b57cec5SDimitry Andric while (NumVals - ValNo > NumPositionalRequired && !Done) { 17570b57cec5SDimitry Andric switch (PositionalOpts[i]->getNumOccurrencesFlag()) { 17580b57cec5SDimitry Andric case cl::Optional: 17590b57cec5SDimitry Andric Done = true; // Optional arguments want _at most_ one value 1760bdd1243dSDimitry Andric [[fallthrough]]; 17610b57cec5SDimitry Andric case cl::ZeroOrMore: // Zero or more will take all they can get... 17620b57cec5SDimitry Andric case cl::OneOrMore: // One or more will take all they can get... 17630b57cec5SDimitry Andric ProvidePositionalOption(PositionalOpts[i], 17640b57cec5SDimitry Andric PositionalVals[ValNo].first, 17650b57cec5SDimitry Andric PositionalVals[ValNo].second); 17660b57cec5SDimitry Andric ValNo++; 17670b57cec5SDimitry Andric break; 17680b57cec5SDimitry Andric default: 17690b57cec5SDimitry Andric llvm_unreachable("Internal error, unexpected NumOccurrences flag in " 17700b57cec5SDimitry Andric "positional argument processing!"); 17710b57cec5SDimitry Andric } 17720b57cec5SDimitry Andric } 17730b57cec5SDimitry Andric } 17740b57cec5SDimitry Andric } else { 17750b57cec5SDimitry Andric assert(ConsumeAfterOpt && NumPositionalRequired <= PositionalVals.size()); 17760b57cec5SDimitry Andric unsigned ValNo = 0; 17775ffd83dbSDimitry Andric for (size_t J = 0, E = PositionalOpts.size(); J != E; ++J) 17785ffd83dbSDimitry Andric if (RequiresValue(PositionalOpts[J])) { 17795ffd83dbSDimitry Andric ErrorParsing |= ProvidePositionalOption(PositionalOpts[J], 17800b57cec5SDimitry Andric PositionalVals[ValNo].first, 17810b57cec5SDimitry Andric PositionalVals[ValNo].second); 17820b57cec5SDimitry Andric ValNo++; 17830b57cec5SDimitry Andric } 17840b57cec5SDimitry Andric 17850b57cec5SDimitry Andric // Handle the case where there is just one positional option, and it's 17860b57cec5SDimitry Andric // optional. In this case, we want to give JUST THE FIRST option to the 17870b57cec5SDimitry Andric // positional option and keep the rest for the consume after. The above 17880b57cec5SDimitry Andric // loop would have assigned no values to positional options in this case. 17890b57cec5SDimitry Andric // 17900b57cec5SDimitry Andric if (PositionalOpts.size() == 1 && ValNo == 0 && !PositionalVals.empty()) { 17910b57cec5SDimitry Andric ErrorParsing |= ProvidePositionalOption(PositionalOpts[0], 17920b57cec5SDimitry Andric PositionalVals[ValNo].first, 17930b57cec5SDimitry Andric PositionalVals[ValNo].second); 17940b57cec5SDimitry Andric ValNo++; 17950b57cec5SDimitry Andric } 17960b57cec5SDimitry Andric 17970b57cec5SDimitry Andric // Handle over all of the rest of the arguments to the 17980b57cec5SDimitry Andric // cl::ConsumeAfter command line option... 17990b57cec5SDimitry Andric for (; ValNo != PositionalVals.size(); ++ValNo) 18000b57cec5SDimitry Andric ErrorParsing |= 18010b57cec5SDimitry Andric ProvidePositionalOption(ConsumeAfterOpt, PositionalVals[ValNo].first, 18020b57cec5SDimitry Andric PositionalVals[ValNo].second); 18030b57cec5SDimitry Andric } 18040b57cec5SDimitry Andric 18050b57cec5SDimitry Andric // Loop over args and make sure all required args are specified! 18060b57cec5SDimitry Andric for (const auto &Opt : OptionsMap) { 18070b57cec5SDimitry Andric switch (Opt.second->getNumOccurrencesFlag()) { 18080b57cec5SDimitry Andric case Required: 18090b57cec5SDimitry Andric case OneOrMore: 18100b57cec5SDimitry Andric if (Opt.second->getNumOccurrences() == 0) { 18110b57cec5SDimitry Andric Opt.second->error("must be specified at least once!"); 18120b57cec5SDimitry Andric ErrorParsing = true; 18130b57cec5SDimitry Andric } 1814bdd1243dSDimitry Andric [[fallthrough]]; 18150b57cec5SDimitry Andric default: 18160b57cec5SDimitry Andric break; 18170b57cec5SDimitry Andric } 18180b57cec5SDimitry Andric } 18190b57cec5SDimitry Andric 18200b57cec5SDimitry Andric // Now that we know if -debug is specified, we can use it. 18210b57cec5SDimitry Andric // Note that if ReadResponseFiles == true, this must be done before the 18220b57cec5SDimitry Andric // memory allocated for the expanded command line is free()d below. 18230b57cec5SDimitry Andric LLVM_DEBUG(dbgs() << "Args: "; 18240b57cec5SDimitry Andric for (int i = 0; i < argc; ++i) dbgs() << argv[i] << ' '; 18250b57cec5SDimitry Andric dbgs() << '\n';); 18260b57cec5SDimitry Andric 18270b57cec5SDimitry Andric // Free all of the memory allocated to the map. Command line options may only 18280b57cec5SDimitry Andric // be processed once! 18290b57cec5SDimitry Andric MoreHelp.clear(); 18300b57cec5SDimitry Andric 18310b57cec5SDimitry Andric // If we had an error processing our arguments, don't let the program execute 18320b57cec5SDimitry Andric if (ErrorParsing) { 18330b57cec5SDimitry Andric if (!IgnoreErrors) 18340b57cec5SDimitry Andric exit(1); 18350b57cec5SDimitry Andric return false; 18360b57cec5SDimitry Andric } 18370b57cec5SDimitry Andric return true; 18380b57cec5SDimitry Andric } 18390b57cec5SDimitry Andric 18400b57cec5SDimitry Andric //===----------------------------------------------------------------------===// 18410b57cec5SDimitry Andric // Option Base class implementation 18420b57cec5SDimitry Andric // 18430b57cec5SDimitry Andric 18440b57cec5SDimitry Andric bool Option::error(const Twine &Message, StringRef ArgName, raw_ostream &Errs) { 18450b57cec5SDimitry Andric if (!ArgName.data()) 18460b57cec5SDimitry Andric ArgName = ArgStr; 18470b57cec5SDimitry Andric if (ArgName.empty()) 18480b57cec5SDimitry Andric Errs << HelpStr; // Be nice for positional arguments 18490b57cec5SDimitry Andric else 1850480093f4SDimitry Andric Errs << GlobalParser->ProgramName << ": for the " << PrintArg(ArgName, 0); 18510b57cec5SDimitry Andric 18520b57cec5SDimitry Andric Errs << " option: " << Message << "\n"; 18530b57cec5SDimitry Andric return true; 18540b57cec5SDimitry Andric } 18550b57cec5SDimitry Andric 18560b57cec5SDimitry Andric bool Option::addOccurrence(unsigned pos, StringRef ArgName, StringRef Value, 18570b57cec5SDimitry Andric bool MultiArg) { 18580b57cec5SDimitry Andric if (!MultiArg) 18590b57cec5SDimitry Andric NumOccurrences++; // Increment the number of times we have been seen 18600b57cec5SDimitry Andric 18610b57cec5SDimitry Andric return handleOccurrence(pos, ArgName, Value); 18620b57cec5SDimitry Andric } 18630b57cec5SDimitry Andric 18640b57cec5SDimitry Andric // getValueStr - Get the value description string, using "DefaultMsg" if nothing 18650b57cec5SDimitry Andric // has been specified yet. 18660b57cec5SDimitry Andric // 18670b57cec5SDimitry Andric static StringRef getValueStr(const Option &O, StringRef DefaultMsg) { 18680b57cec5SDimitry Andric if (O.ValueStr.empty()) 18690b57cec5SDimitry Andric return DefaultMsg; 18700b57cec5SDimitry Andric return O.ValueStr; 18710b57cec5SDimitry Andric } 18720b57cec5SDimitry Andric 18730b57cec5SDimitry Andric //===----------------------------------------------------------------------===// 18740b57cec5SDimitry Andric // cl::alias class implementation 18750b57cec5SDimitry Andric // 18760b57cec5SDimitry Andric 18770b57cec5SDimitry Andric // Return the width of the option tag for printing... 18780b57cec5SDimitry Andric size_t alias::getOptionWidth() const { 18790b57cec5SDimitry Andric return argPlusPrefixesSize(ArgStr); 18800b57cec5SDimitry Andric } 18810b57cec5SDimitry Andric 18820b57cec5SDimitry Andric void Option::printHelpStr(StringRef HelpStr, size_t Indent, 18830b57cec5SDimitry Andric size_t FirstLineIndentedBy) { 18840b57cec5SDimitry Andric assert(Indent >= FirstLineIndentedBy); 18850b57cec5SDimitry Andric std::pair<StringRef, StringRef> Split = HelpStr.split('\n'); 18860b57cec5SDimitry Andric outs().indent(Indent - FirstLineIndentedBy) 18870b57cec5SDimitry Andric << ArgHelpPrefix << Split.first << "\n"; 18880b57cec5SDimitry Andric while (!Split.second.empty()) { 18890b57cec5SDimitry Andric Split = Split.second.split('\n'); 18900b57cec5SDimitry Andric outs().indent(Indent) << Split.first << "\n"; 18910b57cec5SDimitry Andric } 18920b57cec5SDimitry Andric } 18930b57cec5SDimitry Andric 1894d409305fSDimitry Andric void Option::printEnumValHelpStr(StringRef HelpStr, size_t BaseIndent, 1895d409305fSDimitry Andric size_t FirstLineIndentedBy) { 1896d409305fSDimitry Andric const StringRef ValHelpPrefix = " "; 189723408297SDimitry Andric assert(BaseIndent >= FirstLineIndentedBy); 1898d409305fSDimitry Andric std::pair<StringRef, StringRef> Split = HelpStr.split('\n'); 1899d409305fSDimitry Andric outs().indent(BaseIndent - FirstLineIndentedBy) 1900d409305fSDimitry Andric << ArgHelpPrefix << ValHelpPrefix << Split.first << "\n"; 1901d409305fSDimitry Andric while (!Split.second.empty()) { 1902d409305fSDimitry Andric Split = Split.second.split('\n'); 1903d409305fSDimitry Andric outs().indent(BaseIndent + ValHelpPrefix.size()) << Split.first << "\n"; 1904d409305fSDimitry Andric } 1905d409305fSDimitry Andric } 1906d409305fSDimitry Andric 19070b57cec5SDimitry Andric // Print out the option for the alias. 19080b57cec5SDimitry Andric void alias::printOptionInfo(size_t GlobalWidth) const { 19090b57cec5SDimitry Andric outs() << PrintArg(ArgStr); 19100b57cec5SDimitry Andric printHelpStr(HelpStr, GlobalWidth, argPlusPrefixesSize(ArgStr)); 19110b57cec5SDimitry Andric } 19120b57cec5SDimitry Andric 19130b57cec5SDimitry Andric //===----------------------------------------------------------------------===// 19140b57cec5SDimitry Andric // Parser Implementation code... 19150b57cec5SDimitry Andric // 19160b57cec5SDimitry Andric 19170b57cec5SDimitry Andric // basic_parser implementation 19180b57cec5SDimitry Andric // 19190b57cec5SDimitry Andric 19200b57cec5SDimitry Andric // Return the width of the option tag for printing... 19210b57cec5SDimitry Andric size_t basic_parser_impl::getOptionWidth(const Option &O) const { 19220b57cec5SDimitry Andric size_t Len = argPlusPrefixesSize(O.ArgStr); 19230b57cec5SDimitry Andric auto ValName = getValueName(); 19240b57cec5SDimitry Andric if (!ValName.empty()) { 19250b57cec5SDimitry Andric size_t FormattingLen = 3; 19260b57cec5SDimitry Andric if (O.getMiscFlags() & PositionalEatsArgs) 19270b57cec5SDimitry Andric FormattingLen = 6; 19280b57cec5SDimitry Andric Len += getValueStr(O, ValName).size() + FormattingLen; 19290b57cec5SDimitry Andric } 19300b57cec5SDimitry Andric 19310b57cec5SDimitry Andric return Len; 19320b57cec5SDimitry Andric } 19330b57cec5SDimitry Andric 19340b57cec5SDimitry Andric // printOptionInfo - Print out information about this option. The 19350b57cec5SDimitry Andric // to-be-maintained width is specified. 19360b57cec5SDimitry Andric // 19370b57cec5SDimitry Andric void basic_parser_impl::printOptionInfo(const Option &O, 19380b57cec5SDimitry Andric size_t GlobalWidth) const { 19390b57cec5SDimitry Andric outs() << PrintArg(O.ArgStr); 19400b57cec5SDimitry Andric 19410b57cec5SDimitry Andric auto ValName = getValueName(); 19420b57cec5SDimitry Andric if (!ValName.empty()) { 19430b57cec5SDimitry Andric if (O.getMiscFlags() & PositionalEatsArgs) { 19440b57cec5SDimitry Andric outs() << " <" << getValueStr(O, ValName) << ">..."; 19455ffd83dbSDimitry Andric } else if (O.getValueExpectedFlag() == ValueOptional) 19465ffd83dbSDimitry Andric outs() << "[=<" << getValueStr(O, ValName) << ">]"; 1947753f127fSDimitry Andric else { 1948753f127fSDimitry Andric outs() << (O.ArgStr.size() == 1 ? " <" : "=<") << getValueStr(O, ValName) 1949753f127fSDimitry Andric << '>'; 1950753f127fSDimitry Andric } 19510b57cec5SDimitry Andric } 19520b57cec5SDimitry Andric 19530b57cec5SDimitry Andric Option::printHelpStr(O.HelpStr, GlobalWidth, getOptionWidth(O)); 19540b57cec5SDimitry Andric } 19550b57cec5SDimitry Andric 19560b57cec5SDimitry Andric void basic_parser_impl::printOptionName(const Option &O, 19570b57cec5SDimitry Andric size_t GlobalWidth) const { 19580b57cec5SDimitry Andric outs() << PrintArg(O.ArgStr); 19590b57cec5SDimitry Andric outs().indent(GlobalWidth - O.ArgStr.size()); 19600b57cec5SDimitry Andric } 19610b57cec5SDimitry Andric 19620b57cec5SDimitry Andric // parser<bool> implementation 19630b57cec5SDimitry Andric // 19640b57cec5SDimitry Andric bool parser<bool>::parse(Option &O, StringRef ArgName, StringRef Arg, 19650b57cec5SDimitry Andric bool &Value) { 19660b57cec5SDimitry Andric if (Arg == "" || Arg == "true" || Arg == "TRUE" || Arg == "True" || 19670b57cec5SDimitry Andric Arg == "1") { 19680b57cec5SDimitry Andric Value = true; 19690b57cec5SDimitry Andric return false; 19700b57cec5SDimitry Andric } 19710b57cec5SDimitry Andric 19720b57cec5SDimitry Andric if (Arg == "false" || Arg == "FALSE" || Arg == "False" || Arg == "0") { 19730b57cec5SDimitry Andric Value = false; 19740b57cec5SDimitry Andric return false; 19750b57cec5SDimitry Andric } 19760b57cec5SDimitry Andric return O.error("'" + Arg + 19770b57cec5SDimitry Andric "' is invalid value for boolean argument! Try 0 or 1"); 19780b57cec5SDimitry Andric } 19790b57cec5SDimitry Andric 19800b57cec5SDimitry Andric // parser<boolOrDefault> implementation 19810b57cec5SDimitry Andric // 19820b57cec5SDimitry Andric bool parser<boolOrDefault>::parse(Option &O, StringRef ArgName, StringRef Arg, 19830b57cec5SDimitry Andric boolOrDefault &Value) { 19840b57cec5SDimitry Andric if (Arg == "" || Arg == "true" || Arg == "TRUE" || Arg == "True" || 19850b57cec5SDimitry Andric Arg == "1") { 19860b57cec5SDimitry Andric Value = BOU_TRUE; 19870b57cec5SDimitry Andric return false; 19880b57cec5SDimitry Andric } 19890b57cec5SDimitry Andric if (Arg == "false" || Arg == "FALSE" || Arg == "False" || Arg == "0") { 19900b57cec5SDimitry Andric Value = BOU_FALSE; 19910b57cec5SDimitry Andric return false; 19920b57cec5SDimitry Andric } 19930b57cec5SDimitry Andric 19940b57cec5SDimitry Andric return O.error("'" + Arg + 19950b57cec5SDimitry Andric "' is invalid value for boolean argument! Try 0 or 1"); 19960b57cec5SDimitry Andric } 19970b57cec5SDimitry Andric 19980b57cec5SDimitry Andric // parser<int> implementation 19990b57cec5SDimitry Andric // 20000b57cec5SDimitry Andric bool parser<int>::parse(Option &O, StringRef ArgName, StringRef Arg, 20010b57cec5SDimitry Andric int &Value) { 20020b57cec5SDimitry Andric if (Arg.getAsInteger(0, Value)) 20030b57cec5SDimitry Andric return O.error("'" + Arg + "' value invalid for integer argument!"); 20040b57cec5SDimitry Andric return false; 20050b57cec5SDimitry Andric } 20060b57cec5SDimitry Andric 2007480093f4SDimitry Andric // parser<long> implementation 2008480093f4SDimitry Andric // 2009480093f4SDimitry Andric bool parser<long>::parse(Option &O, StringRef ArgName, StringRef Arg, 2010480093f4SDimitry Andric long &Value) { 2011480093f4SDimitry Andric if (Arg.getAsInteger(0, Value)) 2012480093f4SDimitry Andric return O.error("'" + Arg + "' value invalid for long argument!"); 2013480093f4SDimitry Andric return false; 2014480093f4SDimitry Andric } 2015480093f4SDimitry Andric 2016480093f4SDimitry Andric // parser<long long> implementation 2017480093f4SDimitry Andric // 2018480093f4SDimitry Andric bool parser<long long>::parse(Option &O, StringRef ArgName, StringRef Arg, 2019480093f4SDimitry Andric long long &Value) { 2020480093f4SDimitry Andric if (Arg.getAsInteger(0, Value)) 2021480093f4SDimitry Andric return O.error("'" + Arg + "' value invalid for llong argument!"); 2022480093f4SDimitry Andric return false; 2023480093f4SDimitry Andric } 2024480093f4SDimitry Andric 20250b57cec5SDimitry Andric // parser<unsigned> implementation 20260b57cec5SDimitry Andric // 20270b57cec5SDimitry Andric bool parser<unsigned>::parse(Option &O, StringRef ArgName, StringRef Arg, 20280b57cec5SDimitry Andric unsigned &Value) { 20290b57cec5SDimitry Andric 20300b57cec5SDimitry Andric if (Arg.getAsInteger(0, Value)) 20310b57cec5SDimitry Andric return O.error("'" + Arg + "' value invalid for uint argument!"); 20320b57cec5SDimitry Andric return false; 20330b57cec5SDimitry Andric } 20340b57cec5SDimitry Andric 20350b57cec5SDimitry Andric // parser<unsigned long> implementation 20360b57cec5SDimitry Andric // 20370b57cec5SDimitry Andric bool parser<unsigned long>::parse(Option &O, StringRef ArgName, StringRef Arg, 20380b57cec5SDimitry Andric unsigned long &Value) { 20390b57cec5SDimitry Andric 20400b57cec5SDimitry Andric if (Arg.getAsInteger(0, Value)) 20410b57cec5SDimitry Andric return O.error("'" + Arg + "' value invalid for ulong argument!"); 20420b57cec5SDimitry Andric return false; 20430b57cec5SDimitry Andric } 20440b57cec5SDimitry Andric 20450b57cec5SDimitry Andric // parser<unsigned long long> implementation 20460b57cec5SDimitry Andric // 20470b57cec5SDimitry Andric bool parser<unsigned long long>::parse(Option &O, StringRef ArgName, 20480b57cec5SDimitry Andric StringRef Arg, 20490b57cec5SDimitry Andric unsigned long long &Value) { 20500b57cec5SDimitry Andric 20510b57cec5SDimitry Andric if (Arg.getAsInteger(0, Value)) 20520b57cec5SDimitry Andric return O.error("'" + Arg + "' value invalid for ullong argument!"); 20530b57cec5SDimitry Andric return false; 20540b57cec5SDimitry Andric } 20550b57cec5SDimitry Andric 20560b57cec5SDimitry Andric // parser<double>/parser<float> implementation 20570b57cec5SDimitry Andric // 20580b57cec5SDimitry Andric static bool parseDouble(Option &O, StringRef Arg, double &Value) { 20590b57cec5SDimitry Andric if (to_float(Arg, Value)) 20600b57cec5SDimitry Andric return false; 20610b57cec5SDimitry Andric return O.error("'" + Arg + "' value invalid for floating point argument!"); 20620b57cec5SDimitry Andric } 20630b57cec5SDimitry Andric 20640b57cec5SDimitry Andric bool parser<double>::parse(Option &O, StringRef ArgName, StringRef Arg, 20650b57cec5SDimitry Andric double &Val) { 20660b57cec5SDimitry Andric return parseDouble(O, Arg, Val); 20670b57cec5SDimitry Andric } 20680b57cec5SDimitry Andric 20690b57cec5SDimitry Andric bool parser<float>::parse(Option &O, StringRef ArgName, StringRef Arg, 20700b57cec5SDimitry Andric float &Val) { 20710b57cec5SDimitry Andric double dVal; 20720b57cec5SDimitry Andric if (parseDouble(O, Arg, dVal)) 20730b57cec5SDimitry Andric return true; 20740b57cec5SDimitry Andric Val = (float)dVal; 20750b57cec5SDimitry Andric return false; 20760b57cec5SDimitry Andric } 20770b57cec5SDimitry Andric 20780b57cec5SDimitry Andric // generic_parser_base implementation 20790b57cec5SDimitry Andric // 20800b57cec5SDimitry Andric 20810b57cec5SDimitry Andric // findOption - Return the option number corresponding to the specified 20820b57cec5SDimitry Andric // argument string. If the option is not found, getNumOptions() is returned. 20830b57cec5SDimitry Andric // 20840b57cec5SDimitry Andric unsigned generic_parser_base::findOption(StringRef Name) { 20850b57cec5SDimitry Andric unsigned e = getNumOptions(); 20860b57cec5SDimitry Andric 20870b57cec5SDimitry Andric for (unsigned i = 0; i != e; ++i) { 20880b57cec5SDimitry Andric if (getOption(i) == Name) 20890b57cec5SDimitry Andric return i; 20900b57cec5SDimitry Andric } 20910b57cec5SDimitry Andric return e; 20920b57cec5SDimitry Andric } 20930b57cec5SDimitry Andric 20940b57cec5SDimitry Andric static StringRef EqValue = "=<value>"; 20950b57cec5SDimitry Andric static StringRef EmptyOption = "<empty>"; 20960b57cec5SDimitry Andric static StringRef OptionPrefix = " ="; 2097fe6060f1SDimitry Andric static size_t getOptionPrefixesSize() { 2098fe6060f1SDimitry Andric return OptionPrefix.size() + ArgHelpPrefix.size(); 2099fe6060f1SDimitry Andric } 21000b57cec5SDimitry Andric 21010b57cec5SDimitry Andric static bool shouldPrintOption(StringRef Name, StringRef Description, 21020b57cec5SDimitry Andric const Option &O) { 21030b57cec5SDimitry Andric return O.getValueExpectedFlag() != ValueOptional || !Name.empty() || 21040b57cec5SDimitry Andric !Description.empty(); 21050b57cec5SDimitry Andric } 21060b57cec5SDimitry Andric 21070b57cec5SDimitry Andric // Return the width of the option tag for printing... 21080b57cec5SDimitry Andric size_t generic_parser_base::getOptionWidth(const Option &O) const { 21090b57cec5SDimitry Andric if (O.hasArgStr()) { 21100b57cec5SDimitry Andric size_t Size = 21110b57cec5SDimitry Andric argPlusPrefixesSize(O.ArgStr) + EqValue.size(); 21120b57cec5SDimitry Andric for (unsigned i = 0, e = getNumOptions(); i != e; ++i) { 21130b57cec5SDimitry Andric StringRef Name = getOption(i); 21140b57cec5SDimitry Andric if (!shouldPrintOption(Name, getDescription(i), O)) 21150b57cec5SDimitry Andric continue; 21160b57cec5SDimitry Andric size_t NameSize = Name.empty() ? EmptyOption.size() : Name.size(); 2117fe6060f1SDimitry Andric Size = std::max(Size, NameSize + getOptionPrefixesSize()); 21180b57cec5SDimitry Andric } 21190b57cec5SDimitry Andric return Size; 21200b57cec5SDimitry Andric } else { 21210b57cec5SDimitry Andric size_t BaseSize = 0; 21220b57cec5SDimitry Andric for (unsigned i = 0, e = getNumOptions(); i != e; ++i) 21230b57cec5SDimitry Andric BaseSize = std::max(BaseSize, getOption(i).size() + 8); 21240b57cec5SDimitry Andric return BaseSize; 21250b57cec5SDimitry Andric } 21260b57cec5SDimitry Andric } 21270b57cec5SDimitry Andric 21280b57cec5SDimitry Andric // printOptionInfo - Print out information about this option. The 21290b57cec5SDimitry Andric // to-be-maintained width is specified. 21300b57cec5SDimitry Andric // 21310b57cec5SDimitry Andric void generic_parser_base::printOptionInfo(const Option &O, 21320b57cec5SDimitry Andric size_t GlobalWidth) const { 21330b57cec5SDimitry Andric if (O.hasArgStr()) { 21340b57cec5SDimitry Andric // When the value is optional, first print a line just describing the 21350b57cec5SDimitry Andric // option without values. 21360b57cec5SDimitry Andric if (O.getValueExpectedFlag() == ValueOptional) { 21370b57cec5SDimitry Andric for (unsigned i = 0, e = getNumOptions(); i != e; ++i) { 21380b57cec5SDimitry Andric if (getOption(i).empty()) { 21390b57cec5SDimitry Andric outs() << PrintArg(O.ArgStr); 21400b57cec5SDimitry Andric Option::printHelpStr(O.HelpStr, GlobalWidth, 21410b57cec5SDimitry Andric argPlusPrefixesSize(O.ArgStr)); 21420b57cec5SDimitry Andric break; 21430b57cec5SDimitry Andric } 21440b57cec5SDimitry Andric } 21450b57cec5SDimitry Andric } 21460b57cec5SDimitry Andric 21470b57cec5SDimitry Andric outs() << PrintArg(O.ArgStr) << EqValue; 21480b57cec5SDimitry Andric Option::printHelpStr(O.HelpStr, GlobalWidth, 21490b57cec5SDimitry Andric EqValue.size() + 21500b57cec5SDimitry Andric argPlusPrefixesSize(O.ArgStr)); 21510b57cec5SDimitry Andric for (unsigned i = 0, e = getNumOptions(); i != e; ++i) { 21520b57cec5SDimitry Andric StringRef OptionName = getOption(i); 21530b57cec5SDimitry Andric StringRef Description = getDescription(i); 21540b57cec5SDimitry Andric if (!shouldPrintOption(OptionName, Description, O)) 21550b57cec5SDimitry Andric continue; 2156fe6060f1SDimitry Andric size_t FirstLineIndent = OptionName.size() + getOptionPrefixesSize(); 21570b57cec5SDimitry Andric outs() << OptionPrefix << OptionName; 21580b57cec5SDimitry Andric if (OptionName.empty()) { 21590b57cec5SDimitry Andric outs() << EmptyOption; 2160d409305fSDimitry Andric assert(FirstLineIndent >= EmptyOption.size()); 2161d409305fSDimitry Andric FirstLineIndent += EmptyOption.size(); 21620b57cec5SDimitry Andric } 21630b57cec5SDimitry Andric if (!Description.empty()) 2164d409305fSDimitry Andric Option::printEnumValHelpStr(Description, GlobalWidth, FirstLineIndent); 2165d409305fSDimitry Andric else 21660b57cec5SDimitry Andric outs() << '\n'; 21670b57cec5SDimitry Andric } 21680b57cec5SDimitry Andric } else { 21690b57cec5SDimitry Andric if (!O.HelpStr.empty()) 21700b57cec5SDimitry Andric outs() << " " << O.HelpStr << '\n'; 21710b57cec5SDimitry Andric for (unsigned i = 0, e = getNumOptions(); i != e; ++i) { 21720b57cec5SDimitry Andric StringRef Option = getOption(i); 21730b57cec5SDimitry Andric outs() << " " << PrintArg(Option); 21740b57cec5SDimitry Andric Option::printHelpStr(getDescription(i), GlobalWidth, Option.size() + 8); 21750b57cec5SDimitry Andric } 21760b57cec5SDimitry Andric } 21770b57cec5SDimitry Andric } 21780b57cec5SDimitry Andric 21790b57cec5SDimitry Andric static const size_t MaxOptWidth = 8; // arbitrary spacing for printOptionDiff 21800b57cec5SDimitry Andric 21810b57cec5SDimitry Andric // printGenericOptionDiff - Print the value of this option and it's default. 21820b57cec5SDimitry Andric // 21830b57cec5SDimitry Andric // "Generic" options have each value mapped to a name. 21840b57cec5SDimitry Andric void generic_parser_base::printGenericOptionDiff( 21850b57cec5SDimitry Andric const Option &O, const GenericOptionValue &Value, 21860b57cec5SDimitry Andric const GenericOptionValue &Default, size_t GlobalWidth) const { 21870b57cec5SDimitry Andric outs() << " " << PrintArg(O.ArgStr); 21880b57cec5SDimitry Andric outs().indent(GlobalWidth - O.ArgStr.size()); 21890b57cec5SDimitry Andric 21900b57cec5SDimitry Andric unsigned NumOpts = getNumOptions(); 21910b57cec5SDimitry Andric for (unsigned i = 0; i != NumOpts; ++i) { 21925f757f3fSDimitry Andric if (!Value.compare(getOptionValue(i))) 21930b57cec5SDimitry Andric continue; 21940b57cec5SDimitry Andric 21950b57cec5SDimitry Andric outs() << "= " << getOption(i); 21960b57cec5SDimitry Andric size_t L = getOption(i).size(); 21970b57cec5SDimitry Andric size_t NumSpaces = MaxOptWidth > L ? MaxOptWidth - L : 0; 21980b57cec5SDimitry Andric outs().indent(NumSpaces) << " (default: "; 21990b57cec5SDimitry Andric for (unsigned j = 0; j != NumOpts; ++j) { 22005f757f3fSDimitry Andric if (!Default.compare(getOptionValue(j))) 22010b57cec5SDimitry Andric continue; 22020b57cec5SDimitry Andric outs() << getOption(j); 22030b57cec5SDimitry Andric break; 22040b57cec5SDimitry Andric } 22050b57cec5SDimitry Andric outs() << ")\n"; 22060b57cec5SDimitry Andric return; 22070b57cec5SDimitry Andric } 22080b57cec5SDimitry Andric outs() << "= *unknown option value*\n"; 22090b57cec5SDimitry Andric } 22100b57cec5SDimitry Andric 22110b57cec5SDimitry Andric // printOptionDiff - Specializations for printing basic value types. 22120b57cec5SDimitry Andric // 22130b57cec5SDimitry Andric #define PRINT_OPT_DIFF(T) \ 22140b57cec5SDimitry Andric void parser<T>::printOptionDiff(const Option &O, T V, OptionValue<T> D, \ 22150b57cec5SDimitry Andric size_t GlobalWidth) const { \ 22160b57cec5SDimitry Andric printOptionName(O, GlobalWidth); \ 22170b57cec5SDimitry Andric std::string Str; \ 22180b57cec5SDimitry Andric { \ 22190b57cec5SDimitry Andric raw_string_ostream SS(Str); \ 22200b57cec5SDimitry Andric SS << V; \ 22210b57cec5SDimitry Andric } \ 22220b57cec5SDimitry Andric outs() << "= " << Str; \ 22230b57cec5SDimitry Andric size_t NumSpaces = \ 22240b57cec5SDimitry Andric MaxOptWidth > Str.size() ? MaxOptWidth - Str.size() : 0; \ 22250b57cec5SDimitry Andric outs().indent(NumSpaces) << " (default: "; \ 22260b57cec5SDimitry Andric if (D.hasValue()) \ 22270b57cec5SDimitry Andric outs() << D.getValue(); \ 22280b57cec5SDimitry Andric else \ 22290b57cec5SDimitry Andric outs() << "*no default*"; \ 22300b57cec5SDimitry Andric outs() << ")\n"; \ 22310b57cec5SDimitry Andric } 22320b57cec5SDimitry Andric 22330b57cec5SDimitry Andric PRINT_OPT_DIFF(bool) 22340b57cec5SDimitry Andric PRINT_OPT_DIFF(boolOrDefault) 22350b57cec5SDimitry Andric PRINT_OPT_DIFF(int) 2236480093f4SDimitry Andric PRINT_OPT_DIFF(long) 2237480093f4SDimitry Andric PRINT_OPT_DIFF(long long) 22380b57cec5SDimitry Andric PRINT_OPT_DIFF(unsigned) 22390b57cec5SDimitry Andric PRINT_OPT_DIFF(unsigned long) 22400b57cec5SDimitry Andric PRINT_OPT_DIFF(unsigned long long) 22410b57cec5SDimitry Andric PRINT_OPT_DIFF(double) 22420b57cec5SDimitry Andric PRINT_OPT_DIFF(float) 22430b57cec5SDimitry Andric PRINT_OPT_DIFF(char) 22440b57cec5SDimitry Andric 22450b57cec5SDimitry Andric void parser<std::string>::printOptionDiff(const Option &O, StringRef V, 22460b57cec5SDimitry Andric const OptionValue<std::string> &D, 22470b57cec5SDimitry Andric size_t GlobalWidth) const { 22480b57cec5SDimitry Andric printOptionName(O, GlobalWidth); 22490b57cec5SDimitry Andric outs() << "= " << V; 22500b57cec5SDimitry Andric size_t NumSpaces = MaxOptWidth > V.size() ? MaxOptWidth - V.size() : 0; 22510b57cec5SDimitry Andric outs().indent(NumSpaces) << " (default: "; 22520b57cec5SDimitry Andric if (D.hasValue()) 22530b57cec5SDimitry Andric outs() << D.getValue(); 22540b57cec5SDimitry Andric else 22550b57cec5SDimitry Andric outs() << "*no default*"; 22560b57cec5SDimitry Andric outs() << ")\n"; 22570b57cec5SDimitry Andric } 22580b57cec5SDimitry Andric 22590b57cec5SDimitry Andric // Print a placeholder for options that don't yet support printOptionDiff(). 22600b57cec5SDimitry Andric void basic_parser_impl::printOptionNoValue(const Option &O, 22610b57cec5SDimitry Andric size_t GlobalWidth) const { 22620b57cec5SDimitry Andric printOptionName(O, GlobalWidth); 22630b57cec5SDimitry Andric outs() << "= *cannot print option value*\n"; 22640b57cec5SDimitry Andric } 22650b57cec5SDimitry Andric 22660b57cec5SDimitry Andric //===----------------------------------------------------------------------===// 22670b57cec5SDimitry Andric // -help and -help-hidden option implementation 22680b57cec5SDimitry Andric // 22690b57cec5SDimitry Andric 22700b57cec5SDimitry Andric static int OptNameCompare(const std::pair<const char *, Option *> *LHS, 22710b57cec5SDimitry Andric const std::pair<const char *, Option *> *RHS) { 22720b57cec5SDimitry Andric return strcmp(LHS->first, RHS->first); 22730b57cec5SDimitry Andric } 22740b57cec5SDimitry Andric 22750b57cec5SDimitry Andric static int SubNameCompare(const std::pair<const char *, SubCommand *> *LHS, 22760b57cec5SDimitry Andric const std::pair<const char *, SubCommand *> *RHS) { 22770b57cec5SDimitry Andric return strcmp(LHS->first, RHS->first); 22780b57cec5SDimitry Andric } 22790b57cec5SDimitry Andric 22800b57cec5SDimitry Andric // Copy Options into a vector so we can sort them as we like. 22810b57cec5SDimitry Andric static void sortOpts(StringMap<Option *> &OptMap, 22820b57cec5SDimitry Andric SmallVectorImpl<std::pair<const char *, Option *>> &Opts, 22830b57cec5SDimitry Andric bool ShowHidden) { 22840b57cec5SDimitry Andric SmallPtrSet<Option *, 32> OptionSet; // Duplicate option detection. 22850b57cec5SDimitry Andric 22860b57cec5SDimitry Andric for (StringMap<Option *>::iterator I = OptMap.begin(), E = OptMap.end(); 22870b57cec5SDimitry Andric I != E; ++I) { 22880b57cec5SDimitry Andric // Ignore really-hidden options. 22890b57cec5SDimitry Andric if (I->second->getOptionHiddenFlag() == ReallyHidden) 22900b57cec5SDimitry Andric continue; 22910b57cec5SDimitry Andric 22920b57cec5SDimitry Andric // Unless showhidden is set, ignore hidden flags. 22930b57cec5SDimitry Andric if (I->second->getOptionHiddenFlag() == Hidden && !ShowHidden) 22940b57cec5SDimitry Andric continue; 22950b57cec5SDimitry Andric 22960b57cec5SDimitry Andric // If we've already seen this option, don't add it to the list again. 22970b57cec5SDimitry Andric if (!OptionSet.insert(I->second).second) 22980b57cec5SDimitry Andric continue; 22990b57cec5SDimitry Andric 23000b57cec5SDimitry Andric Opts.push_back( 23010b57cec5SDimitry Andric std::pair<const char *, Option *>(I->getKey().data(), I->second)); 23020b57cec5SDimitry Andric } 23030b57cec5SDimitry Andric 23040b57cec5SDimitry Andric // Sort the options list alphabetically. 23050b57cec5SDimitry Andric array_pod_sort(Opts.begin(), Opts.end(), OptNameCompare); 23060b57cec5SDimitry Andric } 23070b57cec5SDimitry Andric 23080b57cec5SDimitry Andric static void 23090b57cec5SDimitry Andric sortSubCommands(const SmallPtrSetImpl<SubCommand *> &SubMap, 23100b57cec5SDimitry Andric SmallVectorImpl<std::pair<const char *, SubCommand *>> &Subs) { 2311480093f4SDimitry Andric for (auto *S : SubMap) { 23120b57cec5SDimitry Andric if (S->getName().empty()) 23130b57cec5SDimitry Andric continue; 23140b57cec5SDimitry Andric Subs.push_back(std::make_pair(S->getName().data(), S)); 23150b57cec5SDimitry Andric } 23160b57cec5SDimitry Andric array_pod_sort(Subs.begin(), Subs.end(), SubNameCompare); 23170b57cec5SDimitry Andric } 23180b57cec5SDimitry Andric 23190b57cec5SDimitry Andric namespace { 23200b57cec5SDimitry Andric 23210b57cec5SDimitry Andric class HelpPrinter { 23220b57cec5SDimitry Andric protected: 23230b57cec5SDimitry Andric const bool ShowHidden; 23240b57cec5SDimitry Andric typedef SmallVector<std::pair<const char *, Option *>, 128> 23250b57cec5SDimitry Andric StrOptionPairVector; 23260b57cec5SDimitry Andric typedef SmallVector<std::pair<const char *, SubCommand *>, 128> 23270b57cec5SDimitry Andric StrSubCommandPairVector; 23280b57cec5SDimitry Andric // Print the options. Opts is assumed to be alphabetically sorted. 23290b57cec5SDimitry Andric virtual void printOptions(StrOptionPairVector &Opts, size_t MaxArgLen) { 23300b57cec5SDimitry Andric for (size_t i = 0, e = Opts.size(); i != e; ++i) 23310b57cec5SDimitry Andric Opts[i].second->printOptionInfo(MaxArgLen); 23320b57cec5SDimitry Andric } 23330b57cec5SDimitry Andric 23340b57cec5SDimitry Andric void printSubCommands(StrSubCommandPairVector &Subs, size_t MaxSubLen) { 23350b57cec5SDimitry Andric for (const auto &S : Subs) { 23360b57cec5SDimitry Andric outs() << " " << S.first; 23370b57cec5SDimitry Andric if (!S.second->getDescription().empty()) { 23380b57cec5SDimitry Andric outs().indent(MaxSubLen - strlen(S.first)); 23390b57cec5SDimitry Andric outs() << " - " << S.second->getDescription(); 23400b57cec5SDimitry Andric } 23410b57cec5SDimitry Andric outs() << "\n"; 23420b57cec5SDimitry Andric } 23430b57cec5SDimitry Andric } 23440b57cec5SDimitry Andric 23450b57cec5SDimitry Andric public: 23460b57cec5SDimitry Andric explicit HelpPrinter(bool showHidden) : ShowHidden(showHidden) {} 234781ad6265SDimitry Andric virtual ~HelpPrinter() = default; 23480b57cec5SDimitry Andric 23490b57cec5SDimitry Andric // Invoke the printer. 23500b57cec5SDimitry Andric void operator=(bool Value) { 23510b57cec5SDimitry Andric if (!Value) 23520b57cec5SDimitry Andric return; 23530b57cec5SDimitry Andric printHelp(); 23540b57cec5SDimitry Andric 23550b57cec5SDimitry Andric // Halt the program since help information was printed 23560b57cec5SDimitry Andric exit(0); 23570b57cec5SDimitry Andric } 23580b57cec5SDimitry Andric 23590b57cec5SDimitry Andric void printHelp() { 23600b57cec5SDimitry Andric SubCommand *Sub = GlobalParser->getActiveSubCommand(); 23610b57cec5SDimitry Andric auto &OptionsMap = Sub->OptionsMap; 23620b57cec5SDimitry Andric auto &PositionalOpts = Sub->PositionalOpts; 23630b57cec5SDimitry Andric auto &ConsumeAfterOpt = Sub->ConsumeAfterOpt; 23640b57cec5SDimitry Andric 23650b57cec5SDimitry Andric StrOptionPairVector Opts; 23660b57cec5SDimitry Andric sortOpts(OptionsMap, Opts, ShowHidden); 23670b57cec5SDimitry Andric 23680b57cec5SDimitry Andric StrSubCommandPairVector Subs; 23690b57cec5SDimitry Andric sortSubCommands(GlobalParser->RegisteredSubCommands, Subs); 23700b57cec5SDimitry Andric 23710b57cec5SDimitry Andric if (!GlobalParser->ProgramOverview.empty()) 23720b57cec5SDimitry Andric outs() << "OVERVIEW: " << GlobalParser->ProgramOverview << "\n"; 23730b57cec5SDimitry Andric 2374bdd1243dSDimitry Andric if (Sub == &SubCommand::getTopLevel()) { 23750b57cec5SDimitry Andric outs() << "USAGE: " << GlobalParser->ProgramName; 23765f757f3fSDimitry Andric if (!Subs.empty()) 23770b57cec5SDimitry Andric outs() << " [subcommand]"; 23780b57cec5SDimitry Andric outs() << " [options]"; 23790b57cec5SDimitry Andric } else { 23800b57cec5SDimitry Andric if (!Sub->getDescription().empty()) { 23810b57cec5SDimitry Andric outs() << "SUBCOMMAND '" << Sub->getName() 23820b57cec5SDimitry Andric << "': " << Sub->getDescription() << "\n\n"; 23830b57cec5SDimitry Andric } 23840b57cec5SDimitry Andric outs() << "USAGE: " << GlobalParser->ProgramName << " " << Sub->getName() 23850b57cec5SDimitry Andric << " [options]"; 23860b57cec5SDimitry Andric } 23870b57cec5SDimitry Andric 2388fe6060f1SDimitry Andric for (auto *Opt : PositionalOpts) { 23890b57cec5SDimitry Andric if (Opt->hasArgStr()) 23900b57cec5SDimitry Andric outs() << " --" << Opt->ArgStr; 23910b57cec5SDimitry Andric outs() << " " << Opt->HelpStr; 23920b57cec5SDimitry Andric } 23930b57cec5SDimitry Andric 23940b57cec5SDimitry Andric // Print the consume after option info if it exists... 23950b57cec5SDimitry Andric if (ConsumeAfterOpt) 23960b57cec5SDimitry Andric outs() << " " << ConsumeAfterOpt->HelpStr; 23970b57cec5SDimitry Andric 2398bdd1243dSDimitry Andric if (Sub == &SubCommand::getTopLevel() && !Subs.empty()) { 23990b57cec5SDimitry Andric // Compute the maximum subcommand length... 24000b57cec5SDimitry Andric size_t MaxSubLen = 0; 24010b57cec5SDimitry Andric for (size_t i = 0, e = Subs.size(); i != e; ++i) 24020b57cec5SDimitry Andric MaxSubLen = std::max(MaxSubLen, strlen(Subs[i].first)); 24030b57cec5SDimitry Andric 24040b57cec5SDimitry Andric outs() << "\n\n"; 24050b57cec5SDimitry Andric outs() << "SUBCOMMANDS:\n\n"; 24060b57cec5SDimitry Andric printSubCommands(Subs, MaxSubLen); 24070b57cec5SDimitry Andric outs() << "\n"; 24080b57cec5SDimitry Andric outs() << " Type \"" << GlobalParser->ProgramName 24090b57cec5SDimitry Andric << " <subcommand> --help\" to get more help on a specific " 24100b57cec5SDimitry Andric "subcommand"; 24110b57cec5SDimitry Andric } 24120b57cec5SDimitry Andric 24130b57cec5SDimitry Andric outs() << "\n\n"; 24140b57cec5SDimitry Andric 24150b57cec5SDimitry Andric // Compute the maximum argument length... 24160b57cec5SDimitry Andric size_t MaxArgLen = 0; 24170b57cec5SDimitry Andric for (size_t i = 0, e = Opts.size(); i != e; ++i) 24180b57cec5SDimitry Andric MaxArgLen = std::max(MaxArgLen, Opts[i].second->getOptionWidth()); 24190b57cec5SDimitry Andric 24200b57cec5SDimitry Andric outs() << "OPTIONS:\n"; 24210b57cec5SDimitry Andric printOptions(Opts, MaxArgLen); 24220b57cec5SDimitry Andric 24230b57cec5SDimitry Andric // Print any extra help the user has declared. 2424fe6060f1SDimitry Andric for (const auto &I : GlobalParser->MoreHelp) 24250b57cec5SDimitry Andric outs() << I; 24260b57cec5SDimitry Andric GlobalParser->MoreHelp.clear(); 24270b57cec5SDimitry Andric } 24280b57cec5SDimitry Andric }; 24290b57cec5SDimitry Andric 24300b57cec5SDimitry Andric class CategorizedHelpPrinter : public HelpPrinter { 24310b57cec5SDimitry Andric public: 24320b57cec5SDimitry Andric explicit CategorizedHelpPrinter(bool showHidden) : HelpPrinter(showHidden) {} 24330b57cec5SDimitry Andric 24340b57cec5SDimitry Andric // Helper function for printOptions(). 24350b57cec5SDimitry Andric // It shall return a negative value if A's name should be lexicographically 24360b57cec5SDimitry Andric // ordered before B's name. It returns a value greater than zero if B's name 24370b57cec5SDimitry Andric // should be ordered before A's name, and it returns 0 otherwise. 24380b57cec5SDimitry Andric static int OptionCategoryCompare(OptionCategory *const *A, 24390b57cec5SDimitry Andric OptionCategory *const *B) { 24400b57cec5SDimitry Andric return (*A)->getName().compare((*B)->getName()); 24410b57cec5SDimitry Andric } 24420b57cec5SDimitry Andric 24430b57cec5SDimitry Andric // Make sure we inherit our base class's operator=() 24440b57cec5SDimitry Andric using HelpPrinter::operator=; 24450b57cec5SDimitry Andric 24460b57cec5SDimitry Andric protected: 24470b57cec5SDimitry Andric void printOptions(StrOptionPairVector &Opts, size_t MaxArgLen) override { 24480b57cec5SDimitry Andric std::vector<OptionCategory *> SortedCategories; 244904eeddc0SDimitry Andric DenseMap<OptionCategory *, std::vector<Option *>> CategorizedOptions; 24500b57cec5SDimitry Andric 24510b57cec5SDimitry Andric // Collect registered option categories into vector in preparation for 24520b57cec5SDimitry Andric // sorting. 24530eae32dcSDimitry Andric for (OptionCategory *Category : GlobalParser->RegisteredOptionCategories) 24540eae32dcSDimitry Andric SortedCategories.push_back(Category); 24550b57cec5SDimitry Andric 24560b57cec5SDimitry Andric // Sort the different option categories alphabetically. 24570b57cec5SDimitry Andric assert(SortedCategories.size() > 0 && "No option categories registered!"); 24580b57cec5SDimitry Andric array_pod_sort(SortedCategories.begin(), SortedCategories.end(), 24590b57cec5SDimitry Andric OptionCategoryCompare); 24600b57cec5SDimitry Andric 24610b57cec5SDimitry Andric // Walk through pre-sorted options and assign into categories. 24620b57cec5SDimitry Andric // Because the options are already alphabetically sorted the 24630b57cec5SDimitry Andric // options within categories will also be alphabetically sorted. 24640b57cec5SDimitry Andric for (size_t I = 0, E = Opts.size(); I != E; ++I) { 24650b57cec5SDimitry Andric Option *Opt = Opts[I].second; 24660b57cec5SDimitry Andric for (auto &Cat : Opt->Categories) { 2467fcaf7f86SDimitry Andric assert(llvm::is_contained(SortedCategories, Cat) && 24680b57cec5SDimitry Andric "Option has an unregistered category"); 24690b57cec5SDimitry Andric CategorizedOptions[Cat].push_back(Opt); 24700b57cec5SDimitry Andric } 24710b57cec5SDimitry Andric } 24720b57cec5SDimitry Andric 24730b57cec5SDimitry Andric // Now do printing. 24740eae32dcSDimitry Andric for (OptionCategory *Category : SortedCategories) { 24750b57cec5SDimitry Andric // Hide empty categories for --help, but show for --help-hidden. 24760eae32dcSDimitry Andric const auto &CategoryOptions = CategorizedOptions[Category]; 24770b57cec5SDimitry Andric bool IsEmptyCategory = CategoryOptions.empty(); 24780b57cec5SDimitry Andric if (!ShowHidden && IsEmptyCategory) 24790b57cec5SDimitry Andric continue; 24800b57cec5SDimitry Andric 24810b57cec5SDimitry Andric // Print category information. 24820b57cec5SDimitry Andric outs() << "\n"; 24830eae32dcSDimitry Andric outs() << Category->getName() << ":\n"; 24840b57cec5SDimitry Andric 24850b57cec5SDimitry Andric // Check if description is set. 24860eae32dcSDimitry Andric if (!Category->getDescription().empty()) 24870eae32dcSDimitry Andric outs() << Category->getDescription() << "\n\n"; 24880b57cec5SDimitry Andric else 24890b57cec5SDimitry Andric outs() << "\n"; 24900b57cec5SDimitry Andric 24910b57cec5SDimitry Andric // When using --help-hidden explicitly state if the category has no 24920b57cec5SDimitry Andric // options associated with it. 24930b57cec5SDimitry Andric if (IsEmptyCategory) { 24940b57cec5SDimitry Andric outs() << " This option category has no options.\n"; 24950b57cec5SDimitry Andric continue; 24960b57cec5SDimitry Andric } 24970b57cec5SDimitry Andric // Loop over the options in the category and print. 24980b57cec5SDimitry Andric for (const Option *Opt : CategoryOptions) 24990b57cec5SDimitry Andric Opt->printOptionInfo(MaxArgLen); 25000b57cec5SDimitry Andric } 25010b57cec5SDimitry Andric } 25020b57cec5SDimitry Andric }; 25030b57cec5SDimitry Andric 25040b57cec5SDimitry Andric // This wraps the Uncategorizing and Categorizing printers and decides 25050b57cec5SDimitry Andric // at run time which should be invoked. 25060b57cec5SDimitry Andric class HelpPrinterWrapper { 25070b57cec5SDimitry Andric private: 25080b57cec5SDimitry Andric HelpPrinter &UncategorizedPrinter; 25090b57cec5SDimitry Andric CategorizedHelpPrinter &CategorizedPrinter; 25100b57cec5SDimitry Andric 25110b57cec5SDimitry Andric public: 25120b57cec5SDimitry Andric explicit HelpPrinterWrapper(HelpPrinter &UncategorizedPrinter, 25130b57cec5SDimitry Andric CategorizedHelpPrinter &CategorizedPrinter) 25140b57cec5SDimitry Andric : UncategorizedPrinter(UncategorizedPrinter), 25150b57cec5SDimitry Andric CategorizedPrinter(CategorizedPrinter) {} 25160b57cec5SDimitry Andric 25170b57cec5SDimitry Andric // Invoke the printer. 25180b57cec5SDimitry Andric void operator=(bool Value); 25190b57cec5SDimitry Andric }; 25200b57cec5SDimitry Andric 25210b57cec5SDimitry Andric } // End anonymous namespace 25220b57cec5SDimitry Andric 2523480093f4SDimitry Andric #if defined(__GNUC__) 2524480093f4SDimitry Andric // GCC and GCC-compatible compilers define __OPTIMIZE__ when optimizations are 2525480093f4SDimitry Andric // enabled. 2526480093f4SDimitry Andric # if defined(__OPTIMIZE__) 2527480093f4SDimitry Andric # define LLVM_IS_DEBUG_BUILD 0 2528480093f4SDimitry Andric # else 2529480093f4SDimitry Andric # define LLVM_IS_DEBUG_BUILD 1 2530480093f4SDimitry Andric # endif 2531480093f4SDimitry Andric #elif defined(_MSC_VER) 2532480093f4SDimitry Andric // MSVC doesn't have a predefined macro indicating if optimizations are enabled. 2533480093f4SDimitry Andric // Use _DEBUG instead. This macro actually corresponds to the choice between 2534480093f4SDimitry Andric // debug and release CRTs, but it is a reasonable proxy. 2535480093f4SDimitry Andric # if defined(_DEBUG) 2536480093f4SDimitry Andric # define LLVM_IS_DEBUG_BUILD 1 2537480093f4SDimitry Andric # else 2538480093f4SDimitry Andric # define LLVM_IS_DEBUG_BUILD 0 2539480093f4SDimitry Andric # endif 2540480093f4SDimitry Andric #else 2541480093f4SDimitry Andric // Otherwise, for an unknown compiler, assume this is an optimized build. 2542480093f4SDimitry Andric # define LLVM_IS_DEBUG_BUILD 0 2543480093f4SDimitry Andric #endif 2544480093f4SDimitry Andric 25450b57cec5SDimitry Andric namespace { 25460b57cec5SDimitry Andric class VersionPrinter { 25470b57cec5SDimitry Andric public: 2548bdd1243dSDimitry Andric void print(std::vector<VersionPrinterTy> ExtraPrinters = {}) { 25490b57cec5SDimitry Andric raw_ostream &OS = outs(); 25500b57cec5SDimitry Andric #ifdef PACKAGE_VENDOR 25510b57cec5SDimitry Andric OS << PACKAGE_VENDOR << " "; 25520b57cec5SDimitry Andric #else 25530b57cec5SDimitry Andric OS << "LLVM (http://llvm.org/):\n "; 25540b57cec5SDimitry Andric #endif 255581ad6265SDimitry Andric OS << PACKAGE_NAME << " version " << PACKAGE_VERSION << "\n "; 2556480093f4SDimitry Andric #if LLVM_IS_DEBUG_BUILD 25570b57cec5SDimitry Andric OS << "DEBUG build"; 25580b57cec5SDimitry Andric #else 25590b57cec5SDimitry Andric OS << "Optimized build"; 25600b57cec5SDimitry Andric #endif 25610b57cec5SDimitry Andric #ifndef NDEBUG 25620b57cec5SDimitry Andric OS << " with assertions"; 25630b57cec5SDimitry Andric #endif 2564bdd1243dSDimitry Andric OS << ".\n"; 2565bdd1243dSDimitry Andric 2566bdd1243dSDimitry Andric // Iterate over any registered extra printers and call them to add further 2567bdd1243dSDimitry Andric // information. 2568bdd1243dSDimitry Andric if (!ExtraPrinters.empty()) { 2569bdd1243dSDimitry Andric for (const auto &I : ExtraPrinters) 2570bdd1243dSDimitry Andric I(outs()); 2571bdd1243dSDimitry Andric } 25720b57cec5SDimitry Andric } 2573fe6060f1SDimitry Andric void operator=(bool OptionWasSpecified); 2574fe6060f1SDimitry Andric }; 2575fe6060f1SDimitry Andric 2576fe6060f1SDimitry Andric struct CommandLineCommonOptions { 2577fe6060f1SDimitry Andric // Declare the four HelpPrinter instances that are used to print out help, or 2578fe6060f1SDimitry Andric // help-hidden as an uncategorized list or in categories. 2579fe6060f1SDimitry Andric HelpPrinter UncategorizedNormalPrinter{false}; 2580fe6060f1SDimitry Andric HelpPrinter UncategorizedHiddenPrinter{true}; 2581fe6060f1SDimitry Andric CategorizedHelpPrinter CategorizedNormalPrinter{false}; 2582fe6060f1SDimitry Andric CategorizedHelpPrinter CategorizedHiddenPrinter{true}; 2583fe6060f1SDimitry Andric // Declare HelpPrinter wrappers that will decide whether or not to invoke 2584fe6060f1SDimitry Andric // a categorizing help printer 2585fe6060f1SDimitry Andric HelpPrinterWrapper WrappedNormalPrinter{UncategorizedNormalPrinter, 2586fe6060f1SDimitry Andric CategorizedNormalPrinter}; 2587fe6060f1SDimitry Andric HelpPrinterWrapper WrappedHiddenPrinter{UncategorizedHiddenPrinter, 2588fe6060f1SDimitry Andric CategorizedHiddenPrinter}; 2589fe6060f1SDimitry Andric // Define a category for generic options that all tools should have. 2590fe6060f1SDimitry Andric cl::OptionCategory GenericCategory{"Generic Options"}; 2591fe6060f1SDimitry Andric 2592fe6060f1SDimitry Andric // Define uncategorized help printers. 2593fe6060f1SDimitry Andric // --help-list is hidden by default because if Option categories are being 2594fe6060f1SDimitry Andric // used then --help behaves the same as --help-list. 2595fe6060f1SDimitry Andric cl::opt<HelpPrinter, true, parser<bool>> HLOp{ 2596fe6060f1SDimitry Andric "help-list", 2597fe6060f1SDimitry Andric cl::desc( 2598fe6060f1SDimitry Andric "Display list of available options (--help-list-hidden for more)"), 2599fe6060f1SDimitry Andric cl::location(UncategorizedNormalPrinter), 2600fe6060f1SDimitry Andric cl::Hidden, 2601fe6060f1SDimitry Andric cl::ValueDisallowed, 2602fe6060f1SDimitry Andric cl::cat(GenericCategory), 2603bdd1243dSDimitry Andric cl::sub(SubCommand::getAll())}; 2604fe6060f1SDimitry Andric 2605fe6060f1SDimitry Andric cl::opt<HelpPrinter, true, parser<bool>> HLHOp{ 2606fe6060f1SDimitry Andric "help-list-hidden", 2607fe6060f1SDimitry Andric cl::desc("Display list of all available options"), 2608fe6060f1SDimitry Andric cl::location(UncategorizedHiddenPrinter), 2609fe6060f1SDimitry Andric cl::Hidden, 2610fe6060f1SDimitry Andric cl::ValueDisallowed, 2611fe6060f1SDimitry Andric cl::cat(GenericCategory), 2612bdd1243dSDimitry Andric cl::sub(SubCommand::getAll())}; 2613fe6060f1SDimitry Andric 2614fe6060f1SDimitry Andric // Define uncategorized/categorized help printers. These printers change their 2615fe6060f1SDimitry Andric // behaviour at runtime depending on whether one or more Option categories 2616fe6060f1SDimitry Andric // have been declared. 2617fe6060f1SDimitry Andric cl::opt<HelpPrinterWrapper, true, parser<bool>> HOp{ 2618fe6060f1SDimitry Andric "help", 2619fe6060f1SDimitry Andric cl::desc("Display available options (--help-hidden for more)"), 2620fe6060f1SDimitry Andric cl::location(WrappedNormalPrinter), 2621fe6060f1SDimitry Andric cl::ValueDisallowed, 2622fe6060f1SDimitry Andric cl::cat(GenericCategory), 2623bdd1243dSDimitry Andric cl::sub(SubCommand::getAll())}; 2624fe6060f1SDimitry Andric 2625fe6060f1SDimitry Andric cl::alias HOpA{"h", cl::desc("Alias for --help"), cl::aliasopt(HOp), 2626fe6060f1SDimitry Andric cl::DefaultOption}; 2627fe6060f1SDimitry Andric 2628fe6060f1SDimitry Andric cl::opt<HelpPrinterWrapper, true, parser<bool>> HHOp{ 2629fe6060f1SDimitry Andric "help-hidden", 2630fe6060f1SDimitry Andric cl::desc("Display all available options"), 2631fe6060f1SDimitry Andric cl::location(WrappedHiddenPrinter), 2632fe6060f1SDimitry Andric cl::Hidden, 2633fe6060f1SDimitry Andric cl::ValueDisallowed, 2634fe6060f1SDimitry Andric cl::cat(GenericCategory), 2635bdd1243dSDimitry Andric cl::sub(SubCommand::getAll())}; 2636fe6060f1SDimitry Andric 2637fe6060f1SDimitry Andric cl::opt<bool> PrintOptions{ 2638fe6060f1SDimitry Andric "print-options", 2639fe6060f1SDimitry Andric cl::desc("Print non-default options after command line parsing"), 2640fe6060f1SDimitry Andric cl::Hidden, 2641fe6060f1SDimitry Andric cl::init(false), 2642fe6060f1SDimitry Andric cl::cat(GenericCategory), 2643bdd1243dSDimitry Andric cl::sub(SubCommand::getAll())}; 2644fe6060f1SDimitry Andric 2645fe6060f1SDimitry Andric cl::opt<bool> PrintAllOptions{ 2646fe6060f1SDimitry Andric "print-all-options", 2647fe6060f1SDimitry Andric cl::desc("Print all option values after command line parsing"), 2648fe6060f1SDimitry Andric cl::Hidden, 2649fe6060f1SDimitry Andric cl::init(false), 2650fe6060f1SDimitry Andric cl::cat(GenericCategory), 2651bdd1243dSDimitry Andric cl::sub(SubCommand::getAll())}; 2652fe6060f1SDimitry Andric 2653fe6060f1SDimitry Andric VersionPrinterTy OverrideVersionPrinter = nullptr; 2654fe6060f1SDimitry Andric 2655fe6060f1SDimitry Andric std::vector<VersionPrinterTy> ExtraVersionPrinters; 2656fe6060f1SDimitry Andric 2657fe6060f1SDimitry Andric // Define the --version option that prints out the LLVM version for the tool 2658fe6060f1SDimitry Andric VersionPrinter VersionPrinterInstance; 2659fe6060f1SDimitry Andric 2660fe6060f1SDimitry Andric cl::opt<VersionPrinter, true, parser<bool>> VersOp{ 2661fe6060f1SDimitry Andric "version", cl::desc("Display the version of this program"), 2662fe6060f1SDimitry Andric cl::location(VersionPrinterInstance), cl::ValueDisallowed, 2663fe6060f1SDimitry Andric cl::cat(GenericCategory)}; 2664fe6060f1SDimitry Andric }; 2665fe6060f1SDimitry Andric } // End anonymous namespace 2666fe6060f1SDimitry Andric 2667fe6060f1SDimitry Andric // Lazy-initialized global instance of options controlling the command-line 2668fe6060f1SDimitry Andric // parser and general handling. 2669fe6060f1SDimitry Andric static ManagedStatic<CommandLineCommonOptions> CommonOptions; 2670fe6060f1SDimitry Andric 2671fe6060f1SDimitry Andric static void initCommonOptions() { 2672fe6060f1SDimitry Andric *CommonOptions; 2673fe6060f1SDimitry Andric initDebugCounterOptions(); 2674fe6060f1SDimitry Andric initGraphWriterOptions(); 2675fe6060f1SDimitry Andric initSignalsOptions(); 2676fe6060f1SDimitry Andric initStatisticOptions(); 2677fe6060f1SDimitry Andric initTimerOptions(); 2678fe6060f1SDimitry Andric initTypeSizeOptions(); 2679fe6060f1SDimitry Andric initWithColorOptions(); 2680fe6060f1SDimitry Andric initDebugOptions(); 2681fe6060f1SDimitry Andric initRandomSeedOptions(); 2682fe6060f1SDimitry Andric } 2683fe6060f1SDimitry Andric 2684fe6060f1SDimitry Andric OptionCategory &cl::getGeneralCategory() { 2685fe6060f1SDimitry Andric // Initialise the general option category. 2686fe6060f1SDimitry Andric static OptionCategory GeneralCategory{"General options"}; 2687fe6060f1SDimitry Andric return GeneralCategory; 2688fe6060f1SDimitry Andric } 2689fe6060f1SDimitry Andric 2690fe6060f1SDimitry Andric void VersionPrinter::operator=(bool OptionWasSpecified) { 26910b57cec5SDimitry Andric if (!OptionWasSpecified) 26920b57cec5SDimitry Andric return; 26930b57cec5SDimitry Andric 2694fe6060f1SDimitry Andric if (CommonOptions->OverrideVersionPrinter != nullptr) { 2695fe6060f1SDimitry Andric CommonOptions->OverrideVersionPrinter(outs()); 26960b57cec5SDimitry Andric exit(0); 26970b57cec5SDimitry Andric } 2698bdd1243dSDimitry Andric print(CommonOptions->ExtraVersionPrinters); 26990b57cec5SDimitry Andric 27000b57cec5SDimitry Andric exit(0); 27010b57cec5SDimitry Andric } 27020b57cec5SDimitry Andric 2703fe6060f1SDimitry Andric void HelpPrinterWrapper::operator=(bool Value) { 2704fe6060f1SDimitry Andric if (!Value) 2705fe6060f1SDimitry Andric return; 27060b57cec5SDimitry Andric 2707fe6060f1SDimitry Andric // Decide which printer to invoke. If more than one option category is 2708fe6060f1SDimitry Andric // registered then it is useful to show the categorized help instead of 2709fe6060f1SDimitry Andric // uncategorized help. 2710fe6060f1SDimitry Andric if (GlobalParser->RegisteredOptionCategories.size() > 1) { 2711fe6060f1SDimitry Andric // unhide --help-list option so user can have uncategorized output if they 2712fe6060f1SDimitry Andric // want it. 2713fe6060f1SDimitry Andric CommonOptions->HLOp.setHiddenFlag(NotHidden); 2714fe6060f1SDimitry Andric 2715fe6060f1SDimitry Andric CategorizedPrinter = true; // Invoke categorized printer 2716fe6060f1SDimitry Andric } else 2717fe6060f1SDimitry Andric UncategorizedPrinter = true; // Invoke uncategorized printer 2718fe6060f1SDimitry Andric } 2719fe6060f1SDimitry Andric 2720fe6060f1SDimitry Andric // Print the value of each option. 2721fe6060f1SDimitry Andric void cl::PrintOptionValues() { GlobalParser->printOptionValues(); } 2722fe6060f1SDimitry Andric 2723fe6060f1SDimitry Andric void CommandLineParser::printOptionValues() { 2724fe6060f1SDimitry Andric if (!CommonOptions->PrintOptions && !CommonOptions->PrintAllOptions) 2725fe6060f1SDimitry Andric return; 2726fe6060f1SDimitry Andric 2727fe6060f1SDimitry Andric SmallVector<std::pair<const char *, Option *>, 128> Opts; 2728fe6060f1SDimitry Andric sortOpts(ActiveSubCommand->OptionsMap, Opts, /*ShowHidden*/ true); 2729fe6060f1SDimitry Andric 2730fe6060f1SDimitry Andric // Compute the maximum argument length... 2731fe6060f1SDimitry Andric size_t MaxArgLen = 0; 2732fe6060f1SDimitry Andric for (size_t i = 0, e = Opts.size(); i != e; ++i) 2733fe6060f1SDimitry Andric MaxArgLen = std::max(MaxArgLen, Opts[i].second->getOptionWidth()); 2734fe6060f1SDimitry Andric 2735fe6060f1SDimitry Andric for (size_t i = 0, e = Opts.size(); i != e; ++i) 2736fe6060f1SDimitry Andric Opts[i].second->printOptionValue(MaxArgLen, CommonOptions->PrintAllOptions); 2737fe6060f1SDimitry Andric } 27380b57cec5SDimitry Andric 27390b57cec5SDimitry Andric // Utility function for printing the help message. 27400b57cec5SDimitry Andric void cl::PrintHelpMessage(bool Hidden, bool Categorized) { 27410b57cec5SDimitry Andric if (!Hidden && !Categorized) 2742fe6060f1SDimitry Andric CommonOptions->UncategorizedNormalPrinter.printHelp(); 27430b57cec5SDimitry Andric else if (!Hidden && Categorized) 2744fe6060f1SDimitry Andric CommonOptions->CategorizedNormalPrinter.printHelp(); 27450b57cec5SDimitry Andric else if (Hidden && !Categorized) 2746fe6060f1SDimitry Andric CommonOptions->UncategorizedHiddenPrinter.printHelp(); 27470b57cec5SDimitry Andric else 2748fe6060f1SDimitry Andric CommonOptions->CategorizedHiddenPrinter.printHelp(); 27490b57cec5SDimitry Andric } 27500b57cec5SDimitry Andric 27510b57cec5SDimitry Andric /// Utility function for printing version number. 2752fe6060f1SDimitry Andric void cl::PrintVersionMessage() { 2753bdd1243dSDimitry Andric CommonOptions->VersionPrinterInstance.print(CommonOptions->ExtraVersionPrinters); 2754fe6060f1SDimitry Andric } 27550b57cec5SDimitry Andric 2756fe6060f1SDimitry Andric void cl::SetVersionPrinter(VersionPrinterTy func) { 2757fe6060f1SDimitry Andric CommonOptions->OverrideVersionPrinter = func; 2758fe6060f1SDimitry Andric } 27590b57cec5SDimitry Andric 27600b57cec5SDimitry Andric void cl::AddExtraVersionPrinter(VersionPrinterTy func) { 2761fe6060f1SDimitry Andric CommonOptions->ExtraVersionPrinters.push_back(func); 27620b57cec5SDimitry Andric } 27630b57cec5SDimitry Andric 27640b57cec5SDimitry Andric StringMap<Option *> &cl::getRegisteredOptions(SubCommand &Sub) { 2765349cc55cSDimitry Andric initCommonOptions(); 27660b57cec5SDimitry Andric auto &Subs = GlobalParser->RegisteredSubCommands; 27670b57cec5SDimitry Andric (void)Subs; 276806c3fb27SDimitry Andric assert(Subs.contains(&Sub)); 27690b57cec5SDimitry Andric return Sub.OptionsMap; 27700b57cec5SDimitry Andric } 27710b57cec5SDimitry Andric 27720b57cec5SDimitry Andric iterator_range<typename SmallPtrSet<SubCommand *, 4>::iterator> 27730b57cec5SDimitry Andric cl::getRegisteredSubcommands() { 27740b57cec5SDimitry Andric return GlobalParser->getRegisteredSubcommands(); 27750b57cec5SDimitry Andric } 27760b57cec5SDimitry Andric 27770b57cec5SDimitry Andric void cl::HideUnrelatedOptions(cl::OptionCategory &Category, SubCommand &Sub) { 2778fe6060f1SDimitry Andric initCommonOptions(); 27790b57cec5SDimitry Andric for (auto &I : Sub.OptionsMap) { 27804824e7fdSDimitry Andric bool Unrelated = true; 27810b57cec5SDimitry Andric for (auto &Cat : I.second->Categories) { 27824824e7fdSDimitry Andric if (Cat == &Category || Cat == &CommonOptions->GenericCategory) 27834824e7fdSDimitry Andric Unrelated = false; 27840b57cec5SDimitry Andric } 27854824e7fdSDimitry Andric if (Unrelated) 27864824e7fdSDimitry Andric I.second->setHiddenFlag(cl::ReallyHidden); 27870b57cec5SDimitry Andric } 27880b57cec5SDimitry Andric } 27890b57cec5SDimitry Andric 27900b57cec5SDimitry Andric void cl::HideUnrelatedOptions(ArrayRef<const cl::OptionCategory *> Categories, 27910b57cec5SDimitry Andric SubCommand &Sub) { 2792fe6060f1SDimitry Andric initCommonOptions(); 27930b57cec5SDimitry Andric for (auto &I : Sub.OptionsMap) { 27944824e7fdSDimitry Andric bool Unrelated = true; 27950b57cec5SDimitry Andric for (auto &Cat : I.second->Categories) { 27964824e7fdSDimitry Andric if (is_contained(Categories, Cat) || 27974824e7fdSDimitry Andric Cat == &CommonOptions->GenericCategory) 27984824e7fdSDimitry Andric Unrelated = false; 27990b57cec5SDimitry Andric } 28004824e7fdSDimitry Andric if (Unrelated) 28014824e7fdSDimitry Andric I.second->setHiddenFlag(cl::ReallyHidden); 28020b57cec5SDimitry Andric } 28030b57cec5SDimitry Andric } 28040b57cec5SDimitry Andric 28050b57cec5SDimitry Andric void cl::ResetCommandLineParser() { GlobalParser->reset(); } 28060b57cec5SDimitry Andric void cl::ResetAllOptionOccurrences() { 28070b57cec5SDimitry Andric GlobalParser->ResetAllOptionOccurrences(); 28080b57cec5SDimitry Andric } 28090b57cec5SDimitry Andric 28100b57cec5SDimitry Andric void LLVMParseCommandLineOptions(int argc, const char *const *argv, 28110b57cec5SDimitry Andric const char *Overview) { 28120b57cec5SDimitry Andric llvm::cl::ParseCommandLineOptions(argc, argv, StringRef(Overview), 28130b57cec5SDimitry Andric &llvm::nulls()); 28140b57cec5SDimitry Andric } 2815