Daniel Dunbar | 27e738d | 2009-11-19 00:15:11 +0000 | [diff] [blame] | 1 | //===--- OptTable.cpp - Option Table Implementation ---------------------*-===// |
Daniel Dunbar | 2c6f6f3 | 2009-03-04 08:33:23 +0000 | [diff] [blame] | 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
| 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
| 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | |
Daniel Dunbar | 27e738d | 2009-11-19 00:15:11 +0000 | [diff] [blame] | 10 | #include "clang/Driver/OptTable.h" |
Daniel Dunbar | 70a0dbb | 2009-03-04 22:41:37 +0000 | [diff] [blame] | 11 | #include "clang/Driver/Arg.h" |
| 12 | #include "clang/Driver/ArgList.h" |
Daniel Dunbar | 2c6f6f3 | 2009-03-04 08:33:23 +0000 | [diff] [blame] | 13 | #include "clang/Driver/Option.h" |
Daniel Dunbar | 60e107f | 2009-12-03 07:01:38 +0000 | [diff] [blame] | 14 | #include "llvm/Support/raw_ostream.h" |
Daniel Dunbar | 7547f74 | 2009-03-23 21:50:40 +0000 | [diff] [blame] | 15 | #include <algorithm> |
Daniel Dunbar | 2c6f6f3 | 2009-03-04 08:33:23 +0000 | [diff] [blame] | 16 | #include <cassert> |
Daniel Dunbar | 2658f05 | 2009-12-04 21:08:40 +0000 | [diff] [blame] | 17 | #include <map> |
Daniel Dunbar | 2c6f6f3 | 2009-03-04 08:33:23 +0000 | [diff] [blame] | 18 | using namespace clang::driver; |
| 19 | using namespace clang::driver::options; |
| 20 | |
Daniel Dunbar | b355692 | 2009-03-23 18:41:45 +0000 | [diff] [blame] | 21 | // Ordering on Info. The ordering is *almost* lexicographic, with two |
| 22 | // exceptions. First, '\0' comes at the end of the alphabet instead of |
| 23 | // the beginning (thus options preceed any other options which prefix |
| 24 | // them). Second, for options with the same name, the less permissive |
| 25 | // version should come first; a Flag option should preceed a Joined |
| 26 | // option, for example. |
| 27 | |
| 28 | static int StrCmpOptionName(const char *A, const char *B) { |
| 29 | char a = *A, b = *B; |
| 30 | while (a == b) { |
| 31 | if (a == '\0') |
| 32 | return 0; |
| 33 | |
| 34 | a = *++A; |
| 35 | b = *++B; |
| 36 | } |
| 37 | |
| 38 | if (a == '\0') // A is a prefix of B. |
| 39 | return 1; |
| 40 | if (b == '\0') // B is a prefix of A. |
| 41 | return -1; |
| 42 | |
| 43 | // Otherwise lexicographic. |
| 44 | return (a < b) ? -1 : 1; |
| 45 | } |
| 46 | |
Daniel Dunbar | 1ce9cf0 | 2009-11-18 21:42:57 +0000 | [diff] [blame] | 47 | namespace clang { |
| 48 | namespace driver { |
Daniel Dunbar | a79a2b5 | 2009-11-18 20:19:36 +0000 | [diff] [blame] | 49 | static inline bool operator<(const OptTable::Info &A, const OptTable::Info &B) { |
Daniel Dunbar | b355692 | 2009-03-23 18:41:45 +0000 | [diff] [blame] | 50 | if (&A == &B) |
| 51 | return false; |
| 52 | |
| 53 | if (int N = StrCmpOptionName(A.Name, B.Name)) |
| 54 | return N == -1; |
| 55 | |
| 56 | // Names are the same, check that classes are in order; exactly one |
| 57 | // should be joined, and it should succeed the other. |
Daniel Dunbar | cf51ece | 2009-03-25 03:06:26 +0000 | [diff] [blame] | 58 | assert(((A.Kind == Option::JoinedClass) ^ (B.Kind == Option::JoinedClass)) && |
Daniel Dunbar | b355692 | 2009-03-23 18:41:45 +0000 | [diff] [blame] | 59 | "Unexpected classes for options with same name."); |
| 60 | return B.Kind == Option::JoinedClass; |
| 61 | } |
| 62 | |
Daniel Dunbar | 1ce9cf0 | 2009-11-18 21:42:57 +0000 | [diff] [blame] | 63 | // Support lower_bound between info and an option name. |
| 64 | static inline bool operator<(const OptTable::Info &I, const char *Name) { |
| 65 | return StrCmpOptionName(I.Name, Name) == -1; |
| 66 | } |
| 67 | static inline bool operator<(const char *Name, const OptTable::Info &I) { |
| 68 | return StrCmpOptionName(Name, I.Name) == -1; |
| 69 | } |
| 70 | } |
| 71 | } |
| 72 | |
Daniel Dunbar | b355692 | 2009-03-23 18:41:45 +0000 | [diff] [blame] | 73 | // |
| 74 | |
Daniel Dunbar | 9e1f982 | 2009-11-19 04:14:53 +0000 | [diff] [blame] | 75 | OptSpecifier::OptSpecifier(const Option *Opt) : ID(Opt->getID()) {} |
| 76 | |
| 77 | // |
| 78 | |
Daniel Dunbar | a79a2b5 | 2009-11-18 20:19:36 +0000 | [diff] [blame] | 79 | OptTable::OptTable(const Info *_OptionInfos, unsigned _NumOptionInfos) |
| 80 | : OptionInfos(_OptionInfos), NumOptionInfos(_NumOptionInfos), |
| 81 | Options(new Option*[NumOptionInfos]), |
| 82 | TheInputOption(0), TheUnknownOption(0), FirstSearchableIndex(0) |
| 83 | { |
Daniel Dunbar | 47393ba | 2009-07-13 21:50:47 +0000 | [diff] [blame] | 84 | // Explicitly zero initialize the error to work around a bug in array |
| 85 | // value-initialization on MinGW with gcc 4.3.5. |
Daniel Dunbar | a79a2b5 | 2009-11-18 20:19:36 +0000 | [diff] [blame] | 86 | memset(Options, 0, sizeof(*Options) * NumOptionInfos); |
Daniel Dunbar | 47393ba | 2009-07-13 21:50:47 +0000 | [diff] [blame] | 87 | |
Daniel Dunbar | b355692 | 2009-03-23 18:41:45 +0000 | [diff] [blame] | 88 | // Find start of normal options. |
Daniel Dunbar | a79a2b5 | 2009-11-18 20:19:36 +0000 | [diff] [blame] | 89 | for (unsigned i = 0, e = getNumOptions(); i != e; ++i) { |
| 90 | unsigned Kind = getInfo(i + 1).Kind; |
| 91 | if (Kind == Option::InputClass) { |
| 92 | assert(!TheInputOption && "Cannot have multiple input options!"); |
| 93 | TheInputOption = getOption(i + 1); |
| 94 | } else if (Kind == Option::UnknownClass) { |
| 95 | assert(!TheUnknownOption && "Cannot have multiple input options!"); |
| 96 | TheUnknownOption = getOption(i + 1); |
| 97 | } else if (Kind != Option::GroupClass) { |
| 98 | FirstSearchableIndex = i; |
Daniel Dunbar | b355692 | 2009-03-23 18:41:45 +0000 | [diff] [blame] | 99 | break; |
| 100 | } |
| 101 | } |
Daniel Dunbar | a79a2b5 | 2009-11-18 20:19:36 +0000 | [diff] [blame] | 102 | assert(FirstSearchableIndex != 0 && "No searchable options?"); |
Daniel Dunbar | b355692 | 2009-03-23 18:41:45 +0000 | [diff] [blame] | 103 | |
| 104 | #ifndef NDEBUG |
| 105 | // Check that everything after the first searchable option is a |
| 106 | // regular option class. |
Daniel Dunbar | a79a2b5 | 2009-11-18 20:19:36 +0000 | [diff] [blame] | 107 | for (unsigned i = FirstSearchableIndex, e = getNumOptions(); i != e; ++i) { |
| 108 | Option::OptionClass Kind = (Option::OptionClass) getInfo(i + 1).Kind; |
Daniel Dunbar | b355692 | 2009-03-23 18:41:45 +0000 | [diff] [blame] | 109 | assert((Kind != Option::InputClass && Kind != Option::UnknownClass && |
| 110 | Kind != Option::GroupClass) && |
| 111 | "Special options should be defined first!"); |
| 112 | } |
| 113 | |
| 114 | // Check that options are in order. |
Daniel Dunbar | a79a2b5 | 2009-11-18 20:19:36 +0000 | [diff] [blame] | 115 | for (unsigned i = FirstSearchableIndex+1, e = getNumOptions(); i != e; ++i) { |
| 116 | if (!(getInfo(i) < getInfo(i + 1))) { |
| 117 | getOption(i)->dump(); |
| 118 | getOption(i + 1)->dump(); |
Daniel Dunbar | b355692 | 2009-03-23 18:41:45 +0000 | [diff] [blame] | 119 | assert(0 && "Options are not in order!"); |
| 120 | } |
| 121 | } |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 122 | #endif |
Daniel Dunbar | 2c6f6f3 | 2009-03-04 08:33:23 +0000 | [diff] [blame] | 123 | } |
| 124 | |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 125 | OptTable::~OptTable() { |
Daniel Dunbar | a79a2b5 | 2009-11-18 20:19:36 +0000 | [diff] [blame] | 126 | for (unsigned i = 0, e = getNumOptions(); i != e; ++i) |
Daniel Dunbar | 2c6f6f3 | 2009-03-04 08:33:23 +0000 | [diff] [blame] | 127 | delete Options[i]; |
| 128 | delete[] Options; |
| 129 | } |
| 130 | |
Daniel Dunbar | a79a2b5 | 2009-11-18 20:19:36 +0000 | [diff] [blame] | 131 | Option *OptTable::CreateOption(unsigned id) const { |
| 132 | const Info &info = getInfo(id); |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 133 | const OptionGroup *Group = |
Daniel Dunbar | a79a2b5 | 2009-11-18 20:19:36 +0000 | [diff] [blame] | 134 | cast_or_null<OptionGroup>(getOption(info.GroupID)); |
| 135 | const Option *Alias = getOption(info.AliasID); |
Daniel Dunbar | 2c6f6f3 | 2009-03-04 08:33:23 +0000 | [diff] [blame] | 136 | |
| 137 | Option *Opt = 0; |
| 138 | switch (info.Kind) { |
Daniel Dunbar | 30b055f | 2009-03-04 21:53:04 +0000 | [diff] [blame] | 139 | case Option::InputClass: |
Daniel Dunbar | a0289fd | 2009-11-19 04:25:06 +0000 | [diff] [blame] | 140 | Opt = new InputOption(id); break; |
Daniel Dunbar | 30b055f | 2009-03-04 21:53:04 +0000 | [diff] [blame] | 141 | case Option::UnknownClass: |
Daniel Dunbar | a0289fd | 2009-11-19 04:25:06 +0000 | [diff] [blame] | 142 | Opt = new UnknownOption(id); break; |
Daniel Dunbar | 2c6f6f3 | 2009-03-04 08:33:23 +0000 | [diff] [blame] | 143 | case Option::GroupClass: |
Daniel Dunbar | 30b055f | 2009-03-04 21:53:04 +0000 | [diff] [blame] | 144 | Opt = new OptionGroup(id, info.Name, Group); break; |
Daniel Dunbar | 2c6f6f3 | 2009-03-04 08:33:23 +0000 | [diff] [blame] | 145 | case Option::FlagClass: |
Daniel Dunbar | 30b055f | 2009-03-04 21:53:04 +0000 | [diff] [blame] | 146 | Opt = new FlagOption(id, info.Name, Group, Alias); break; |
Daniel Dunbar | 2c6f6f3 | 2009-03-04 08:33:23 +0000 | [diff] [blame] | 147 | case Option::JoinedClass: |
Daniel Dunbar | 30b055f | 2009-03-04 21:53:04 +0000 | [diff] [blame] | 148 | Opt = new JoinedOption(id, info.Name, Group, Alias); break; |
Daniel Dunbar | 2c6f6f3 | 2009-03-04 08:33:23 +0000 | [diff] [blame] | 149 | case Option::SeparateClass: |
Daniel Dunbar | 30b055f | 2009-03-04 21:53:04 +0000 | [diff] [blame] | 150 | Opt = new SeparateOption(id, info.Name, Group, Alias); break; |
Daniel Dunbar | 2c6f6f3 | 2009-03-04 08:33:23 +0000 | [diff] [blame] | 151 | case Option::CommaJoinedClass: |
Daniel Dunbar | 30b055f | 2009-03-04 21:53:04 +0000 | [diff] [blame] | 152 | Opt = new CommaJoinedOption(id, info.Name, Group, Alias); break; |
Daniel Dunbar | 2c6f6f3 | 2009-03-04 08:33:23 +0000 | [diff] [blame] | 153 | case Option::MultiArgClass: |
Daniel Dunbar | 30b055f | 2009-03-04 21:53:04 +0000 | [diff] [blame] | 154 | Opt = new MultiArgOption(id, info.Name, Group, Alias, info.Param); break; |
Daniel Dunbar | 2c6f6f3 | 2009-03-04 08:33:23 +0000 | [diff] [blame] | 155 | case Option::JoinedOrSeparateClass: |
Daniel Dunbar | 30b055f | 2009-03-04 21:53:04 +0000 | [diff] [blame] | 156 | Opt = new JoinedOrSeparateOption(id, info.Name, Group, Alias); break; |
Daniel Dunbar | 2c6f6f3 | 2009-03-04 08:33:23 +0000 | [diff] [blame] | 157 | case Option::JoinedAndSeparateClass: |
Daniel Dunbar | 30b055f | 2009-03-04 21:53:04 +0000 | [diff] [blame] | 158 | Opt = new JoinedAndSeparateOption(id, info.Name, Group, Alias); break; |
Daniel Dunbar | 2c6f6f3 | 2009-03-04 08:33:23 +0000 | [diff] [blame] | 159 | } |
| 160 | |
Daniel Dunbar | a4f6480 | 2009-11-18 17:42:34 +0000 | [diff] [blame] | 161 | if (info.Flags & DriverOption) |
| 162 | Opt->setDriverOption(true); |
| 163 | if (info.Flags & LinkerInput) |
| 164 | Opt->setLinkerInput(true); |
| 165 | if (info.Flags & NoArgumentUnused) |
| 166 | Opt->setNoArgumentUnused(true); |
| 167 | if (info.Flags & RenderAsInput) |
| 168 | Opt->setNoOptAsInput(true); |
| 169 | if (info.Flags & RenderJoined) { |
Daniel Dunbar | bbd2a04 | 2010-03-20 01:12:00 +0000 | [diff] [blame] | 170 | assert((info.Kind == Option::JoinedOrSeparateClass || |
| 171 | info.Kind == Option::SeparateClass) && "Invalid option."); |
Daniel Dunbar | e375c4a | 2010-06-09 22:31:04 +0000 | [diff] [blame^] | 172 | Opt->setRenderStyle(Option::RenderJoinedStyle); |
Daniel Dunbar | 2c6f6f3 | 2009-03-04 08:33:23 +0000 | [diff] [blame] | 173 | } |
Daniel Dunbar | a4f6480 | 2009-11-18 17:42:34 +0000 | [diff] [blame] | 174 | if (info.Flags & RenderSeparate) { |
Daniel Dunbar | bbd2a04 | 2010-03-20 01:12:00 +0000 | [diff] [blame] | 175 | assert((info.Kind == Option::JoinedOrSeparateClass || |
| 176 | info.Kind == Option::JoinedClass) && "Invalid option."); |
Daniel Dunbar | e375c4a | 2010-06-09 22:31:04 +0000 | [diff] [blame^] | 177 | Opt->setRenderStyle(Option::RenderSeparateStyle); |
Daniel Dunbar | a4f6480 | 2009-11-18 17:42:34 +0000 | [diff] [blame] | 178 | } |
| 179 | if (info.Flags & Unsupported) |
| 180 | Opt->setUnsupported(true); |
Daniel Dunbar | 2c6f6f3 | 2009-03-04 08:33:23 +0000 | [diff] [blame] | 181 | |
| 182 | return Opt; |
| 183 | } |
Daniel Dunbar | 70a0dbb | 2009-03-04 22:41:37 +0000 | [diff] [blame] | 184 | |
Daniel Dunbar | f3cad36 | 2009-03-25 04:13:45 +0000 | [diff] [blame] | 185 | Arg *OptTable::ParseOneArg(const InputArgList &Args, unsigned &Index) const { |
Daniel Dunbar | b0c4df5 | 2009-03-22 23:26:43 +0000 | [diff] [blame] | 186 | unsigned Prev = Index; |
Daniel Dunbar | 70a0dbb | 2009-03-04 22:41:37 +0000 | [diff] [blame] | 187 | const char *Str = Args.getArgString(Index); |
| 188 | |
Daniel Dunbar | a948045 | 2009-03-12 08:44:47 +0000 | [diff] [blame] | 189 | // Anything that doesn't start with '-' is an input, as is '-' itself. |
| 190 | if (Str[0] != '-' || Str[1] == '\0') |
Daniel Dunbar | 4465a77 | 2010-06-09 22:31:00 +0000 | [diff] [blame] | 191 | return new PositionalArg(TheInputOption, Index++, Str); |
Daniel Dunbar | 70a0dbb | 2009-03-04 22:41:37 +0000 | [diff] [blame] | 192 | |
Daniel Dunbar | a79a2b5 | 2009-11-18 20:19:36 +0000 | [diff] [blame] | 193 | const Info *Start = OptionInfos + FirstSearchableIndex; |
Daniel Dunbar | a0289fd | 2009-11-19 04:25:06 +0000 | [diff] [blame] | 194 | const Info *End = OptionInfos + getNumOptions(); |
Daniel Dunbar | b0c4df5 | 2009-03-22 23:26:43 +0000 | [diff] [blame] | 195 | |
Daniel Dunbar | 4ae24e7 | 2009-04-07 18:21:47 +0000 | [diff] [blame] | 196 | // Search for the first next option which could be a prefix. |
Daniel Dunbar | 7547f74 | 2009-03-23 21:50:40 +0000 | [diff] [blame] | 197 | Start = std::lower_bound(Start, End, Str); |
| 198 | |
Daniel Dunbar | 4ae24e7 | 2009-04-07 18:21:47 +0000 | [diff] [blame] | 199 | // Options are stored in sorted order, with '\0' at the end of the |
| 200 | // alphabet. Since the only options which can accept a string must |
| 201 | // prefix it, we iteratively search for the next option which could |
| 202 | // be a prefix. |
| 203 | // |
| 204 | // FIXME: This is searching much more than necessary, but I am |
| 205 | // blanking on the simplest way to make it fast. We can solve this |
| 206 | // problem when we move to TableGen. |
Daniel Dunbar | 7547f74 | 2009-03-23 21:50:40 +0000 | [diff] [blame] | 207 | for (; Start != End; ++Start) { |
Daniel Dunbar | 4ae24e7 | 2009-04-07 18:21:47 +0000 | [diff] [blame] | 208 | // Scan for first option which is a proper prefix. |
| 209 | for (; Start != End; ++Start) |
| 210 | if (memcmp(Str, Start->Name, strlen(Start->Name)) == 0) |
| 211 | break; |
| 212 | if (Start == End) |
Daniel Dunbar | 7547f74 | 2009-03-23 21:50:40 +0000 | [diff] [blame] | 213 | break; |
| 214 | |
Daniel Dunbar | 4ae24e7 | 2009-04-07 18:21:47 +0000 | [diff] [blame] | 215 | // See if this option matches. |
Daniel Dunbar | a0289fd | 2009-11-19 04:25:06 +0000 | [diff] [blame] | 216 | if (Arg *A = getOption(Start - OptionInfos + 1)->accept(Args, Index)) |
Daniel Dunbar | 7547f74 | 2009-03-23 21:50:40 +0000 | [diff] [blame] | 217 | return A; |
| 218 | |
| 219 | // Otherwise, see if this argument was missing values. |
| 220 | if (Prev != Index) |
| 221 | return 0; |
Daniel Dunbar | 70a0dbb | 2009-03-04 22:41:37 +0000 | [diff] [blame] | 222 | } |
| 223 | |
Daniel Dunbar | 4465a77 | 2010-06-09 22:31:00 +0000 | [diff] [blame] | 224 | return new PositionalArg(TheUnknownOption, Index++, Str); |
Daniel Dunbar | 70a0dbb | 2009-03-04 22:41:37 +0000 | [diff] [blame] | 225 | } |
Daniel Dunbar | 847abaa | 2009-11-19 06:35:06 +0000 | [diff] [blame] | 226 | |
| 227 | InputArgList *OptTable::ParseArgs(const char **ArgBegin, const char **ArgEnd, |
| 228 | unsigned &MissingArgIndex, |
| 229 | unsigned &MissingArgCount) const { |
| 230 | InputArgList *Args = new InputArgList(ArgBegin, ArgEnd); |
| 231 | |
| 232 | // FIXME: Handle '@' args (or at least error on them). |
| 233 | |
| 234 | MissingArgIndex = MissingArgCount = 0; |
| 235 | unsigned Index = 0, End = ArgEnd - ArgBegin; |
| 236 | while (Index < End) { |
| 237 | // Ignore empty arguments (other things may still take them as arguments). |
| 238 | if (Args->getArgString(Index)[0] == '\0') { |
| 239 | ++Index; |
| 240 | continue; |
| 241 | } |
| 242 | |
| 243 | unsigned Prev = Index; |
| 244 | Arg *A = ParseOneArg(*Args, Index); |
| 245 | assert(Index > Prev && "Parser failed to consume argument."); |
| 246 | |
| 247 | // Check for missing argument error. |
| 248 | if (!A) { |
| 249 | assert(Index >= End && "Unexpected parser error."); |
| 250 | assert(Index - Prev - 1 && "No missing arguments!"); |
| 251 | MissingArgIndex = Prev; |
| 252 | MissingArgCount = Index - Prev - 1; |
| 253 | break; |
| 254 | } |
| 255 | |
| 256 | Args->append(A); |
| 257 | } |
| 258 | |
| 259 | return Args; |
| 260 | } |
Daniel Dunbar | 60e107f | 2009-12-03 07:01:38 +0000 | [diff] [blame] | 261 | |
| 262 | static std::string getOptionHelpName(const OptTable &Opts, OptSpecifier Id) { |
| 263 | std::string Name = Opts.getOptionName(Id); |
| 264 | |
| 265 | // Add metavar, if used. |
| 266 | switch (Opts.getOptionKind(Id)) { |
| 267 | case Option::GroupClass: case Option::InputClass: case Option::UnknownClass: |
| 268 | assert(0 && "Invalid option with help text."); |
| 269 | |
| 270 | case Option::MultiArgClass: case Option::JoinedAndSeparateClass: |
| 271 | assert(0 && "Cannot print metavar for this kind of option."); |
| 272 | |
| 273 | case Option::FlagClass: |
| 274 | break; |
| 275 | |
| 276 | case Option::SeparateClass: case Option::JoinedOrSeparateClass: |
| 277 | Name += ' '; |
| 278 | // FALLTHROUGH |
| 279 | case Option::JoinedClass: case Option::CommaJoinedClass: |
| 280 | if (const char *MetaVarName = Opts.getOptionMetaVar(Id)) |
| 281 | Name += MetaVarName; |
| 282 | else |
| 283 | Name += "<value>"; |
| 284 | break; |
| 285 | } |
| 286 | |
| 287 | return Name; |
| 288 | } |
| 289 | |
Daniel Dunbar | 2658f05 | 2009-12-04 21:08:40 +0000 | [diff] [blame] | 290 | static void PrintHelpOptionList(llvm::raw_ostream &OS, llvm::StringRef Title, |
| 291 | std::vector<std::pair<std::string, |
| 292 | const char*> > &OptionHelp) { |
| 293 | OS << Title << ":\n"; |
Daniel Dunbar | 60e107f | 2009-12-03 07:01:38 +0000 | [diff] [blame] | 294 | |
| 295 | // Find the maximum option length. |
| 296 | unsigned OptionFieldWidth = 0; |
| 297 | for (unsigned i = 0, e = OptionHelp.size(); i != e; ++i) { |
| 298 | // Skip titles. |
| 299 | if (!OptionHelp[i].second) |
| 300 | continue; |
| 301 | |
| 302 | // Limit the amount of padding we are willing to give up for alignment. |
| 303 | unsigned Length = OptionHelp[i].first.size(); |
| 304 | if (Length <= 23) |
| 305 | OptionFieldWidth = std::max(OptionFieldWidth, Length); |
| 306 | } |
| 307 | |
| 308 | const unsigned InitialPad = 2; |
| 309 | for (unsigned i = 0, e = OptionHelp.size(); i != e; ++i) { |
| 310 | const std::string &Option = OptionHelp[i].first; |
| 311 | int Pad = OptionFieldWidth - int(Option.size()); |
| 312 | OS.indent(InitialPad) << Option; |
| 313 | |
| 314 | // Break on long option names. |
| 315 | if (Pad < 0) { |
| 316 | OS << "\n"; |
| 317 | Pad = OptionFieldWidth + InitialPad; |
| 318 | } |
| 319 | OS.indent(Pad + 1) << OptionHelp[i].second << '\n'; |
| 320 | } |
Daniel Dunbar | 2658f05 | 2009-12-04 21:08:40 +0000 | [diff] [blame] | 321 | } |
| 322 | |
| 323 | static const char *getOptionHelpGroup(const OptTable &Opts, OptSpecifier Id) { |
| 324 | unsigned GroupID = Opts.getOptionGroupID(Id); |
| 325 | |
| 326 | // If not in a group, return the default help group. |
| 327 | if (!GroupID) |
| 328 | return "OPTIONS"; |
| 329 | |
| 330 | // Abuse the help text of the option groups to store the "help group" |
| 331 | // name. |
| 332 | // |
| 333 | // FIXME: Split out option groups. |
| 334 | if (const char *GroupHelp = Opts.getOptionHelpText(GroupID)) |
| 335 | return GroupHelp; |
| 336 | |
| 337 | // Otherwise keep looking. |
| 338 | return getOptionHelpGroup(Opts, GroupID); |
| 339 | } |
| 340 | |
| 341 | void OptTable::PrintHelp(llvm::raw_ostream &OS, const char *Name, |
| 342 | const char *Title, bool ShowHidden) const { |
| 343 | OS << "OVERVIEW: " << Title << "\n"; |
| 344 | OS << '\n'; |
| 345 | OS << "USAGE: " << Name << " [options] <inputs>\n"; |
| 346 | OS << '\n'; |
| 347 | |
| 348 | // Render help text into a map of group-name to a list of (option, help) |
| 349 | // pairs. |
| 350 | typedef std::map<std::string, |
| 351 | std::vector<std::pair<std::string, const char*> > > helpmap_ty; |
| 352 | helpmap_ty GroupedOptionHelp; |
| 353 | |
| 354 | for (unsigned i = 0, e = getNumOptions(); i != e; ++i) { |
| 355 | unsigned Id = i + 1; |
| 356 | |
| 357 | // FIXME: Split out option groups. |
| 358 | if (getOptionKind(Id) == Option::GroupClass) |
| 359 | continue; |
| 360 | |
| 361 | if (!ShowHidden && isOptionHelpHidden(Id)) |
| 362 | continue; |
| 363 | |
| 364 | if (const char *Text = getOptionHelpText(Id)) { |
| 365 | const char *HelpGroup = getOptionHelpGroup(*this, Id); |
| 366 | const std::string &OptName = getOptionHelpName(*this, Id); |
| 367 | GroupedOptionHelp[HelpGroup].push_back(std::make_pair(OptName, Text)); |
| 368 | } |
| 369 | } |
| 370 | |
| 371 | for (helpmap_ty::iterator it = GroupedOptionHelp .begin(), |
| 372 | ie = GroupedOptionHelp.end(); it != ie; ++it) { |
| 373 | if (it != GroupedOptionHelp .begin()) |
| 374 | OS << "\n"; |
| 375 | PrintHelpOptionList(OS, it->first, it->second); |
| 376 | } |
Daniel Dunbar | 60e107f | 2009-12-03 07:01:38 +0000 | [diff] [blame] | 377 | |
| 378 | OS.flush(); |
| 379 | } |