CommandLine.cpp Source File (original) (raw)

31#include "llvm/Config/config.h"

45#include

46#include

47#include

48using namespace llvm;

49using namespace cl;

51#define DEBUG_TYPE "commandline"

56namespace llvm {

57namespace cl {

71#if !(defined(LLVM_ENABLE_LLVM_EXPORT_ANNOTATIONS) && defined(_MSC_VER))

77#endif

84}

85}

88void GenericOptionValue::anchor() {}

89void OptionValue::anchor() {}

90void OptionValuestd::string::anchor() {}

91void Option::anchor() {}

106

107

108

109

110

115

116

117

119

123

125 size_t Len = ArgName.size();

126 if (Len == 1)

129}

130

133 for (size_t I = 0; I < Pad; ++I) {

134 Prefix.push_back(' ');

135 }

138}

139

140

148

149

150namespace {

151

152class PrintArg {

153 StringRef ArgName;

154 size_t Pad;

155public:

156 PrintArg(StringRef ArgName, size_t Pad = DefaultPad) : ArgName(ArgName), Pad(Pad) {}

157 friend raw_ostream &operator<<(raw_ostream &OS, const PrintArg &);

158};

159

160raw_ostream &operator<<(raw_ostream &OS, const PrintArg& Arg) {

161 OS << argPrefix(Arg.ArgName, Arg.Pad) << Arg.ArgName;

162 return OS;

163}

164

165class CommandLineParser {

166public:

167

168

169 std::string ProgramName;

170 StringRef ProgramOverview;

171

172

173 std::vector MoreHelp;

174

175

176

177

179

180

181 SmallPtrSet<OptionCategory *, 16> RegisteredOptionCategories;

182

183

184 SmallPtrSet<SubCommand *, 4> RegisteredSubCommands;

185

187

189

191 StringRef Overview, raw_ostream *Errs = nullptr,

192 vfs::FileSystem *VFS = nullptr,

193 bool LongOptionsUseDoubleDash = false);

194

195 void forEachSubCommand(Option &Opt, function_ref<void(SubCommand &)> Action) {

196 if (Opt.Subs.empty()) {

198 return;

199 }

201 for (auto *SC : RegisteredSubCommands)

202 Action(*SC);

204 return;

205 }

206 for (auto *SC : Opt.Subs) {

208 "SubCommand::getAll() should not be used with other subcommands");

209 Action(*SC);

210 }

211 }

212

213 void addLiteralOption(Option &Opt, SubCommand *SC, StringRef Name) {

215 return;

216 if (!SC->OptionsMap.insert(std::make_pair(Name, &Opt)).second) {

217 errs() << ProgramName << ": CommandLine Error: Option '" << Name

218 << "' registered more than once!\n";

219 report_fatal_error("inconsistency in registered CommandLine options");

220 }

221 }

222

223 void addLiteralOption(Option &Opt, StringRef Name) {

224 forEachSubCommand(

225 Opt, [&](SubCommand &SC) { addLiteralOption(Opt, &SC, Name); });

226 }

227

228 void addOption(Option *O, SubCommand *SC) {

229 bool HadErrors = false;

230 if (O->hasArgStr()) {

231

232 if (O->isDefaultOption() && SC->OptionsMap.contains(O->ArgStr))

233 return;

234

235

236 if (!SC->OptionsMap.insert(std::make_pair(O->ArgStr, O)).second) {

237 errs() << ProgramName << ": CommandLine Error: Option '" << O->ArgStr

238 << "' registered more than once!\n";

239 HadErrors = true;

240 }

241 }

242

243

246 else if (O->getMiscFlags() & cl::Sink)

250 O->error("Cannot specify more than one option with cl::ConsumeAfter!");

251 HadErrors = true;

252 }

254 }

255

256

257

258

259

260 if (HadErrors)

261 report_fatal_error("inconsistency in registered CommandLine options");

262 }

263

264 void addOption(Option *O, bool ProcessDefaultOption = false) {

265 if (!ProcessDefaultOption && O->isDefaultOption()) {

267 return;

268 }

269 forEachSubCommand(*O, [&](SubCommand &SC) { addOption(O, &SC); });

270 }

271

272 void removeOption(Option *O, SubCommand *SC) {

273 SmallVector<StringRef, 16> OptionNames;

274 O->getExtraOptionNames(OptionNames);

275 if (O->hasArgStr())

277

278 SubCommand &Sub = *SC;

280 for (auto Name : OptionNames) {

281 auto I = Sub.OptionsMap.find(Name);

282 if (I != End && I->getValue() == O)

283 Sub.OptionsMap.erase(I);

284 }

285

287 for (auto *Opt = Sub.PositionalOpts.begin();

288 Opt != Sub.PositionalOpts.end(); ++Opt) {

289 if (*Opt == O) {

290 Sub.PositionalOpts.erase(Opt);

291 break;

292 }

293 }

294 else if (O->getMiscFlags() & cl::Sink)

295 for (auto *Opt = Sub.SinkOpts.begin(); Opt != Sub.SinkOpts.end(); ++Opt) {

296 if (*Opt == O) {

297 Sub.SinkOpts.erase(Opt);

298 break;

299 }

300 }

301 else if (O == Sub.ConsumeAfterOpt)

302 Sub.ConsumeAfterOpt = nullptr;

303 }

304

305 void removeOption(Option *O) {

306 forEachSubCommand(*O, [&](SubCommand &SC) { removeOption(O, &SC); });

307 }

308

309 bool hasOptions(const SubCommand &Sub) const {

310 return ( Sub .OptionsMap.empty() || Sub .PositionalOpts.empty() ||

311 nullptr != Sub.ConsumeAfterOpt);

312 }

313

314 bool hasOptions() const {

315 for (const auto *S : RegisteredSubCommands) {

316 if (hasOptions(*S))

317 return true;

318 }

319 return false;

320 }

321

322 bool hasNamedSubCommands() const {

323 for (const auto *S : RegisteredSubCommands)

324 if (!S->getName().empty())

325 return true;

326 return false;

327 }

328

329 SubCommand *getActiveSubCommand() { return ActiveSubCommand; }

330

331 void updateArgStr(Option *O, StringRef NewName, SubCommand *SC) {

332 SubCommand &Sub = *SC;

333 if ( Sub .OptionsMap.insert(std::make_pair(NewName, O)).second) {

334 errs() << ProgramName << ": CommandLine Error: Option '" << O->ArgStr

335 << "' registered more than once!\n";

336 report_fatal_error("inconsistency in registered CommandLine options");

337 }

339 }

340

341 void updateArgStr(Option *O, StringRef NewName) {

342 forEachSubCommand(*O,

343 [&](SubCommand &SC) { updateArgStr(O, NewName, &SC); });

344 }

345

346 void printOptionValues();

347

348 void registerCategory(OptionCategory *cat) {

350 [cat](const OptionCategory *Category) {

352 }) == 0 &&

353 "Duplicate option categories");

354

355 RegisteredOptionCategories.insert(cat);

356 }

357

358 void registerSubCommand(SubCommand *sub) {

360 [sub](const SubCommand *Sub) {

361 return ( sub ->getName().empty()) &&

362 (Sub->getName() == sub->getName());

363 }) == 0 &&

364 "Duplicate subcommands");

365 RegisteredSubCommands.insert(sub);

366

367

368

370 "SubCommand::getAll() should not be registered");

373 if ((O->isPositional() || O->isSink() || O->isConsumeAfter()) ||

374 O->hasArgStr())

375 addOption(O, sub);

376 else

377 addLiteralOption(*O, sub, E.first());

378 }

379 }

380

381 void unregisterSubCommand(SubCommand *sub) {

382 RegisteredSubCommands.erase(sub);

383 }

384

385 iterator_range<SmallPtrSet<SubCommand *, 4>::iterator>

387 return make_range(RegisteredSubCommands.begin(),

388 RegisteredSubCommands.end());

389 }

390

391 void reset() {

392 ActiveSubCommand = nullptr;

393 ProgramName.clear();

394 ProgramOverview = StringRef();

395

396 MoreHelp.clear();

397 RegisteredOptionCategories.clear();

398

400 RegisteredSubCommands.clear();

401

405

406 DefaultOptions.clear();

407 }

408

409private:

410 SubCommand *ActiveSubCommand = nullptr;

411

412 Option *LookupOption(SubCommand &Sub, StringRef &Arg, StringRef &Value);

413 Option *LookupLongOption(SubCommand &Sub, StringRef &Arg, StringRef &Value,

414 bool LongOptionsUseDoubleDash, bool HaveDoubleDash) {

416 if (Opt && LongOptionsUseDoubleDash && !HaveDoubleDash && isGrouping (Opt))

417 return nullptr;

418 return Opt;

419 }

420 SubCommand *LookupSubCommand(StringRef Name, std::string &NearestString);

421};

422

423}

424

426

427template <typename T, T TrueVal, T FalseVal>

429 if (Arg == "" || Arg == "true" || Arg == "TRUE" || Arg == "True" ||

430 Arg == "1") {

432 return false;

433 }

434

435 if (Arg == "false" || Arg == "FALSE" || Arg == "False" || Arg == "0") {

436 Value = FalseVal;

437 return false;

438 }

439 return O.error("'" + Arg +

440 "' is invalid value for boolean argument! Try 0 or 1");

441}

442

446

450

453 FullyInitialized = true;

454}

455

457

459 if (FullyInitialized)

463 if (ArgStr.size() == 1)

465}

466

468 assert(.empty() && "Categories cannot be empty.");

469

470

471

476}

477

479 NumOccurrences = 0;

483}

484

485void OptionCategory::registerCategory() {

487}

488

489

490

491

492

495

496

498

500

502

506

510

518

519SubCommand::operator bool() const {

520 return (GlobalParser->getActiveSubCommand() == this);

521}

522

523

524

525

526

527

528

529

532

534 return nullptr;

536

537 size_t EqualPos = Arg.find('=');

538

539

541

542 return Sub.OptionsMap.lookup(Arg);

543 }

544

545

546

547

548 auto I = Sub.OptionsMap.find(Arg.substr(0, EqualPos));

549 if (I == Sub.OptionsMap.end())

550 return nullptr;

551

552 auto *O = I->second;

554 return nullptr;

555

557 Arg = Arg.substr(0, EqualPos);

558 return I->second;

559}

560

562 std::string &NearestString) {

563 if (Name.empty())

565

567 for (auto *S : RegisteredSubCommands) {

569 "SubCommand::getAll() is not expected in RegisteredSubCommands");

570 if (S->getName().empty())

571 continue;

572

573 if (S->getName() == Name)

574 return S;

575

576 if (!NearestMatch && S->getName().edit_distance(Name) < 2)

577 NearestMatch = S;

578 }

579

580 if (NearestMatch)

581 NearestString = NearestMatch->getName();

582

584}

585

586

587

588

589

592 std::string &NearestString) {

593

595 return nullptr;

596

597

598 std::pair<StringRef, StringRef> SplitArg = Arg.split('=');

599 StringRef &LHS = SplitArg.first;

601

602

603 Option *Best = nullptr;

604 unsigned BestDistance = 0;

605 for (const auto &[_, O] : OptionsMap) {

606

607 if (O->getOptionHiddenFlag() == ReallyHidden)

608 continue;

609

611 O->getExtraOptionNames(OptionNames);

612 if (O->hasArgStr())

613 OptionNames.push_back(O->ArgStr);

614

617 for (const auto &Name : OptionNames) {

619 Flag, true, BestDistance);

620 if (!Best || Distance < BestDistance) {

621 Best = O;

622 BestDistance = Distance;

623 if (RHS.empty() || !PermitValue)

624 NearestString = std::string(Name);

625 else

626 NearestString = (Twine(Name) + "=" + RHS).str();

627 }

628 }

629 }

630

631 return Best;

632}

633

634

635

638 bool MultiArg = false) {

639

640

644

646

648 return true;

649

650 Val = Val.substr(Pos + 1);

651

652 Pos = Val.find(',');

653 }

654

656 }

657

659}

660

661

662

663

666 const char *const *argv, int &i) {

667

669

670

673 if ( Value .data()) {

674

675

677 return Handler->error("requires a value!");

678

679 assert(argv && "null check");

681 }

682 break;

684 if (NumAdditionalVals > 0)

685 return Handler->error("multi-valued option specified"

686 " with ValueDisallowed modifier!");

687

688 if (Value.data())

689 return Handler->error("does not allow a value! '" + Twine(Value) +

690 "' specified.");

691 break;

693 break;

694 }

695

696

697 if (NumAdditionalVals == 0)

699

700

701 bool MultiArg = false;

702

703 if (Value.data()) {

705 return true;

706 --NumAdditionalVals;

707 MultiArg = true;

708 }

709

710 while (NumAdditionalVals > 0) {

711 if (i + 1 >= argc)

712 return Handler->error("not enough values!");

713 assert(argv && "null check");

715

717 return true;

718 MultiArg = true;

719 --NumAdditionalVals;

720 }

721 return false;

722}

723

728

729

730

731

732

733

734

736 bool (*Pred)(const Option *),

739 if (OMI != OptionsMap.end() && !Pred(OMI->getValue()))

740 OMI = OptionsMap.end();

741

742

743

744

745 while (OMI == OptionsMap.end() && Name.size() > 1) {

746 Name = Name.drop_back();

747 OMI = OptionsMap.find(Name);

748 if (OMI != OptionsMap.end() && !Pred(OMI->getValue()))

749 OMI = OptionsMap.end();

750 }

751

752 if (OMI != OptionsMap.end() && Pred(OMI->second)) {

753 Length = Name.size();

754 return OMI->second;

755 }

756 return nullptr;

757}

758

759

760

761

762

765 bool &ErrorParsing,

767 if (Arg.size() == 1)

768 return nullptr;

769

770

773 if (!PGOpt)

774 return nullptr;

775

776 do {

780 assert(OptionsMap.count(Arg) && OptionsMap.find(Arg)->second == PGOpt);

781

782

783

786 Value = MaybeValue;

787 return PGOpt;

788 }

789

790 if (MaybeValue[0] == '=') {

792 return PGOpt;

793 }

794

795

797

798

800 ErrorParsing |= PGOpt->error("may not occur within a group!");

801 return nullptr;

802 }

803

804

805

806 int Dummy = 0;

808

809

810 Arg = MaybeValue;

812 } while (PGOpt);

813

814

815 return nullptr;

816}

817

819 return O->getNumOccurrencesFlag() == cl::Required ||

821}

822

827

829 return C == ' ' || C == '\t' || C == '\r' || C == '\n';

830}

831

835

836static bool isQuote(char C) { return C == '\"' || C == '\''; }

837

840 bool MarkEOLs) {

842 for (size_t I = 0, E = Src.size(); I != E; ++I) {

843

844 if (Token.empty()) {

846

847 if (MarkEOLs && Src[I] == '\n')

849 ++I;

850 }

851 if (I == E)

852 break;

853 }

854

855 char C = Src[I];

856

857

858 if (I + 1 < E && C == '\\') {

859 ++I;

861 continue;

862 }

863

864

866 ++I;

867 while (I != E && Src[I] != C) {

868

869 if (Src[I] == '\\' && I + 1 != E)

870 ++I;

872 ++I;

873 }

874 if (I == E)

875 break;

876 continue;

877 }

878

879

881 if (!Token.empty())

883

884 if (MarkEOLs && C == '\n')

887 continue;

888 }

889

890

892 }

893

894

895 if (!Token.empty())

897}

898

899

900

901

902

903

904

905

906

907

908

909

910

911

912

913

914

915

917 size_t E = Src.size();

918 int BackslashCount = 0;

919

920 do {

921 ++I;

922 ++BackslashCount;

923 } while (I != E && Src[I] == '\\');

924

925 bool FollowedByDoubleQuote = (I != E && Src[I] == '"');

926 if (FollowedByDoubleQuote) {

927 Token.append(BackslashCount / 2, '\\');

928 if (BackslashCount % 2 == 0)

929 return I - 1;

931 return I;

932 }

933 Token.append(BackslashCount, '\\');

934 return I - 1;

935}

936

937

938

939

946

947

948

951 bool AlwaysCopy, function_ref<void()> MarkEOL, bool InitialCommandName) {

953

954

955

956

957

958

959

960 bool CommandName = InitialCommandName;

961

962

963 enum { INIT, UNQUOTED, QUOTED } State = INIT;

964

965 for (size_t I = 0, E = Src.size(); I < E; ++I) {

966 switch (State) {

968 assert(Token.empty() && "token should be empty in initial state");

969

971 if (Src[I] == '\n')

972 MarkEOL();

973 ++I;

974 }

975

976 if (I >= E)

977 break;

978 size_t Start = I;

979 if (CommandName) {

981 ++I;

982 } else {

984 ++I;

985 }

988

989

990 AddToken(AlwaysCopy ? Saver.save(NormalChars) : NormalChars);

991 if (I < E && Src[I] == '\n') {

992 MarkEOL();

993 CommandName = InitialCommandName;

994 } else {

995 CommandName = false;

996 }

997 } else if (Src[I] == '\"') {

998 Token += NormalChars;

999 State = QUOTED;

1000 } else if (Src[I] == '\\') {

1001 assert(!CommandName && "or else we'd have treated it as a normal char");

1002 Token += NormalChars;

1004 State = UNQUOTED;

1005 } else {

1007 }

1008 break;

1009 }

1010

1011 case UNQUOTED:

1013

1014

1015

1016 AddToken(Saver.save(Token.str()));

1018 if (Src[I] == '\n') {

1019 CommandName = InitialCommandName;

1020 MarkEOL();

1021 } else {

1022 CommandName = false;

1023 }

1024 State = INIT;

1025 } else if (Src[I] == '\"') {

1026 State = QUOTED;

1027 } else if (Src[I] == '\\' && !CommandName) {

1029 } else {

1031 }

1032 break;

1033

1034 case QUOTED:

1035 if (Src[I] == '\"') {

1036 if (I < (E - 1) && Src[I + 1] == '"') {

1037

1038

1040 ++I;

1041 } else {

1042

1043 State = UNQUOTED;

1044 }

1045 } else if (Src[I] == '\\' && !CommandName) {

1047 } else {

1049 }

1050 break;

1051 }

1052 }

1053

1054 if (State != INIT)

1055 AddToken(Saver.save(Token.str()));

1056}

1057

1060 bool MarkEOLs) {

1061 auto AddToken = [&](StringRef Tok) { NewArgv.push_back(Tok.data()); };

1062 auto OnEOL = [&]() {

1063 if (MarkEOLs)

1065 };

1067 true, OnEOL, false);

1068}

1069

1073 auto OnEOL = []() {};

1075 OnEOL, false);

1076}

1077

1080 bool MarkEOLs) {

1081 auto AddToken = [&](StringRef Tok) { NewArgv.push_back(Tok.data()); };

1082 auto OnEOL = [&]() {

1083 if (MarkEOLs)

1085 };

1087 true, OnEOL, true);

1088}

1089

1092 bool MarkEOLs) {

1093 for (const char *Cur = Source.begin(); Cur != Source.end();) {

1095

1097 while (Cur != Source.end() && isWhitespace(*Cur))

1098 ++Cur;

1099 continue;

1100 }

1101 if (*Cur == '#') {

1102 while (Cur != Source.end() && *Cur != '\n')

1103 ++Cur;

1104 continue;

1105 }

1106

1107 const char *Start = Cur;

1108 for (const char *End = Source.end(); Cur != End; ++Cur) {

1109 if (*Cur == '\\') {

1110 if (Cur + 1 != End) {

1111 ++Cur;

1112 if (*Cur == '\n' ||

1113 (*Cur == '\r' && (Cur + 1 != End) && Cur[1] == '\n')) {

1114 Line.append(Start, Cur - 1);

1115 if (*Cur == '\r')

1116 ++Cur;

1117 Start = Cur + 1;

1118 }

1119 }

1120 } else if (*Cur == '\n')

1121 break;

1122 }

1123

1124 Line.append(Start, Cur);

1126 }

1127}

1128

1129

1130

1132 return (S.size() >= 3 && S[0] == '\xef' && S[1] == '\xbb' && S[2] == '\xbf');

1133}

1134

1135

1137 const char *&Arg) {

1141

1146 TokenPos = ArgString.find(Token, StartPos)) {

1147

1148

1149 const StringRef LHS = ArgString.substr(StartPos, TokenPos - StartPos);

1150 if (ResponseFile.empty())

1151 ResponseFile = LHS;

1152 else

1154 ResponseFile.append(BasePath);

1155 StartPos = TokenPos + Token.size();

1156 }

1157

1158 if (!ResponseFile.empty()) {

1159

1161 if (!Remaining.empty())

1163 Arg = Saver.save(ResponseFile.str()).data();

1164 }

1165}

1166

1167

1168Error ExpansionContext::expandResponseFile(

1169 StringRef FName, SmallVectorImpl<const char *> &NewArgv) {

1171 llvm::ErrorOr<std::unique_ptr> MemBufOrErr =

1172 FS->getBufferForFile(FName);

1173 if (!MemBufOrErr) {

1174 std::error_code EC = MemBufOrErr.getError();

1176 "': " + EC.message());

1177 }

1178 MemoryBuffer &MemBuf = *MemBufOrErr.get();

1180

1181

1183 std::string UTF8Buf;

1187 "Could not convert UTF16 to UTF8");

1188 Str = StringRef(UTF8Buf);

1189 }

1190

1191

1192

1194 Str = StringRef(BufRef.data() + 3, BufRef.size() - 3);

1195

1196

1197 Tokenizer(Str, Saver, NewArgv, MarkEOLs);

1198

1199

1200

1201

1202 if (!RelativeNames && !InConfigFile)

1204

1206 for (const char *&Arg : NewArgv) {

1207 if (!Arg)

1208 continue;

1209

1210

1211 if (InConfigFile)

1213

1214

1215

1216 StringRef ArgStr(Arg);

1217 StringRef FileName;

1218 bool ConfigInclusion = false;

1219 if (ArgStr.consume_front("@")) {

1220 FileName = ArgStr;

1222 continue;

1223 } else if (ArgStr.consume_front("--config=")) {

1224 FileName = ArgStr;

1225 ConfigInclusion = true;

1226 } else {

1227 continue;

1228 }

1229

1230

1231 SmallString<128> ResponseFile;

1234 SmallString<128> FilePath;

1237 std::make_error_code(std::errc::no_such_file_or_directory),

1238 "cannot not find configuration file: " + FileName);

1239 ResponseFile.append(FilePath);

1240 } else {

1241 ResponseFile.append(BasePath);

1243 }

1244 Arg = Saver.save(ResponseFile.str()).data();

1245 }

1247}

1248

1249

1250

1253 struct ResponseFileRecord {

1254 std::string File;

1255 size_t End;

1256 };

1257

1258

1259

1260

1262

1263

1264

1266

1267

1268 for (unsigned I = 0; I != Argv.size();) {

1269 while (I == FileStack.back().End) {

1270

1271

1273 }

1274

1275 const char *Arg = Argv[I];

1276

1277 if (Arg == nullptr) {

1278 ++I;

1279 continue;

1280 }

1281

1282 if (Arg[0] != '@') {

1283 ++I;

1284 continue;

1285 }

1286

1287 const char *FName = Arg + 1;

1288

1289

1292 if (CurrentDir.empty()) {

1293 if (auto CWD = FS->getCurrentWorkingDirectory()) {

1294 CurrDir = *CWD;

1295 } else {

1297 CWD.getError(), Twine("cannot get absolute path for: ") + FName);

1298 }

1299 } else {

1300 CurrDir = CurrentDir;

1301 }

1303 FName = CurrDir.c_str();

1304 }

1305

1307 if (!Res || !Res->exists()) {

1308 std::error_code EC = Res.getError();

1309 if (!InConfigFile) {

1310

1311

1313 ++I;

1314 continue;

1315 }

1316 }

1317 if (!EC)

1320 "': " + EC.message());

1321 }

1323

1324 auto IsEquivalent =

1325 [FileStatus, this](const ResponseFileRecord &RFile) -> ErrorOr {

1327 if (!RHS)

1330 };

1331

1332

1333 for (const auto &F : drop_begin(FileStack)) {

1335 if (R.get())

1337 R.getError(), Twine("recursive expansion of: '") + F.File + "'");

1338 } else {

1340 Twine("cannot open file: ") + F.File);

1341 }

1342 }

1343

1344

1345

1347 if (Error Err = expandResponseFile(FName, ExpandedArgv))

1348 return Err;

1349

1350 for (ResponseFileRecord &Record : FileStack) {

1351

1352

1353 Record.End += ExpandedArgv.size() - 1;

1354 }

1355

1356 FileStack.push_back({FName, I + ExpandedArgv.size()});

1359 }

1360

1361

1362

1363

1364

1365

1366 assert(FileStack.size() > 0 && Argv.size() == FileStack.back().End);

1368}

1369

1373#ifdef _WIN32

1375#else

1377#endif

1378

1379 if (EnvVar)

1381 Tokenize(*EnvValue, Saver, NewArgv, false);

1382

1383

1384 NewArgv.append(Argv + 1, Argv + Argc);

1388 return false;

1389 }

1390 return true;

1391}

1392

1398 return false;

1399 }

1400 return true;

1401}

1402

1405 : Saver(A), Tokenizer(T), FS(FS ? FS : vfs::getRealFileSystem().get()) {}

1406

1410 const auto FileExists = [this](SmallString<128> Path) -> bool {

1411 auto Status = FS->status(Path);

1414 };

1415

1416

1417

1419 CfgFilePath = FileName;

1421 return false;

1422 if (!FileExists(CfgFilePath))

1423 return false;

1424 FilePath.assign(CfgFilePath.begin(), CfgFilePath.end());

1425 return true;

1426 }

1427

1428

1429 for (const StringRef &Dir : SearchDirs) {

1430 if (Dir.empty())

1431 continue;

1432 CfgFilePath.assign(Dir);

1435 if (FileExists(CfgFilePath)) {

1436 FilePath.assign(CfgFilePath.begin(), CfgFilePath.end());

1437 return true;

1438 }

1439 }

1440

1441 return false;

1442}

1443

1448 AbsPath.assign(CfgFile);

1449 if (std::error_code EC = FS->makeAbsolute(AbsPath))

1451 EC, Twine("cannot get absolute path for " + CfgFile));

1452 CfgFile = AbsPath.str();

1453 }

1454 InConfigFile = true;

1455 RelativeNames = true;

1456 if (Error Err = expandResponseFile(CfgFile, Argv))

1457 return Err;

1459}

1460

1465 bool LongOptionsUseDoubleDash) {

1471

1472

1473 if (EnvVar) {

1474 if (std::optionalstd::string EnvValue =

1477 }

1478

1479

1480 for (int I = 1; I < argc; ++I)

1482 int NewArgc = static_cast<int>(NewArgv.size());

1483

1484

1485 return GlobalParser->ParseCommandLineOptions(

1486 NewArgc, &NewArgv[0], Overview, Errs, VFS, LongOptionsUseDoubleDash);

1487}

1488

1489

1490void CommandLineParser::ResetAllOptionOccurrences() {

1491

1492

1493

1494 for (auto *SC : RegisteredSubCommands) {

1496 O.second->reset();

1498 O->reset();

1500 O->reset();

1503 }

1504}

1505

1506bool CommandLineParser::ParseCommandLineOptions(

1509 assert(hasOptions() && "No options specified!");

1510

1511 ProgramOverview = Overview;

1512 bool IgnoreErrors = Errs;

1513 if (!Errs)

1514 Errs = &errs();

1515 if (!VFS)

1517 bool ErrorParsing = false;

1518

1519

1522#ifdef _WIN32

1524#else

1526#endif

1528 if (Error Err = ECtx.expandResponseFiles(newArgv)) {

1529 *Errs << toString(std::move(Err)) << '\n';

1530 return false;

1531 }

1532 argv = &newArgv[0];

1533 argc = static_cast<int>(newArgv.size());

1534

1535

1537

1538

1539 unsigned NumPositionalRequired = 0;

1540

1541

1542 bool HasUnlimitedPositionals = false;

1543

1544 int FirstArg = 1;

1546 std::string NearestSubCommandString;

1547 bool MaybeNamedSubCommand =

1548 argc >= 2 && argv[FirstArg][0] != '-' && hasNamedSubCommands();

1549 if (MaybeNamedSubCommand) {

1550

1551

1552 ChosenSubCommand =

1553 LookupSubCommand(StringRef(argv[FirstArg]), NearestSubCommandString);

1555 FirstArg = 2;

1556 }

1557 GlobalParser->ActiveSubCommand = ChosenSubCommand;

1558

1559 assert(ChosenSubCommand);

1560 auto &ConsumeAfterOpt = ChosenSubCommand->ConsumeAfterOpt;

1561 auto &PositionalOpts = ChosenSubCommand->PositionalOpts;

1562 auto &SinkOpts = ChosenSubCommand->SinkOpts;

1563 auto &OptionsMap = ChosenSubCommand->OptionsMap;

1564

1565 for (auto *O: DefaultOptions) {

1566 addOption(O, true);

1567 }

1568

1569 if (ConsumeAfterOpt) {

1570 assert(PositionalOpts.size() > 0 &&

1571 "Cannot specify cl::ConsumeAfter without a positional argument!");

1572 }

1573 if (!PositionalOpts.empty()) {

1574

1575

1576 bool UnboundedFound = false;

1577 for (size_t i = 0, e = PositionalOpts.size(); i != e; ++i) {

1578 Option *Opt = PositionalOpts[i];

1580 ++NumPositionalRequired;

1581 else if (ConsumeAfterOpt) {

1582

1583

1584 if (PositionalOpts.size() > 1) {

1585 if (!IgnoreErrors)

1586 Opt->error("error - this positional option will never be matched, "

1587 "because it does not Require a value, and a "

1588 "cl::ConsumeAfter option is active!");

1589 ErrorParsing = true;

1590 }

1591 } else if (UnboundedFound && !Opt->hasArgStr()) {

1592

1593

1594

1595

1596 if (!IgnoreErrors)

1597 Opt->error("error - option can never match, because "

1598 "another positional argument will match an "

1599 "unbounded number of values, and this option"

1600 " does not require a value!");

1601 *Errs << ProgramName << ": CommandLine Error: Option '" << Opt->ArgStr

1602 << "' is all messed up!\n";

1603 *Errs << PositionalOpts.size();

1604 ErrorParsing = true;

1605 }

1607 }

1608 HasUnlimitedPositionals = UnboundedFound || ConsumeAfterOpt;

1609 }

1610

1611

1612

1613

1615

1616

1617

1618

1619 Option *ActivePositionalArg = nullptr;

1620

1621

1622 bool DashDashFound = false;

1623 for (int i = FirstArg; i < argc; ++i) {

1624 Option *Handler = nullptr;

1625 std::string NearestHandlerString;

1626 StringRef Value;

1627 StringRef ArgName = "";

1628 bool HaveDoubleDash = false;

1629

1630

1631

1632

1633

1634 if (argv[i][0] != '-' || argv[i][1] == 0 || DashDashFound) {

1635

1636 if (ActivePositionalArg) {

1638 continue;

1639 }

1640

1641 if (!PositionalOpts.empty()) {

1642 PositionalVals.push_back(std::make_pair(StringRef(argv[i]), i));

1643

1644

1645

1646

1647 if (PositionalVals.size() >= NumPositionalRequired && ConsumeAfterOpt) {

1648 for (++i; i < argc; ++i)

1649 PositionalVals.push_back(std::make_pair(StringRef(argv[i]), i));

1650 break;

1651 }

1652

1653

1654 continue;

1655 }

1656 } else if (argv[i][0] == '-' && argv[i][1] == '-' && argv[i][2] == 0 &&

1657 !DashDashFound) {

1658 DashDashFound = true;

1659 continue;

1660 } else if (ActivePositionalArg &&

1662

1663

1664

1665 ArgName = StringRef(argv[i] + 1);

1666

1668 HaveDoubleDash = true;

1669

1670 Handler = LookupLongOption(*ChosenSubCommand, ArgName, Value,

1671 LongOptionsUseDoubleDash, HaveDoubleDash);

1674 continue;

1675 }

1676 } else {

1677 ArgName = StringRef(argv[i] + 1);

1678

1680 HaveDoubleDash = true;

1681

1682 Handler = LookupLongOption(*ChosenSubCommand, ArgName, Value,

1683 LongOptionsUseDoubleDash, HaveDoubleDash);

1684

1685

1686

1687

1690 LongOptionsUseDoubleDash, HaveDoubleDash);

1691

1692

1693 if (!Handler && !(LongOptionsUseDoubleDash && HaveDoubleDash))

1695 OptionsMap);

1696

1697

1698

1699 if (!Handler && SinkOpts.empty())

1701 }

1702

1703 if (!Handler) {

1704 if (!SinkOpts.empty()) {

1705 for (Option *SinkOpt : SinkOpts)

1706 SinkOpt->addOccurrence(i, "", StringRef(argv[i]));

1707 continue;

1708 }

1709

1710 auto ReportUnknownArgument = [&](bool IsArg,

1711 StringRef NearestArgumentName) {

1712 *Errs << ProgramName << ": Unknown "

1713 << (IsArg ? "command line argument" : "subcommand") << " '"

1714 << argv[i] << "'. Try: '" << argv[0] << " --help'\n";

1715

1716 if (NearestArgumentName.empty())

1717 return;

1718

1719 *Errs << ProgramName << ": Did you mean '";

1720 if (IsArg)

1721 *Errs << PrintArg(NearestArgumentName, 0);

1722 else

1723 *Errs << NearestArgumentName;

1724 *Errs << "'?\n";

1725 };

1726

1727 if (i > 1 || !MaybeNamedSubCommand)

1728 ReportUnknownArgument(true, NearestHandlerString);

1729 else

1730 ReportUnknownArgument(false, NearestSubCommandString);

1731

1732 ErrorParsing = true;

1733 continue;

1734 }

1735

1736

1737

1740 Handler->error("This argument does not take a value.\n"

1741 "\tInstead, it consumes any positional arguments until "

1742 "the next recognized option.", *Errs);

1743 ErrorParsing = true;

1744 }

1745 ActivePositionalArg = Handler;

1746 }

1747 else

1748 ErrorParsing |= ProvideOption(Handler, ArgName, Value, argc, argv, i);

1749 }

1750

1751

1752 if (NumPositionalRequired > PositionalVals.size()) {

1753 *Errs << ProgramName

1754 << ": Not enough positional command line arguments specified!\n"

1755 << "Must specify at least " << NumPositionalRequired

1756 << " positional argument" << (NumPositionalRequired > 1 ? "s" : "")

1757 << ": See: " << argv[0] << " --help\n";

1758

1759 ErrorParsing = true;

1760 } else if (!HasUnlimitedPositionals &&

1761 PositionalVals.size() > PositionalOpts.size()) {

1762 *Errs << ProgramName << ": Too many positional arguments specified!\n"

1763 << "Can specify at most " << PositionalOpts.size()

1764 << " positional arguments: See: " << argv[0] << " --help\n";

1765 ErrorParsing = true;

1766

1767 } else if (!ConsumeAfterOpt) {

1768

1769 unsigned ValNo = 0, NumVals = static_cast<unsigned>(PositionalVals.size());

1770 for (Option *Opt : PositionalOpts) {

1773 PositionalVals[ValNo].second);

1774 ValNo++;

1775 --NumPositionalRequired;

1776 }

1777

1778

1779

1780

1781

1783 while (NumVals - ValNo > NumPositionalRequired && Done ) {

1786 Done = true;

1787 [[fallthrough]];

1788 case cl::ZeroOrMore:

1789 case cl::OneOrMore:

1791 PositionalVals[ValNo].second);

1792 ValNo++;

1793 break;

1794 default:

1795 llvm_unreachable("Internal error, unexpected NumOccurrences flag in "

1796 "positional argument processing!");

1797 }

1798 }

1799 }

1800 } else {

1801 assert(ConsumeAfterOpt && NumPositionalRequired <= PositionalVals.size());

1802 unsigned ValNo = 0;

1803 for (Option *Opt : PositionalOpts)

1806 Opt, PositionalVals[ValNo].first, PositionalVals[ValNo].second);

1807 ValNo++;

1808 }

1809

1810

1811

1812

1813

1814

1815 if (PositionalOpts.size() == 1 && ValNo == 0 && !PositionalVals.empty()) {

1817 PositionalVals[ValNo].first,

1818 PositionalVals[ValNo].second);

1819 ValNo++;

1820 }

1821

1822

1823

1824 for (; ValNo != PositionalVals.size(); ++ValNo)

1825 ErrorParsing |=

1827 PositionalVals[ValNo].second);

1828 }

1829

1830

1831 for (const auto &Opt : OptionsMap) {

1836 Opt.second->error("must be specified at least once!");

1837 ErrorParsing = true;

1838 }

1839 [[fallthrough]];

1840 default:

1841 break;

1842 }

1843 }

1844

1845

1846

1847

1849 for (int i = 0; i < argc; ++i) dbgs() << argv[i] << ' ';

1850 dbgs() << '\n';);

1851

1852

1853

1854 MoreHelp.clear();

1855

1856

1857 if (ErrorParsing) {

1858 if (!IgnoreErrors)

1859 exit(1);

1860 return false;

1861 }

1862 return true;

1863}

1864

1865

1866

1867

1868

1870 if (!ArgName.data())

1872 if (ArgName.empty())

1873 Errs << HelpStr;

1874 else

1875 Errs << GlobalParser->ProgramName << ": for the " << PrintArg(ArgName, 0);

1876

1877 Errs << " option: " << Message << "\n";

1878 return true;

1879}

1880

1882 bool MultiArg) {

1883 if (!MultiArg)

1884 NumOccurrences++;

1885

1886 return handleOccurrence(pos, ArgName, Value);

1887}

1888

1889

1890

1891

1893 if (O.ValueStr.empty())

1894 return DefaultMsg;

1895 return O.ValueStr;

1896}

1897

1898

1899

1900

1901

1902

1905}

1906

1908 size_t FirstLineIndentedBy) {

1909 assert(Indent >= FirstLineIndentedBy);

1910 std::pair<StringRef, StringRef> Split = HelpStr.split('\n');

1911 outs().indent(Indent - FirstLineIndentedBy)

1913 while (!Split.second.empty()) {

1914 Split = Split.second.split('\n');

1915 outs().indent(Indent) << Split.first << "\n";

1916 }

1917}

1918

1920 size_t FirstLineIndentedBy) {

1921 const StringRef ValHelpPrefix = " ";

1922 assert(BaseIndent >= FirstLineIndentedBy);

1923 std::pair<StringRef, StringRef> Split = HelpStr.split('\n');

1924 outs().indent(BaseIndent - FirstLineIndentedBy)

1925 << ArgHelpPrefix << ValHelpPrefix << Split.first << "\n";

1926 while (!Split.second.empty()) {

1927 Split = Split.second.split('\n');

1928 outs().indent(BaseIndent + ValHelpPrefix.size()) << Split.first << "\n";

1929 }

1930}

1931

1932

1933void alias::printOptionInfo(size_t GlobalWidth) const {

1936}

1937

1938

1939

1940

1941

1942

1943

1944

1945

1949 if (!ValName.empty()) {

1950 size_t FormattingLen = 3;

1952 FormattingLen = 6;

1954 }

1955

1956 return Len;

1957}

1958

1959

1960

1961

1963 size_t GlobalWidth) const {

1964 outs() << PrintArg(O.ArgStr);

1965

1967 if (!ValName.empty()) {

1970 } else if (O.getValueExpectedFlag() == ValueOptional)

1972 else {

1973 outs() << (O.ArgStr.size() == 1 ? " <" : "=<") << getValueStr(O, ValName)

1974 << '>';

1975 }

1976 }

1977

1979}

1980

1982 size_t GlobalWidth) const {

1983 outs() << PrintArg(O.ArgStr);

1984 outs().indent(GlobalWidth - O.ArgStr.size());

1985}

1986

1987

1988

1992}

1993

1994

1995

1999}

2000

2001

2002

2006 return O.error("'" + Arg + "' value invalid for integer argument!");

2007 return false;

2008}

2009

2010

2011

2015 return O.error("'" + Arg + "' value invalid for long argument!");

2016 return false;

2017}

2018

2019

2020

2022 long long &Value) {

2024 return O.error("'" + Arg + "' value invalid for llong argument!");

2025 return false;

2026}

2027

2028

2029

2031 unsigned &Value) {

2032

2034 return O.error("'" + Arg + "' value invalid for uint argument!");

2035 return false;

2036}

2037

2038

2039

2041 unsigned long &Value) {

2042

2044 return O.error("'" + Arg + "' value invalid for ulong argument!");

2045 return false;

2046}

2047

2048

2049

2051 StringRef Arg,

2052 unsigned long long &Value) {

2053

2055 return O.error("'" + Arg + "' value invalid for ullong argument!");

2056 return false;

2057}

2058

2059

2060

2063 return false;

2064 return O.error("'" + Arg + "' value invalid for floating point argument!");

2065}

2066

2068 double &Val) {

2070}

2071

2073 float &Val) {

2074 double dVal;

2076 return true;

2077 Val = (float)dVal;

2078 return false;

2079}

2080

2081

2082

2083

2084

2085

2086

2089

2090 for (unsigned i = 0; i != e; ++i) {

2092 return i;

2093 }

2094 return e;

2095}

2096

2103

2106 return O.getValueExpectedFlag() != ValueOptional || !Name.empty() ||

2107 !Description.empty();

2108}

2109

2110

2112 if (O.hasArgStr()) {

2113 size_t Size =

2115 for (unsigned i = 0, e = getNumOptions(); i != e; ++i) {

2118 continue;

2121 }

2122 return Size;

2123 } else {

2124 size_t BaseSize = 0;

2125 for (unsigned i = 0, e = getNumOptions(); i != e; ++i)

2126 BaseSize = std::max(BaseSize, getOption(i).size() + 8);

2127 return BaseSize;

2128 }

2129}

2130

2131

2132

2133

2135 size_t GlobalWidth) const {

2136 if (O.hasArgStr()) {

2137

2138

2139 if (O.getValueExpectedFlag() == ValueOptional) {

2140 for (unsigned i = 0, e = getNumOptions(); i != e; ++i) {

2142 outs() << PrintArg(O.ArgStr);

2145 break;

2146 }

2147 }

2148 }

2149

2150 outs() << PrintArg(O.ArgStr) << EqValue;

2154 for (unsigned i = 0, e = getNumOptions(); i != e; ++i) {

2158 continue;

2161 if (OptionName.empty()) {

2165 }

2166 if (!Description.empty())

2168 else

2169 outs() << '\n';

2170 }

2171 } else {

2172 if (!O.HelpStr.empty())

2173 outs() << " " << O.HelpStr << '\n';

2174 for (unsigned i = 0, e = getNumOptions(); i != e; ++i) {

2178 }

2179 }

2180}

2181

2182static const size_t MaxOptWidth = 8;

2183

2184

2185

2186

2190 outs() << " " << PrintArg(O.ArgStr);

2191 outs().indent(GlobalWidth - O.ArgStr.size());

2192

2194 for (unsigned i = 0; i != NumOpts; ++i) {

2196 continue;

2197

2201 outs().indent(NumSpaces) << " (default: ";

2202 for (unsigned j = 0; j != NumOpts; ++j) {

2204 continue;

2206 break;

2207 }

2208 outs() << ")\n";

2209 return;

2210 }

2211 outs() << "= *unknown option value*\n";

2212}

2213

2214

2215

2216#define PRINT_OPT_DIFF(T) \

2217 void parser::printOptionDiff(const Option &O, T V, OptionValue D, \

2218 size_t GlobalWidth) const { \

2219 printOptionName(O, GlobalWidth); \

2220 std::string Str; \

2221 { \

2222 raw_string_ostream SS(Str); \

2223 SS << V; \

2224 } \

2225 outs() << "= " << Str; \

2226 size_t NumSpaces = \

2227 MaxOptWidth > Str.size() ? MaxOptWidth - Str.size() : 0; \

2228 outs().indent(NumSpaces) << " (default: "; \

2229 if (D.hasValue()) \

2230 outs() << D.getValue(); \

2231 else \

2232 outs() << "*no default*"; \

2233 outs() << ")\n"; \

2234 }

2235

2247

2250 size_t GlobalWidth) const {

2251 printOptionName(O, GlobalWidth);

2252 outs() << "= " << V;

2254 outs().indent(NumSpaces) << " (default: ";

2255 if (D.hasValue())

2256 outs() << D.getValue();

2257 else

2258 outs() << "*no default*";

2259 outs() << ")\n";

2260}

2261

2263 const Option &O, std::optional V,

2264 const OptionValue<std::optionalstd::string> &D,

2265 size_t GlobalWidth) const {

2266 printOptionName(O, GlobalWidth);

2267 outs() << "= " << V;

2268 size_t VSize = V.has_value() ? V.value().size() : 0;

2270 outs().indent(NumSpaces) << " (default: ";

2271 if (D.hasValue() && D.getValue().has_value())

2272 outs() << D.getValue();

2273 else

2274 outs() << "*no value*";

2275 outs() << ")\n";

2276}

2277

2278

2280 size_t GlobalWidth) const {

2282 outs() << "= *cannot print option value*\n";

2283}

2284

2285

2286

2287

2288

2290 const std::pair<const char *, Option *> *RHS) {

2291 return strcmp(LHS->first, RHS->first);

2292}

2293

2295 const std::pair<const char *, SubCommand *> *RHS) {

2296 return strcmp(LHS->first, RHS->first);

2297}

2298

2299

2301 SmallVectorImpl<std::pair<const char *, Option *>> &Opts,

2302 bool ShowHidden) {

2304

2306 I != E; ++I) {

2307

2308 if (I->second->getOptionHiddenFlag() == ReallyHidden)

2309 continue;

2310

2311

2312 if (I->second->getOptionHiddenFlag() == Hidden && !ShowHidden)

2313 continue;

2314

2315

2316 if (!OptionSet.insert(I->second).second)

2317 continue;

2318

2319 Opts.push_back(

2320 std::pair<const char *, Option *>(I->getKey().data(), I->second));

2321 }

2322

2323

2325}

2326

2327static void

2329 SmallVectorImpl<std::pair<const char *, SubCommand *>> &Subs) {

2330 for (auto *S : SubMap) {

2331 if (S->getName().empty())

2332 continue;

2333 Subs.push_back(std::make_pair(S->getName().data(), S));

2334 }

2336}

2337

2338namespace {

2339

2340class HelpPrinter {

2341protected:

2342 const bool ShowHidden;

2343 using StrOptionPairVector =

2345 using StrSubCommandPairVector =

2347

2348 virtual void printOptions(StrOptionPairVector &Opts, size_t MaxArgLen) {

2349 for (const auto &Opt : Opts)

2351 }

2352

2353 void printSubCommands(StrSubCommandPairVector &Subs, size_t MaxSubLen) {

2354 for (const auto &S : Subs) {

2355 outs() << " " << S.first;

2356 if (!S.second->getDescription().empty()) {

2357 outs().indent(MaxSubLen - strlen(S.first));

2358 outs() << " - " << S.second->getDescription();

2359 }

2360 outs() << "\n";

2361 }

2362 }

2363

2364public:

2365 explicit HelpPrinter(bool showHidden) : ShowHidden(showHidden) {}

2366 virtual ~HelpPrinter() = default;

2367

2368

2369 void operator=(bool Value) {

2371 return;

2372 printHelp();

2373

2374

2375 exit(0);

2376 }

2377

2378 void printHelp() {

2380 auto &OptionsMap = Sub->OptionsMap;

2381 auto &PositionalOpts = Sub->PositionalOpts;

2382 auto &ConsumeAfterOpt = Sub->ConsumeAfterOpt;

2383

2384 StrOptionPairVector Opts;

2385 sortOpts(OptionsMap, Opts, ShowHidden);

2386

2387 StrSubCommandPairVector Subs;

2389

2391 outs() << "OVERVIEW: " << GlobalParser->ProgramOverview << "\n";

2392

2395 if (!Subs.empty())

2396 outs() << " [subcommand]";

2397 outs() << " [options]";

2398 } else {

2399 if ( Sub ->getDescription().empty()) {

2400 outs() << "SUBCOMMAND '" << Sub->getName()

2401 << "': " << Sub->getDescription() << "\n\n";

2402 }

2403 outs() << "USAGE: " << GlobalParser->ProgramName << " " << Sub->getName()

2404 << " [options]";

2405 }

2406

2407 for (auto *Opt : PositionalOpts) {

2411 }

2412

2413

2414 if (ConsumeAfterOpt)

2415 outs() << " " << ConsumeAfterOpt->HelpStr;

2416

2418

2419 size_t MaxSubLen = 0;

2420 for (const auto &Sub : Subs)

2421 MaxSubLen = std::max(MaxSubLen, strlen(Sub.first));

2422

2423 outs() << "\n\n";

2424 outs() << "SUBCOMMANDS:\n\n";

2425 printSubCommands(Subs, MaxSubLen);

2426 outs() << "\n";

2428 << " --help\" to get more help on a specific "

2429 "subcommand";

2430 }

2431

2432 outs() << "\n\n";

2433

2434

2435 size_t MaxArgLen = 0;

2436 for (const auto &Opt : Opts)

2437 MaxArgLen = std::max(MaxArgLen, Opt.second->getOptionWidth());

2438

2439 outs() << "OPTIONS:\n";

2440 printOptions(Opts, MaxArgLen);

2441

2442

2446 }

2447};

2448

2449class CategorizedHelpPrinter : public HelpPrinter {

2450public:

2451 explicit CategorizedHelpPrinter(bool showHidden) : HelpPrinter(showHidden) {}

2452

2453

2454

2455

2456

2457 static int OptionCategoryCompare(OptionCategory *const *A,

2458 OptionCategory *const *B) {

2459 return (*A)->getName().compare((*B)->getName());

2460 }

2461

2462

2463 using HelpPrinter::operator=;

2464

2465protected:

2466 void printOptions(StrOptionPairVector &Opts, size_t MaxArgLen) override {

2467 std::vector<OptionCategory *> SortedCategories;

2468 DenseMap<OptionCategory *, std::vector<Option *>> CategorizedOptions;

2469

2470

2471

2474

2475

2476 assert(SortedCategories.size() > 0 && "No option categories registered!");

2477 array_pod_sort(SortedCategories.begin(), SortedCategories.end(),

2478 OptionCategoryCompare);

2479

2480

2481

2482

2483 for (const auto &I : Opts) {

2485 for (OptionCategory *Cat : Opt->Categories) {

2487 "Option has an unregistered category");

2488 CategorizedOptions[Cat].push_back(Opt);

2489 }

2490 }

2491

2492

2493 for (OptionCategory *Category : SortedCategories) {

2494

2495 const auto &CategoryOptions = CategorizedOptions[Category];

2496 if (CategoryOptions.empty())

2497 continue;

2498

2499

2500 outs() << "\n";

2502

2503

2506 else

2507 outs() << "\n";

2508

2509

2510 for (const Option *Opt : CategoryOptions)

2512 }

2513 }

2514};

2515

2516

2517

2518class HelpPrinterWrapper {

2519private:

2520 HelpPrinter &UncategorizedPrinter;

2521 CategorizedHelpPrinter &CategorizedPrinter;

2522

2523public:

2524 explicit HelpPrinterWrapper(HelpPrinter &UncategorizedPrinter,

2525 CategorizedHelpPrinter &CategorizedPrinter)

2526 : UncategorizedPrinter(UncategorizedPrinter),

2527 CategorizedPrinter(CategorizedPrinter) {}

2528

2529

2530 void operator=(bool Value);

2531};

2532

2533}

2534

2535#if defined(__GNUC__)

2536

2537

2538# if defined(__OPTIMIZE__)

2539# define LLVM_IS_DEBUG_BUILD 0

2540# else

2541# define LLVM_IS_DEBUG_BUILD 1

2542# endif

2543#elif defined(_MSC_VER)

2544

2545

2546

2547# if defined(_DEBUG)

2548# define LLVM_IS_DEBUG_BUILD 1

2549# else

2550# define LLVM_IS_DEBUG_BUILD 0

2551# endif

2552#else

2553

2554# define LLVM_IS_DEBUG_BUILD 0

2555#endif

2556

2557namespace {

2558class VersionPrinter {

2559public:

2560 void print(std::vector ExtraPrinters = {}) {

2562#ifdef PACKAGE_VENDOR

2563 OS << PACKAGE_VENDOR << " ";

2564#else

2565 OS << "LLVM (http://llvm.org/):\\n ";

2566#endif

2567 OS << PACKAGE_NAME << " version " << PACKAGE_VERSION << "\n ";

2568#if LLVM_IS_DEBUG_BUILD

2569 OS << "DEBUG build";

2570#else

2571 OS << "Optimized build";

2572#endif

2573#ifndef NDEBUG

2574 OS << " with assertions";

2575#endif

2576 OS << ".\n";

2577

2578

2579

2580 if (!ExtraPrinters.empty()) {

2581 for (const auto &I : ExtraPrinters)

2583 }

2584 }

2585 void operator=(bool OptionWasSpecified);

2586};

2587

2588struct CommandLineCommonOptions {

2589

2590

2591 HelpPrinter UncategorizedNormalPrinter{false};

2592 HelpPrinter UncategorizedHiddenPrinter{true};

2593 CategorizedHelpPrinter CategorizedNormalPrinter{false};

2594 CategorizedHelpPrinter CategorizedHiddenPrinter{true};

2595

2596

2597 HelpPrinterWrapper WrappedNormalPrinter{UncategorizedNormalPrinter,

2598 CategorizedNormalPrinter};

2599 HelpPrinterWrapper WrappedHiddenPrinter{UncategorizedHiddenPrinter,

2600 CategorizedHiddenPrinter};

2601

2603

2604

2605

2606

2608 "help-list",

2610 "Display list of available options (--help-list-hidden for more)"),

2614 cl::cat(GenericCategory),

2616

2618 "help-list-hidden",

2619 cl::desc("Display list of all available options"),

2623 cl::cat(GenericCategory),

2625

2626

2627

2628

2630 "help",

2631 cl::desc("Display available options (--help-hidden for more)"),

2634 cl::cat(GenericCategory),

2636

2639

2641 "help-hidden",

2642 cl::desc("Display all available options"),

2646 cl::cat(GenericCategory),

2648

2650 "print-options",

2651 cl::desc("Print non-default options after command line parsing"),

2654 cl::cat(GenericCategory),

2656

2658 "print-all-options",

2659 cl::desc("Print all option values after command line parsing"),

2662 cl::cat(GenericCategory),

2664

2666

2667 std::vector ExtraVersionPrinters;

2668

2669

2670 VersionPrinter VersionPrinterInstance;

2671

2673 "version", cl::desc("Display the version of this program"),

2675 cl::cat(GenericCategory)};

2676};

2677}

2678

2679

2680

2682

2694

2696

2697 static OptionCategory GeneralCategory{"General options"};

2698 return GeneralCategory;

2699}

2700

2701void VersionPrinter::operator=(bool OptionWasSpecified) {

2702 if (!OptionWasSpecified)

2703 return;

2704

2705 if (CommonOptions->OverrideVersionPrinter != nullptr) {

2707 exit(0);

2708 }

2710

2711 exit(0);

2712}

2713

2714void HelpPrinterWrapper::operator=(bool Value) {

2716 return;

2717

2718

2719

2720

2721 if (GlobalParser->RegisteredOptionCategories.size() > 1) {

2722

2723

2725

2726 CategorizedPrinter = true;

2727 } else {

2728 UncategorizedPrinter = true;

2729 }

2730}

2731

2732

2734

2735void CommandLineParser::printOptionValues() {

2737 return;

2738

2741

2742

2743 size_t MaxArgLen = 0;

2744 for (const auto &Opt : Opts)

2745 MaxArgLen = std::max(MaxArgLen, Opt.second->getOptionWidth());

2746

2747 for (const auto &Opt : Opts)

2749}

2750

2751

2753 if ( Hidden && !Categorized)

2754 CommonOptions->UncategorizedNormalPrinter.printHelp();

2755 else if ( Hidden && Categorized)

2756 CommonOptions->CategorizedNormalPrinter.printHelp();

2757 else if (Hidden && !Categorized)

2758 CommonOptions->UncategorizedHiddenPrinter.printHelp();

2759 else

2760 CommonOptions->CategorizedHiddenPrinter.printHelp();

2761}

2762

2764 static const StringRef Config[] = {

2765

2766

2767 "",

2768

2769#if LLVM_IS_DEBUG_BUILD

2770 "+unoptimized",

2771#endif

2772#ifndef NDEBUG

2773 "+assertions",

2774#endif

2775#ifdef EXPENSIVE_CHECKS

2776 "+expensive-checks",

2777#endif

2778#if __has_feature(address_sanitizer)

2779 "+asan",

2780#endif

2781#if __has_feature(dataflow_sanitizer)

2782 "+dfsan",

2783#endif

2784#if __has_feature(hwaddress_sanitizer)

2785 "+hwasan",

2786#endif

2787#if __has_feature(memory_sanitizer)

2788 "+msan",

2789#endif

2790#if __has_feature(thread_sanitizer)

2791 "+tsan",

2792#endif

2793#if __has_feature(undefined_behavior_sanitizer)

2794 "+ubsan",

2795#endif

2796 };

2798}

2799

2800

2802#if LLVM_VERSION_PRINTER_SHOW_BUILD_CONFIG

2803 OS << "Build config: ";

2805 OS << '\n';

2806#endif

2807}

2808

2809

2813

2817

2821

2824 auto &Subs = GlobalParser->RegisteredSubCommands;

2825 (void)Subs;

2827 return Sub.OptionsMap;

2828}

2829

2834

2837 for (auto &I : Sub.OptionsMap) {

2838 bool Unrelated = true;

2839 for (auto &Cat : I.second->Categories) {

2840 if (Cat == &Category || Cat == &CommonOptions->GenericCategory)

2841 Unrelated = false;

2842 }

2843 if (Unrelated)

2845 }

2846}

2847

2851 for (auto &I : Sub.OptionsMap) {

2852 bool Unrelated = true;

2853 for (auto &Cat : I.second->Categories) {

2856 Unrelated = false;

2857 }

2858 if (Unrelated)

2860 }

2861}

2862

2866}

2867

2869 const char *Overview) {

2872}

assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")

This file defines the StringMap class.

static void print(raw_ostream &Out, object::Archive::Kind Kind, T Val)

static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")

static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")

static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")

static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")

static bool CommaSeparateAndAddOccurrence(Option *Handler, unsigned pos, StringRef ArgName, StringRef Value, bool MultiArg=false)

CommaSeparateAndAddOccurrence - A wrapper around Handler->addOccurrence() that does special handling ...

Definition CommandLine.cpp:636

void opt_bool_anchor()

Definition CommandLine.cpp:111

static StringRef OptionPrefix

Definition CommandLine.cpp:2099

static bool RequiresValue(const Option *O)

Definition CommandLine.cpp:818

static int SubNameCompare(const std::pair< const char *, SubCommand * > *LHS, const std::pair< const char *, SubCommand * > *RHS)

Definition CommandLine.cpp:2294

static size_t argPlusPrefixesSize(StringRef ArgName, size_t Pad=DefaultPad)

Definition CommandLine.cpp:124

static bool isPrefixedOrGrouping(const Option *O)

Definition CommandLine.cpp:144

static bool shouldPrintOption(StringRef Name, StringRef Description, const Option &O)

Definition CommandLine.cpp:2104

static ManagedStatic< SubCommand > AllSubCommands

Definition CommandLine.cpp:497

static Option * HandlePrefixedOrGroupedOption(StringRef &Arg, StringRef &Value, bool &ErrorParsing, const StringMap< Option * > &OptionsMap)

HandlePrefixedOrGroupedOption - The specified argument string (which started with at least one '-') d...

Definition CommandLine.cpp:764

static bool parseDouble(Option &O, StringRef Arg, double &Value)

Definition CommandLine.cpp:2061

static bool parseBool(Option &O, StringRef ArgName, StringRef Arg, T &Value)

Definition CommandLine.cpp:428

static const size_t DefaultPad

Definition CommandLine.cpp:118

static StringRef EmptyOption

Definition CommandLine.cpp:2098

static bool hasUTF8ByteOrderMark(ArrayRef< char > S)

Definition CommandLine.cpp:1131

static ManagedStatic< CommandLineParser > GlobalParser

Definition CommandLine.cpp:425

static void ExpandBasePaths(StringRef BasePath, StringSaver &Saver, const char *&Arg)

Definition CommandLine.cpp:1136

static SmallString< 8 > argPrefix(StringRef ArgName, size_t Pad=DefaultPad)

Definition CommandLine.cpp:131

static StringRef ArgHelpPrefix

Definition CommandLine.cpp:122

void opt_unsigned_anchor()

Definition CommandLine.cpp:114

static bool isWindowsSpecialCharInCommandName(char C)

Definition CommandLine.cpp:943

static Option * getOptionPred(StringRef Name, size_t &Length, bool(*Pred)(const Option *), const StringMap< Option * > &OptionsMap)

Definition CommandLine.cpp:735

static StringRef getValueStr(const Option &O, StringRef DefaultMsg)

Definition CommandLine.cpp:1892

static size_t getOptionPrefixesSize()

Definition CommandLine.cpp:2100

static bool ProvideOption(Option *Handler, StringRef ArgName, StringRef Value, int argc, const char *const *argv, int &i)

ProvideOption - For Value, this differentiates between an empty value ("") and a null value (StringRe...

Definition CommandLine.cpp:664

static bool isQuote(char C)

Definition CommandLine.cpp:836

static ManagedStatic< CommandLineCommonOptions > CommonOptions

Definition CommandLine.cpp:2681

static void initCommonOptions()

Definition CommandLine.cpp:2683

void opt_char_anchor()

Definition CommandLine.cpp:112

static void tokenizeWindowsCommandLineImpl(StringRef Src, StringSaver &Saver, function_ref< void(StringRef)> AddToken, bool AlwaysCopy, function_ref< void()> MarkEOL, bool InitialCommandName)

Definition CommandLine.cpp:949

static bool isWhitespace(char C)

Definition CommandLine.cpp:828

static LLVM_REQUIRE_CONSTANT_INITIALIZATION ManagedStatic< SubCommand > TopLevelSubCommand

Definition CommandLine.cpp:494

static size_t parseBackslash(StringRef Src, size_t I, SmallString< 128 > &Token)

Backslashes are interpreted in a rather complicated way in the Windows-style command line,...

Definition CommandLine.cpp:916

static StringRef ArgPrefixLong

Definition CommandLine.cpp:121

static void sortSubCommands(const SmallPtrSetImpl< SubCommand * > &SubMap, SmallVectorImpl< std::pair< const char *, SubCommand * > > &Subs)

Definition CommandLine.cpp:2328

#define PRINT_OPT_DIFF(T)

Definition CommandLine.cpp:2216

static bool isWhitespaceOrNull(char C)

Definition CommandLine.cpp:832

static StringRef EqValue

Definition CommandLine.cpp:2097

static const size_t MaxOptWidth

Definition CommandLine.cpp:2182

static Option * LookupNearestOption(StringRef Arg, const StringMap< Option * > &OptionsMap, std::string &NearestString)

LookupNearestOption - Lookup the closest match to the option specified by the specified option on the...

Definition CommandLine.cpp:590

static bool EatsUnboundedNumberOfValues(const Option *O)

Definition CommandLine.cpp:823

static int OptNameCompare(const std::pair< const char *, Option * > *LHS, const std::pair< const char *, Option * > *RHS)

Definition CommandLine.cpp:2289

void opt_int_anchor()

Definition CommandLine.cpp:113

static void sortOpts(StringMap< Option * > &OptMap, SmallVectorImpl< std::pair< const char *, Option * > > &Opts, bool ShowHidden)

Definition CommandLine.cpp:2300

static StringRef ArgPrefix

Definition CommandLine.cpp:120

static bool isWindowsSpecialChar(char C)

Definition CommandLine.cpp:940

static bool isGrouping(const Option *O)

Definition CommandLine.cpp:141

#define LLVM_REQUIRE_CONSTANT_INITIALIZATION

LLVM_REQUIRE_CONSTANT_INITIALIZATION - Apply this to globals to ensure that they are constant initial...

#define LLVM_EXPORT_TEMPLATE

static void Help(ArrayRef< StringRef > CPUNames, ArrayRef< SubtargetFeatureKV > FeatTable)

Display help for feature and mcpu choices.

Provides a library for accessing information about this process and other processes on the operating ...

This file defines the SmallPtrSet class.

This file defines the SmallString class.

Defines the virtual file system interface vfs::FileSystem.

ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...

size_t size() const

size - Get the array size.

Represents either an error or a value T.

std::error_code getError() const

Lightweight error class with error context and mandatory checking.

static ErrorSuccess success()

Create a success value.

ManagedStatic - This transparently changes the behavior of global statics to be lazily constructed on...

size_t getBufferSize() const

const char * getBufferEnd() const

const char * getBufferStart() const

A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...

std::pair< iterator, bool > insert(PtrType Ptr)

Inserts Ptr if and only if there is no element in the container equal to Ptr.

SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.

SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...

void assign(StringRef RHS)

Assign from a StringRef.

void append(StringRef RHS)

Append from a StringRef.

StringRef str() const

Explicit conversion to StringRef.

This class consists of common code factored out of the SmallVector class to reduce code duplication b...

void assign(size_type NumElts, ValueParamT Elt)

iterator erase(const_iterator CI)

void append(ItTy in_start, ItTy in_end)

Add the specified range to the end of the SmallVector.

iterator insert(iterator I, T &&Elt)

void push_back(const T &Elt)

This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.

A wrapper around a string literal that serves as a proxy for constructing global tables of StringRefs...

StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...

iterator find(StringRef Key)

StringMapIterBase< ValueTy, false > iterator

size_type count(StringRef Key) const

count - Return 1 if the element is in the map, 0 otherwise.

StringMapIterBase< ValueTy, true > const_iterator

StringRef - Represent a constant reference to a string, i.e.

std::pair< StringRef, StringRef > split(char Separator) const

Split into two substrings around the first occurrence of a separator character.

static constexpr size_t npos

bool getAsInteger(unsigned Radix, T &Result) const

Parse the current string as an integer of the specified radix.

constexpr StringRef substr(size_t Start, size_t N=npos) const

Return a reference to the substring from [Start, Start + N).

bool starts_with(StringRef Prefix) const

Check if this string starts with the given Prefix.

constexpr bool empty() const

empty - Check if the string is empty.

StringRef drop_front(size_t N=1) const

Return a StringRef equal to 'this' but with the first N elements dropped.

LLVM_ABI unsigned edit_distance(StringRef Other, bool AllowReplacements=true, unsigned MaxEditDistance=0) const

Determine the edit distance between this string and another string.

StringRef slice(size_t Start, size_t End) const

Return a reference to the substring from [Start, End).

constexpr size_t size() const

size - Get the string size.

constexpr const char * data() const

data - Get a pointer to the start of the string (which may not be null terminated).

bool consume_front(StringRef Prefix)

Returns true if this StringRef has the given prefix and removes that prefix.

size_t find(char C, size_t From=0) const

Search for the first character C in the string.

Saves strings in the provided stable storage and returns a StringRef with a stable character pointer.

BumpPtrAllocator & getAllocator() const

StringRef save(const char *S)

Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...

LLVM Value Representation.

Contains options that control response file expansion.

LLVM_ABI ExpansionContext(BumpPtrAllocator &A, TokenizerCallback T, vfs::FileSystem *FS=nullptr)

Definition CommandLine.cpp:1403

LLVM_ABI bool findConfigFile(StringRef FileName, SmallVectorImpl< char > &FilePath)

Looks for the specified configuration file.

Definition CommandLine.cpp:1407

LLVM_ABI Error expandResponseFiles(SmallVectorImpl< const char * > &Argv)

Expands constructs "@file" in the provided array of arguments recursively.

Definition CommandLine.cpp:1251

LLVM_ABI Error readConfigFile(StringRef CfgFile, SmallVectorImpl< const char * > &Argv)

Reads command line options from the given configuration file.

Definition CommandLine.cpp:1444

StringRef getDescription() const

StringRef getName() const

SmallPtrSet< SubCommand *, 1 > Subs

int getNumOccurrences() const

enum ValueExpected getValueExpectedFlag() const

void addCategory(OptionCategory &C)

Definition CommandLine.cpp:467

virtual bool addOccurrence(unsigned pos, StringRef ArgName, StringRef Value, bool MultiArg=false)

Definition CommandLine.cpp:1881

void setMiscFlag(enum MiscFlags M)

enum FormattingFlags getFormattingFlag() const

virtual void printOptionInfo(size_t GlobalWidth) const =0

enum NumOccurrencesFlag getNumOccurrencesFlag() const

void reset()

Definition CommandLine.cpp:478

SmallVector< OptionCategory *, 1 > Categories

void addArgument()

Definition CommandLine.cpp:451

bool error(const Twine &Message, StringRef ArgName=StringRef(), raw_ostream &Errs=llvm::errs())

Definition CommandLine.cpp:1869

void setArgStr(StringRef S)

Definition CommandLine.cpp:458

bool isDefaultOption() const

unsigned getMiscFlags() const

virtual void setDefault()=0

virtual void printOptionValue(size_t GlobalWidth, bool Force) const =0

static void printEnumValHelpStr(StringRef HelpStr, size_t Indent, size_t FirstLineIndentedBy)

Definition CommandLine.cpp:1919

unsigned getNumAdditionalVals() const

void removeArgument()

Unregisters this option from the CommandLine system.

Definition CommandLine.cpp:456

static void printHelpStr(StringRef HelpStr, size_t Indent, size_t FirstLineIndentedBy)

Definition CommandLine.cpp:1907

virtual size_t getOptionWidth() const =0

StringRef getName() const

SubCommand(StringRef Name, StringRef Description="")

SmallVector< Option *, 4 > SinkOpts

static LLVM_ABI SubCommand & getTopLevel()

Definition CommandLine.cpp:499

LLVM_ABI void unregisterSubCommand()

Definition CommandLine.cpp:507

static LLVM_ABI SubCommand & getAll()

Definition CommandLine.cpp:501

LLVM_ABI void reset()

Definition CommandLine.cpp:511

LLVM_ABI void registerSubCommand()

Definition CommandLine.cpp:503

SmallVector< Option *, 4 > PositionalOpts

StringMap< Option * > OptionsMap

void printOptionInfo(const Option &O, size_t GlobalWidth) const

Definition CommandLine.cpp:1962

virtual void anchor()

Definition CommandLine.cpp:92

virtual StringRef getValueName() const

void printOptionNoValue(const Option &O, size_t GlobalWidth) const

Definition CommandLine.cpp:2279

size_t getOptionWidth(const Option &O) const

Definition CommandLine.cpp:1946

void printOptionName(const Option &O, size_t GlobalWidth) const

Definition CommandLine.cpp:1981

virtual size_t getOptionWidth(const Option &O) const

Definition CommandLine.cpp:2111

virtual StringRef getDescription(unsigned N) const =0

virtual const GenericOptionValue & getOptionValue(unsigned N) const =0

virtual unsigned getNumOptions() const =0

virtual StringRef getOption(unsigned N) const =0

void printOptionDiff(const Option &O, const AnyOptionValue &V, const AnyOptionValue &Default, size_t GlobalWidth) const

void printGenericOptionDiff(const Option &O, const GenericOptionValue &V, const GenericOptionValue &Default, size_t GlobalWidth) const

Definition CommandLine.cpp:2187

virtual void printOptionInfo(const Option &O, size_t GlobalWidth) const

Definition CommandLine.cpp:2134

unsigned findOption(StringRef Name)

Definition CommandLine.cpp:2087

bool parse(Option &O, StringRef ArgName, StringRef Arg, DataType &V)

An efficient, type-erasing, non-owning reference to a callable.

A range adaptor for a pair of iterators.

This class implements an extremely fast bulk output stream that can only output to a stream.

raw_ostream & indent(unsigned NumSpaces)

indent - Insert 'NumSpaces' spaces.

static LLVM_ABI std::optional< std::string > GetEnv(StringRef name)

The virtual file system interface.

The result of a status operation.

LLVM_ABI bool equivalent(const Status &Other) const

LLVM_C_ABI void LLVMParseCommandLineOptions(int argc, const char *const *argv, const char *Overview)

This function parses the given arguments using the LLVM command line parser.

Definition CommandLine.cpp:2868

#define llvm_unreachable(msg)

Marks that the current location is not supposed to be reachable.

@ C

The default llvm calling convention, compatible with C.

constexpr size_t NameSize

This namespace contains all of the command line option processing machinery.

LLVM_ABI iterator_range< SmallPtrSet< SubCommand *, 4 >::iterator > getRegisteredSubcommands()

Use this to get all registered SubCommands from the provided parser.

Definition CommandLine.cpp:2831

LLVM_ABI void PrintVersionMessage()

Utility function for printing version number.

Definition CommandLine.cpp:2810

LLVM_ABI bool ExpandResponseFiles(StringSaver &Saver, TokenizerCallback Tokenizer, SmallVectorImpl< const char * > &Argv)

A convenience helper which supports the typical use case of expansion function call.

Definition CommandLine.cpp:1393

LLVM_ABI void TokenizeWindowsCommandLine(StringRef Source, StringSaver &Saver, SmallVectorImpl< const char * > &NewArgv, bool MarkEOLs=false)

Tokenizes a string of Windows command line arguments, which may contain quotes and escaped quotes.

Definition CommandLine.cpp:1058

LLVM_ABI OptionCategory & getGeneralCategory()

Definition CommandLine.cpp:2695

LLVM_ABI void ResetAllOptionOccurrences()

Reset all command line options to a state that looks as if they have never appeared on the command li...

Definition CommandLine.cpp:1490

LLVM_ABI void SetVersionPrinter(VersionPrinterTy func)

===------------------------------------------------------------------—===// Override the default (LLV...

Definition CommandLine.cpp:2814

LLVM_ABI void tokenizeConfigFile(StringRef Source, StringSaver &Saver, SmallVectorImpl< const char * > &NewArgv, bool MarkEOLs=false)

Tokenizes content of configuration file.

Definition CommandLine.cpp:1090

LLVM_ABI StringMap< Option * > & getRegisteredOptions(SubCommand &Sub=SubCommand::getTopLevel())

Use this to get a StringMap to all registered named options (e.g.

Definition CommandLine.cpp:2822

LLVM_ABI void ResetCommandLineParser()

Reset the command line parser back to its initial state.

Definition CommandLine.cpp:2863

LLVM_ABI void PrintOptionValues()

Definition CommandLine.cpp:2733

LLVM_ABI void AddLiteralOption(Option &O, StringRef Name)

Adds a new option for parsing and provides the option it refers to.

Definition CommandLine.cpp:443

void printOptionDiff(const Option &O, const generic_parser_base &P, const DT &V, const OptionValue< DT > &Default, size_t GlobalWidth)

LLVM_ABI void TokenizeWindowsCommandLineNoCopy(StringRef Source, StringSaver &Saver, SmallVectorImpl< StringRef > &NewArgv)

Tokenizes a Windows command line while attempting to avoid copies.

Definition CommandLine.cpp:1070

LLVM_ABI void printBuildConfig(raw_ostream &OS)

Prints the compiler build configuration.

Definition CommandLine.cpp:2801

void(*)(StringRef Source, StringSaver &Saver, SmallVectorImpl< const char * > &NewArgv, bool MarkEOLs) TokenizerCallback

String tokenization function type.

LLVM_ABI bool ProvidePositionalOption(Option *Handler, StringRef Arg, int i)

Parses Arg into the option handler Handler.

Definition CommandLine.cpp:724

LLVM_ABI bool expandResponseFiles(int Argc, const char *const *Argv, const char *EnvVar, SmallVectorImpl< const char * > &NewArgv)

A convenience helper which concatenates the options specified by the environment variable EnvVar and ...

initializer< Ty > init(const Ty &Val)

std::function< void(raw_ostream &)> VersionPrinterTy

LLVM_ABI ArrayRef< StringRef > getCompilerBuildConfig()

An array of optional enabled settings in the LLVM build configuration, which may be of interest to co...

Definition CommandLine.cpp:2763

LocationClass< Ty > location(Ty &L)

LLVM_ABI void HideUnrelatedOptions(cl::OptionCategory &Category, SubCommand &Sub=SubCommand::getTopLevel())

Mark all options not part of this category as cl::ReallyHidden.

Definition CommandLine.cpp:2835

LLVM_ABI void AddExtraVersionPrinter(VersionPrinterTy func)

===------------------------------------------------------------------—===// Add an extra printer to u...

Definition CommandLine.cpp:2818

LLVM_ABI void PrintHelpMessage(bool Hidden=false, bool Categorized=false)

This function just prints the help message, exactly the same way as if the -help or -help-hidden opti...

Definition CommandLine.cpp:2752

LLVM_ABI void TokenizeWindowsCommandLineFull(StringRef Source, StringSaver &Saver, SmallVectorImpl< const char * > &NewArgv, bool MarkEOLs=false)

Tokenizes a Windows full command line, including command name at the start.

Definition CommandLine.cpp:1078

LLVM_ABI bool ParseCommandLineOptions(int argc, const char *const *argv, StringRef Overview="", raw_ostream *Errs=nullptr, vfs::FileSystem *VFS=nullptr, const char *EnvVar=nullptr, bool LongOptionsUseDoubleDash=false)

Definition CommandLine.cpp:1462

LLVM_ABI void TokenizeGNUCommandLine(StringRef Source, StringSaver &Saver, SmallVectorImpl< const char * > &NewArgv, bool MarkEOLs=false)

Tokenizes a command line that can contain escapes and quotes.

Definition CommandLine.cpp:838

LLVM_ABI StringRef parent_path(StringRef path LLVM_LIFETIME_BOUND, Style style=Style::native)

Get parent path.

LLVM_ABI bool has_parent_path(const Twine &path, Style style=Style::native)

Has parent path?

LLVM_ABI bool is_relative(const Twine &path, Style style=Style::native)

Is path relative?

LLVM_ABI StringRef filename(StringRef path LLVM_LIFETIME_BOUND, Style style=Style::native)

Get filename.

LLVM_ABI bool is_absolute(const Twine &path, Style style=Style::native)

Is path absolute?

LLVM_ABI void append(SmallVectorImpl< char > &path, const Twine &a, const Twine &b="", const Twine &c="", const Twine &d="")

Append to path.

LLVM_ABI IntrusiveRefCntPtr< FileSystem > getRealFileSystem()

Gets an vfs::FileSystem for the 'real' file system, as seen by the operating system.

This is an optimization pass for GlobalISel generic memory operations.

auto drop_begin(T &&RangeOrContainer, size_t N=1)

Return a range covering RangeOrContainer with the first N elements excluded.

FunctionAddr VTableAddr Value

void initWithColorOptions()

Printable print(const GCNRegPressure &RP, const GCNSubtarget *ST=nullptr, unsigned DynamicVGPRBlockSize=0)

auto size(R &&Range, std::enable_if_t< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(Range.begin())>::iterator_category >::value, void > *=nullptr)

Get the size of a range.

LLVM_ABI raw_fd_ostream & outs()

This returns a reference to a raw_fd_ostream for standard output.

iterator_range< T > make_range(T x, T y)

Convenience function for iterating over sub-ranges.

void append_range(Container &C, Range &&R)

Wrapper function to append range R to container C.

void interleaveComma(const Container &c, StreamT &os, UnaryFunctor each_fn)

LLVM_ABI bool hasUTF16ByteOrderMark(ArrayRef< char > SrcBytes)

Returns true if a blob of text starts with a UTF-16 big or little endian byte order mark.

void initDebugCounterOptions()

Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)

Create formatted StringError object.

bool to_float(const Twine &T, float &Num)

@ no_such_file_or_directory

decltype(auto) get(const PointerIntPair< PointerTy, IntBits, IntType, PtrTraits, Info > &Pair)

LLVM_ABI raw_ostream & dbgs()

dbgs() - This returns a reference to a raw_ostream for debugging messages.

LLVM_ABI void report_fatal_error(Error Err, bool gen_crash_diag=true)

LLVM_ABI bool convertUTF16ToUTF8String(ArrayRef< char > SrcBytes, std::string &Out)

Converts a stream of raw bytes assumed to be UTF16 into a UTF8 std::string.

void initSignalsOptions()

void initStatisticOptions()

LLVM_ABI raw_ostream & nulls()

This returns a reference to a raw_ostream which simply discards output.

class LLVM_GSL_OWNER SmallVector

Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...

Error make_error(ArgTs &&... Args)

Make a Error instance representing failure using the given error info type.

LLVM_ABI raw_fd_ostream & errs()

This returns a reference to a raw_ostream for standard error.

void initRandomSeedOptions()

@ Sub

Subtraction of integers.

void initGraphWriterOptions()

raw_ostream & operator<<(raw_ostream &OS, const APFixedPoint &FX)

ArrayRef(const T &OneElt) -> ArrayRef< T >

std::string toString(const APInt &I, unsigned Radix, bool Signed, bool formatAsCLiteral=false, bool UpperCase=true, bool InsertSeparators=false)

auto count_if(R &&Range, UnaryPredicate P)

Wrapper function around std::count_if to count the number of times an element satisfying a given pred...

bool is_contained(R &&Range, const E &Element)

Returns true if Element is found in Range.

void array_pod_sort(IteratorTy Start, IteratorTy End)

array_pod_sort - This sorts an array with the specified start and end extent.

BumpPtrAllocatorImpl<> BumpPtrAllocator

The standard BumpPtrAllocator which just uses the default template parameters.

@ Default

The result values are uniform if and only if all operands are uniform.