CommandLine.cpp revision 5114004110d771e2cc838be569207784f2519010
1dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner//===-- CommandLine.cpp - Command line parser implementation --------------===// 2b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// 3b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// The LLVM Compiler Infrastructure 4b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// 5b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// This file was developed by the LLVM research group and is distributed under 6b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// the University of Illinois Open Source License. See LICENSE.TXT for details. 7b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// 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 19cee8f9ae67104576b2028125b56e9ba4856a1d66Chris Lattner#include "Support/CommandLine.h" 20dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner#include <algorithm> 21dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner#include <map> 22dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner#include <set> 23697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner#include <iostream> 242d6a2360036cf511af0a06f9720e6a1752779d1cBrian Gaeke#include <cstdlib> 252d6a2360036cf511af0a06f9720e6a1752779d1cBrian Gaeke#include <cerrno> 265114004110d771e2cc838be569207784f2519010Chris Lattner#include <cstring> 272cdd21c2e4d855500dfb53f77aa74da53ccf9de6Chris Lattnerusing namespace llvm; 28d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke 29dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattnerusing namespace cl; 30dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 31331de23705a719514e37c211f327379688f81b0dChris Lattner//===----------------------------------------------------------------------===// 32331de23705a719514e37c211f327379688f81b0dChris Lattner// Basic, shared command line option processing machinery... 33331de23705a719514e37c211f327379688f81b0dChris Lattner// 34331de23705a719514e37c211f327379688f81b0dChris Lattner 35dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// Return the global command line option vector. Making it a function scoped 36f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner// static ensures that it will be initialized correctly before its first use. 37dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 38ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattnerstatic std::map<std::string, Option*> *CommandLineOptions = 0; 39ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattnerstatic std::map<std::string, Option*> &getOpts() { 40ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner if (CommandLineOptions == 0) 41ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner CommandLineOptions = new std::map<std::string,Option*>(); 42e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner return *CommandLineOptions; 43e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner} 44e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner 45ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattnerstatic Option *getOption(const std::string &Str) { 46e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner if (CommandLineOptions == 0) return 0; 47ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::map<std::string,Option*>::iterator I = CommandLineOptions->find(Str); 48e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner return I != CommandLineOptions->end() ? I->second : 0; 49dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 50dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 51ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattnerstatic std::vector<Option*> &getPositionalOpts() { 525f65adda508bff0e9f40cf6013469c76fdcb1a09Alkis Evlogimenos static std::vector<Option*> *Positional = 0; 535f65adda508bff0e9f40cf6013469c76fdcb1a09Alkis Evlogimenos if (!Positional) Positional = new std::vector<Option*>(); 545f65adda508bff0e9f40cf6013469c76fdcb1a09Alkis Evlogimenos return *Positional; 55331de23705a719514e37c211f327379688f81b0dChris Lattner} 56331de23705a719514e37c211f327379688f81b0dChris Lattner 57e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattnerstatic void AddArgument(const char *ArgName, Option *Opt) { 58e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner if (getOption(ArgName)) { 59ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << "CommandLine Error: Argument '" << ArgName 60ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner << "' defined more than once!\n"; 61dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } else { 62f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner // Add argument to the argument map! 63e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner getOpts()[ArgName] = Opt; 64e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner } 65e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner} 66e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner 67e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner// RemoveArgument - It's possible that the argument is no longer in the map if 68e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner// options have already been processed and the map has been deleted! 69e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner// 70e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattnerstatic void RemoveArgument(const char *ArgName, Option *Opt) { 71e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner if (CommandLineOptions == 0) return; 72e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner assert(getOption(ArgName) == Opt && "Arg not in map!"); 73e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner CommandLineOptions->erase(ArgName); 74e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner if (CommandLineOptions->empty()) { 75e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner delete CommandLineOptions; 76e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner CommandLineOptions = 0; 77dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 78dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 79dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 80dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattnerstatic const char *ProgramName = 0; 81dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattnerstatic const char *ProgramOverview = 0; 82dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 83caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattnerstatic inline bool ProvideOption(Option *Handler, const char *ArgName, 84caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner const char *Value, int argc, char **argv, 85caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner int &i) { 86caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner // Enforce value requirements 87caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner switch (Handler->getValueExpectedFlag()) { 88caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner case ValueRequired: 89caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner if (Value == 0 || *Value == 0) { // No value specified? 90caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner if (i+1 < argc) { // Steal the next argument, like for '-o filename' 91caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner Value = argv[++i]; 92caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner } else { 93caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner return Handler->error(" requires a value!"); 94caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner } 95caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner } 96caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner break; 97caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner case ValueDisallowed: 98caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner if (*Value != 0) 99caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner return Handler->error(" does not allow a value! '" + 100ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::string(Value) + "' specified."); 101caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner break; 102caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner case ValueOptional: break; 103ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner default: std::cerr << "Bad ValueMask flag! CommandLine usage error:" 104ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner << Handler->getValueExpectedFlag() << "\n"; abort(); 105caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner } 106caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner 107caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner // Run the handler now! 108dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman return Handler->addOccurrence(ArgName, Value); 109caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner} 110caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner 1119cf3d4770230238f2f395514bf04e0e64352d261Chris Lattnerstatic bool ProvidePositionalOption(Option *Handler, const std::string &Arg) { 112331de23705a719514e37c211f327379688f81b0dChris Lattner int Dummy; 1139cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner return ProvideOption(Handler, Handler->ArgStr, Arg.c_str(), 0, 0, Dummy); 114331de23705a719514e37c211f327379688f81b0dChris Lattner} 115331de23705a719514e37c211f327379688f81b0dChris Lattner 116331de23705a719514e37c211f327379688f81b0dChris Lattner 117331de23705a719514e37c211f327379688f81b0dChris Lattner// Option predicates... 118331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic inline bool isGrouping(const Option *O) { 119331de23705a719514e37c211f327379688f81b0dChris Lattner return O->getFormattingFlag() == cl::Grouping; 120331de23705a719514e37c211f327379688f81b0dChris Lattner} 121331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic inline bool isPrefixedOrGrouping(const Option *O) { 122331de23705a719514e37c211f327379688f81b0dChris Lattner return isGrouping(O) || O->getFormattingFlag() == cl::Prefix; 123331de23705a719514e37c211f327379688f81b0dChris Lattner} 124331de23705a719514e37c211f327379688f81b0dChris Lattner 125331de23705a719514e37c211f327379688f81b0dChris Lattner// getOptionPred - Check to see if there are any options that satisfy the 126331de23705a719514e37c211f327379688f81b0dChris Lattner// specified predicate with names that are the prefixes in Name. This is 127331de23705a719514e37c211f327379688f81b0dChris Lattner// checked by progressively stripping characters off of the name, checking to 128331de23705a719514e37c211f327379688f81b0dChris Lattner// see if there options that satisfy the predicate. If we find one, return it, 129331de23705a719514e37c211f327379688f81b0dChris Lattner// otherwise return null. 130f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner// 131331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic Option *getOptionPred(std::string Name, unsigned &Length, 132331de23705a719514e37c211f327379688f81b0dChris Lattner bool (*Pred)(const Option*)) { 133331de23705a719514e37c211f327379688f81b0dChris Lattner 134e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner Option *Op = getOption(Name); 135e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner if (Op && Pred(Op)) { 136331de23705a719514e37c211f327379688f81b0dChris Lattner Length = Name.length(); 137e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner return Op; 138331de23705a719514e37c211f327379688f81b0dChris Lattner } 139f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner 140331de23705a719514e37c211f327379688f81b0dChris Lattner if (Name.size() == 1) return 0; 141331de23705a719514e37c211f327379688f81b0dChris Lattner do { 142331de23705a719514e37c211f327379688f81b0dChris Lattner Name.erase(Name.end()-1, Name.end()); // Chop off the last character... 143e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner Op = getOption(Name); 144331de23705a719514e37c211f327379688f81b0dChris Lattner 145331de23705a719514e37c211f327379688f81b0dChris Lattner // Loop while we haven't found an option and Name still has at least two 146331de23705a719514e37c211f327379688f81b0dChris Lattner // characters in it (so that the next iteration will not be the empty 147331de23705a719514e37c211f327379688f81b0dChris Lattner // string... 148e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner } while ((Op == 0 || !Pred(Op)) && Name.size() > 1); 149331de23705a719514e37c211f327379688f81b0dChris Lattner 150e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner if (Op && Pred(Op)) { 151331de23705a719514e37c211f327379688f81b0dChris Lattner Length = Name.length(); 152e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner return Op; // Found one! 153f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner } 154331de23705a719514e37c211f327379688f81b0dChris Lattner return 0; // No option found! 155331de23705a719514e37c211f327379688f81b0dChris Lattner} 156f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner 157331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic bool RequiresValue(const Option *O) { 158dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman return O->getNumOccurrencesFlag() == cl::Required || 159dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman O->getNumOccurrencesFlag() == cl::OneOrMore; 160331de23705a719514e37c211f327379688f81b0dChris Lattner} 161331de23705a719514e37c211f327379688f81b0dChris Lattner 162331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic bool EatsUnboundedNumberOfValues(const Option *O) { 163dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman return O->getNumOccurrencesFlag() == cl::ZeroOrMore || 164dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman O->getNumOccurrencesFlag() == cl::OneOrMore; 165f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner} 166caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner 167c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke/// ParseCStringVector - Break INPUT up wherever one or more 168c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke/// whitespace characters are found, and store the resulting tokens in 169c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke/// OUTPUT. The tokens stored in OUTPUT are dynamically allocated 170c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke/// using strdup (), so it is the caller's responsibility to free () 171c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke/// them later. 17206b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// 173c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaekestatic void ParseCStringVector (std::vector<char *> &output, 174c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke const char *input) { 175c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Characters which will be treated as token separators: 176c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke static const char *delims = " \v\f\t\r\n"; 177c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke 17806b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke std::string work (input); 179c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Skip past any delims at head of input string. 180c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke size_t pos = work.find_first_not_of (delims); 181c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // If the string consists entirely of delims, then exit early. 182c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke if (pos == std::string::npos) return; 183c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Otherwise, jump forward to beginning of first word. 18406b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke work = work.substr (pos); 185c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Find position of first delimiter. 18606b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke pos = work.find_first_of (delims); 187c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke 188c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke while (!work.empty() && pos != std::string::npos) { 189c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Everything from 0 to POS is the next word to copy. 190c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke output.push_back (strdup (work.substr (0,pos).c_str ())); 191c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Is there another word in the string? 192c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke size_t nextpos = work.find_first_not_of (delims, pos + 1); 193c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke if (nextpos != std::string::npos) { 194c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Yes? Then remove delims from beginning ... 19506b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke work = work.substr (work.find_first_not_of (delims, pos + 1)); 196c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // and find the end of the word. 19706b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke pos = work.find_first_of (delims); 19806b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke } else { 199c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // No? (Remainder of string is delims.) End the loop. 20006b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke work = ""; 201c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke pos = std::string::npos; 20206b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke } 20306b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke } 20406b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke 205c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // If `input' ended with non-delim char, then we'll get here with 206c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // the last word of `input' in `work'; copy it now. 207c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke if (!work.empty ()) { 208c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke output.push_back (strdup (work.c_str ())); 20906b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke } 21006b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke} 21106b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke 21206b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// ParseEnvironmentOptions - An alternative entry point to the 21306b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// CommandLine library, which allows you to read the program's name 21406b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// from the caller (as PROGNAME) and its command-line arguments from 21506b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// an environment variable (whose name is given in ENVVAR). 21606b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// 217bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattnervoid cl::ParseEnvironmentOptions(const char *progName, const char *envVar, 218bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner const char *Overview) { 219c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Check args. 220bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner assert(progName && "Program name not specified"); 221bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner assert(envVar && "Environment variable name missing"); 222c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke 22306b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke // Get the environment variable they want us to parse options out of. 224c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke const char *envValue = getenv (envVar); 225c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke if (!envValue) 22606b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke return; 227c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke 228c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Get program's "name", which we wouldn't know without the caller 229c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // telling us. 230c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke std::vector<char *> newArgv; 231c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke newArgv.push_back (strdup (progName)); 23206b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke 23306b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke // Parse the value of the environment variable into a "command line" 23406b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke // and hand it off to ParseCommandLineOptions(). 235c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke ParseCStringVector (newArgv, envValue); 236c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke int newArgc = newArgv.size (); 237c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke ParseCommandLineOptions (newArgc, &newArgv[0], Overview); 238c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke 239c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Free all the strdup()ed strings. 240c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke for (std::vector<char *>::iterator i = newArgv.begin (), e = newArgv.end (); 241c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke i != e; ++i) { 242c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke free (*i); 243c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke } 24406b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke} 24506b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke 246bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner/// LookupOption - Lookup the option specified by the specified option on the 247bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner/// command line. If there is a value specified (after an equal sign) return 248bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner/// that as well. 249bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattnerstatic Option *LookupOption(const char *&Arg, const char *&Value) { 250bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner while (*Arg == '-') ++Arg; // Eat leading dashes 251bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner 252bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner const char *ArgEnd = Arg; 253bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner while (*ArgEnd && *ArgEnd != '=') 254bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner ++ArgEnd; // Scan till end of argument name... 255bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner 256bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner Value = ArgEnd; 257bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner if (*Value) // If we have an equals sign... 258bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner ++Value; // Advance to value... 259bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner 260bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner if (*Arg == 0) return 0; 261bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner 262bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner // Look up the option. 263bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner std::map<std::string, Option*> &Opts = getOpts(); 264bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner std::map<std::string, Option*>::iterator I = 265bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner Opts.find(std::string(Arg, ArgEnd)); 266bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner return (I != Opts.end()) ? I->second : 0; 267bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner} 268bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner 269dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattnervoid cl::ParseCommandLineOptions(int &argc, char **argv, 2700c0edf8afc35a42b15a24ebb5fa5f3fc674290aeChris Lattner const char *Overview) { 271331de23705a719514e37c211f327379688f81b0dChris Lattner assert((!getOpts().empty() || !getPositionalOpts().empty()) && 272331de23705a719514e37c211f327379688f81b0dChris Lattner "No options specified, or ParseCommandLineOptions called more" 273331de23705a719514e37c211f327379688f81b0dChris Lattner " than once!"); 274dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner ProgramName = argv[0]; // Save this away safe and snug 275dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner ProgramOverview = Overview; 276dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner bool ErrorParsing = false; 277dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 278ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::map<std::string, Option*> &Opts = getOpts(); 279ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::vector<Option*> &PositionalOpts = getPositionalOpts(); 280331de23705a719514e37c211f327379688f81b0dChris Lattner 281331de23705a719514e37c211f327379688f81b0dChris Lattner // Check out the positional arguments to collect information about them. 282331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned NumPositionalRequired = 0; 283331de23705a719514e37c211f327379688f81b0dChris Lattner Option *ConsumeAfterOpt = 0; 284331de23705a719514e37c211f327379688f81b0dChris Lattner if (!PositionalOpts.empty()) { 285dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman if (PositionalOpts[0]->getNumOccurrencesFlag() == cl::ConsumeAfter) { 286331de23705a719514e37c211f327379688f81b0dChris Lattner assert(PositionalOpts.size() > 1 && 287331de23705a719514e37c211f327379688f81b0dChris Lattner "Cannot specify cl::ConsumeAfter without a positional argument!"); 288331de23705a719514e37c211f327379688f81b0dChris Lattner ConsumeAfterOpt = PositionalOpts[0]; 289331de23705a719514e37c211f327379688f81b0dChris Lattner } 290331de23705a719514e37c211f327379688f81b0dChris Lattner 291331de23705a719514e37c211f327379688f81b0dChris Lattner // Calculate how many positional values are _required_. 292331de23705a719514e37c211f327379688f81b0dChris Lattner bool UnboundedFound = false; 293331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = ConsumeAfterOpt != 0, e = PositionalOpts.size(); 294331de23705a719514e37c211f327379688f81b0dChris Lattner i != e; ++i) { 295331de23705a719514e37c211f327379688f81b0dChris Lattner Option *Opt = PositionalOpts[i]; 296331de23705a719514e37c211f327379688f81b0dChris Lattner if (RequiresValue(Opt)) 297331de23705a719514e37c211f327379688f81b0dChris Lattner ++NumPositionalRequired; 298331de23705a719514e37c211f327379688f81b0dChris Lattner else if (ConsumeAfterOpt) { 299331de23705a719514e37c211f327379688f81b0dChris Lattner // ConsumeAfter cannot be combined with "optional" positional options 30054ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner // unless there is only one positional argument... 30154ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner if (PositionalOpts.size() > 2) 30254ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner ErrorParsing |= 30354ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner Opt->error(" error - this positional option will never be matched, " 30454ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner "because it does not Require a value, and a " 30554ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner "cl::ConsumeAfter option is active!"); 3069cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner } else if (UnboundedFound && !Opt->ArgStr[0]) { 3079cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // This option does not "require" a value... Make sure this option is 3089cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // not specified after an option that eats all extra arguments, or this 3099cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // one will never get any! 310331de23705a719514e37c211f327379688f81b0dChris Lattner // 311331de23705a719514e37c211f327379688f81b0dChris Lattner ErrorParsing |= Opt->error(" error - option can never match, because " 312331de23705a719514e37c211f327379688f81b0dChris Lattner "another positional argument will match an " 313331de23705a719514e37c211f327379688f81b0dChris Lattner "unbounded number of values, and this option" 314331de23705a719514e37c211f327379688f81b0dChris Lattner " does not require a value!"); 315331de23705a719514e37c211f327379688f81b0dChris Lattner } 316331de23705a719514e37c211f327379688f81b0dChris Lattner UnboundedFound |= EatsUnboundedNumberOfValues(Opt); 317331de23705a719514e37c211f327379688f81b0dChris Lattner } 318331de23705a719514e37c211f327379688f81b0dChris Lattner } 319331de23705a719514e37c211f327379688f81b0dChris Lattner 320331de23705a719514e37c211f327379688f81b0dChris Lattner // PositionalVals - A vector of "positional" arguments we accumulate into to 321331de23705a719514e37c211f327379688f81b0dChris Lattner // processes at the end... 322331de23705a719514e37c211f327379688f81b0dChris Lattner // 323ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::vector<std::string> PositionalVals; 324331de23705a719514e37c211f327379688f81b0dChris Lattner 3259cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // If the program has named positional arguments, and the name has been run 3269cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // across, keep track of which positional argument was named. Otherwise put 3279cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // the positional args into the PositionalVals list... 3289cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner Option *ActivePositionalArg = 0; 3299cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner 330dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Loop over all of the arguments... processing them. 331331de23705a719514e37c211f327379688f81b0dChris Lattner bool DashDashFound = false; // Have we read '--'? 332dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner for (int i = 1; i < argc; ++i) { 333dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner Option *Handler = 0; 334dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner const char *Value = ""; 335dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner const char *ArgName = ""; 336331de23705a719514e37c211f327379688f81b0dChris Lattner 337331de23705a719514e37c211f327379688f81b0dChris Lattner // Check to see if this is a positional argument. This argument is 338331de23705a719514e37c211f327379688f81b0dChris Lattner // considered to be positional if it doesn't start with '-', if it is "-" 3391115e0483fc6da16d52382f159005baddf028063Misha Brukman // itself, or if we have seen "--" already. 340331de23705a719514e37c211f327379688f81b0dChris Lattner // 341331de23705a719514e37c211f327379688f81b0dChris Lattner if (argv[i][0] != '-' || argv[i][1] == 0 || DashDashFound) { 342331de23705a719514e37c211f327379688f81b0dChris Lattner // Positional argument! 3439cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (ActivePositionalArg) { 3449cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner ProvidePositionalOption(ActivePositionalArg, argv[i]); 3459cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner continue; // We are done! 3469cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner } else if (!PositionalOpts.empty()) { 347331de23705a719514e37c211f327379688f81b0dChris Lattner PositionalVals.push_back(argv[i]); 348331de23705a719514e37c211f327379688f81b0dChris Lattner 349331de23705a719514e37c211f327379688f81b0dChris Lattner // All of the positional arguments have been fulfulled, give the rest to 350331de23705a719514e37c211f327379688f81b0dChris Lattner // the consume after option... if it's specified... 351331de23705a719514e37c211f327379688f81b0dChris Lattner // 352d16714b5ed076d0c1d14543098c1e9b90fd92a38Chris Lattner if (PositionalVals.size() >= NumPositionalRequired && 353331de23705a719514e37c211f327379688f81b0dChris Lattner ConsumeAfterOpt != 0) { 354331de23705a719514e37c211f327379688f81b0dChris Lattner for (++i; i < argc; ++i) 355331de23705a719514e37c211f327379688f81b0dChris Lattner PositionalVals.push_back(argv[i]); 356331de23705a719514e37c211f327379688f81b0dChris Lattner break; // Handle outside of the argument processing loop... 357331de23705a719514e37c211f327379688f81b0dChris Lattner } 358331de23705a719514e37c211f327379688f81b0dChris Lattner 359331de23705a719514e37c211f327379688f81b0dChris Lattner // Delay processing positional arguments until the end... 360331de23705a719514e37c211f327379688f81b0dChris Lattner continue; 361331de23705a719514e37c211f327379688f81b0dChris Lattner } 362bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner } else if (argv[i][0] == '-' && argv[i][1] == '-' && argv[i][2] == 0 && 363bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner !DashDashFound) { 364bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner DashDashFound = true; // This is the mythical "--"? 365bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner continue; // Don't try to process it as an argument itself. 366bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner } else if (ActivePositionalArg && 367bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner (ActivePositionalArg->getMiscFlags() & PositionalEatsArgs)) { 368bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner // If there is a positional argument eating options, check to see if this 369bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner // option is another positional argument. If so, treat it as an argument, 370bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner // otherwise feed it to the eating positional. 371dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner ArgName = argv[i]+1; 372bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner Handler = LookupOption(ArgName, Value); 373bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner if (!Handler || Handler->getFormattingFlag() != cl::Positional) { 374bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner ProvidePositionalOption(ActivePositionalArg, argv[i]); 375bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner continue; // We are done! 376331de23705a719514e37c211f327379688f81b0dChris Lattner } 377331de23705a719514e37c211f327379688f81b0dChris Lattner 378bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner } else { // We start with a '-', must be an argument... 379bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner ArgName = argv[i]+1; 380bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner Handler = LookupOption(ArgName, Value); 381331de23705a719514e37c211f327379688f81b0dChris Lattner 382bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner // Check to see if this "option" is really a prefixed or grouped argument. 383bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner if (Handler == 0 && *Value == 0) { 384bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner std::string RealName(ArgName); 385bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner if (RealName.size() > 1) { 386331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned Length = 0; 387331de23705a719514e37c211f327379688f81b0dChris Lattner Option *PGOpt = getOptionPred(RealName, Length, isPrefixedOrGrouping); 388bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner 389331de23705a719514e37c211f327379688f81b0dChris Lattner // If the option is a prefixed option, then the value is simply the 390331de23705a719514e37c211f327379688f81b0dChris Lattner // rest of the name... so fall through to later processing, by 391331de23705a719514e37c211f327379688f81b0dChris Lattner // setting up the argument name flags and value fields. 392331de23705a719514e37c211f327379688f81b0dChris Lattner // 393331de23705a719514e37c211f327379688f81b0dChris Lattner if (PGOpt && PGOpt->getFormattingFlag() == cl::Prefix) { 394bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner Value = ArgName+Length; 395bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner assert(Opts.find(std::string(ArgName, Value)) != Opts.end() && 396bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner Opts.find(std::string(ArgName, Value))->second == PGOpt); 397bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner Handler = PGOpt; 398331de23705a719514e37c211f327379688f81b0dChris Lattner } else if (PGOpt) { 399bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner // This must be a grouped option... handle them now. 400331de23705a719514e37c211f327379688f81b0dChris Lattner assert(isGrouping(PGOpt) && "Broken getOptionPred!"); 401bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner 402331de23705a719514e37c211f327379688f81b0dChris Lattner do { 403331de23705a719514e37c211f327379688f81b0dChris Lattner // Move current arg name out of RealName into RealArgName... 404bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner std::string RealArgName(RealName.begin(), 405bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner RealName.begin() + Length); 406bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner RealName.erase(RealName.begin(), RealName.begin() + Length); 407bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner 408b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman // Because ValueRequired is an invalid flag for grouped arguments, 409b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman // we don't need to pass argc/argv in... 410b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman // 411331de23705a719514e37c211f327379688f81b0dChris Lattner assert(PGOpt->getValueExpectedFlag() != cl::ValueRequired && 412331de23705a719514e37c211f327379688f81b0dChris Lattner "Option can not be cl::Grouping AND cl::ValueRequired!"); 413331de23705a719514e37c211f327379688f81b0dChris Lattner int Dummy; 414bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner ErrorParsing |= ProvideOption(PGOpt, RealArgName.c_str(), 415bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner "", 0, 0, Dummy); 416bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner 417331de23705a719514e37c211f327379688f81b0dChris Lattner // Get the next grouping option... 418bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner PGOpt = getOptionPred(RealName, Length, isGrouping); 419bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner } while (PGOpt && Length != RealName.size()); 420bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner 421bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner Handler = PGOpt; // Ate all of the options. 422331de23705a719514e37c211f327379688f81b0dChris Lattner } 423b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman } 424dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 425dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 426dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 427dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner if (Handler == 0) { 428c86e84bcf38a94d0bcd09e76ff127ee636354bc0Brian Gaeke std::cerr << "Unknown command line argument '" << argv[i] << "'. Try: '" 429ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner << argv[0] << " --help'\n"; 430dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner ErrorParsing = true; 431dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner continue; 432dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 433dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 43472fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner // Check to see if this option accepts a comma separated list of values. If 43572fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner // it does, we have to split up the value into multiple values... 43672fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner if (Handler->getMiscFlags() & CommaSeparated) { 43772fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner std::string Val(Value); 43872fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner std::string::size_type Pos = Val.find(','); 43972fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner 44072fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner while (Pos != std::string::npos) { 44172fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner // Process the portion before the comma... 44272fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner ErrorParsing |= ProvideOption(Handler, ArgName, 44372fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner std::string(Val.begin(), 44472fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner Val.begin()+Pos).c_str(), 44572fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner argc, argv, i); 44672fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner // Erase the portion before the comma, AND the comma... 44772fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner Val.erase(Val.begin(), Val.begin()+Pos+1); 44872fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner Value += Pos+1; // Increment the original value pointer as well... 44972fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner 45072fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner // Check for another comma... 45172fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner Pos = Val.find(','); 45272fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner } 45372fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner } 4549cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner 4559cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // If this is a named positional argument, just remember that it is the 4569cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // active one... 4579cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (Handler->getFormattingFlag() == cl::Positional) 4589cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner ActivePositionalArg = Handler; 4599cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner else 4609cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner ErrorParsing |= ProvideOption(Handler, ArgName, Value, argc, argv, i); 461331de23705a719514e37c211f327379688f81b0dChris Lattner } 462dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 463331de23705a719514e37c211f327379688f81b0dChris Lattner // Check and handle positional arguments now... 464331de23705a719514e37c211f327379688f81b0dChris Lattner if (NumPositionalRequired > PositionalVals.size()) { 465ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << "Not enough positional command line arguments specified!\n" 466ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner << "Must specify at least " << NumPositionalRequired 467ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner << " positional arguments: See: " << argv[0] << " --help\n"; 468331de23705a719514e37c211f327379688f81b0dChris Lattner ErrorParsing = true; 469331de23705a719514e37c211f327379688f81b0dChris Lattner 470331de23705a719514e37c211f327379688f81b0dChris Lattner 471331de23705a719514e37c211f327379688f81b0dChris Lattner } else if (ConsumeAfterOpt == 0) { 472331de23705a719514e37c211f327379688f81b0dChris Lattner // Positional args have already been handled if ConsumeAfter is specified... 473331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned ValNo = 0, NumVals = PositionalVals.size(); 474331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = PositionalOpts.size(); i != e; ++i) { 475331de23705a719514e37c211f327379688f81b0dChris Lattner if (RequiresValue(PositionalOpts[i])) { 476331de23705a719514e37c211f327379688f81b0dChris Lattner ProvidePositionalOption(PositionalOpts[i], PositionalVals[ValNo++]); 477331de23705a719514e37c211f327379688f81b0dChris Lattner --NumPositionalRequired; // We fulfilled our duty... 478331de23705a719514e37c211f327379688f81b0dChris Lattner } 479331de23705a719514e37c211f327379688f81b0dChris Lattner 480331de23705a719514e37c211f327379688f81b0dChris Lattner // If we _can_ give this option more arguments, do so now, as long as we 481331de23705a719514e37c211f327379688f81b0dChris Lattner // do not give it values that others need. 'Done' controls whether the 482331de23705a719514e37c211f327379688f81b0dChris Lattner // option even _WANTS_ any more. 483331de23705a719514e37c211f327379688f81b0dChris Lattner // 484dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman bool Done = PositionalOpts[i]->getNumOccurrencesFlag() == cl::Required; 485331de23705a719514e37c211f327379688f81b0dChris Lattner while (NumVals-ValNo > NumPositionalRequired && !Done) { 486dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman switch (PositionalOpts[i]->getNumOccurrencesFlag()) { 487331de23705a719514e37c211f327379688f81b0dChris Lattner case cl::Optional: 488331de23705a719514e37c211f327379688f81b0dChris Lattner Done = true; // Optional arguments want _at most_ one value 489331de23705a719514e37c211f327379688f81b0dChris Lattner // FALL THROUGH 490331de23705a719514e37c211f327379688f81b0dChris Lattner case cl::ZeroOrMore: // Zero or more will take all they can get... 491331de23705a719514e37c211f327379688f81b0dChris Lattner case cl::OneOrMore: // One or more will take all they can get... 492331de23705a719514e37c211f327379688f81b0dChris Lattner ProvidePositionalOption(PositionalOpts[i], PositionalVals[ValNo++]); 493331de23705a719514e37c211f327379688f81b0dChris Lattner break; 494331de23705a719514e37c211f327379688f81b0dChris Lattner default: 495dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman assert(0 && "Internal error, unexpected NumOccurrences flag in " 496331de23705a719514e37c211f327379688f81b0dChris Lattner "positional argument processing!"); 497331de23705a719514e37c211f327379688f81b0dChris Lattner } 498331de23705a719514e37c211f327379688f81b0dChris Lattner } 499caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner } 500331de23705a719514e37c211f327379688f81b0dChris Lattner } else { 501331de23705a719514e37c211f327379688f81b0dChris Lattner assert(ConsumeAfterOpt && NumPositionalRequired <= PositionalVals.size()); 502331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned ValNo = 0; 503331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned j = 1, e = PositionalOpts.size(); j != e; ++j) 504331de23705a719514e37c211f327379688f81b0dChris Lattner if (RequiresValue(PositionalOpts[j])) 505faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner ErrorParsing |= ProvidePositionalOption(PositionalOpts[j], 506faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner PositionalVals[ValNo++]); 507faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner 508faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // Handle the case where there is just one positional option, and it's 509faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // optional. In this case, we want to give JUST THE FIRST option to the 510faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // positional option and keep the rest for the consume after. The above 511faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // loop would have assigned no values to positional options in this case. 512faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // 513b490c20b3891717f95804517d47d269bbcf3dc03Chris Lattner if (PositionalOpts.size() == 2 && ValNo == 0 && !PositionalVals.empty()) 514faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner ErrorParsing |= ProvidePositionalOption(PositionalOpts[1], 515faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner PositionalVals[ValNo++]); 516331de23705a719514e37c211f327379688f81b0dChris Lattner 517331de23705a719514e37c211f327379688f81b0dChris Lattner // Handle over all of the rest of the arguments to the 518331de23705a719514e37c211f327379688f81b0dChris Lattner // cl::ConsumeAfter command line option... 519331de23705a719514e37c211f327379688f81b0dChris Lattner for (; ValNo != PositionalVals.size(); ++ValNo) 520331de23705a719514e37c211f327379688f81b0dChris Lattner ErrorParsing |= ProvidePositionalOption(ConsumeAfterOpt, 521331de23705a719514e37c211f327379688f81b0dChris Lattner PositionalVals[ValNo]); 522dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 523dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 524dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner // Loop over args and make sure all required args are specified! 525ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner for (std::map<std::string, Option*>::iterator I = Opts.begin(), 526b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman E = Opts.end(); I != E; ++I) { 527dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman switch (I->second->getNumOccurrencesFlag()) { 528dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner case Required: 529dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner case OneOrMore: 530dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman if (I->second->getNumOccurrences() == 0) { 531b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman I->second->error(" must be specified at least once!"); 532f038acbee21cfed998451aedd00a81901d299516Chris Lattner ErrorParsing = true; 533f038acbee21cfed998451aedd00a81901d299516Chris Lattner } 534dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner // Fall through 535dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner default: 536dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner break; 537dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner } 538dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner } 539dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 540331de23705a719514e37c211f327379688f81b0dChris Lattner // Free all of the memory allocated to the map. Command line options may only 541331de23705a719514e37c211f327379688f81b0dChris Lattner // be processed once! 542e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner delete CommandLineOptions; 543e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner CommandLineOptions = 0; 544331de23705a719514e37c211f327379688f81b0dChris Lattner PositionalOpts.clear(); 545dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 546dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // If we had an error processing our arguments, don't let the program execute 547dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner if (ErrorParsing) exit(1); 548dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 549dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 550dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner//===----------------------------------------------------------------------===// 551dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// Option Base class implementation 552dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 553dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 554ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattnerbool Option::error(std::string Message, const char *ArgName) { 555dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner if (ArgName == 0) ArgName = ArgStr; 556331de23705a719514e37c211f327379688f81b0dChris Lattner if (ArgName[0] == 0) 557ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << HelpStr; // Be nice for positional arguments 558331de23705a719514e37c211f327379688f81b0dChris Lattner else 559ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << "-" << ArgName; 560ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << " option" << Message << "\n"; 561dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return true; 562dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 563dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 564dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukmanbool Option::addOccurrence(const char *ArgName, const std::string &Value) { 565dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman NumOccurrences++; // Increment the number of times we have been seen 566dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 567dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman switch (getNumOccurrencesFlag()) { 568dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner case Optional: 569dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman if (NumOccurrences > 1) 570dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return error(": may only occur zero or one times!", ArgName); 571dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner break; 572dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner case Required: 573dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman if (NumOccurrences > 1) 574dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return error(": must occur exactly one time!", ArgName); 575dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Fall through 576dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner case OneOrMore: 577caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner case ZeroOrMore: 578caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner case ConsumeAfter: break; 579b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman default: return error(": bad num occurrences flag value!"); 580dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 581dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 582dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman return handleOccurrence(ArgName, Value); 583dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 584dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 585331de23705a719514e37c211f327379688f81b0dChris Lattner// addArgument - Tell the system that this Option subclass will handle all 586b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman// occurrences of -ArgStr on the command line. 587331de23705a719514e37c211f327379688f81b0dChris Lattner// 588331de23705a719514e37c211f327379688f81b0dChris Lattnervoid Option::addArgument(const char *ArgStr) { 589331de23705a719514e37c211f327379688f81b0dChris Lattner if (ArgStr[0]) 590331de23705a719514e37c211f327379688f81b0dChris Lattner AddArgument(ArgStr, this); 5919cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner 5929cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (getFormattingFlag() == Positional) 593331de23705a719514e37c211f327379688f81b0dChris Lattner getPositionalOpts().push_back(this); 594dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman else if (getNumOccurrencesFlag() == ConsumeAfter) { 5959cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (!getPositionalOpts().empty() && 5969cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner getPositionalOpts().front()->getNumOccurrencesFlag() == ConsumeAfter) 5979cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner error("Cannot specify more than one option with cl::ConsumeAfter!"); 598331de23705a719514e37c211f327379688f81b0dChris Lattner getPositionalOpts().insert(getPositionalOpts().begin(), this); 599331de23705a719514e37c211f327379688f81b0dChris Lattner } 600331de23705a719514e37c211f327379688f81b0dChris Lattner} 601331de23705a719514e37c211f327379688f81b0dChris Lattner 602aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattnervoid Option::removeArgument(const char *ArgStr) { 6039cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (ArgStr[0]) 604e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner RemoveArgument(ArgStr, this); 6059cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner 6069cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (getFormattingFlag() == Positional) { 607ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::vector<Option*>::iterator I = 608aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner std::find(getPositionalOpts().begin(), getPositionalOpts().end(), this); 609aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner assert(I != getPositionalOpts().end() && "Arg not registered!"); 610aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner getPositionalOpts().erase(I); 611dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman } else if (getNumOccurrencesFlag() == ConsumeAfter) { 612aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner assert(!getPositionalOpts().empty() && getPositionalOpts()[0] == this && 613aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner "Arg not registered correctly!"); 614aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner getPositionalOpts().erase(getPositionalOpts().begin()); 615aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner } 616aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner} 617aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner 618331de23705a719514e37c211f327379688f81b0dChris Lattner 619331de23705a719514e37c211f327379688f81b0dChris Lattner// getValueStr - Get the value description string, using "DefaultMsg" if nothing 620331de23705a719514e37c211f327379688f81b0dChris Lattner// has been specified yet. 621331de23705a719514e37c211f327379688f81b0dChris Lattner// 622331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic const char *getValueStr(const Option &O, const char *DefaultMsg) { 623331de23705a719514e37c211f327379688f81b0dChris Lattner if (O.ValueStr[0] == 0) return DefaultMsg; 624331de23705a719514e37c211f327379688f81b0dChris Lattner return O.ValueStr; 625331de23705a719514e37c211f327379688f81b0dChris Lattner} 626331de23705a719514e37c211f327379688f81b0dChris Lattner 627331de23705a719514e37c211f327379688f81b0dChris Lattner//===----------------------------------------------------------------------===// 628331de23705a719514e37c211f327379688f81b0dChris Lattner// cl::alias class implementation 629331de23705a719514e37c211f327379688f81b0dChris Lattner// 630331de23705a719514e37c211f327379688f81b0dChris Lattner 631dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// Return the width of the option tag for printing... 632331de23705a719514e37c211f327379688f81b0dChris Lattnerunsigned alias::getOptionWidth() const { 633dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return std::strlen(ArgStr)+6; 634dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 635dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 636331de23705a719514e37c211f327379688f81b0dChris Lattner// Print out the option for the alias... 637331de23705a719514e37c211f327379688f81b0dChris Lattnervoid alias::printOptionInfo(unsigned GlobalWidth) const { 638dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner unsigned L = std::strlen(ArgStr); 639ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << " -" << ArgStr << std::string(GlobalWidth-L-6, ' ') << " - " 640ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner << HelpStr << "\n"; 641dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 642dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 643dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 644331de23705a719514e37c211f327379688f81b0dChris Lattner 645dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner//===----------------------------------------------------------------------===// 646331de23705a719514e37c211f327379688f81b0dChris Lattner// Parser Implementation code... 647dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 648dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 6499b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// basic_parser implementation 6509b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// 6519b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 6529b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// Return the width of the option tag for printing... 6539b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattnerunsigned basic_parser_impl::getOptionWidth(const Option &O) const { 6549b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner unsigned Len = std::strlen(O.ArgStr); 6559b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner if (const char *ValName = getValueName()) 6569b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner Len += std::strlen(getValueStr(O, ValName))+3; 6579b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 6589b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner return Len + 6; 6599b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner} 6609b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 6619b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// printOptionInfo - Print out information about this option. The 6629b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// to-be-maintained width is specified. 6639b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// 6649b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattnervoid basic_parser_impl::printOptionInfo(const Option &O, 6659b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner unsigned GlobalWidth) const { 666ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << " -" << O.ArgStr; 6679b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 6689b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner if (const char *ValName = getValueName()) 669ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << "=<" << getValueStr(O, ValName) << ">"; 6709b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 671ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << std::string(GlobalWidth-getOptionWidth(O), ' ') << " - " 672ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner << O.HelpStr << "\n"; 6739b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner} 6749b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 6759b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 6769b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 6779b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 678331de23705a719514e37c211f327379688f81b0dChris Lattner// parser<bool> implementation 679331de23705a719514e37c211f327379688f81b0dChris Lattner// 6809b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattnerbool parser<bool>::parse(Option &O, const char *ArgName, 681ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner const std::string &Arg, bool &Value) { 682dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner if (Arg == "" || Arg == "true" || Arg == "TRUE" || Arg == "True" || 683dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner Arg == "1") { 684dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner Value = true; 685dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } else if (Arg == "false" || Arg == "FALSE" || Arg == "False" || Arg == "0") { 686dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner Value = false; 687dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } else { 688331de23705a719514e37c211f327379688f81b0dChris Lattner return O.error(": '" + Arg + 689331de23705a719514e37c211f327379688f81b0dChris Lattner "' is invalid value for boolean argument! Try 0 or 1"); 690dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 691dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return false; 692dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 693dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 694331de23705a719514e37c211f327379688f81b0dChris Lattner// parser<int> implementation 695dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 6969b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattnerbool parser<int>::parse(Option &O, const char *ArgName, 697ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner const std::string &Arg, int &Value) { 698331de23705a719514e37c211f327379688f81b0dChris Lattner char *End; 699d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner Value = (int)strtol(Arg.c_str(), &End, 0); 700331de23705a719514e37c211f327379688f81b0dChris Lattner if (*End != 0) 701331de23705a719514e37c211f327379688f81b0dChris Lattner return O.error(": '" + Arg + "' value invalid for integer argument!"); 702331de23705a719514e37c211f327379688f81b0dChris Lattner return false; 703dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 704dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 705d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner// parser<unsigned> implementation 706d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner// 707d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattnerbool parser<unsigned>::parse(Option &O, const char *ArgName, 708d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner const std::string &Arg, unsigned &Value) { 709d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner char *End; 7102d6a2360036cf511af0a06f9720e6a1752779d1cBrian Gaeke errno = 0; 7112d6a2360036cf511af0a06f9720e6a1752779d1cBrian Gaeke unsigned long V = strtoul(Arg.c_str(), &End, 0); 712d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner Value = (unsigned)V; 7132d6a2360036cf511af0a06f9720e6a1752779d1cBrian Gaeke if (((V == ULONG_MAX) && (errno == ERANGE)) 7142d6a2360036cf511af0a06f9720e6a1752779d1cBrian Gaeke || (*End != 0) 7152d6a2360036cf511af0a06f9720e6a1752779d1cBrian Gaeke || (Value != V)) 716d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner return O.error(": '" + Arg + "' value invalid for uint argument!"); 717d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner return false; 718d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner} 719d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner 7209b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// parser<double>/parser<float> implementation 721331de23705a719514e37c211f327379688f81b0dChris Lattner// 722ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattnerstatic bool parseDouble(Option &O, const std::string &Arg, double &Value) { 723331de23705a719514e37c211f327379688f81b0dChris Lattner const char *ArgStart = Arg.c_str(); 724331de23705a719514e37c211f327379688f81b0dChris Lattner char *End; 725331de23705a719514e37c211f327379688f81b0dChris Lattner Value = strtod(ArgStart, &End); 726331de23705a719514e37c211f327379688f81b0dChris Lattner if (*End != 0) 727331de23705a719514e37c211f327379688f81b0dChris Lattner return O.error(": '" +Arg+ "' value invalid for floating point argument!"); 728dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return false; 729dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 730dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 7319b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattnerbool parser<double>::parse(Option &O, const char *AN, 7329b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner const std::string &Arg, double &Val) { 7339b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner return parseDouble(O, Arg, Val); 734dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 735dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 7369b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattnerbool parser<float>::parse(Option &O, const char *AN, 7379b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner const std::string &Arg, float &Val) { 7389b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner double dVal; 7399b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner if (parseDouble(O, Arg, dVal)) 7409b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner return true; 7419b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner Val = (float)dVal; 7429b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner return false; 743dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 744dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 745dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 746dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 747331de23705a719514e37c211f327379688f81b0dChris Lattner// generic_parser_base implementation 748dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 749dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 750aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner// findOption - Return the option number corresponding to the specified 751aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner// argument string. If the option is not found, getNumOptions() is returned. 752aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner// 753aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattnerunsigned generic_parser_base::findOption(const char *Name) { 754aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner unsigned i = 0, e = getNumOptions(); 755ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::string N(Name); 756aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner 757aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner while (i != e) 758aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner if (getOption(i) == N) 759aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner return i; 760aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner else 761aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner ++i; 762aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner return e; 763aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner} 764aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner 765aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner 766dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// Return the width of the option tag for printing... 767331de23705a719514e37c211f327379688f81b0dChris Lattnerunsigned generic_parser_base::getOptionWidth(const Option &O) const { 768331de23705a719514e37c211f327379688f81b0dChris Lattner if (O.hasArgStr()) { 769331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned Size = std::strlen(O.ArgStr)+6; 770331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = getNumOptions(); i != e; ++i) 771331de23705a719514e37c211f327379688f81b0dChris Lattner Size = std::max(Size, (unsigned)std::strlen(getOption(i))+8); 772331de23705a719514e37c211f327379688f81b0dChris Lattner return Size; 773331de23705a719514e37c211f327379688f81b0dChris Lattner } else { 774331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned BaseSize = 0; 775331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = getNumOptions(); i != e; ++i) 776331de23705a719514e37c211f327379688f81b0dChris Lattner BaseSize = std::max(BaseSize, (unsigned)std::strlen(getOption(i))+8); 777331de23705a719514e37c211f327379688f81b0dChris Lattner return BaseSize; 778331de23705a719514e37c211f327379688f81b0dChris Lattner } 779dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 780dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 781dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// printOptionInfo - Print out information about this option. The 782dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// to-be-maintained width is specified. 783dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 784331de23705a719514e37c211f327379688f81b0dChris Lattnervoid generic_parser_base::printOptionInfo(const Option &O, 785331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned GlobalWidth) const { 786331de23705a719514e37c211f327379688f81b0dChris Lattner if (O.hasArgStr()) { 787331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned L = std::strlen(O.ArgStr); 788ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << " -" << O.ArgStr << std::string(GlobalWidth-L-6, ' ') 789ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner << " - " << O.HelpStr << "\n"; 790331de23705a719514e37c211f327379688f81b0dChris Lattner 791331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = getNumOptions(); i != e; ++i) { 792331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned NumSpaces = GlobalWidth-strlen(getOption(i))-8; 793ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << " =" << getOption(i) << std::string(NumSpaces, ' ') 794ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner << " - " << getDescription(i) << "\n"; 795331de23705a719514e37c211f327379688f81b0dChris Lattner } 796331de23705a719514e37c211f327379688f81b0dChris Lattner } else { 797331de23705a719514e37c211f327379688f81b0dChris Lattner if (O.HelpStr[0]) 798ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << " " << O.HelpStr << "\n"; 799331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = getNumOptions(); i != e; ++i) { 800331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned L = std::strlen(getOption(i)); 801ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << " -" << getOption(i) << std::string(GlobalWidth-L-8, ' ') 802ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner << " - " << getDescription(i) << "\n"; 803331de23705a719514e37c211f327379688f81b0dChris Lattner } 804dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 805dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 806dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 807dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 808dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner//===----------------------------------------------------------------------===// 809331de23705a719514e37c211f327379688f81b0dChris Lattner// --help and --help-hidden option implementation 810dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 811dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattnernamespace { 812dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 813331de23705a719514e37c211f327379688f81b0dChris Lattnerclass HelpPrinter { 814dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner unsigned MaxArgLen; 815dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner const Option *EmptyArg; 816dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner const bool ShowHidden; 817dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 818331de23705a719514e37c211f327379688f81b0dChris Lattner // isHidden/isReallyHidden - Predicates to be used to filter down arg lists. 819ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner inline static bool isHidden(std::pair<std::string, Option *> &OptPair) { 820331de23705a719514e37c211f327379688f81b0dChris Lattner return OptPair.second->getOptionHiddenFlag() >= Hidden; 821331de23705a719514e37c211f327379688f81b0dChris Lattner } 822ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner inline static bool isReallyHidden(std::pair<std::string, Option *> &OptPair) { 823331de23705a719514e37c211f327379688f81b0dChris Lattner return OptPair.second->getOptionHiddenFlag() == ReallyHidden; 824331de23705a719514e37c211f327379688f81b0dChris Lattner } 825331de23705a719514e37c211f327379688f81b0dChris Lattner 826331de23705a719514e37c211f327379688f81b0dChris Lattnerpublic: 827331de23705a719514e37c211f327379688f81b0dChris Lattner HelpPrinter(bool showHidden) : ShowHidden(showHidden) { 828331de23705a719514e37c211f327379688f81b0dChris Lattner EmptyArg = 0; 829331de23705a719514e37c211f327379688f81b0dChris Lattner } 830331de23705a719514e37c211f327379688f81b0dChris Lattner 831331de23705a719514e37c211f327379688f81b0dChris Lattner void operator=(bool Value) { 832331de23705a719514e37c211f327379688f81b0dChris Lattner if (Value == false) return; 833331de23705a719514e37c211f327379688f81b0dChris Lattner 834dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Copy Options into a vector so we can sort them as we like... 835ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::vector<std::pair<std::string, Option*> > Options; 836697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner copy(getOpts().begin(), getOpts().end(), std::back_inserter(Options)); 837dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 838dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Eliminate Hidden or ReallyHidden arguments, depending on ShowHidden 839331de23705a719514e37c211f327379688f81b0dChris Lattner Options.erase(std::remove_if(Options.begin(), Options.end(), 840331de23705a719514e37c211f327379688f81b0dChris Lattner std::ptr_fun(ShowHidden ? isReallyHidden : isHidden)), 841b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman Options.end()); 842dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 843dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Eliminate duplicate entries in table (from enum flags options, f.e.) 844331de23705a719514e37c211f327379688f81b0dChris Lattner { // Give OptionSet a scope 845331de23705a719514e37c211f327379688f81b0dChris Lattner std::set<Option*> OptionSet; 846331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0; i != Options.size(); ++i) 847331de23705a719514e37c211f327379688f81b0dChris Lattner if (OptionSet.count(Options[i].second) == 0) 848331de23705a719514e37c211f327379688f81b0dChris Lattner OptionSet.insert(Options[i].second); // Add new entry to set 849331de23705a719514e37c211f327379688f81b0dChris Lattner else 850331de23705a719514e37c211f327379688f81b0dChris Lattner Options.erase(Options.begin()+i--); // Erase duplicate 851331de23705a719514e37c211f327379688f81b0dChris Lattner } 852dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 853dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner if (ProgramOverview) 854ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << "OVERVIEW:" << ProgramOverview << "\n"; 855dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 856ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << "USAGE: " << ProgramName << " [options]"; 857331de23705a719514e37c211f327379688f81b0dChris Lattner 858331de23705a719514e37c211f327379688f81b0dChris Lattner // Print out the positional options... 859ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::vector<Option*> &PosOpts = getPositionalOpts(); 860331de23705a719514e37c211f327379688f81b0dChris Lattner Option *CAOpt = 0; // The cl::ConsumeAfter option, if it exists... 861dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman if (!PosOpts.empty() && PosOpts[0]->getNumOccurrencesFlag() == ConsumeAfter) 862331de23705a719514e37c211f327379688f81b0dChris Lattner CAOpt = PosOpts[0]; 863331de23705a719514e37c211f327379688f81b0dChris Lattner 8649cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner for (unsigned i = CAOpt != 0, e = PosOpts.size(); i != e; ++i) { 8659cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (PosOpts[i]->ArgStr[0]) 8669cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner std::cerr << " --" << PosOpts[i]->ArgStr; 867ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << " " << PosOpts[i]->HelpStr; 8689cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner } 869331de23705a719514e37c211f327379688f81b0dChris Lattner 870331de23705a719514e37c211f327379688f81b0dChris Lattner // Print the consume after option info if it exists... 871ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner if (CAOpt) std::cerr << " " << CAOpt->HelpStr; 872331de23705a719514e37c211f327379688f81b0dChris Lattner 873ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << "\n\n"; 874dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 875dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Compute the maximum argument length... 876dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner MaxArgLen = 0; 877331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = Options.size(); i != e; ++i) 878331de23705a719514e37c211f327379688f81b0dChris Lattner MaxArgLen = std::max(MaxArgLen, Options[i].second->getOptionWidth()); 879dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 880ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << "OPTIONS:\n"; 881331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = Options.size(); i != e; ++i) 882331de23705a719514e37c211f327379688f81b0dChris Lattner Options[i].second->printOptionInfo(MaxArgLen); 883dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 884331de23705a719514e37c211f327379688f81b0dChris Lattner // Halt the program if help information is printed 885331de23705a719514e37c211f327379688f81b0dChris Lattner exit(1); 886dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 887331de23705a719514e37c211f327379688f81b0dChris Lattner}; 888dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 889dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 890dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 891331de23705a719514e37c211f327379688f81b0dChris Lattner// Define the two HelpPrinter instances that are used to print out help, or 892331de23705a719514e37c211f327379688f81b0dChris Lattner// help-hidden... 893331de23705a719514e37c211f327379688f81b0dChris Lattner// 894331de23705a719514e37c211f327379688f81b0dChris LattnerHelpPrinter NormalPrinter(false); 895331de23705a719514e37c211f327379688f81b0dChris LattnerHelpPrinter HiddenPrinter(true); 896331de23705a719514e37c211f327379688f81b0dChris Lattner 897331de23705a719514e37c211f327379688f81b0dChris Lattnercl::opt<HelpPrinter, true, parser<bool> > 898331de23705a719514e37c211f327379688f81b0dChris LattnerHOp("help", cl::desc("display available options (--help-hidden for more)"), 8999b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner cl::location(NormalPrinter), cl::ValueDisallowed); 900dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 901331de23705a719514e37c211f327379688f81b0dChris Lattnercl::opt<HelpPrinter, true, parser<bool> > 902331de23705a719514e37c211f327379688f81b0dChris LattnerHHOp("help-hidden", cl::desc("display all available options"), 9039b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner cl::location(HiddenPrinter), cl::Hidden, cl::ValueDisallowed); 904dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 905dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} // End anonymous namespace 906