CommandLine.cpp revision 7059d47a6e1a378232dce3e47b51434dec0ea608
1dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner//===-- CommandLine.cpp - Command line parser implementation --------------===// 2f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman// 3b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// The LLVM Compiler Infrastructure 4b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// 54ee451de366474b9c228b4e5fa573795a715216dChris Lattner// This file is distributed under the University of Illinois Open Source 64ee451de366474b9c228b4e5fa573795a715216dChris Lattner// License. See LICENSE.TXT for details. 7f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman// 8b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell//===----------------------------------------------------------------------===// 9dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 10dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// This class implements a command line argument processor that is useful when 11dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// creating a tool. It provides a simple, minimalistic interface that is easily 12dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// extensible and supports nonlocal (library) command line options. 13dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 1403fe1bd149b21855098e9cc9f959c8e8ca80693cChris Lattner// Note that rather than trying to figure out what this code does, you could try 1503fe1bd149b21855098e9cc9f959c8e8ca80693cChris Lattner// reading the library documentation located in docs/CommandLine.html 1603fe1bd149b21855098e9cc9f959c8e8ca80693cChris Lattner// 17dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner//===----------------------------------------------------------------------===// 18dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 19551ccae044b0ff658fe629dd67edd5ffe75d10e8Reid Spencer#include "llvm/Config/config.h" 20beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov#include "llvm/ADT/OwningPtr.h" 21551ccae044b0ff658fe629dd67edd5ffe75d10e8Reid Spencer#include "llvm/Support/CommandLine.h" 22beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov#include "llvm/Support/MemoryBuffer.h" 2390aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner#include "llvm/Support/ManagedStatic.h" 24fe6b146dcd09f488b12c7ff888ead9cedc92c2a6Bill Wendling#include "llvm/Support/Streams.h" 256f4c60770cfe6c485cdcb1397df59d2c7778cbc9Reid Spencer#include "llvm/System/Path.h" 26dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner#include <algorithm> 27786e3e22a98ce45782932478f76cf8007fb73ec4Duraid Madina#include <functional> 28dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner#include <map> 291a097e30d39e60303ae2b19f7a56e813f3e3c18eBill Wendling#include <ostream> 30dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner#include <set> 312d6a2360036cf511af0a06f9720e6a1752779d1cBrian Gaeke#include <cstdlib> 322d6a2360036cf511af0a06f9720e6a1752779d1cBrian Gaeke#include <cerrno> 335114004110d771e2cc838be569207784f2519010Chris Lattner#include <cstring> 34ae9f3a3b7c915f725aef5a7250e88eaeddda03c6Anton Korobeynikov#include <climits> 352cdd21c2e4d855500dfb53f77aa74da53ccf9de6Chris Lattnerusing namespace llvm; 36dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattnerusing namespace cl; 37dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 387422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner//===----------------------------------------------------------------------===// 397422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner// Template instantiations and anchors. 407422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner// 417422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class basic_parser<bool>); 4281da02b553b86868637f27b89c6e919c31ed5b51Dale JohannesenTEMPLATE_INSTANTIATION(class basic_parser<boolOrDefault>); 437422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class basic_parser<int>); 447422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class basic_parser<unsigned>); 457422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class basic_parser<double>); 467422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class basic_parser<float>); 477422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class basic_parser<std::string>); 487422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner 497422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class opt<unsigned>); 507422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class opt<int>); 517422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class opt<std::string>); 527422a761008ef63152417c5e69ddc31252fb6b10Chris LattnerTEMPLATE_INSTANTIATION(class opt<bool>); 537422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner 547422a761008ef63152417c5e69ddc31252fb6b10Chris Lattnervoid Option::anchor() {} 557422a761008ef63152417c5e69ddc31252fb6b10Chris Lattnervoid basic_parser_impl::anchor() {} 567422a761008ef63152417c5e69ddc31252fb6b10Chris Lattnervoid parser<bool>::anchor() {} 5781da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesenvoid parser<boolOrDefault>::anchor() {} 587422a761008ef63152417c5e69ddc31252fb6b10Chris Lattnervoid parser<int>::anchor() {} 597422a761008ef63152417c5e69ddc31252fb6b10Chris Lattnervoid parser<unsigned>::anchor() {} 607422a761008ef63152417c5e69ddc31252fb6b10Chris Lattnervoid parser<double>::anchor() {} 617422a761008ef63152417c5e69ddc31252fb6b10Chris Lattnervoid parser<float>::anchor() {} 627422a761008ef63152417c5e69ddc31252fb6b10Chris Lattnervoid parser<std::string>::anchor() {} 637422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner 647422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner//===----------------------------------------------------------------------===// 657422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner 66efa3da5593117eab5209c9197cad5ca42213c12eChris Lattner// Globals for name and overview of program. Program name is not a string to 67efa3da5593117eab5209c9197cad5ca42213c12eChris Lattner// avoid static ctor/dtor issues. 68efa3da5593117eab5209c9197cad5ca42213c12eChris Lattnerstatic char ProgramName[80] = "<premain>"; 69e1cc150a8e6b451e42b04b04ffb41596e01bbef5Reid Spencerstatic const char *ProgramOverview = 0; 70e1cc150a8e6b451e42b04b04ffb41596e01bbef5Reid Spencer 71c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner// This collects additional help to be printed. 7290aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattnerstatic ManagedStatic<std::vector<const char*> > MoreHelp; 73c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner 7490aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattnerextrahelp::extrahelp(const char *Help) 75c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner : morehelp(Help) { 7690aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner MoreHelp->push_back(Help); 77c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner} 78c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner 7969d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattnerstatic bool OptionListChanged = false; 8069d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattner 8169d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattner// MarkOptionsChanged - Internal helper function. 8269d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattnervoid cl::MarkOptionsChanged() { 8369d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattner OptionListChanged = true; 8469d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattner} 8569d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattner 869878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner/// RegisteredOptionList - This is the list of the command line options that 879878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner/// have statically constructed themselves. 889878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattnerstatic Option *RegisteredOptionList = 0; 899878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner 909878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattnervoid Option::addArgument() { 919878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner assert(NextRegistered == 0 && "argument multiply registered!"); 92beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 939878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner NextRegistered = RegisteredOptionList; 949878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner RegisteredOptionList = this; 9569d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattner MarkOptionsChanged(); 969878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner} 979878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner 9869d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattner 99331de23705a719514e37c211f327379688f81b0dChris Lattner//===----------------------------------------------------------------------===// 1007422a761008ef63152417c5e69ddc31252fb6b10Chris Lattner// Basic, shared command line option processing machinery. 101331de23705a719514e37c211f327379688f81b0dChris Lattner// 102331de23705a719514e37c211f327379688f81b0dChris Lattner 1039878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner/// GetOptionInfo - Scan the list of registered options, turning them into data 1049878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner/// structures that are easier to handle. 1059878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattnerstatic void GetOptionInfo(std::vector<Option*> &PositionalOpts, 106d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov std::vector<Option*> &SinkOpts, 1079878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner std::map<std::string, Option*> &OptionsMap) { 1089878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner std::vector<const char*> OptionNames; 109ee2b32082eff7366621ed2ab119deb96b7c26cecChris Lattner Option *CAOpt = 0; // The ConsumeAfter option if it exists. 1109878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner for (Option *O = RegisteredOptionList; O; O = O->getNextRegisteredOption()) { 1119878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner // If this option wants to handle multiple option names, get the full set. 1129878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner // This handles enum options like "-O1 -O2" etc. 1139878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner O->getExtraOptionNames(OptionNames); 1149878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner if (O->ArgStr[0]) 1159878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner OptionNames.push_back(O->ArgStr); 116beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 1179878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner // Handle named options. 11834cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng for (size_t i = 0, e = OptionNames.size(); i != e; ++i) { 1199878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner // Add argument to the argument map! 1209878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner if (!OptionsMap.insert(std::pair<std::string,Option*>(OptionNames[i], 1219878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner O)).second) { 1229878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner cerr << ProgramName << ": CommandLine Error: Argument '" 12333540adca55b95a5fdbb0dc783ded319a90b4bc1Matthijs Kooijman << OptionNames[i] << "' defined more than once!\n"; 1249878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner } 1259878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner } 126beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 1279878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner OptionNames.clear(); 128beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 1299878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner // Remember information about positional options. 1309878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner if (O->getFormattingFlag() == cl::Positional) 1319878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner PositionalOpts.push_back(O); 13261e015fe7426ca97c3c7afb583f04f5f93050370Dan Gohman else if (O->getMiscFlags() & cl::Sink) // Remember sink options 133d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov SinkOpts.push_back(O); 1349878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner else if (O->getNumOccurrencesFlag() == cl::ConsumeAfter) { 135ee2b32082eff7366621ed2ab119deb96b7c26cecChris Lattner if (CAOpt) 1369878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner O->error("Cannot specify more than one option with cl::ConsumeAfter!"); 137ee2b32082eff7366621ed2ab119deb96b7c26cecChris Lattner CAOpt = O; 1389878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner } 139e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner } 140beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 141ee2b32082eff7366621ed2ab119deb96b7c26cecChris Lattner if (CAOpt) 142ee2b32082eff7366621ed2ab119deb96b7c26cecChris Lattner PositionalOpts.push_back(CAOpt); 143beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 144ee2b32082eff7366621ed2ab119deb96b7c26cecChris Lattner // Make sure that they are in order of registration not backwards. 145ee2b32082eff7366621ed2ab119deb96b7c26cecChris Lattner std::reverse(PositionalOpts.begin(), PositionalOpts.end()); 146e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner} 147e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner 1489878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner 149af035f3460f7d758f73987c3f692faf8d6cae062Chris Lattner/// LookupOption - Lookup the option specified by the specified option on the 150af035f3460f7d758f73987c3f692faf8d6cae062Chris Lattner/// command line. If there is a value specified (after an equal sign) return 151af035f3460f7d758f73987c3f692faf8d6cae062Chris Lattner/// that as well. 1529878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattnerstatic Option *LookupOption(const char *&Arg, const char *&Value, 1539878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner std::map<std::string, Option*> &OptionsMap) { 154af035f3460f7d758f73987c3f692faf8d6cae062Chris Lattner while (*Arg == '-') ++Arg; // Eat leading dashes 155beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 156af035f3460f7d758f73987c3f692faf8d6cae062Chris Lattner const char *ArgEnd = Arg; 157af035f3460f7d758f73987c3f692faf8d6cae062Chris Lattner while (*ArgEnd && *ArgEnd != '=') 158af035f3460f7d758f73987c3f692faf8d6cae062Chris Lattner ++ArgEnd; // Scan till end of argument name. 159beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 160af035f3460f7d758f73987c3f692faf8d6cae062Chris Lattner if (*ArgEnd == '=') // If we have an equals sign... 161af035f3460f7d758f73987c3f692faf8d6cae062Chris Lattner Value = ArgEnd+1; // Get the value, not the equals 162beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 163beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 164af035f3460f7d758f73987c3f692faf8d6cae062Chris Lattner if (*Arg == 0) return 0; 165beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 166af035f3460f7d758f73987c3f692faf8d6cae062Chris Lattner // Look up the option. 167af035f3460f7d758f73987c3f692faf8d6cae062Chris Lattner std::map<std::string, Option*>::iterator I = 1689878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner OptionsMap.find(std::string(Arg, ArgEnd)); 1699878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner return I != OptionsMap.end() ? I->second : 0; 170dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 171dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 172caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattnerstatic inline bool ProvideOption(Option *Handler, const char *ArgName, 173caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner const char *Value, int argc, char **argv, 174caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner int &i) { 1757059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov // Is this a multi-argument option? 1767059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov unsigned NumAdditionalVals = Handler->getNumAdditionalVals(); 1777059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov 178caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner // Enforce value requirements 179caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner switch (Handler->getValueExpectedFlag()) { 180caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner case ValueRequired: 1816d5857e139df71410e98ccf6cd0e783f90a9fc16Chris Lattner if (Value == 0) { // No value specified? 182caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner if (i+1 < argc) { // Steal the next argument, like for '-o filename' 183caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner Value = argv[++i]; 184caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner } else { 185caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner return Handler->error(" requires a value!"); 186caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner } 187caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner } 188caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner break; 189caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner case ValueDisallowed: 1907059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov if (NumAdditionalVals > 0) 1917059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov return Handler->error(": multi-valued option specified" 1927059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov " with ValueDisallowed modifier!"); 1937059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov 1946d5857e139df71410e98ccf6cd0e783f90a9fc16Chris Lattner if (Value) 195f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman return Handler->error(" does not allow a value! '" + 196ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::string(Value) + "' specified."); 197caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner break; 198f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman case ValueOptional: 199e1cc150a8e6b451e42b04b04ffb41596e01bbef5Reid Spencer break; 200f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman default: 201e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cerr << ProgramName 202e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << ": Bad ValueMask flag! CommandLine usage error:" 203e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << Handler->getValueExpectedFlag() << "\n"; 204e1cc150a8e6b451e42b04b04ffb41596e01bbef5Reid Spencer abort(); 205e1cc150a8e6b451e42b04b04ffb41596e01bbef5Reid Spencer break; 206caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner } 207caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner 2087059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov // If this isn't a multi-arg option, just run the handler. 2097059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov if (NumAdditionalVals == 0) { 2107059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov return Handler->addOccurrence(i, ArgName, Value ? Value : ""); 2117059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov } 2127059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov // If it is, run the handle several times. 2137059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov else { 2147059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov bool MultiArg = false; 2157059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov 2167059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov if (Value) { 2177059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov if (Handler->addOccurrence(i, ArgName, Value, MultiArg)) 2187059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov return true; 2197059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov --NumAdditionalVals; 2207059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov MultiArg = true; 2217059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov } 2227059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov 2237059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov while (NumAdditionalVals > 0) { 2247059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov 2257059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov if (i+1 < argc) { 2267059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov Value = argv[++i]; 2277059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov } else { 2287059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov return Handler->error(": not enough values!"); 2297059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov } 2307059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov if (Handler->addOccurrence(i, ArgName, Value, MultiArg)) 2317059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov return true; 2327059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov MultiArg = true; 2337059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov --NumAdditionalVals; 2347059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov } 2357059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov return false; 2367059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov } 237caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner} 238caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner 239f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukmanstatic bool ProvidePositionalOption(Option *Handler, const std::string &Arg, 2401e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer int i) { 2411e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer int Dummy = i; 2429cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner return ProvideOption(Handler, Handler->ArgStr, Arg.c_str(), 0, 0, Dummy); 243331de23705a719514e37c211f327379688f81b0dChris Lattner} 244331de23705a719514e37c211f327379688f81b0dChris Lattner 245331de23705a719514e37c211f327379688f81b0dChris Lattner 246331de23705a719514e37c211f327379688f81b0dChris Lattner// Option predicates... 247331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic inline bool isGrouping(const Option *O) { 248331de23705a719514e37c211f327379688f81b0dChris Lattner return O->getFormattingFlag() == cl::Grouping; 249331de23705a719514e37c211f327379688f81b0dChris Lattner} 250331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic inline bool isPrefixedOrGrouping(const Option *O) { 251331de23705a719514e37c211f327379688f81b0dChris Lattner return isGrouping(O) || O->getFormattingFlag() == cl::Prefix; 252331de23705a719514e37c211f327379688f81b0dChris Lattner} 253331de23705a719514e37c211f327379688f81b0dChris Lattner 254331de23705a719514e37c211f327379688f81b0dChris Lattner// getOptionPred - Check to see if there are any options that satisfy the 255331de23705a719514e37c211f327379688f81b0dChris Lattner// specified predicate with names that are the prefixes in Name. This is 256331de23705a719514e37c211f327379688f81b0dChris Lattner// checked by progressively stripping characters off of the name, checking to 257331de23705a719514e37c211f327379688f81b0dChris Lattner// see if there options that satisfy the predicate. If we find one, return it, 258331de23705a719514e37c211f327379688f81b0dChris Lattner// otherwise return null. 259f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner// 26034cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Chengstatic Option *getOptionPred(std::string Name, size_t &Length, 2619878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner bool (*Pred)(const Option*), 2629878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner std::map<std::string, Option*> &OptionsMap) { 263f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 2649878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner std::map<std::string, Option*>::iterator OMI = OptionsMap.find(Name); 2659878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner if (OMI != OptionsMap.end() && Pred(OMI->second)) { 266331de23705a719514e37c211f327379688f81b0dChris Lattner Length = Name.length(); 2679878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner return OMI->second; 268331de23705a719514e37c211f327379688f81b0dChris Lattner } 269f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner 270331de23705a719514e37c211f327379688f81b0dChris Lattner if (Name.size() == 1) return 0; 271331de23705a719514e37c211f327379688f81b0dChris Lattner do { 272331de23705a719514e37c211f327379688f81b0dChris Lattner Name.erase(Name.end()-1, Name.end()); // Chop off the last character... 2739878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner OMI = OptionsMap.find(Name); 274331de23705a719514e37c211f327379688f81b0dChris Lattner 275331de23705a719514e37c211f327379688f81b0dChris Lattner // Loop while we haven't found an option and Name still has at least two 276331de23705a719514e37c211f327379688f81b0dChris Lattner // characters in it (so that the next iteration will not be the empty 277331de23705a719514e37c211f327379688f81b0dChris Lattner // string... 2789878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner } while ((OMI == OptionsMap.end() || !Pred(OMI->second)) && Name.size() > 1); 279331de23705a719514e37c211f327379688f81b0dChris Lattner 2809878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner if (OMI != OptionsMap.end() && Pred(OMI->second)) { 281331de23705a719514e37c211f327379688f81b0dChris Lattner Length = Name.length(); 2829878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner return OMI->second; // Found one! 283f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner } 284331de23705a719514e37c211f327379688f81b0dChris Lattner return 0; // No option found! 285331de23705a719514e37c211f327379688f81b0dChris Lattner} 286f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner 287331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic bool RequiresValue(const Option *O) { 288dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman return O->getNumOccurrencesFlag() == cl::Required || 289dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman O->getNumOccurrencesFlag() == cl::OneOrMore; 290331de23705a719514e37c211f327379688f81b0dChris Lattner} 291331de23705a719514e37c211f327379688f81b0dChris Lattner 292331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic bool EatsUnboundedNumberOfValues(const Option *O) { 293dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman return O->getNumOccurrencesFlag() == cl::ZeroOrMore || 294dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman O->getNumOccurrencesFlag() == cl::OneOrMore; 295f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner} 296caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner 297c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke/// ParseCStringVector - Break INPUT up wherever one or more 298c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke/// whitespace characters are found, and store the resulting tokens in 299c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke/// OUTPUT. The tokens stored in OUTPUT are dynamically allocated 300c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke/// using strdup (), so it is the caller's responsibility to free () 301c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke/// them later. 30206b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// 303232885873fb0081acc1420ab83b14ab6f8eba280Chris Lattnerstatic void ParseCStringVector(std::vector<char *> &output, 304232885873fb0081acc1420ab83b14ab6f8eba280Chris Lattner const char *input) { 305c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Characters which will be treated as token separators: 306cfbb2f074da2842e42956d3b4c21e91b37f36f06Dan Gohman static const char *const delims = " \v\f\t\r\n"; 307c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke 30806b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke std::string work (input); 309c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Skip past any delims at head of input string. 310c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke size_t pos = work.find_first_not_of (delims); 311c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // If the string consists entirely of delims, then exit early. 312c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke if (pos == std::string::npos) return; 313c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Otherwise, jump forward to beginning of first word. 31406b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke work = work.substr (pos); 315c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Find position of first delimiter. 31606b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke pos = work.find_first_of (delims); 317c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke 318c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke while (!work.empty() && pos != std::string::npos) { 319c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Everything from 0 to POS is the next word to copy. 320c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke output.push_back (strdup (work.substr (0,pos).c_str ())); 321c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Is there another word in the string? 322c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke size_t nextpos = work.find_first_not_of (delims, pos + 1); 323c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke if (nextpos != std::string::npos) { 324c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Yes? Then remove delims from beginning ... 32506b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke work = work.substr (work.find_first_not_of (delims, pos + 1)); 326c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // and find the end of the word. 32706b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke pos = work.find_first_of (delims); 32806b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke } else { 329c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // No? (Remainder of string is delims.) End the loop. 33006b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke work = ""; 331c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke pos = std::string::npos; 33206b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke } 33306b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke } 33406b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke 335c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // If `input' ended with non-delim char, then we'll get here with 336c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // the last word of `input' in `work'; copy it now. 337c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke if (!work.empty ()) { 338c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke output.push_back (strdup (work.c_str ())); 33906b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke } 34006b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke} 34106b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke 34206b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// ParseEnvironmentOptions - An alternative entry point to the 34306b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// CommandLine library, which allows you to read the program's name 34406b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// from the caller (as PROGNAME) and its command-line arguments from 34506b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// an environment variable (whose name is given in ENVVAR). 34606b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// 347bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattnervoid cl::ParseEnvironmentOptions(const char *progName, const char *envVar, 348beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov const char *Overview, bool ReadResponseFiles) { 349c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Check args. 350bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner assert(progName && "Program name not specified"); 351bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner assert(envVar && "Environment variable name missing"); 352f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 35306b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke // Get the environment variable they want us to parse options out of. 354232885873fb0081acc1420ab83b14ab6f8eba280Chris Lattner const char *envValue = getenv(envVar); 355c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke if (!envValue) 35606b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke return; 357c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke 358c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Get program's "name", which we wouldn't know without the caller 359c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // telling us. 360232885873fb0081acc1420ab83b14ab6f8eba280Chris Lattner std::vector<char*> newArgv; 361232885873fb0081acc1420ab83b14ab6f8eba280Chris Lattner newArgv.push_back(strdup(progName)); 36206b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke 36306b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke // Parse the value of the environment variable into a "command line" 36406b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke // and hand it off to ParseCommandLineOptions(). 365232885873fb0081acc1420ab83b14ab6f8eba280Chris Lattner ParseCStringVector(newArgv, envValue); 36634cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng int newArgc = static_cast<int>(newArgv.size()); 367beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov ParseCommandLineOptions(newArgc, &newArgv[0], Overview, ReadResponseFiles); 368c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke 369c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Free all the strdup()ed strings. 370232885873fb0081acc1420ab83b14ab6f8eba280Chris Lattner for (std::vector<char*>::iterator i = newArgv.begin(), e = newArgv.end(); 371232885873fb0081acc1420ab83b14ab6f8eba280Chris Lattner i != e; ++i) 372c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke free (*i); 37306b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke} 37406b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke 375beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 376beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov/// ExpandResponseFiles - Copy the contents of argv into newArgv, 377beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov/// substituting the contents of the response files for the arguments 378beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov/// of type @file. 379beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkovstatic void ExpandResponseFiles(int argc, char** argv, 380beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov std::vector<char*>& newArgv) { 381beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov for (int i = 1; i != argc; ++i) { 382beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov char* arg = argv[i]; 383beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 384beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov if (arg[0] == '@') { 385beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 386beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov sys::PathWithStatus respFile(++arg); 387beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 388beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov // Check that the response file is not empty (mmap'ing empty 389beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov // files can be problematic). 390beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov const sys::FileStatus *FileStat = respFile.getFileStatus(); 391beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov if (!FileStat) 392beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov continue; 393beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov if (FileStat->getSize() == 0) 394beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov continue; 395beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 396beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov // Mmap the response file into memory. 397beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov OwningPtr<MemoryBuffer> 398beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov respFilePtr(MemoryBuffer::getFile(respFile.c_str())); 399beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 400beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov if (respFilePtr == 0) 401beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov continue; 402beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 403beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov ParseCStringVector(newArgv, respFilePtr->getBufferStart()); 404beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov } 405beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov else { 406beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov newArgv.push_back(strdup(arg)); 407beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov } 408beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov } 409beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov} 410beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 4119a5263241d40d493445d7f386b4d76be088c3ac1Dan Gohmanvoid cl::ParseCommandLineOptions(int argc, char **argv, 412beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov const char *Overview, bool ReadResponseFiles) { 4139878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner // Process all registered options. 4149878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner std::vector<Option*> PositionalOpts; 415d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov std::vector<Option*> SinkOpts; 4169878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner std::map<std::string, Option*> Opts; 417d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov GetOptionInfo(PositionalOpts, SinkOpts, Opts); 418beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 4199878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner assert((!Opts.empty() || !PositionalOpts.empty()) && 4209878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner "No options specified!"); 421beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 422beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov // Expand response files. 423beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov std::vector<char*> newArgv; 424beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov if (ReadResponseFiles) { 425beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov newArgv.push_back(strdup(argv[0])); 426beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov ExpandResponseFiles(argc, argv, newArgv); 427beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov argv = &newArgv[0]; 42834cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng argc = static_cast<int>(newArgv.size()); 429beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov } 430beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 431efa3da5593117eab5209c9197cad5ca42213c12eChris Lattner // Copy the program name into ProgName, making sure not to overflow it. 432efa3da5593117eab5209c9197cad5ca42213c12eChris Lattner std::string ProgName = sys::Path(argv[0]).getLast(); 433efa3da5593117eab5209c9197cad5ca42213c12eChris Lattner if (ProgName.size() > 79) ProgName.resize(79); 434efa3da5593117eab5209c9197cad5ca42213c12eChris Lattner strcpy(ProgramName, ProgName.c_str()); 435beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 436dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner ProgramOverview = Overview; 437dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner bool ErrorParsing = false; 438dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 439331de23705a719514e37c211f327379688f81b0dChris Lattner // Check out the positional arguments to collect information about them. 440331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned NumPositionalRequired = 0; 441beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 442de0132453e2939488c2d69290bfdfb2cde94a0afChris Lattner // Determine whether or not there are an unlimited number of positionals 443de0132453e2939488c2d69290bfdfb2cde94a0afChris Lattner bool HasUnlimitedPositionals = false; 444beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 445331de23705a719514e37c211f327379688f81b0dChris Lattner Option *ConsumeAfterOpt = 0; 446331de23705a719514e37c211f327379688f81b0dChris Lattner if (!PositionalOpts.empty()) { 447dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman if (PositionalOpts[0]->getNumOccurrencesFlag() == cl::ConsumeAfter) { 448331de23705a719514e37c211f327379688f81b0dChris Lattner assert(PositionalOpts.size() > 1 && 449331de23705a719514e37c211f327379688f81b0dChris Lattner "Cannot specify cl::ConsumeAfter without a positional argument!"); 450331de23705a719514e37c211f327379688f81b0dChris Lattner ConsumeAfterOpt = PositionalOpts[0]; 451331de23705a719514e37c211f327379688f81b0dChris Lattner } 452331de23705a719514e37c211f327379688f81b0dChris Lattner 453331de23705a719514e37c211f327379688f81b0dChris Lattner // Calculate how many positional values are _required_. 454331de23705a719514e37c211f327379688f81b0dChris Lattner bool UnboundedFound = false; 45534cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng for (size_t i = ConsumeAfterOpt != 0, e = PositionalOpts.size(); 456331de23705a719514e37c211f327379688f81b0dChris Lattner i != e; ++i) { 457331de23705a719514e37c211f327379688f81b0dChris Lattner Option *Opt = PositionalOpts[i]; 458331de23705a719514e37c211f327379688f81b0dChris Lattner if (RequiresValue(Opt)) 459331de23705a719514e37c211f327379688f81b0dChris Lattner ++NumPositionalRequired; 460331de23705a719514e37c211f327379688f81b0dChris Lattner else if (ConsumeAfterOpt) { 461331de23705a719514e37c211f327379688f81b0dChris Lattner // ConsumeAfter cannot be combined with "optional" positional options 46254ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner // unless there is only one positional argument... 46354ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner if (PositionalOpts.size() > 2) 46454ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner ErrorParsing |= 46554ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner Opt->error(" error - this positional option will never be matched, " 46654ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner "because it does not Require a value, and a " 46754ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner "cl::ConsumeAfter option is active!"); 4689cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner } else if (UnboundedFound && !Opt->ArgStr[0]) { 4699cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // This option does not "require" a value... Make sure this option is 4709cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // not specified after an option that eats all extra arguments, or this 4719cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // one will never get any! 472331de23705a719514e37c211f327379688f81b0dChris Lattner // 473331de23705a719514e37c211f327379688f81b0dChris Lattner ErrorParsing |= Opt->error(" error - option can never match, because " 474331de23705a719514e37c211f327379688f81b0dChris Lattner "another positional argument will match an " 475331de23705a719514e37c211f327379688f81b0dChris Lattner "unbounded number of values, and this option" 476331de23705a719514e37c211f327379688f81b0dChris Lattner " does not require a value!"); 477331de23705a719514e37c211f327379688f81b0dChris Lattner } 478331de23705a719514e37c211f327379688f81b0dChris Lattner UnboundedFound |= EatsUnboundedNumberOfValues(Opt); 479331de23705a719514e37c211f327379688f81b0dChris Lattner } 48021e1a79a31fe45fcd861d64118a60c1fcfad618aChris Lattner HasUnlimitedPositionals = UnboundedFound || ConsumeAfterOpt; 481331de23705a719514e37c211f327379688f81b0dChris Lattner } 482331de23705a719514e37c211f327379688f81b0dChris Lattner 4831e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer // PositionalVals - A vector of "positional" arguments we accumulate into 4841e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer // the process at the end... 485331de23705a719514e37c211f327379688f81b0dChris Lattner // 4861e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer std::vector<std::pair<std::string,unsigned> > PositionalVals; 487331de23705a719514e37c211f327379688f81b0dChris Lattner 4889cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // If the program has named positional arguments, and the name has been run 4899cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // across, keep track of which positional argument was named. Otherwise put 4909cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // the positional args into the PositionalVals list... 4919cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner Option *ActivePositionalArg = 0; 4929cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner 493dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Loop over all of the arguments... processing them. 494331de23705a719514e37c211f327379688f81b0dChris Lattner bool DashDashFound = false; // Have we read '--'? 495dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner for (int i = 1; i < argc; ++i) { 496dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner Option *Handler = 0; 4976d5857e139df71410e98ccf6cd0e783f90a9fc16Chris Lattner const char *Value = 0; 498dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner const char *ArgName = ""; 499331de23705a719514e37c211f327379688f81b0dChris Lattner 50069d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattner // If the option list changed, this means that some command line 501159b0a43408e2521110e22e445ec126aaab16788Chris Lattner // option has just been registered or deregistered. This can occur in 502159b0a43408e2521110e22e445ec126aaab16788Chris Lattner // response to things like -load, etc. If this happens, rescan the options. 50369d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattner if (OptionListChanged) { 504159b0a43408e2521110e22e445ec126aaab16788Chris Lattner PositionalOpts.clear(); 505d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov SinkOpts.clear(); 506159b0a43408e2521110e22e445ec126aaab16788Chris Lattner Opts.clear(); 507d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov GetOptionInfo(PositionalOpts, SinkOpts, Opts); 50869d6f1358ca8c442a65fd8d5900f7296fbb2762dChris Lattner OptionListChanged = false; 509159b0a43408e2521110e22e445ec126aaab16788Chris Lattner } 510beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 511331de23705a719514e37c211f327379688f81b0dChris Lattner // Check to see if this is a positional argument. This argument is 512331de23705a719514e37c211f327379688f81b0dChris Lattner // considered to be positional if it doesn't start with '-', if it is "-" 5131115e0483fc6da16d52382f159005baddf028063Misha Brukman // itself, or if we have seen "--" already. 514331de23705a719514e37c211f327379688f81b0dChris Lattner // 515331de23705a719514e37c211f327379688f81b0dChris Lattner if (argv[i][0] != '-' || argv[i][1] == 0 || DashDashFound) { 516331de23705a719514e37c211f327379688f81b0dChris Lattner // Positional argument! 5179cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (ActivePositionalArg) { 5181e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ProvidePositionalOption(ActivePositionalArg, argv[i], i); 5199cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner continue; // We are done! 5209cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner } else if (!PositionalOpts.empty()) { 5211e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals.push_back(std::make_pair(argv[i],i)); 522331de23705a719514e37c211f327379688f81b0dChris Lattner 523331de23705a719514e37c211f327379688f81b0dChris Lattner // All of the positional arguments have been fulfulled, give the rest to 524331de23705a719514e37c211f327379688f81b0dChris Lattner // the consume after option... if it's specified... 525331de23705a719514e37c211f327379688f81b0dChris Lattner // 526f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman if (PositionalVals.size() >= NumPositionalRequired && 527331de23705a719514e37c211f327379688f81b0dChris Lattner ConsumeAfterOpt != 0) { 528331de23705a719514e37c211f327379688f81b0dChris Lattner for (++i; i < argc; ++i) 5291e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals.push_back(std::make_pair(argv[i],i)); 530331de23705a719514e37c211f327379688f81b0dChris Lattner break; // Handle outside of the argument processing loop... 531331de23705a719514e37c211f327379688f81b0dChris Lattner } 532331de23705a719514e37c211f327379688f81b0dChris Lattner 533331de23705a719514e37c211f327379688f81b0dChris Lattner // Delay processing positional arguments until the end... 534331de23705a719514e37c211f327379688f81b0dChris Lattner continue; 535331de23705a719514e37c211f327379688f81b0dChris Lattner } 536bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner } else if (argv[i][0] == '-' && argv[i][1] == '-' && argv[i][2] == 0 && 537bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner !DashDashFound) { 538bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner DashDashFound = true; // This is the mythical "--"? 539bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner continue; // Don't try to process it as an argument itself. 540bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner } else if (ActivePositionalArg && 541bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner (ActivePositionalArg->getMiscFlags() & PositionalEatsArgs)) { 542bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner // If there is a positional argument eating options, check to see if this 543bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner // option is another positional argument. If so, treat it as an argument, 544bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner // otherwise feed it to the eating positional. 545dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner ArgName = argv[i]+1; 5469878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner Handler = LookupOption(ArgName, Value, Opts); 547bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner if (!Handler || Handler->getFormattingFlag() != cl::Positional) { 5481e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ProvidePositionalOption(ActivePositionalArg, argv[i], i); 549bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner continue; // We are done! 550331de23705a719514e37c211f327379688f81b0dChris Lattner } 551331de23705a719514e37c211f327379688f81b0dChris Lattner 552bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner } else { // We start with a '-', must be an argument... 553bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner ArgName = argv[i]+1; 5549878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner Handler = LookupOption(ArgName, Value, Opts); 555331de23705a719514e37c211f327379688f81b0dChris Lattner 556bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner // Check to see if this "option" is really a prefixed or grouped argument. 5575f8448f79c2876466d586f2e1caec89e6f070623Reid Spencer if (Handler == 0) { 558bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner std::string RealName(ArgName); 559bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner if (RealName.size() > 1) { 56034cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng size_t Length = 0; 5619878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner Option *PGOpt = getOptionPred(RealName, Length, isPrefixedOrGrouping, 5629878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner Opts); 563f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 564331de23705a719514e37c211f327379688f81b0dChris Lattner // If the option is a prefixed option, then the value is simply the 565331de23705a719514e37c211f327379688f81b0dChris Lattner // rest of the name... so fall through to later processing, by 566331de23705a719514e37c211f327379688f81b0dChris Lattner // setting up the argument name flags and value fields. 567331de23705a719514e37c211f327379688f81b0dChris Lattner // 568331de23705a719514e37c211f327379688f81b0dChris Lattner if (PGOpt && PGOpt->getFormattingFlag() == cl::Prefix) { 569bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner Value = ArgName+Length; 570bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner assert(Opts.find(std::string(ArgName, Value)) != Opts.end() && 571bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner Opts.find(std::string(ArgName, Value))->second == PGOpt); 572bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner Handler = PGOpt; 573331de23705a719514e37c211f327379688f81b0dChris Lattner } else if (PGOpt) { 574bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner // This must be a grouped option... handle them now. 575331de23705a719514e37c211f327379688f81b0dChris Lattner assert(isGrouping(PGOpt) && "Broken getOptionPred!"); 576f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 577331de23705a719514e37c211f327379688f81b0dChris Lattner do { 578331de23705a719514e37c211f327379688f81b0dChris Lattner // Move current arg name out of RealName into RealArgName... 579bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner std::string RealArgName(RealName.begin(), 580bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner RealName.begin() + Length); 581bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner RealName.erase(RealName.begin(), RealName.begin() + Length); 582f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 583b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman // Because ValueRequired is an invalid flag for grouped arguments, 584b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman // we don't need to pass argc/argv in... 585b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman // 586331de23705a719514e37c211f327379688f81b0dChris Lattner assert(PGOpt->getValueExpectedFlag() != cl::ValueRequired && 587331de23705a719514e37c211f327379688f81b0dChris Lattner "Option can not be cl::Grouping AND cl::ValueRequired!"); 588331de23705a719514e37c211f327379688f81b0dChris Lattner int Dummy; 589bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner ErrorParsing |= ProvideOption(PGOpt, RealArgName.c_str(), 5906d5857e139df71410e98ccf6cd0e783f90a9fc16Chris Lattner 0, 0, 0, Dummy); 591f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 592331de23705a719514e37c211f327379688f81b0dChris Lattner // Get the next grouping option... 5939878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner PGOpt = getOptionPred(RealName, Length, isGrouping, Opts); 594bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner } while (PGOpt && Length != RealName.size()); 595f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 596bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner Handler = PGOpt; // Ate all of the options. 597331de23705a719514e37c211f327379688f81b0dChris Lattner } 598b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman } 599dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 600dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 601dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 602dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner if (Handler == 0) { 603d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov if (SinkOpts.empty()) { 604d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov cerr << ProgramName << ": Unknown command line argument '" 605d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov << argv[i] << "'. Try: '" << argv[0] << " --help'\n"; 606d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov ErrorParsing = true; 607d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov } else { 608d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov for (std::vector<Option*>::iterator I = SinkOpts.begin(), 609d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov E = SinkOpts.end(); I != E ; ++I) 610d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov (*I)->addOccurrence(i, "", argv[i]); 611d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov } 612dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner continue; 613dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 614dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 61572fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner // Check to see if this option accepts a comma separated list of values. If 61672fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner // it does, we have to split up the value into multiple values... 6176d5857e139df71410e98ccf6cd0e783f90a9fc16Chris Lattner if (Value && Handler->getMiscFlags() & CommaSeparated) { 61872fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner std::string Val(Value); 61972fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner std::string::size_type Pos = Val.find(','); 62072fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner 62172fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner while (Pos != std::string::npos) { 62272fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner // Process the portion before the comma... 62372fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner ErrorParsing |= ProvideOption(Handler, ArgName, 62472fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner std::string(Val.begin(), 62572fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner Val.begin()+Pos).c_str(), 62672fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner argc, argv, i); 62772fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner // Erase the portion before the comma, AND the comma... 62872fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner Val.erase(Val.begin(), Val.begin()+Pos+1); 62972fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner Value += Pos+1; // Increment the original value pointer as well... 63072fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner 63172fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner // Check for another comma... 63272fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner Pos = Val.find(','); 63372fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner } 63472fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner } 6359cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner 6369cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // If this is a named positional argument, just remember that it is the 6379cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // active one... 6389cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (Handler->getFormattingFlag() == cl::Positional) 6399cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner ActivePositionalArg = Handler; 640f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman else 6419cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner ErrorParsing |= ProvideOption(Handler, ArgName, Value, argc, argv, i); 642331de23705a719514e37c211f327379688f81b0dChris Lattner } 643dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 644331de23705a719514e37c211f327379688f81b0dChris Lattner // Check and handle positional arguments now... 645331de23705a719514e37c211f327379688f81b0dChris Lattner if (NumPositionalRequired > PositionalVals.size()) { 646e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cerr << ProgramName 647e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << ": Not enough positional command line arguments specified!\n" 648e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << "Must specify at least " << NumPositionalRequired 649e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << " positional arguments: See: " << argv[0] << " --help\n"; 650beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 651331de23705a719514e37c211f327379688f81b0dChris Lattner ErrorParsing = true; 652de0132453e2939488c2d69290bfdfb2cde94a0afChris Lattner } else if (!HasUnlimitedPositionals 653de0132453e2939488c2d69290bfdfb2cde94a0afChris Lattner && PositionalVals.size() > PositionalOpts.size()) { 654e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cerr << ProgramName 655e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << ": Too many positional arguments specified!\n" 656e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << "Can specify at most " << PositionalOpts.size() 657e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << " positional arguments: See: " << argv[0] << " --help\n"; 658de0132453e2939488c2d69290bfdfb2cde94a0afChris Lattner ErrorParsing = true; 659331de23705a719514e37c211f327379688f81b0dChris Lattner 660331de23705a719514e37c211f327379688f81b0dChris Lattner } else if (ConsumeAfterOpt == 0) { 661331de23705a719514e37c211f327379688f81b0dChris Lattner // Positional args have already been handled if ConsumeAfter is specified... 66234cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng unsigned ValNo = 0, NumVals = static_cast<unsigned>(PositionalVals.size()); 66334cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng for (size_t i = 0, e = PositionalOpts.size(); i != e; ++i) { 664331de23705a719514e37c211f327379688f81b0dChris Lattner if (RequiresValue(PositionalOpts[i])) { 665f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman ProvidePositionalOption(PositionalOpts[i], PositionalVals[ValNo].first, 6661e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].second); 6671e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ValNo++; 668331de23705a719514e37c211f327379688f81b0dChris Lattner --NumPositionalRequired; // We fulfilled our duty... 669331de23705a719514e37c211f327379688f81b0dChris Lattner } 670331de23705a719514e37c211f327379688f81b0dChris Lattner 671331de23705a719514e37c211f327379688f81b0dChris Lattner // If we _can_ give this option more arguments, do so now, as long as we 672331de23705a719514e37c211f327379688f81b0dChris Lattner // do not give it values that others need. 'Done' controls whether the 673331de23705a719514e37c211f327379688f81b0dChris Lattner // option even _WANTS_ any more. 674331de23705a719514e37c211f327379688f81b0dChris Lattner // 675dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman bool Done = PositionalOpts[i]->getNumOccurrencesFlag() == cl::Required; 676331de23705a719514e37c211f327379688f81b0dChris Lattner while (NumVals-ValNo > NumPositionalRequired && !Done) { 677dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman switch (PositionalOpts[i]->getNumOccurrencesFlag()) { 678331de23705a719514e37c211f327379688f81b0dChris Lattner case cl::Optional: 679331de23705a719514e37c211f327379688f81b0dChris Lattner Done = true; // Optional arguments want _at most_ one value 680331de23705a719514e37c211f327379688f81b0dChris Lattner // FALL THROUGH 681331de23705a719514e37c211f327379688f81b0dChris Lattner case cl::ZeroOrMore: // Zero or more will take all they can get... 682331de23705a719514e37c211f327379688f81b0dChris Lattner case cl::OneOrMore: // One or more will take all they can get... 6831e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ProvidePositionalOption(PositionalOpts[i], 6841e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].first, 6851e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].second); 6861e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ValNo++; 687331de23705a719514e37c211f327379688f81b0dChris Lattner break; 688331de23705a719514e37c211f327379688f81b0dChris Lattner default: 689dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman assert(0 && "Internal error, unexpected NumOccurrences flag in " 690331de23705a719514e37c211f327379688f81b0dChris Lattner "positional argument processing!"); 691331de23705a719514e37c211f327379688f81b0dChris Lattner } 692331de23705a719514e37c211f327379688f81b0dChris Lattner } 693caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner } 694331de23705a719514e37c211f327379688f81b0dChris Lattner } else { 695331de23705a719514e37c211f327379688f81b0dChris Lattner assert(ConsumeAfterOpt && NumPositionalRequired <= PositionalVals.size()); 696331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned ValNo = 0; 69734cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng for (size_t j = 1, e = PositionalOpts.size(); j != e; ++j) 6981e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer if (RequiresValue(PositionalOpts[j])) { 699faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner ErrorParsing |= ProvidePositionalOption(PositionalOpts[j], 7001e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].first, 7011e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].second); 7021e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ValNo++; 7031e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer } 704faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner 705faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // Handle the case where there is just one positional option, and it's 706faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // optional. In this case, we want to give JUST THE FIRST option to the 707faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // positional option and keep the rest for the consume after. The above 708faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // loop would have assigned no values to positional options in this case. 709faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // 7101e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer if (PositionalOpts.size() == 2 && ValNo == 0 && !PositionalVals.empty()) { 711faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner ErrorParsing |= ProvidePositionalOption(PositionalOpts[1], 7121e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].first, 7131e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].second); 7141e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ValNo++; 7151e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer } 716f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 717331de23705a719514e37c211f327379688f81b0dChris Lattner // Handle over all of the rest of the arguments to the 718331de23705a719514e37c211f327379688f81b0dChris Lattner // cl::ConsumeAfter command line option... 719331de23705a719514e37c211f327379688f81b0dChris Lattner for (; ValNo != PositionalVals.size(); ++ValNo) 720331de23705a719514e37c211f327379688f81b0dChris Lattner ErrorParsing |= ProvidePositionalOption(ConsumeAfterOpt, 7211e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].first, 7221e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].second); 723dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 724dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 725dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner // Loop over args and make sure all required args are specified! 726f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman for (std::map<std::string, Option*>::iterator I = Opts.begin(), 727b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman E = Opts.end(); I != E; ++I) { 728dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman switch (I->second->getNumOccurrencesFlag()) { 729dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner case Required: 730dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner case OneOrMore: 731dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman if (I->second->getNumOccurrences() == 0) { 732b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman I->second->error(" must be specified at least once!"); 733f038acbee21cfed998451aedd00a81901d299516Chris Lattner ErrorParsing = true; 734f038acbee21cfed998451aedd00a81901d299516Chris Lattner } 735dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner // Fall through 736dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner default: 737dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner break; 738dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner } 739dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner } 740dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 741331de23705a719514e37c211f327379688f81b0dChris Lattner // Free all of the memory allocated to the map. Command line options may only 742331de23705a719514e37c211f327379688f81b0dChris Lattner // be processed once! 74390aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner Opts.clear(); 744331de23705a719514e37c211f327379688f81b0dChris Lattner PositionalOpts.clear(); 74590aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner MoreHelp->clear(); 746dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 747beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov // Free the memory allocated by ExpandResponseFiles. 748beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov if (ReadResponseFiles) { 749beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov // Free all the strdup()ed strings. 750beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov for (std::vector<char*>::iterator i = newArgv.begin(), e = newArgv.end(); 751beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov i != e; ++i) 752beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov free (*i); 753beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov } 754beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 755dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // If we had an error processing our arguments, don't let the program execute 756dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner if (ErrorParsing) exit(1); 757dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 758dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 759dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner//===----------------------------------------------------------------------===// 760dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// Option Base class implementation 761dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 762dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 763ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattnerbool Option::error(std::string Message, const char *ArgName) { 764dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner if (ArgName == 0) ArgName = ArgStr; 765331de23705a719514e37c211f327379688f81b0dChris Lattner if (ArgName[0] == 0) 766e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cerr << HelpStr; // Be nice for positional arguments 767331de23705a719514e37c211f327379688f81b0dChris Lattner else 768e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cerr << ProgramName << ": for the -" << ArgName; 769beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 770e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cerr << " option: " << Message << "\n"; 771dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return true; 772dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 773dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 7746d5857e139df71410e98ccf6cd0e783f90a9fc16Chris Lattnerbool Option::addOccurrence(unsigned pos, const char *ArgName, 7757059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov const std::string &Value, 7767059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov bool MultiArg) { 7777059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov if (!MultiArg) 7787059d47a6e1a378232dce3e47b51434dec0ea608Mikhail Glushenkov NumOccurrences++; // Increment the number of times we have been seen 779dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 780dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman switch (getNumOccurrencesFlag()) { 781dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner case Optional: 782dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman if (NumOccurrences > 1) 783dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return error(": may only occur zero or one times!", ArgName); 784dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner break; 785dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner case Required: 786dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman if (NumOccurrences > 1) 787dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return error(": must occur exactly one time!", ArgName); 788dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Fall through 789dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner case OneOrMore: 790caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner case ZeroOrMore: 791caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner case ConsumeAfter: break; 792b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman default: return error(": bad num occurrences flag value!"); 793dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 794dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 7951e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer return handleOccurrence(pos, ArgName, Value); 796dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 797dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 798331de23705a719514e37c211f327379688f81b0dChris Lattner 799331de23705a719514e37c211f327379688f81b0dChris Lattner// getValueStr - Get the value description string, using "DefaultMsg" if nothing 800331de23705a719514e37c211f327379688f81b0dChris Lattner// has been specified yet. 801331de23705a719514e37c211f327379688f81b0dChris Lattner// 802331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic const char *getValueStr(const Option &O, const char *DefaultMsg) { 803331de23705a719514e37c211f327379688f81b0dChris Lattner if (O.ValueStr[0] == 0) return DefaultMsg; 804331de23705a719514e37c211f327379688f81b0dChris Lattner return O.ValueStr; 805331de23705a719514e37c211f327379688f81b0dChris Lattner} 806331de23705a719514e37c211f327379688f81b0dChris Lattner 807331de23705a719514e37c211f327379688f81b0dChris Lattner//===----------------------------------------------------------------------===// 808331de23705a719514e37c211f327379688f81b0dChris Lattner// cl::alias class implementation 809331de23705a719514e37c211f327379688f81b0dChris Lattner// 810331de23705a719514e37c211f327379688f81b0dChris Lattner 811dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// Return the width of the option tag for printing... 81234cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Chengsize_t alias::getOptionWidth() const { 813dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return std::strlen(ArgStr)+6; 814dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 815dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 816a0de843535627977d107bbe84e4ad20cd2a5060aChris Lattner// Print out the option for the alias. 81734cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Chengvoid alias::printOptionInfo(size_t GlobalWidth) const { 81834cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng size_t L = std::strlen(ArgStr); 819e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << " -" << ArgStr << std::string(GlobalWidth-L-6, ' ') << " - " 820e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << HelpStr << "\n"; 821dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 822dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 823dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 824331de23705a719514e37c211f327379688f81b0dChris Lattner 825dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner//===----------------------------------------------------------------------===// 826331de23705a719514e37c211f327379688f81b0dChris Lattner// Parser Implementation code... 827dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 828dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 8299b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// basic_parser implementation 8309b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// 8319b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 8329b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// Return the width of the option tag for printing... 83334cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Chengsize_t basic_parser_impl::getOptionWidth(const Option &O) const { 83434cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng size_t Len = std::strlen(O.ArgStr); 8359b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner if (const char *ValName = getValueName()) 8369b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner Len += std::strlen(getValueStr(O, ValName))+3; 8379b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 8389b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner return Len + 6; 8399b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner} 8409b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 841f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman// printOptionInfo - Print out information about this option. The 8429b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// to-be-maintained width is specified. 8439b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// 8449b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattnervoid basic_parser_impl::printOptionInfo(const Option &O, 84534cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng size_t GlobalWidth) const { 846e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << " -" << O.ArgStr; 8479b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 8489b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner if (const char *ValName = getValueName()) 849e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << "=<" << getValueStr(O, ValName) << ">"; 8509b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 851e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << std::string(GlobalWidth-getOptionWidth(O), ' ') << " - " 852e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << O.HelpStr << "\n"; 8539b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner} 8549b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 8559b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 8569b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 8579b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 858331de23705a719514e37c211f327379688f81b0dChris Lattner// parser<bool> implementation 859331de23705a719514e37c211f327379688f81b0dChris Lattner// 8609b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattnerbool parser<bool>::parse(Option &O, const char *ArgName, 861ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner const std::string &Arg, bool &Value) { 862f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman if (Arg == "" || Arg == "true" || Arg == "TRUE" || Arg == "True" || 863dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner Arg == "1") { 864dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner Value = true; 865dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } else if (Arg == "false" || Arg == "FALSE" || Arg == "False" || Arg == "0") { 866dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner Value = false; 867dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } else { 868331de23705a719514e37c211f327379688f81b0dChris Lattner return O.error(": '" + Arg + 869331de23705a719514e37c211f327379688f81b0dChris Lattner "' is invalid value for boolean argument! Try 0 or 1"); 870dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 871dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return false; 872dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 873dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 87481da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen// parser<boolOrDefault> implementation 87581da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen// 87681da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesenbool parser<boolOrDefault>::parse(Option &O, const char *ArgName, 87781da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen const std::string &Arg, boolOrDefault &Value) { 87881da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen if (Arg == "" || Arg == "true" || Arg == "TRUE" || Arg == "True" || 87981da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen Arg == "1") { 88081da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen Value = BOU_TRUE; 88181da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen } else if (Arg == "false" || Arg == "FALSE" || Arg == "False" || Arg == "0") { 88281da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen Value = BOU_FALSE; 88381da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen } else { 88481da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen return O.error(": '" + Arg + 88581da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen "' is invalid value for boolean argument! Try 0 or 1"); 88681da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen } 88781da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen return false; 88881da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen} 88981da02b553b86868637f27b89c6e919c31ed5b51Dale Johannesen 890331de23705a719514e37c211f327379688f81b0dChris Lattner// parser<int> implementation 891dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 8929b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattnerbool parser<int>::parse(Option &O, const char *ArgName, 893ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner const std::string &Arg, int &Value) { 894331de23705a719514e37c211f327379688f81b0dChris Lattner char *End; 895d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner Value = (int)strtol(Arg.c_str(), &End, 0); 896f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman if (*End != 0) 897331de23705a719514e37c211f327379688f81b0dChris Lattner return O.error(": '" + Arg + "' value invalid for integer argument!"); 898331de23705a719514e37c211f327379688f81b0dChris Lattner return false; 899dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 900dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 901d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner// parser<unsigned> implementation 902d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner// 903d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattnerbool parser<unsigned>::parse(Option &O, const char *ArgName, 904d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner const std::string &Arg, unsigned &Value) { 905d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner char *End; 9062d6a2360036cf511af0a06f9720e6a1752779d1cBrian Gaeke errno = 0; 9072d6a2360036cf511af0a06f9720e6a1752779d1cBrian Gaeke unsigned long V = strtoul(Arg.c_str(), &End, 0); 908d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner Value = (unsigned)V; 9092d6a2360036cf511af0a06f9720e6a1752779d1cBrian Gaeke if (((V == ULONG_MAX) && (errno == ERANGE)) 9102d6a2360036cf511af0a06f9720e6a1752779d1cBrian Gaeke || (*End != 0) 9112d6a2360036cf511af0a06f9720e6a1752779d1cBrian Gaeke || (Value != V)) 912d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner return O.error(": '" + Arg + "' value invalid for uint argument!"); 913d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner return false; 914d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner} 915d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner 9169b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// parser<double>/parser<float> implementation 917331de23705a719514e37c211f327379688f81b0dChris Lattner// 918ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattnerstatic bool parseDouble(Option &O, const std::string &Arg, double &Value) { 919331de23705a719514e37c211f327379688f81b0dChris Lattner const char *ArgStart = Arg.c_str(); 920331de23705a719514e37c211f327379688f81b0dChris Lattner char *End; 921331de23705a719514e37c211f327379688f81b0dChris Lattner Value = strtod(ArgStart, &End); 922f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman if (*End != 0) 923331de23705a719514e37c211f327379688f81b0dChris Lattner return O.error(": '" +Arg+ "' value invalid for floating point argument!"); 924dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return false; 925dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 926dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 9279b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattnerbool parser<double>::parse(Option &O, const char *AN, 9289b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner const std::string &Arg, double &Val) { 9299b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner return parseDouble(O, Arg, Val); 930dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 931dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 9329b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattnerbool parser<float>::parse(Option &O, const char *AN, 9339b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner const std::string &Arg, float &Val) { 9349b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner double dVal; 9359b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner if (parseDouble(O, Arg, dVal)) 9369b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner return true; 9379b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner Val = (float)dVal; 9389b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner return false; 939dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 940dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 941dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 942dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 943331de23705a719514e37c211f327379688f81b0dChris Lattner// generic_parser_base implementation 944dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 945dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 946aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner// findOption - Return the option number corresponding to the specified 947aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner// argument string. If the option is not found, getNumOptions() is returned. 948aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner// 949aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattnerunsigned generic_parser_base::findOption(const char *Name) { 950aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner unsigned i = 0, e = getNumOptions(); 951ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::string N(Name); 952aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner 953aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner while (i != e) 954aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner if (getOption(i) == N) 955aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner return i; 956aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner else 957aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner ++i; 958aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner return e; 959aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner} 960aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner 961aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner 962dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// Return the width of the option tag for printing... 96334cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Chengsize_t generic_parser_base::getOptionWidth(const Option &O) const { 964331de23705a719514e37c211f327379688f81b0dChris Lattner if (O.hasArgStr()) { 96534cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng size_t Size = std::strlen(O.ArgStr)+6; 966331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = getNumOptions(); i != e; ++i) 96734cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng Size = std::max(Size, std::strlen(getOption(i))+8); 968331de23705a719514e37c211f327379688f81b0dChris Lattner return Size; 969331de23705a719514e37c211f327379688f81b0dChris Lattner } else { 97034cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng size_t BaseSize = 0; 971331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = getNumOptions(); i != e; ++i) 97234cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng BaseSize = std::max(BaseSize, std::strlen(getOption(i))+8); 973331de23705a719514e37c211f327379688f81b0dChris Lattner return BaseSize; 974331de23705a719514e37c211f327379688f81b0dChris Lattner } 975dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 976dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 977f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman// printOptionInfo - Print out information about this option. The 978dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// to-be-maintained width is specified. 979dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 980331de23705a719514e37c211f327379688f81b0dChris Lattnervoid generic_parser_base::printOptionInfo(const Option &O, 98134cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng size_t GlobalWidth) const { 982331de23705a719514e37c211f327379688f81b0dChris Lattner if (O.hasArgStr()) { 98334cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng size_t L = std::strlen(O.ArgStr); 984e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << " -" << O.ArgStr << std::string(GlobalWidth-L-6, ' ') 985e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << " - " << O.HelpStr << "\n"; 986331de23705a719514e37c211f327379688f81b0dChris Lattner 987331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = getNumOptions(); i != e; ++i) { 98834cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng size_t NumSpaces = GlobalWidth-strlen(getOption(i))-8; 989e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << " =" << getOption(i) << std::string(NumSpaces, ' ') 990b8cab9227a0f6ffbdaae33e3c64268e265008a6aDan Gohman << " - " << getDescription(i) << "\n"; 991331de23705a719514e37c211f327379688f81b0dChris Lattner } 992331de23705a719514e37c211f327379688f81b0dChris Lattner } else { 993331de23705a719514e37c211f327379688f81b0dChris Lattner if (O.HelpStr[0]) 994e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << " " << O.HelpStr << "\n"; 995331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = getNumOptions(); i != e; ++i) { 99634cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng size_t L = std::strlen(getOption(i)); 997e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << " -" << getOption(i) << std::string(GlobalWidth-L-8, ' ') 998e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling << " - " << getDescription(i) << "\n"; 999331de23705a719514e37c211f327379688f81b0dChris Lattner } 1000dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 1001dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 1002dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1003dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1004dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner//===----------------------------------------------------------------------===// 1005331de23705a719514e37c211f327379688f81b0dChris Lattner// --help and --help-hidden option implementation 1006dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 1007ad0846bd8be0a86e0277e1890fd280c9868f830aReid Spencer 1008dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattnernamespace { 1009dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1010331de23705a719514e37c211f327379688f81b0dChris Lattnerclass HelpPrinter { 101134cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng size_t MaxArgLen; 1012dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner const Option *EmptyArg; 1013dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner const bool ShowHidden; 1014dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1015331de23705a719514e37c211f327379688f81b0dChris Lattner // isHidden/isReallyHidden - Predicates to be used to filter down arg lists. 1016ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner inline static bool isHidden(std::pair<std::string, Option *> &OptPair) { 1017331de23705a719514e37c211f327379688f81b0dChris Lattner return OptPair.second->getOptionHiddenFlag() >= Hidden; 1018331de23705a719514e37c211f327379688f81b0dChris Lattner } 1019ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner inline static bool isReallyHidden(std::pair<std::string, Option *> &OptPair) { 1020331de23705a719514e37c211f327379688f81b0dChris Lattner return OptPair.second->getOptionHiddenFlag() == ReallyHidden; 1021331de23705a719514e37c211f327379688f81b0dChris Lattner } 1022331de23705a719514e37c211f327379688f81b0dChris Lattner 1023331de23705a719514e37c211f327379688f81b0dChris Lattnerpublic: 1024950a4c40b823cd4f09dc71be635229246dfd6cacDan Gohman explicit HelpPrinter(bool showHidden) : ShowHidden(showHidden) { 1025331de23705a719514e37c211f327379688f81b0dChris Lattner EmptyArg = 0; 1026331de23705a719514e37c211f327379688f81b0dChris Lattner } 1027331de23705a719514e37c211f327379688f81b0dChris Lattner 1028331de23705a719514e37c211f327379688f81b0dChris Lattner void operator=(bool Value) { 1029331de23705a719514e37c211f327379688f81b0dChris Lattner if (Value == false) return; 1030331de23705a719514e37c211f327379688f81b0dChris Lattner 10319878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner // Get all the options. 10329878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner std::vector<Option*> PositionalOpts; 1033d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov std::vector<Option*> SinkOpts; 10349878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner std::map<std::string, Option*> OptMap; 1035d57160d097d6cdb966e5c851215acbd2bf1aa236Anton Korobeynikov GetOptionInfo(PositionalOpts, SinkOpts, OptMap); 1036beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov 1037dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Copy Options into a vector so we can sort them as we like... 103890aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner std::vector<std::pair<std::string, Option*> > Opts; 10399878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner copy(OptMap.begin(), OptMap.end(), std::back_inserter(Opts)); 1040dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1041dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Eliminate Hidden or ReallyHidden arguments, depending on ShowHidden 104290aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner Opts.erase(std::remove_if(Opts.begin(), Opts.end(), 104390aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner std::ptr_fun(ShowHidden ? isReallyHidden : isHidden)), 104490aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner Opts.end()); 1045dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1046dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Eliminate duplicate entries in table (from enum flags options, f.e.) 1047331de23705a719514e37c211f327379688f81b0dChris Lattner { // Give OptionSet a scope 1048331de23705a719514e37c211f327379688f81b0dChris Lattner std::set<Option*> OptionSet; 104990aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner for (unsigned i = 0; i != Opts.size(); ++i) 105090aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner if (OptionSet.count(Opts[i].second) == 0) 105190aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner OptionSet.insert(Opts[i].second); // Add new entry to set 1052331de23705a719514e37c211f327379688f81b0dChris Lattner else 105390aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner Opts.erase(Opts.begin()+i--); // Erase duplicate 1054331de23705a719514e37c211f327379688f81b0dChris Lattner } 1055dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1056dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner if (ProgramOverview) 105782a13c9c4811e40d0ff858c508cb54d672ee926eDan Gohman cout << "OVERVIEW: " << ProgramOverview << "\n"; 1058dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1059e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << "USAGE: " << ProgramName << " [options]"; 1060331de23705a719514e37c211f327379688f81b0dChris Lattner 106190aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner // Print out the positional options. 1062331de23705a719514e37c211f327379688f81b0dChris Lattner Option *CAOpt = 0; // The cl::ConsumeAfter option, if it exists... 1063beb4d8293d5311c4581fd3d914f865e358af53a5Mikhail Glushenkov if (!PositionalOpts.empty() && 10649878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner PositionalOpts[0]->getNumOccurrencesFlag() == ConsumeAfter) 10659878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner CAOpt = PositionalOpts[0]; 10669878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner 106734cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng for (size_t i = CAOpt != 0, e = PositionalOpts.size(); i != e; ++i) { 10689878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner if (PositionalOpts[i]->ArgStr[0]) 10699878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner cout << " --" << PositionalOpts[i]->ArgStr; 10709878d6ae3a535e421f69e0c08e27b259ad1bdbdcChris Lattner cout << " " << PositionalOpts[i]->HelpStr; 10719cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner } 1072331de23705a719514e37c211f327379688f81b0dChris Lattner 1073331de23705a719514e37c211f327379688f81b0dChris Lattner // Print the consume after option info if it exists... 1074e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling if (CAOpt) cout << " " << CAOpt->HelpStr; 1075331de23705a719514e37c211f327379688f81b0dChris Lattner 1076e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << "\n\n"; 1077dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1078dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Compute the maximum argument length... 1079dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner MaxArgLen = 0; 108034cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng for (size_t i = 0, e = Opts.size(); i != e; ++i) 108190aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner MaxArgLen = std::max(MaxArgLen, Opts[i].second->getOptionWidth()); 1082dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1083e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << "OPTIONS:\n"; 108434cd4a484e532cc463fd5a4bf59b88d13c5467c1Evan Cheng for (size_t i = 0, e = Opts.size(); i != e; ++i) 108590aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner Opts[i].second->printOptionInfo(MaxArgLen); 1086dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1087c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner // Print any extra help the user has declared. 108890aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner for (std::vector<const char *>::iterator I = MoreHelp->begin(), 108990aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner E = MoreHelp->end(); I != E; ++I) 1090e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << *I; 109190aa839c88776e3dd0b3a798a98ea30d85b6b53cChris Lattner MoreHelp->clear(); 1092ad0846bd8be0a86e0277e1890fd280c9868f830aReid Spencer 10939bbba091396922093687d11a181e5886c42c5dfdReid Spencer // Halt the program since help information was printed 1094331de23705a719514e37c211f327379688f81b0dChris Lattner exit(1); 1095dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 1096331de23705a719514e37c211f327379688f81b0dChris Lattner}; 1097500d8bff2077ac327deec076fc8793e740b358c0Chris Lattner} // End anonymous namespace 1098dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1099331de23705a719514e37c211f327379688f81b0dChris Lattner// Define the two HelpPrinter instances that are used to print out help, or 1100331de23705a719514e37c211f327379688f81b0dChris Lattner// help-hidden... 1101331de23705a719514e37c211f327379688f81b0dChris Lattner// 1102500d8bff2077ac327deec076fc8793e740b358c0Chris Lattnerstatic HelpPrinter NormalPrinter(false); 1103500d8bff2077ac327deec076fc8793e740b358c0Chris Lattnerstatic HelpPrinter HiddenPrinter(true); 1104331de23705a719514e37c211f327379688f81b0dChris Lattner 1105500d8bff2077ac327deec076fc8793e740b358c0Chris Lattnerstatic cl::opt<HelpPrinter, true, parser<bool> > 11064bf7afcc271138512c38ab2e4a348e2fe6164140Chris LattnerHOp("help", cl::desc("Display available options (--help-hidden for more)"), 11079b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner cl::location(NormalPrinter), cl::ValueDisallowed); 1108dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1109500d8bff2077ac327deec076fc8793e740b358c0Chris Lattnerstatic cl::opt<HelpPrinter, true, parser<bool> > 11104bf7afcc271138512c38ab2e4a348e2fe6164140Chris LattnerHHOp("help-hidden", cl::desc("Display all available options"), 11119b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner cl::location(HiddenPrinter), cl::Hidden, cl::ValueDisallowed); 1112dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 1113500d8bff2077ac327deec076fc8793e740b358c0Chris Lattnerstatic void (*OverrideVersionPrinter)() = 0; 1114515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer 1115500d8bff2077ac327deec076fc8793e740b358c0Chris Lattnernamespace { 1116515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencerclass VersionPrinter { 1117515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencerpublic: 1118aed293dfba04b07a867491c11dfff4bf3eb6bdddDevang Patel void print() { 1119e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << "Low Level Virtual Machine (http://llvm.org/):\n"; 1120e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << " " << PACKAGE_NAME << " version " << PACKAGE_VERSION; 11213fc2f4e83f3317f592c06e2ae7d9f1832210decbChris Lattner#ifdef LLVM_VERSION_INFO 1122e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << LLVM_VERSION_INFO; 11233fc2f4e83f3317f592c06e2ae7d9f1832210decbChris Lattner#endif 1124e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << "\n "; 11253fc2f4e83f3317f592c06e2ae7d9f1832210decbChris Lattner#ifndef __OPTIMIZE__ 1126e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << "DEBUG build"; 1127515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer#else 1128e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << "Optimized build"; 11293fc2f4e83f3317f592c06e2ae7d9f1832210decbChris Lattner#endif 11303fc2f4e83f3317f592c06e2ae7d9f1832210decbChris Lattner#ifndef NDEBUG 1131e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << " with assertions"; 1132515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer#endif 1133e81561909d128c6e2d8033cb5465a49b2596b26aBill Wendling cout << ".\n"; 11341f33f8e4cc90c62a2f311a0d506c2fb43c4cbdacSteve Naroff cout << " Built " << __DATE__ << "(" << __TIME__ << ").\n"; 1135aed293dfba04b07a867491c11dfff4bf3eb6bdddDevang Patel } 1136aed293dfba04b07a867491c11dfff4bf3eb6bdddDevang Patel void operator=(bool OptionWasSpecified) { 1137aed293dfba04b07a867491c11dfff4bf3eb6bdddDevang Patel if (OptionWasSpecified) { 1138aed293dfba04b07a867491c11dfff4bf3eb6bdddDevang Patel if (OverrideVersionPrinter == 0) { 1139aed293dfba04b07a867491c11dfff4bf3eb6bdddDevang Patel print(); 1140515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer exit(1); 1141515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer } else { 1142515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer (*OverrideVersionPrinter)(); 1143515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer exit(1); 1144515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer } 1145515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer } 1146515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer } 1147515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer}; 1148500d8bff2077ac327deec076fc8793e740b358c0Chris Lattner} // End anonymous namespace 1149515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer 1150515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer 115169105f33c190621a6b1ad61f925b1a9e6b0512afReid Spencer// Define the --version option that prints out the LLVM version for the tool 1152500d8bff2077ac327deec076fc8793e740b358c0Chris Lattnerstatic VersionPrinter VersionPrinterInstance; 1153500d8bff2077ac327deec076fc8793e740b358c0Chris Lattner 1154500d8bff2077ac327deec076fc8793e740b358c0Chris Lattnerstatic cl::opt<VersionPrinter, true, parser<bool> > 11554bf7afcc271138512c38ab2e4a348e2fe6164140Chris LattnerVersOp("version", cl::desc("Display the version of this program"), 115669105f33c190621a6b1ad61f925b1a9e6b0512afReid Spencer cl::location(VersionPrinterInstance), cl::ValueDisallowed); 115769105f33c190621a6b1ad61f925b1a9e6b0512afReid Spencer 11589bbba091396922093687d11a181e5886c42c5dfdReid Spencer// Utility function for printing the help message. 11599bbba091396922093687d11a181e5886c42c5dfdReid Spencervoid cl::PrintHelpMessage() { 1160f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman // This looks weird, but it actually prints the help message. The 11615cc498f116cd76235c9c0a2ded46bc29f8fb35e0Reid Spencer // NormalPrinter variable is a HelpPrinter and the help gets printed when 11625cc498f116cd76235c9c0a2ded46bc29f8fb35e0Reid Spencer // its operator= is invoked. That's because the "normal" usages of the 1163f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman // help printer is to be assigned true/false depending on whether the 11645cc498f116cd76235c9c0a2ded46bc29f8fb35e0Reid Spencer // --help option was given or not. Since we're circumventing that we have 11655cc498f116cd76235c9c0a2ded46bc29f8fb35e0Reid Spencer // to make it look like --help was given, so we assign true. 11669bbba091396922093687d11a181e5886c42c5dfdReid Spencer NormalPrinter = true; 11679bbba091396922093687d11a181e5886c42c5dfdReid Spencer} 1168515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer 1169aed293dfba04b07a867491c11dfff4bf3eb6bdddDevang Patel/// Utility function for printing version number. 1170aed293dfba04b07a867491c11dfff4bf3eb6bdddDevang Patelvoid cl::PrintVersionMessage() { 1171aed293dfba04b07a867491c11dfff4bf3eb6bdddDevang Patel VersionPrinterInstance.print(); 1172aed293dfba04b07a867491c11dfff4bf3eb6bdddDevang Patel} 1173aed293dfba04b07a867491c11dfff4bf3eb6bdddDevang Patel 1174515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencervoid cl::SetVersionPrinter(void (*func)()) { 1175515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer OverrideVersionPrinter = func; 1176515b5b379f3508f36f647bfdafce409e28a3d90bReid Spencer} 1177