CommandLine.cpp revision 21e1a79a31fe45fcd861d64118a60c1fcfad618a
1dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner//===-- CommandLine.cpp - Command line parser implementation --------------===// 2f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman// 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. 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" 20551ccae044b0ff658fe629dd67edd5ffe75d10e8Reid Spencer#include "llvm/Support/CommandLine.h" 21dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner#include <algorithm> 22dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner#include <map> 23dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner#include <set> 24697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner#include <iostream> 252d6a2360036cf511af0a06f9720e6a1752779d1cBrian Gaeke#include <cstdlib> 262d6a2360036cf511af0a06f9720e6a1752779d1cBrian Gaeke#include <cerrno> 275114004110d771e2cc838be569207784f2519010Chris Lattner#include <cstring> 282cdd21c2e4d855500dfb53f77aa74da53ccf9de6Chris Lattnerusing namespace llvm; 29d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke 30dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattnerusing namespace cl; 31dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 32e1cc150a8e6b451e42b04b04ffb41596e01bbef5Reid Spencer// Globals for name and overview of program 33e1cc150a8e6b451e42b04b04ffb41596e01bbef5Reid Spencerstatic const char *ProgramName = "<unknown>"; 34e1cc150a8e6b451e42b04b04ffb41596e01bbef5Reid Spencerstatic const char *ProgramOverview = 0; 35e1cc150a8e6b451e42b04b04ffb41596e01bbef5Reid Spencer 36c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner// This collects additional help to be printed. 37c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattnerstatic std::vector<const char*> &MoreHelp() { 38c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner static std::vector<const char*> moreHelp; 39c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner return moreHelp; 40c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner} 41c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner 42c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattnerextrahelp::extrahelp(const char* Help) 43c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner : morehelp(Help) { 44c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner MoreHelp().push_back(Help); 45c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner} 46c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner 47331de23705a719514e37c211f327379688f81b0dChris Lattner//===----------------------------------------------------------------------===// 48331de23705a719514e37c211f327379688f81b0dChris Lattner// Basic, shared command line option processing machinery... 49331de23705a719514e37c211f327379688f81b0dChris Lattner// 50331de23705a719514e37c211f327379688f81b0dChris Lattner 51dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// Return the global command line option vector. Making it a function scoped 52f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner// static ensures that it will be initialized correctly before its first use. 53dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 54ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattnerstatic std::map<std::string, Option*> &getOpts() { 55c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner static std::map<std::string, Option*> CommandLineOptions; 56c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner return CommandLineOptions; 57e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner} 58e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner 59ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattnerstatic Option *getOption(const std::string &Str) { 60c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner std::map<std::string,Option*>::iterator I = getOpts().find(Str); 61c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner return I != getOpts().end() ? I->second : 0; 62dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 63dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 64ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattnerstatic std::vector<Option*> &getPositionalOpts() { 65c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner static std::vector<Option*> Positional; 66c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner return Positional; 67331de23705a719514e37c211f327379688f81b0dChris Lattner} 68331de23705a719514e37c211f327379688f81b0dChris Lattner 69e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattnerstatic void AddArgument(const char *ArgName, Option *Opt) { 70e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner if (getOption(ArgName)) { 71f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman std::cerr << ProgramName << ": CommandLine Error: Argument '" 72e1cc150a8e6b451e42b04b04ffb41596e01bbef5Reid Spencer << ArgName << "' defined more than once!\n"; 73dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } else { 74f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner // Add argument to the argument map! 75e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner getOpts()[ArgName] = Opt; 76e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner } 77e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner} 78e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner 79e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner// RemoveArgument - It's possible that the argument is no longer in the map if 80e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner// options have already been processed and the map has been deleted! 81f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman// 82e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattnerstatic void RemoveArgument(const char *ArgName, Option *Opt) { 83c4ae8e903c6abd7e391e8a16f8e850073342ca4dTanya Lattner if(getOpts().empty()) return; 84c4ae8e903c6abd7e391e8a16f8e850073342ca4dTanya Lattner 85f98cfc716d1916e3400d8980c972f75fe47b9061Chris Lattner#ifndef NDEBUG 86f98cfc716d1916e3400d8980c972f75fe47b9061Chris Lattner // This disgusting HACK is brought to you courtesy of GCC 3.3.2, which ICE's 87f98cfc716d1916e3400d8980c972f75fe47b9061Chris Lattner // If we pass ArgName directly into getOption here. 88f98cfc716d1916e3400d8980c972f75fe47b9061Chris Lattner std::string Tmp = ArgName; 89f98cfc716d1916e3400d8980c972f75fe47b9061Chris Lattner assert(getOption(Tmp) == Opt && "Arg not in map!"); 90f98cfc716d1916e3400d8980c972f75fe47b9061Chris Lattner#endif 91c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner getOpts().erase(ArgName); 92dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 93dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 94caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattnerstatic inline bool ProvideOption(Option *Handler, const char *ArgName, 95caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner const char *Value, int argc, char **argv, 96caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner int &i) { 97caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner // Enforce value requirements 98caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner switch (Handler->getValueExpectedFlag()) { 99caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner case ValueRequired: 1006d5857e139df71410e98ccf6cd0e783f90a9fc16Chris Lattner if (Value == 0) { // No value specified? 101caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner if (i+1 < argc) { // Steal the next argument, like for '-o filename' 102caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner Value = argv[++i]; 103caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner } else { 104caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner return Handler->error(" requires a value!"); 105caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner } 106caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner } 107caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner break; 108caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner case ValueDisallowed: 1096d5857e139df71410e98ccf6cd0e783f90a9fc16Chris Lattner if (Value) 110f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman return Handler->error(" does not allow a value! '" + 111ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::string(Value) + "' specified."); 112caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner break; 113f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman case ValueOptional: 114e1cc150a8e6b451e42b04b04ffb41596e01bbef5Reid Spencer break; 115f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman default: 116f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman std::cerr << ProgramName 117f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman << ": Bad ValueMask flag! CommandLine usage error:" 118f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman << Handler->getValueExpectedFlag() << "\n"; 119e1cc150a8e6b451e42b04b04ffb41596e01bbef5Reid Spencer abort(); 120e1cc150a8e6b451e42b04b04ffb41596e01bbef5Reid Spencer break; 121caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner } 122caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner 123caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner // Run the handler now! 1246d5857e139df71410e98ccf6cd0e783f90a9fc16Chris Lattner return Handler->addOccurrence(i, ArgName, Value ? Value : ""); 125caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner} 126caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner 127f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukmanstatic bool ProvidePositionalOption(Option *Handler, const std::string &Arg, 1281e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer int i) { 1291e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer int Dummy = i; 1309cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner return ProvideOption(Handler, Handler->ArgStr, Arg.c_str(), 0, 0, Dummy); 131331de23705a719514e37c211f327379688f81b0dChris Lattner} 132331de23705a719514e37c211f327379688f81b0dChris Lattner 133331de23705a719514e37c211f327379688f81b0dChris Lattner 134331de23705a719514e37c211f327379688f81b0dChris Lattner// Option predicates... 135331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic inline bool isGrouping(const Option *O) { 136331de23705a719514e37c211f327379688f81b0dChris Lattner return O->getFormattingFlag() == cl::Grouping; 137331de23705a719514e37c211f327379688f81b0dChris Lattner} 138331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic inline bool isPrefixedOrGrouping(const Option *O) { 139331de23705a719514e37c211f327379688f81b0dChris Lattner return isGrouping(O) || O->getFormattingFlag() == cl::Prefix; 140331de23705a719514e37c211f327379688f81b0dChris Lattner} 141331de23705a719514e37c211f327379688f81b0dChris Lattner 142331de23705a719514e37c211f327379688f81b0dChris Lattner// getOptionPred - Check to see if there are any options that satisfy the 143331de23705a719514e37c211f327379688f81b0dChris Lattner// specified predicate with names that are the prefixes in Name. This is 144331de23705a719514e37c211f327379688f81b0dChris Lattner// checked by progressively stripping characters off of the name, checking to 145331de23705a719514e37c211f327379688f81b0dChris Lattner// see if there options that satisfy the predicate. If we find one, return it, 146331de23705a719514e37c211f327379688f81b0dChris Lattner// otherwise return null. 147f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner// 148331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic Option *getOptionPred(std::string Name, unsigned &Length, 149331de23705a719514e37c211f327379688f81b0dChris Lattner bool (*Pred)(const Option*)) { 150f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 151e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner Option *Op = getOption(Name); 152e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner if (Op && Pred(Op)) { 153331de23705a719514e37c211f327379688f81b0dChris Lattner Length = Name.length(); 154e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner return Op; 155331de23705a719514e37c211f327379688f81b0dChris Lattner } 156f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner 157331de23705a719514e37c211f327379688f81b0dChris Lattner if (Name.size() == 1) return 0; 158331de23705a719514e37c211f327379688f81b0dChris Lattner do { 159331de23705a719514e37c211f327379688f81b0dChris Lattner Name.erase(Name.end()-1, Name.end()); // Chop off the last character... 160e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner Op = getOption(Name); 161331de23705a719514e37c211f327379688f81b0dChris Lattner 162331de23705a719514e37c211f327379688f81b0dChris Lattner // Loop while we haven't found an option and Name still has at least two 163331de23705a719514e37c211f327379688f81b0dChris Lattner // characters in it (so that the next iteration will not be the empty 164331de23705a719514e37c211f327379688f81b0dChris Lattner // string... 165e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner } while ((Op == 0 || !Pred(Op)) && Name.size() > 1); 166331de23705a719514e37c211f327379688f81b0dChris Lattner 167e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner if (Op && Pred(Op)) { 168331de23705a719514e37c211f327379688f81b0dChris Lattner Length = Name.length(); 169e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner return Op; // Found one! 170f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner } 171331de23705a719514e37c211f327379688f81b0dChris Lattner return 0; // No option found! 172331de23705a719514e37c211f327379688f81b0dChris Lattner} 173f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner 174331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic bool RequiresValue(const Option *O) { 175dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman return O->getNumOccurrencesFlag() == cl::Required || 176dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman O->getNumOccurrencesFlag() == cl::OneOrMore; 177331de23705a719514e37c211f327379688f81b0dChris Lattner} 178331de23705a719514e37c211f327379688f81b0dChris Lattner 179331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic bool EatsUnboundedNumberOfValues(const Option *O) { 180dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman return O->getNumOccurrencesFlag() == cl::ZeroOrMore || 181dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman O->getNumOccurrencesFlag() == cl::OneOrMore; 182f78032fe064bdd2b9a19b875261747b7d0a27a73Chris Lattner} 183caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner 184c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke/// ParseCStringVector - Break INPUT up wherever one or more 185c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke/// whitespace characters are found, and store the resulting tokens in 186c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke/// OUTPUT. The tokens stored in OUTPUT are dynamically allocated 187c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke/// using strdup (), so it is the caller's responsibility to free () 188c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke/// them later. 18906b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// 190c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaekestatic void ParseCStringVector (std::vector<char *> &output, 19169105f33c190621a6b1ad61f925b1a9e6b0512afReid Spencer const char *input) { 192c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Characters which will be treated as token separators: 193c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke static const char *delims = " \v\f\t\r\n"; 194c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke 19506b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke std::string work (input); 196c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Skip past any delims at head of input string. 197c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke size_t pos = work.find_first_not_of (delims); 198c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // If the string consists entirely of delims, then exit early. 199c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke if (pos == std::string::npos) return; 200c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Otherwise, jump forward to beginning of first word. 20106b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke work = work.substr (pos); 202c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Find position of first delimiter. 20306b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke pos = work.find_first_of (delims); 204c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke 205c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke while (!work.empty() && pos != std::string::npos) { 206c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Everything from 0 to POS is the next word to copy. 207c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke output.push_back (strdup (work.substr (0,pos).c_str ())); 208c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Is there another word in the string? 209c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke size_t nextpos = work.find_first_not_of (delims, pos + 1); 210c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke if (nextpos != std::string::npos) { 211c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Yes? Then remove delims from beginning ... 21206b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke work = work.substr (work.find_first_not_of (delims, pos + 1)); 213c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // and find the end of the word. 21406b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke pos = work.find_first_of (delims); 21506b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke } else { 216c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // No? (Remainder of string is delims.) End the loop. 21706b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke work = ""; 218c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke pos = std::string::npos; 21906b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke } 22006b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke } 22106b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke 222c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // If `input' ended with non-delim char, then we'll get here with 223c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // the last word of `input' in `work'; copy it now. 224c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke if (!work.empty ()) { 225c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke output.push_back (strdup (work.c_str ())); 22606b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke } 22706b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke} 22806b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke 22906b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// ParseEnvironmentOptions - An alternative entry point to the 23006b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// CommandLine library, which allows you to read the program's name 23106b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// from the caller (as PROGNAME) and its command-line arguments from 23206b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// an environment variable (whose name is given in ENVVAR). 23306b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke/// 234bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattnervoid cl::ParseEnvironmentOptions(const char *progName, const char *envVar, 235bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner const char *Overview) { 236c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Check args. 237bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner assert(progName && "Program name not specified"); 238bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner assert(envVar && "Environment variable name missing"); 239f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 24006b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke // Get the environment variable they want us to parse options out of. 241c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke const char *envValue = getenv (envVar); 242c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke if (!envValue) 24306b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke return; 244c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke 245c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Get program's "name", which we wouldn't know without the caller 246c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // telling us. 247c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke std::vector<char *> newArgv; 248c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke newArgv.push_back (strdup (progName)); 24906b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke 25006b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke // Parse the value of the environment variable into a "command line" 25106b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke // and hand it off to ParseCommandLineOptions(). 252c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke ParseCStringVector (newArgv, envValue); 253c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke int newArgc = newArgv.size (); 254c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke ParseCommandLineOptions (newArgc, &newArgv[0], Overview); 255c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke 256c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke // Free all the strdup()ed strings. 257c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke for (std::vector<char *>::iterator i = newArgv.begin (), e = newArgv.end (); 258c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke i != e; ++i) { 259c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke free (*i); 260c48ef2ae36e2169872a828a5399ccd1993837915Brian Gaeke } 26106b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke} 26206b06c5f00acffdab8c59e3dc5baca3eacca172aBrian Gaeke 263bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner/// LookupOption - Lookup the option specified by the specified option on the 264bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner/// command line. If there is a value specified (after an equal sign) return 265bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner/// that as well. 266bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattnerstatic Option *LookupOption(const char *&Arg, const char *&Value) { 267bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner while (*Arg == '-') ++Arg; // Eat leading dashes 268f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 269bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner const char *ArgEnd = Arg; 270bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner while (*ArgEnd && *ArgEnd != '=') 2716d5857e139df71410e98ccf6cd0e783f90a9fc16Chris Lattner ++ArgEnd; // Scan till end of argument name. 2726d5857e139df71410e98ccf6cd0e783f90a9fc16Chris Lattner 2736d5857e139df71410e98ccf6cd0e783f90a9fc16Chris Lattner if (*ArgEnd == '=') // If we have an equals sign... 2746d5857e139df71410e98ccf6cd0e783f90a9fc16Chris Lattner Value = ArgEnd+1; // Get the value, not the equals 275bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner 276f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 277bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner if (*Arg == 0) return 0; 278bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner 279bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner // Look up the option. 280bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner std::map<std::string, Option*> &Opts = getOpts(); 281bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner std::map<std::string, Option*>::iterator I = 282bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner Opts.find(std::string(Arg, ArgEnd)); 283bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner return (I != Opts.end()) ? I->second : 0; 284bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner} 285bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner 286dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattnervoid cl::ParseCommandLineOptions(int &argc, char **argv, 2870c0edf8afc35a42b15a24ebb5fa5f3fc674290aeChris Lattner const char *Overview) { 288331de23705a719514e37c211f327379688f81b0dChris Lattner assert((!getOpts().empty() || !getPositionalOpts().empty()) && 289331de23705a719514e37c211f327379688f81b0dChris Lattner "No options specified, or ParseCommandLineOptions called more" 290331de23705a719514e37c211f327379688f81b0dChris Lattner " than once!"); 291dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner ProgramName = argv[0]; // Save this away safe and snug 292dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner ProgramOverview = Overview; 293dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner bool ErrorParsing = false; 294dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 295ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::map<std::string, Option*> &Opts = getOpts(); 296ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::vector<Option*> &PositionalOpts = getPositionalOpts(); 297331de23705a719514e37c211f327379688f81b0dChris Lattner 298331de23705a719514e37c211f327379688f81b0dChris Lattner // Check out the positional arguments to collect information about them. 299331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned NumPositionalRequired = 0; 300de0132453e2939488c2d69290bfdfb2cde94a0afChris Lattner 301de0132453e2939488c2d69290bfdfb2cde94a0afChris Lattner // Determine whether or not there are an unlimited number of positionals 302de0132453e2939488c2d69290bfdfb2cde94a0afChris Lattner bool HasUnlimitedPositionals = false; 303de0132453e2939488c2d69290bfdfb2cde94a0afChris Lattner 304331de23705a719514e37c211f327379688f81b0dChris Lattner Option *ConsumeAfterOpt = 0; 305331de23705a719514e37c211f327379688f81b0dChris Lattner if (!PositionalOpts.empty()) { 306dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman if (PositionalOpts[0]->getNumOccurrencesFlag() == cl::ConsumeAfter) { 307331de23705a719514e37c211f327379688f81b0dChris Lattner assert(PositionalOpts.size() > 1 && 308331de23705a719514e37c211f327379688f81b0dChris Lattner "Cannot specify cl::ConsumeAfter without a positional argument!"); 309331de23705a719514e37c211f327379688f81b0dChris Lattner ConsumeAfterOpt = PositionalOpts[0]; 310331de23705a719514e37c211f327379688f81b0dChris Lattner } 311331de23705a719514e37c211f327379688f81b0dChris Lattner 312331de23705a719514e37c211f327379688f81b0dChris Lattner // Calculate how many positional values are _required_. 313331de23705a719514e37c211f327379688f81b0dChris Lattner bool UnboundedFound = false; 314331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = ConsumeAfterOpt != 0, e = PositionalOpts.size(); 315331de23705a719514e37c211f327379688f81b0dChris Lattner i != e; ++i) { 316331de23705a719514e37c211f327379688f81b0dChris Lattner Option *Opt = PositionalOpts[i]; 317331de23705a719514e37c211f327379688f81b0dChris Lattner if (RequiresValue(Opt)) 318331de23705a719514e37c211f327379688f81b0dChris Lattner ++NumPositionalRequired; 319331de23705a719514e37c211f327379688f81b0dChris Lattner else if (ConsumeAfterOpt) { 320331de23705a719514e37c211f327379688f81b0dChris Lattner // ConsumeAfter cannot be combined with "optional" positional options 32154ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner // unless there is only one positional argument... 32254ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner if (PositionalOpts.size() > 2) 32354ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner ErrorParsing |= 32454ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner Opt->error(" error - this positional option will never be matched, " 32554ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner "because it does not Require a value, and a " 32654ec7aed89e4a5d8cc11c36999d88012cbfcc18aChris Lattner "cl::ConsumeAfter option is active!"); 3279cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner } else if (UnboundedFound && !Opt->ArgStr[0]) { 3289cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // This option does not "require" a value... Make sure this option is 3299cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // not specified after an option that eats all extra arguments, or this 3309cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // one will never get any! 331331de23705a719514e37c211f327379688f81b0dChris Lattner // 332331de23705a719514e37c211f327379688f81b0dChris Lattner ErrorParsing |= Opt->error(" error - option can never match, because " 333331de23705a719514e37c211f327379688f81b0dChris Lattner "another positional argument will match an " 334331de23705a719514e37c211f327379688f81b0dChris Lattner "unbounded number of values, and this option" 335331de23705a719514e37c211f327379688f81b0dChris Lattner " does not require a value!"); 336331de23705a719514e37c211f327379688f81b0dChris Lattner } 337331de23705a719514e37c211f327379688f81b0dChris Lattner UnboundedFound |= EatsUnboundedNumberOfValues(Opt); 338331de23705a719514e37c211f327379688f81b0dChris Lattner } 33921e1a79a31fe45fcd861d64118a60c1fcfad618aChris Lattner HasUnlimitedPositionals = UnboundedFound || ConsumeAfterOpt; 340331de23705a719514e37c211f327379688f81b0dChris Lattner } 341331de23705a719514e37c211f327379688f81b0dChris Lattner 3421e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer // PositionalVals - A vector of "positional" arguments we accumulate into 3431e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer // the process at the end... 344331de23705a719514e37c211f327379688f81b0dChris Lattner // 3451e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer std::vector<std::pair<std::string,unsigned> > PositionalVals; 346331de23705a719514e37c211f327379688f81b0dChris Lattner 3479cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // If the program has named positional arguments, and the name has been run 3489cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // across, keep track of which positional argument was named. Otherwise put 3499cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // the positional args into the PositionalVals list... 3509cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner Option *ActivePositionalArg = 0; 3519cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner 352dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Loop over all of the arguments... processing them. 353331de23705a719514e37c211f327379688f81b0dChris Lattner bool DashDashFound = false; // Have we read '--'? 354dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner for (int i = 1; i < argc; ++i) { 355dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner Option *Handler = 0; 3566d5857e139df71410e98ccf6cd0e783f90a9fc16Chris Lattner const char *Value = 0; 357dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner const char *ArgName = ""; 358331de23705a719514e37c211f327379688f81b0dChris Lattner 359331de23705a719514e37c211f327379688f81b0dChris Lattner // Check to see if this is a positional argument. This argument is 360331de23705a719514e37c211f327379688f81b0dChris Lattner // considered to be positional if it doesn't start with '-', if it is "-" 3611115e0483fc6da16d52382f159005baddf028063Misha Brukman // itself, or if we have seen "--" already. 362331de23705a719514e37c211f327379688f81b0dChris Lattner // 363331de23705a719514e37c211f327379688f81b0dChris Lattner if (argv[i][0] != '-' || argv[i][1] == 0 || DashDashFound) { 364331de23705a719514e37c211f327379688f81b0dChris Lattner // Positional argument! 3659cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (ActivePositionalArg) { 3661e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ProvidePositionalOption(ActivePositionalArg, argv[i], i); 3679cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner continue; // We are done! 3689cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner } else if (!PositionalOpts.empty()) { 3691e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals.push_back(std::make_pair(argv[i],i)); 370331de23705a719514e37c211f327379688f81b0dChris Lattner 371331de23705a719514e37c211f327379688f81b0dChris Lattner // All of the positional arguments have been fulfulled, give the rest to 372331de23705a719514e37c211f327379688f81b0dChris Lattner // the consume after option... if it's specified... 373331de23705a719514e37c211f327379688f81b0dChris Lattner // 374f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman if (PositionalVals.size() >= NumPositionalRequired && 375331de23705a719514e37c211f327379688f81b0dChris Lattner ConsumeAfterOpt != 0) { 376331de23705a719514e37c211f327379688f81b0dChris Lattner for (++i; i < argc; ++i) 3771e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals.push_back(std::make_pair(argv[i],i)); 378331de23705a719514e37c211f327379688f81b0dChris Lattner break; // Handle outside of the argument processing loop... 379331de23705a719514e37c211f327379688f81b0dChris Lattner } 380331de23705a719514e37c211f327379688f81b0dChris Lattner 381331de23705a719514e37c211f327379688f81b0dChris Lattner // Delay processing positional arguments until the end... 382331de23705a719514e37c211f327379688f81b0dChris Lattner continue; 383331de23705a719514e37c211f327379688f81b0dChris Lattner } 384bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner } else if (argv[i][0] == '-' && argv[i][1] == '-' && argv[i][2] == 0 && 385bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner !DashDashFound) { 386bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner DashDashFound = true; // This is the mythical "--"? 387bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner continue; // Don't try to process it as an argument itself. 388bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner } else if (ActivePositionalArg && 389bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner (ActivePositionalArg->getMiscFlags() & PositionalEatsArgs)) { 390bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner // If there is a positional argument eating options, check to see if this 391bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner // option is another positional argument. If so, treat it as an argument, 392bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner // otherwise feed it to the eating positional. 393dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner ArgName = argv[i]+1; 394bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner Handler = LookupOption(ArgName, Value); 395bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner if (!Handler || Handler->getFormattingFlag() != cl::Positional) { 3961e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ProvidePositionalOption(ActivePositionalArg, argv[i], i); 397bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner continue; // We are done! 398331de23705a719514e37c211f327379688f81b0dChris Lattner } 399331de23705a719514e37c211f327379688f81b0dChris Lattner 400bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner } else { // We start with a '-', must be an argument... 401bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner ArgName = argv[i]+1; 402bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner Handler = LookupOption(ArgName, Value); 403331de23705a719514e37c211f327379688f81b0dChris Lattner 404bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner // Check to see if this "option" is really a prefixed or grouped argument. 4055f8448f79c2876466d586f2e1caec89e6f070623Reid Spencer if (Handler == 0) { 406bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner std::string RealName(ArgName); 407bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner if (RealName.size() > 1) { 408331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned Length = 0; 409331de23705a719514e37c211f327379688f81b0dChris Lattner Option *PGOpt = getOptionPred(RealName, Length, isPrefixedOrGrouping); 410f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 411331de23705a719514e37c211f327379688f81b0dChris Lattner // If the option is a prefixed option, then the value is simply the 412331de23705a719514e37c211f327379688f81b0dChris Lattner // rest of the name... so fall through to later processing, by 413331de23705a719514e37c211f327379688f81b0dChris Lattner // setting up the argument name flags and value fields. 414331de23705a719514e37c211f327379688f81b0dChris Lattner // 415331de23705a719514e37c211f327379688f81b0dChris Lattner if (PGOpt && PGOpt->getFormattingFlag() == cl::Prefix) { 416bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner Value = ArgName+Length; 417bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner assert(Opts.find(std::string(ArgName, Value)) != Opts.end() && 418bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner Opts.find(std::string(ArgName, Value))->second == PGOpt); 419bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner Handler = PGOpt; 420331de23705a719514e37c211f327379688f81b0dChris Lattner } else if (PGOpt) { 421bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner // This must be a grouped option... handle them now. 422331de23705a719514e37c211f327379688f81b0dChris Lattner assert(isGrouping(PGOpt) && "Broken getOptionPred!"); 423f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 424331de23705a719514e37c211f327379688f81b0dChris Lattner do { 425331de23705a719514e37c211f327379688f81b0dChris Lattner // Move current arg name out of RealName into RealArgName... 426bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner std::string RealArgName(RealName.begin(), 427bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner RealName.begin() + Length); 428bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner RealName.erase(RealName.begin(), RealName.begin() + Length); 429f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 430b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman // Because ValueRequired is an invalid flag for grouped arguments, 431b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman // we don't need to pass argc/argv in... 432b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman // 433331de23705a719514e37c211f327379688f81b0dChris Lattner assert(PGOpt->getValueExpectedFlag() != cl::ValueRequired && 434331de23705a719514e37c211f327379688f81b0dChris Lattner "Option can not be cl::Grouping AND cl::ValueRequired!"); 435331de23705a719514e37c211f327379688f81b0dChris Lattner int Dummy; 436bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner ErrorParsing |= ProvideOption(PGOpt, RealArgName.c_str(), 4376d5857e139df71410e98ccf6cd0e783f90a9fc16Chris Lattner 0, 0, 0, Dummy); 438f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 439331de23705a719514e37c211f327379688f81b0dChris Lattner // Get the next grouping option... 440bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner PGOpt = getOptionPred(RealName, Length, isGrouping); 441bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner } while (PGOpt && Length != RealName.size()); 442f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 443bf455c236001d5424dbda50fd145352f87f11ec1Chris Lattner Handler = PGOpt; // Ate all of the options. 444331de23705a719514e37c211f327379688f81b0dChris Lattner } 445b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman } 446dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 447dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 448dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 449dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner if (Handler == 0) { 450e1cc150a8e6b451e42b04b04ffb41596e01bbef5Reid Spencer std::cerr << ProgramName << ": Unknown command line argument '" << argv[i] 451e1cc150a8e6b451e42b04b04ffb41596e01bbef5Reid Spencer << "'. Try: '" << argv[0] << " --help'\n"; 452dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner ErrorParsing = true; 453dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner continue; 454dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 455dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 45672fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner // Check to see if this option accepts a comma separated list of values. If 45772fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner // it does, we have to split up the value into multiple values... 4586d5857e139df71410e98ccf6cd0e783f90a9fc16Chris Lattner if (Value && Handler->getMiscFlags() & CommaSeparated) { 45972fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner std::string Val(Value); 46072fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner std::string::size_type Pos = Val.find(','); 46172fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner 46272fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner while (Pos != std::string::npos) { 46372fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner // Process the portion before the comma... 46472fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner ErrorParsing |= ProvideOption(Handler, ArgName, 46572fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner std::string(Val.begin(), 46672fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner Val.begin()+Pos).c_str(), 46772fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner argc, argv, i); 46872fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner // Erase the portion before the comma, AND the comma... 46972fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner Val.erase(Val.begin(), Val.begin()+Pos+1); 47072fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner Value += Pos+1; // Increment the original value pointer as well... 47172fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner 47272fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner // Check for another comma... 47372fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner Pos = Val.find(','); 47472fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner } 47572fb8e50820f6fcccae3a63935653ccd7b9ecf84Chris Lattner } 4769cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner 4779cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // If this is a named positional argument, just remember that it is the 4789cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner // active one... 4799cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (Handler->getFormattingFlag() == cl::Positional) 4809cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner ActivePositionalArg = Handler; 481f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman else 4829cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner ErrorParsing |= ProvideOption(Handler, ArgName, Value, argc, argv, i); 483331de23705a719514e37c211f327379688f81b0dChris Lattner } 484dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 485331de23705a719514e37c211f327379688f81b0dChris Lattner // Check and handle positional arguments now... 486331de23705a719514e37c211f327379688f81b0dChris Lattner if (NumPositionalRequired > PositionalVals.size()) { 487f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman std::cerr << ProgramName 488e1cc150a8e6b451e42b04b04ffb41596e01bbef5Reid Spencer << ": Not enough positional command line arguments specified!\n" 489ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner << "Must specify at least " << NumPositionalRequired 490ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner << " positional arguments: See: " << argv[0] << " --help\n"; 491331de23705a719514e37c211f327379688f81b0dChris Lattner ErrorParsing = true; 492de0132453e2939488c2d69290bfdfb2cde94a0afChris Lattner } else if (!HasUnlimitedPositionals 493de0132453e2939488c2d69290bfdfb2cde94a0afChris Lattner && PositionalVals.size() > PositionalOpts.size()) { 494de0132453e2939488c2d69290bfdfb2cde94a0afChris Lattner std::cerr << ProgramName 495de0132453e2939488c2d69290bfdfb2cde94a0afChris Lattner << ": Too many positional arguments specified!\n" 496de0132453e2939488c2d69290bfdfb2cde94a0afChris Lattner << "Can specify at most " << PositionalOpts.size() 497de0132453e2939488c2d69290bfdfb2cde94a0afChris Lattner << " positional arguments: See: " << argv[0] << " --help\n"; 498de0132453e2939488c2d69290bfdfb2cde94a0afChris Lattner ErrorParsing = true; 499331de23705a719514e37c211f327379688f81b0dChris Lattner 500331de23705a719514e37c211f327379688f81b0dChris Lattner } else if (ConsumeAfterOpt == 0) { 501331de23705a719514e37c211f327379688f81b0dChris Lattner // Positional args have already been handled if ConsumeAfter is specified... 502331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned ValNo = 0, NumVals = PositionalVals.size(); 503331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = PositionalOpts.size(); i != e; ++i) { 504331de23705a719514e37c211f327379688f81b0dChris Lattner if (RequiresValue(PositionalOpts[i])) { 505f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman ProvidePositionalOption(PositionalOpts[i], PositionalVals[ValNo].first, 5061e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].second); 5071e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ValNo++; 508331de23705a719514e37c211f327379688f81b0dChris Lattner --NumPositionalRequired; // We fulfilled our duty... 509331de23705a719514e37c211f327379688f81b0dChris Lattner } 510331de23705a719514e37c211f327379688f81b0dChris Lattner 511331de23705a719514e37c211f327379688f81b0dChris Lattner // If we _can_ give this option more arguments, do so now, as long as we 512331de23705a719514e37c211f327379688f81b0dChris Lattner // do not give it values that others need. 'Done' controls whether the 513331de23705a719514e37c211f327379688f81b0dChris Lattner // option even _WANTS_ any more. 514331de23705a719514e37c211f327379688f81b0dChris Lattner // 515dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman bool Done = PositionalOpts[i]->getNumOccurrencesFlag() == cl::Required; 516331de23705a719514e37c211f327379688f81b0dChris Lattner while (NumVals-ValNo > NumPositionalRequired && !Done) { 517dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman switch (PositionalOpts[i]->getNumOccurrencesFlag()) { 518331de23705a719514e37c211f327379688f81b0dChris Lattner case cl::Optional: 519331de23705a719514e37c211f327379688f81b0dChris Lattner Done = true; // Optional arguments want _at most_ one value 520331de23705a719514e37c211f327379688f81b0dChris Lattner // FALL THROUGH 521331de23705a719514e37c211f327379688f81b0dChris Lattner case cl::ZeroOrMore: // Zero or more will take all they can get... 522331de23705a719514e37c211f327379688f81b0dChris Lattner case cl::OneOrMore: // One or more will take all they can get... 5231e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ProvidePositionalOption(PositionalOpts[i], 5241e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].first, 5251e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].second); 5261e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ValNo++; 527331de23705a719514e37c211f327379688f81b0dChris Lattner break; 528331de23705a719514e37c211f327379688f81b0dChris Lattner default: 529dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman assert(0 && "Internal error, unexpected NumOccurrences flag in " 530331de23705a719514e37c211f327379688f81b0dChris Lattner "positional argument processing!"); 531331de23705a719514e37c211f327379688f81b0dChris Lattner } 532331de23705a719514e37c211f327379688f81b0dChris Lattner } 533caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner } 534331de23705a719514e37c211f327379688f81b0dChris Lattner } else { 535331de23705a719514e37c211f327379688f81b0dChris Lattner assert(ConsumeAfterOpt && NumPositionalRequired <= PositionalVals.size()); 536331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned ValNo = 0; 537331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned j = 1, e = PositionalOpts.size(); j != e; ++j) 5381e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer if (RequiresValue(PositionalOpts[j])) { 539faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner ErrorParsing |= ProvidePositionalOption(PositionalOpts[j], 5401e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].first, 5411e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].second); 5421e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ValNo++; 5431e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer } 544faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner 545faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // Handle the case where there is just one positional option, and it's 546faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // optional. In this case, we want to give JUST THE FIRST option to the 547faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // positional option and keep the rest for the consume after. The above 548faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // loop would have assigned no values to positional options in this case. 549faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner // 5501e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer if (PositionalOpts.size() == 2 && ValNo == 0 && !PositionalVals.empty()) { 551faba809472e36fbb28394da6ed907d2652ca8b83Chris Lattner ErrorParsing |= ProvidePositionalOption(PositionalOpts[1], 5521e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].first, 5531e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].second); 5541e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer ValNo++; 5551e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer } 556f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 557331de23705a719514e37c211f327379688f81b0dChris Lattner // Handle over all of the rest of the arguments to the 558331de23705a719514e37c211f327379688f81b0dChris Lattner // cl::ConsumeAfter command line option... 559331de23705a719514e37c211f327379688f81b0dChris Lattner for (; ValNo != PositionalVals.size(); ++ValNo) 560331de23705a719514e37c211f327379688f81b0dChris Lattner ErrorParsing |= ProvidePositionalOption(ConsumeAfterOpt, 5611e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].first, 5621e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer PositionalVals[ValNo].second); 563dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 564dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 565dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner // Loop over args and make sure all required args are specified! 566f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman for (std::map<std::string, Option*>::iterator I = Opts.begin(), 567b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman E = Opts.end(); I != E; ++I) { 568dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman switch (I->second->getNumOccurrencesFlag()) { 569dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner case Required: 570dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner case OneOrMore: 571dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman if (I->second->getNumOccurrences() == 0) { 572b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman I->second->error(" must be specified at least once!"); 573f038acbee21cfed998451aedd00a81901d299516Chris Lattner ErrorParsing = true; 574f038acbee21cfed998451aedd00a81901d299516Chris Lattner } 575dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner // Fall through 576dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner default: 577dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner break; 578dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner } 579dc4693dbcf164ec404a3a91c67cf1dbe5f45a8e5Chris Lattner } 580dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 581331de23705a719514e37c211f327379688f81b0dChris Lattner // Free all of the memory allocated to the map. Command line options may only 582331de23705a719514e37c211f327379688f81b0dChris Lattner // be processed once! 583c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner getOpts().clear(); 584331de23705a719514e37c211f327379688f81b0dChris Lattner PositionalOpts.clear(); 585c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner MoreHelp().clear(); 586dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 587dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // If we had an error processing our arguments, don't let the program execute 588dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner if (ErrorParsing) exit(1); 589dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 590dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 591dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner//===----------------------------------------------------------------------===// 592dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// Option Base class implementation 593dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 594dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 595ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattnerbool Option::error(std::string Message, const char *ArgName) { 596dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner if (ArgName == 0) ArgName = ArgStr; 597331de23705a719514e37c211f327379688f81b0dChris Lattner if (ArgName[0] == 0) 598ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << HelpStr; // Be nice for positional arguments 599331de23705a719514e37c211f327379688f81b0dChris Lattner else 600e1cc150a8e6b451e42b04b04ffb41596e01bbef5Reid Spencer std::cerr << ProgramName << ": for the -" << ArgName; 601e1cc150a8e6b451e42b04b04ffb41596e01bbef5Reid Spencer std::cerr << " option: " << Message << "\n"; 602dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return true; 603dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 604dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 6056d5857e139df71410e98ccf6cd0e783f90a9fc16Chris Lattnerbool Option::addOccurrence(unsigned pos, const char *ArgName, 6066d5857e139df71410e98ccf6cd0e783f90a9fc16Chris Lattner const std::string &Value) { 607dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman NumOccurrences++; // Increment the number of times we have been seen 608dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 609dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman switch (getNumOccurrencesFlag()) { 610dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner case Optional: 611dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman if (NumOccurrences > 1) 612dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return error(": may only occur zero or one times!", ArgName); 613dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner break; 614dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner case Required: 615dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman if (NumOccurrences > 1) 616dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return error(": must occur exactly one time!", ArgName); 617dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Fall through 618dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner case OneOrMore: 619caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner case ZeroOrMore: 620caccd761a6320d9068a44198b9e1b6c3659f8bb5Chris Lattner case ConsumeAfter: break; 621b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman default: return error(": bad num occurrences flag value!"); 622dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 623dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 6241e13fd23d34e53b63cb08c0fe54f0857757ec200Reid Spencer return handleOccurrence(pos, ArgName, Value); 625dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 626dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 627331de23705a719514e37c211f327379688f81b0dChris Lattner// addArgument - Tell the system that this Option subclass will handle all 628b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman// occurrences of -ArgStr on the command line. 629331de23705a719514e37c211f327379688f81b0dChris Lattner// 630331de23705a719514e37c211f327379688f81b0dChris Lattnervoid Option::addArgument(const char *ArgStr) { 631331de23705a719514e37c211f327379688f81b0dChris Lattner if (ArgStr[0]) 632331de23705a719514e37c211f327379688f81b0dChris Lattner AddArgument(ArgStr, this); 6339cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner 6349cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (getFormattingFlag() == Positional) 635331de23705a719514e37c211f327379688f81b0dChris Lattner getPositionalOpts().push_back(this); 636dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman else if (getNumOccurrencesFlag() == ConsumeAfter) { 6379cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (!getPositionalOpts().empty() && 6389cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner getPositionalOpts().front()->getNumOccurrencesFlag() == ConsumeAfter) 6399cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner error("Cannot specify more than one option with cl::ConsumeAfter!"); 640331de23705a719514e37c211f327379688f81b0dChris Lattner getPositionalOpts().insert(getPositionalOpts().begin(), this); 641331de23705a719514e37c211f327379688f81b0dChris Lattner } 642331de23705a719514e37c211f327379688f81b0dChris Lattner} 643331de23705a719514e37c211f327379688f81b0dChris Lattner 644aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattnervoid Option::removeArgument(const char *ArgStr) { 6459cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (ArgStr[0]) 646e8e258b1a7e54a77c802e8b309d0a60a62d1a00dChris Lattner RemoveArgument(ArgStr, this); 6479cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner 6489cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (getFormattingFlag() == Positional) { 649ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::vector<Option*>::iterator I = 650aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner std::find(getPositionalOpts().begin(), getPositionalOpts().end(), this); 651aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner assert(I != getPositionalOpts().end() && "Arg not registered!"); 652aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner getPositionalOpts().erase(I); 653dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman } else if (getNumOccurrencesFlag() == ConsumeAfter) { 654aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner assert(!getPositionalOpts().empty() && getPositionalOpts()[0] == this && 655aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner "Arg not registered correctly!"); 656aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner getPositionalOpts().erase(getPositionalOpts().begin()); 657aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner } 658aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner} 659aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner 660331de23705a719514e37c211f327379688f81b0dChris Lattner 661331de23705a719514e37c211f327379688f81b0dChris Lattner// getValueStr - Get the value description string, using "DefaultMsg" if nothing 662331de23705a719514e37c211f327379688f81b0dChris Lattner// has been specified yet. 663331de23705a719514e37c211f327379688f81b0dChris Lattner// 664331de23705a719514e37c211f327379688f81b0dChris Lattnerstatic const char *getValueStr(const Option &O, const char *DefaultMsg) { 665331de23705a719514e37c211f327379688f81b0dChris Lattner if (O.ValueStr[0] == 0) return DefaultMsg; 666331de23705a719514e37c211f327379688f81b0dChris Lattner return O.ValueStr; 667331de23705a719514e37c211f327379688f81b0dChris Lattner} 668331de23705a719514e37c211f327379688f81b0dChris Lattner 669331de23705a719514e37c211f327379688f81b0dChris Lattner//===----------------------------------------------------------------------===// 670331de23705a719514e37c211f327379688f81b0dChris Lattner// cl::alias class implementation 671331de23705a719514e37c211f327379688f81b0dChris Lattner// 672331de23705a719514e37c211f327379688f81b0dChris Lattner 673dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// Return the width of the option tag for printing... 674331de23705a719514e37c211f327379688f81b0dChris Lattnerunsigned alias::getOptionWidth() const { 675dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return std::strlen(ArgStr)+6; 676dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 677dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 678331de23705a719514e37c211f327379688f81b0dChris Lattner// Print out the option for the alias... 679331de23705a719514e37c211f327379688f81b0dChris Lattnervoid alias::printOptionInfo(unsigned GlobalWidth) const { 680dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner unsigned L = std::strlen(ArgStr); 681ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << " -" << ArgStr << std::string(GlobalWidth-L-6, ' ') << " - " 682ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner << HelpStr << "\n"; 683dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 684dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 685dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 686331de23705a719514e37c211f327379688f81b0dChris Lattner 687dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner//===----------------------------------------------------------------------===// 688331de23705a719514e37c211f327379688f81b0dChris Lattner// Parser Implementation code... 689dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 690dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 6919b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// basic_parser implementation 6929b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// 6939b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 6949b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// Return the width of the option tag for printing... 6959b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattnerunsigned basic_parser_impl::getOptionWidth(const Option &O) const { 6969b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner unsigned Len = std::strlen(O.ArgStr); 6979b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner if (const char *ValName = getValueName()) 6989b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner Len += std::strlen(getValueStr(O, ValName))+3; 6999b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 7009b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner return Len + 6; 7019b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner} 7029b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 703f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman// printOptionInfo - Print out information about this option. The 7049b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// to-be-maintained width is specified. 7059b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// 7069b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattnervoid basic_parser_impl::printOptionInfo(const Option &O, 7079b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner unsigned GlobalWidth) const { 708ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << " -" << O.ArgStr; 7099b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 7109b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner if (const char *ValName = getValueName()) 711ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << "=<" << getValueStr(O, ValName) << ">"; 7129b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 713ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << std::string(GlobalWidth-getOptionWidth(O), ' ') << " - " 714ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner << O.HelpStr << "\n"; 7159b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner} 7169b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 7179b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 7189b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 7199b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner 720331de23705a719514e37c211f327379688f81b0dChris Lattner// parser<bool> implementation 721331de23705a719514e37c211f327379688f81b0dChris Lattner// 7229b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattnerbool parser<bool>::parse(Option &O, const char *ArgName, 723ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner const std::string &Arg, bool &Value) { 724f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman if (Arg == "" || Arg == "true" || Arg == "TRUE" || Arg == "True" || 725dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner Arg == "1") { 726dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner Value = true; 727dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } else if (Arg == "false" || Arg == "FALSE" || Arg == "False" || Arg == "0") { 728dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner Value = false; 729dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } else { 730331de23705a719514e37c211f327379688f81b0dChris Lattner return O.error(": '" + Arg + 731331de23705a719514e37c211f327379688f81b0dChris Lattner "' is invalid value for boolean argument! Try 0 or 1"); 732dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 733dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return false; 734dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 735dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 736331de23705a719514e37c211f327379688f81b0dChris Lattner// parser<int> implementation 737dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 7389b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattnerbool parser<int>::parse(Option &O, const char *ArgName, 739ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner const std::string &Arg, int &Value) { 740331de23705a719514e37c211f327379688f81b0dChris Lattner char *End; 741d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner Value = (int)strtol(Arg.c_str(), &End, 0); 742f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman if (*End != 0) 743331de23705a719514e37c211f327379688f81b0dChris Lattner return O.error(": '" + Arg + "' value invalid for integer argument!"); 744331de23705a719514e37c211f327379688f81b0dChris Lattner return false; 745dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 746dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 747d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner// parser<unsigned> implementation 748d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner// 749d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattnerbool parser<unsigned>::parse(Option &O, const char *ArgName, 750d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner const std::string &Arg, unsigned &Value) { 751d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner char *End; 7522d6a2360036cf511af0a06f9720e6a1752779d1cBrian Gaeke errno = 0; 7532d6a2360036cf511af0a06f9720e6a1752779d1cBrian Gaeke unsigned long V = strtoul(Arg.c_str(), &End, 0); 754d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner Value = (unsigned)V; 7552d6a2360036cf511af0a06f9720e6a1752779d1cBrian Gaeke if (((V == ULONG_MAX) && (errno == ERANGE)) 7562d6a2360036cf511af0a06f9720e6a1752779d1cBrian Gaeke || (*End != 0) 7572d6a2360036cf511af0a06f9720e6a1752779d1cBrian Gaeke || (Value != V)) 758d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner return O.error(": '" + Arg + "' value invalid for uint argument!"); 759d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner return false; 760d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner} 761d2a6fc397ee982936dee7dd5692b1481bcd9fe8fChris Lattner 7629b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner// parser<double>/parser<float> implementation 763331de23705a719514e37c211f327379688f81b0dChris Lattner// 764ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattnerstatic bool parseDouble(Option &O, const std::string &Arg, double &Value) { 765331de23705a719514e37c211f327379688f81b0dChris Lattner const char *ArgStart = Arg.c_str(); 766331de23705a719514e37c211f327379688f81b0dChris Lattner char *End; 767331de23705a719514e37c211f327379688f81b0dChris Lattner Value = strtod(ArgStart, &End); 768f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman if (*End != 0) 769331de23705a719514e37c211f327379688f81b0dChris Lattner return O.error(": '" +Arg+ "' value invalid for floating point argument!"); 770dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner return false; 771dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 772dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 7739b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattnerbool parser<double>::parse(Option &O, const char *AN, 7749b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner const std::string &Arg, double &Val) { 7759b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner return parseDouble(O, Arg, Val); 776dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 777dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 7789b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattnerbool parser<float>::parse(Option &O, const char *AN, 7799b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner const std::string &Arg, float &Val) { 7809b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner double dVal; 7819b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner if (parseDouble(O, Arg, dVal)) 7829b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner return true; 7839b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner Val = (float)dVal; 7849b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner return false; 785dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 786dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 787dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 788dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 789331de23705a719514e37c211f327379688f81b0dChris Lattner// generic_parser_base implementation 790dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 791dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 792aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner// findOption - Return the option number corresponding to the specified 793aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner// argument string. If the option is not found, getNumOptions() is returned. 794aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner// 795aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattnerunsigned generic_parser_base::findOption(const char *Name) { 796aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner unsigned i = 0, e = getNumOptions(); 797ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::string N(Name); 798aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner 799aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner while (i != e) 800aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner if (getOption(i) == N) 801aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner return i; 802aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner else 803aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner ++i; 804aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner return e; 805aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner} 806aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner 807aa852bbb503571d1198856fa4c6e099d7625e3b3Chris Lattner 808dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// Return the width of the option tag for printing... 809331de23705a719514e37c211f327379688f81b0dChris Lattnerunsigned generic_parser_base::getOptionWidth(const Option &O) const { 810331de23705a719514e37c211f327379688f81b0dChris Lattner if (O.hasArgStr()) { 811331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned Size = std::strlen(O.ArgStr)+6; 812331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = getNumOptions(); i != e; ++i) 813331de23705a719514e37c211f327379688f81b0dChris Lattner Size = std::max(Size, (unsigned)std::strlen(getOption(i))+8); 814331de23705a719514e37c211f327379688f81b0dChris Lattner return Size; 815331de23705a719514e37c211f327379688f81b0dChris Lattner } else { 816331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned BaseSize = 0; 817331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = getNumOptions(); i != e; ++i) 818331de23705a719514e37c211f327379688f81b0dChris Lattner BaseSize = std::max(BaseSize, (unsigned)std::strlen(getOption(i))+8); 819331de23705a719514e37c211f327379688f81b0dChris Lattner return BaseSize; 820331de23705a719514e37c211f327379688f81b0dChris Lattner } 821dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 822dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 823f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman// printOptionInfo - Print out information about this option. The 824dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// to-be-maintained width is specified. 825dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 826331de23705a719514e37c211f327379688f81b0dChris Lattnervoid generic_parser_base::printOptionInfo(const Option &O, 827331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned GlobalWidth) const { 828331de23705a719514e37c211f327379688f81b0dChris Lattner if (O.hasArgStr()) { 829331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned L = std::strlen(O.ArgStr); 830ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << " -" << O.ArgStr << std::string(GlobalWidth-L-6, ' ') 831ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner << " - " << O.HelpStr << "\n"; 832331de23705a719514e37c211f327379688f81b0dChris Lattner 833331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = getNumOptions(); i != e; ++i) { 834331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned NumSpaces = GlobalWidth-strlen(getOption(i))-8; 835ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << " =" << getOption(i) << std::string(NumSpaces, ' ') 836ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner << " - " << getDescription(i) << "\n"; 837331de23705a719514e37c211f327379688f81b0dChris Lattner } 838331de23705a719514e37c211f327379688f81b0dChris Lattner } else { 839331de23705a719514e37c211f327379688f81b0dChris Lattner if (O.HelpStr[0]) 840f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman std::cerr << " " << O.HelpStr << "\n"; 841331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = getNumOptions(); i != e; ++i) { 842331de23705a719514e37c211f327379688f81b0dChris Lattner unsigned L = std::strlen(getOption(i)); 843ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << " -" << getOption(i) << std::string(GlobalWidth-L-8, ' ') 844ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner << " - " << getDescription(i) << "\n"; 845331de23705a719514e37c211f327379688f81b0dChris Lattner } 846dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 847dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} 848dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 849dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 850dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner//===----------------------------------------------------------------------===// 851331de23705a719514e37c211f327379688f81b0dChris Lattner// --help and --help-hidden option implementation 852dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner// 853ad0846bd8be0a86e0277e1890fd280c9868f830aReid Spencer 854dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattnernamespace { 855dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 856331de23705a719514e37c211f327379688f81b0dChris Lattnerclass HelpPrinter { 857dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner unsigned MaxArgLen; 858dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner const Option *EmptyArg; 859dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner const bool ShowHidden; 860dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 861331de23705a719514e37c211f327379688f81b0dChris Lattner // isHidden/isReallyHidden - Predicates to be used to filter down arg lists. 862ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner inline static bool isHidden(std::pair<std::string, Option *> &OptPair) { 863331de23705a719514e37c211f327379688f81b0dChris Lattner return OptPair.second->getOptionHiddenFlag() >= Hidden; 864331de23705a719514e37c211f327379688f81b0dChris Lattner } 865ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner inline static bool isReallyHidden(std::pair<std::string, Option *> &OptPair) { 866331de23705a719514e37c211f327379688f81b0dChris Lattner return OptPair.second->getOptionHiddenFlag() == ReallyHidden; 867331de23705a719514e37c211f327379688f81b0dChris Lattner } 868331de23705a719514e37c211f327379688f81b0dChris Lattner 869331de23705a719514e37c211f327379688f81b0dChris Lattnerpublic: 870331de23705a719514e37c211f327379688f81b0dChris Lattner HelpPrinter(bool showHidden) : ShowHidden(showHidden) { 871331de23705a719514e37c211f327379688f81b0dChris Lattner EmptyArg = 0; 872331de23705a719514e37c211f327379688f81b0dChris Lattner } 873331de23705a719514e37c211f327379688f81b0dChris Lattner 874331de23705a719514e37c211f327379688f81b0dChris Lattner void operator=(bool Value) { 875331de23705a719514e37c211f327379688f81b0dChris Lattner if (Value == false) return; 876331de23705a719514e37c211f327379688f81b0dChris Lattner 877dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Copy Options into a vector so we can sort them as we like... 878ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::vector<std::pair<std::string, Option*> > Options; 879697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner copy(getOpts().begin(), getOpts().end(), std::back_inserter(Options)); 880dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 881dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Eliminate Hidden or ReallyHidden arguments, depending on ShowHidden 882f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman Options.erase(std::remove_if(Options.begin(), Options.end(), 883331de23705a719514e37c211f327379688f81b0dChris Lattner std::ptr_fun(ShowHidden ? isReallyHidden : isHidden)), 884b5c520bfb6505caaa6ad8468b372530d44c8b253Misha Brukman Options.end()); 885dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 886dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Eliminate duplicate entries in table (from enum flags options, f.e.) 887331de23705a719514e37c211f327379688f81b0dChris Lattner { // Give OptionSet a scope 888331de23705a719514e37c211f327379688f81b0dChris Lattner std::set<Option*> OptionSet; 889331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0; i != Options.size(); ++i) 890331de23705a719514e37c211f327379688f81b0dChris Lattner if (OptionSet.count(Options[i].second) == 0) 891331de23705a719514e37c211f327379688f81b0dChris Lattner OptionSet.insert(Options[i].second); // Add new entry to set 892331de23705a719514e37c211f327379688f81b0dChris Lattner else 893331de23705a719514e37c211f327379688f81b0dChris Lattner Options.erase(Options.begin()+i--); // Erase duplicate 894331de23705a719514e37c211f327379688f81b0dChris Lattner } 895dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 896dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner if (ProgramOverview) 897ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << "OVERVIEW:" << ProgramOverview << "\n"; 898dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 899ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << "USAGE: " << ProgramName << " [options]"; 900331de23705a719514e37c211f327379688f81b0dChris Lattner 901331de23705a719514e37c211f327379688f81b0dChris Lattner // Print out the positional options... 902ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::vector<Option*> &PosOpts = getPositionalOpts(); 903331de23705a719514e37c211f327379688f81b0dChris Lattner Option *CAOpt = 0; // The cl::ConsumeAfter option, if it exists... 904dd6cb6a43b78732f1a136583ccca4e715bae7d71Misha Brukman if (!PosOpts.empty() && PosOpts[0]->getNumOccurrencesFlag() == ConsumeAfter) 905331de23705a719514e37c211f327379688f81b0dChris Lattner CAOpt = PosOpts[0]; 906331de23705a719514e37c211f327379688f81b0dChris Lattner 9079cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner for (unsigned i = CAOpt != 0, e = PosOpts.size(); i != e; ++i) { 9089cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner if (PosOpts[i]->ArgStr[0]) 9099cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner std::cerr << " --" << PosOpts[i]->ArgStr; 910ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << " " << PosOpts[i]->HelpStr; 9119cf3d4770230238f2f395514bf04e0e64352d261Chris Lattner } 912331de23705a719514e37c211f327379688f81b0dChris Lattner 913331de23705a719514e37c211f327379688f81b0dChris Lattner // Print the consume after option info if it exists... 914ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner if (CAOpt) std::cerr << " " << CAOpt->HelpStr; 915331de23705a719514e37c211f327379688f81b0dChris Lattner 916ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << "\n\n"; 917dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 918dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner // Compute the maximum argument length... 919dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner MaxArgLen = 0; 920331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = Options.size(); i != e; ++i) 921331de23705a719514e37c211f327379688f81b0dChris Lattner MaxArgLen = std::max(MaxArgLen, Options[i].second->getOptionWidth()); 922dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 923ca6433f233b7ed432916ba07976f9a4e9e0767b0Chris Lattner std::cerr << "OPTIONS:\n"; 924331de23705a719514e37c211f327379688f81b0dChris Lattner for (unsigned i = 0, e = Options.size(); i != e; ++i) 925331de23705a719514e37c211f327379688f81b0dChris Lattner Options[i].second->printOptionInfo(MaxArgLen); 926dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 927c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner // Print any extra help the user has declared. 928c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner for (std::vector<const char *>::iterator I = MoreHelp().begin(), 929c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner E = MoreHelp().end(); I != E; ++I) 930c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner std::cerr << *I; 931c540ebbc1b7c2f6a92a968b4d36137a7332cea32Chris Lattner MoreHelp().clear(); 932ad0846bd8be0a86e0277e1890fd280c9868f830aReid Spencer 9339bbba091396922093687d11a181e5886c42c5dfdReid Spencer // Halt the program since help information was printed 934a92d12c053510bdad196965a6bac3168d807802eChris Lattner getOpts().clear(); // Don't bother making option dtors remove from map. 935331de23705a719514e37c211f327379688f81b0dChris Lattner exit(1); 936dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner } 937331de23705a719514e37c211f327379688f81b0dChris Lattner}; 938dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 93969105f33c190621a6b1ad61f925b1a9e6b0512afReid Spencerclass VersionPrinter { 94069105f33c190621a6b1ad61f925b1a9e6b0512afReid Spencerpublic: 94169105f33c190621a6b1ad61f925b1a9e6b0512afReid Spencer void operator=(bool OptionWasSpecified) { 94269105f33c190621a6b1ad61f925b1a9e6b0512afReid Spencer if (OptionWasSpecified) { 943f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman std::cerr << "Low Level Virtual Machine (" << PACKAGE_NAME << ") " 944fb4863ac5506229abe7ee9d9cfffbe4f45fe71ebMisha Brukman << PACKAGE_VERSION << " (see http://llvm.cs.uiuc.edu/)\n"; 945a92d12c053510bdad196965a6bac3168d807802eChris Lattner getOpts().clear(); // Don't bother making option dtors remove from map. 94669105f33c190621a6b1ad61f925b1a9e6b0512afReid Spencer exit(1); 94769105f33c190621a6b1ad61f925b1a9e6b0512afReid Spencer } 94869105f33c190621a6b1ad61f925b1a9e6b0512afReid Spencer } 94969105f33c190621a6b1ad61f925b1a9e6b0512afReid Spencer}; 950dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 951dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 952331de23705a719514e37c211f327379688f81b0dChris Lattner// Define the two HelpPrinter instances that are used to print out help, or 953331de23705a719514e37c211f327379688f81b0dChris Lattner// help-hidden... 954331de23705a719514e37c211f327379688f81b0dChris Lattner// 955331de23705a719514e37c211f327379688f81b0dChris LattnerHelpPrinter NormalPrinter(false); 956331de23705a719514e37c211f327379688f81b0dChris LattnerHelpPrinter HiddenPrinter(true); 957331de23705a719514e37c211f327379688f81b0dChris Lattner 958f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukmancl::opt<HelpPrinter, true, parser<bool> > 9594bf7afcc271138512c38ab2e4a348e2fe6164140Chris LattnerHOp("help", cl::desc("Display available options (--help-hidden for more)"), 9609b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner cl::location(NormalPrinter), cl::ValueDisallowed); 961dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 962331de23705a719514e37c211f327379688f81b0dChris Lattnercl::opt<HelpPrinter, true, parser<bool> > 9634bf7afcc271138512c38ab2e4a348e2fe6164140Chris LattnerHHOp("help-hidden", cl::desc("Display all available options"), 9649b14eb5a781cea80ade37ab9462ba0721cbdbb9cChris Lattner cl::location(HiddenPrinter), cl::Hidden, cl::ValueDisallowed); 965dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner 96669105f33c190621a6b1ad61f925b1a9e6b0512afReid Spencer// Define the --version option that prints out the LLVM version for the tool 96769105f33c190621a6b1ad61f925b1a9e6b0512afReid SpencerVersionPrinter VersionPrinterInstance; 96869105f33c190621a6b1ad61f925b1a9e6b0512afReid Spencercl::opt<VersionPrinter, true, parser<bool> > 9694bf7afcc271138512c38ab2e4a348e2fe6164140Chris LattnerVersOp("version", cl::desc("Display the version of this program"), 97069105f33c190621a6b1ad61f925b1a9e6b0512afReid Spencer cl::location(VersionPrinterInstance), cl::ValueDisallowed); 97169105f33c190621a6b1ad61f925b1a9e6b0512afReid Spencer 9729bbba091396922093687d11a181e5886c42c5dfdReid Spencer 973dbab15a2c9accc0242109881e1632137cb97dbc9Chris Lattner} // End anonymous namespace 9749bbba091396922093687d11a181e5886c42c5dfdReid Spencer 9759bbba091396922093687d11a181e5886c42c5dfdReid Spencer// Utility function for printing the help message. 9769bbba091396922093687d11a181e5886c42c5dfdReid Spencervoid cl::PrintHelpMessage() { 977f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman // This looks weird, but it actually prints the help message. The 9785cc498f116cd76235c9c0a2ded46bc29f8fb35e0Reid Spencer // NormalPrinter variable is a HelpPrinter and the help gets printed when 9795cc498f116cd76235c9c0a2ded46bc29f8fb35e0Reid Spencer // its operator= is invoked. That's because the "normal" usages of the 980f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman // help printer is to be assigned true/false depending on whether the 9815cc498f116cd76235c9c0a2ded46bc29f8fb35e0Reid Spencer // --help option was given or not. Since we're circumventing that we have 9825cc498f116cd76235c9c0a2ded46bc29f8fb35e0Reid Spencer // to make it look like --help was given, so we assign true. 9839bbba091396922093687d11a181e5886c42c5dfdReid Spencer NormalPrinter = true; 9849bbba091396922093687d11a181e5886c42c5dfdReid Spencer} 985