Convert Arg, ArgList, and Option to dump() to dbgs() rather than errs().
[oota-llvm.git] / include / llvm / Option / Option.h
1 //===--- Option.h - Abstract Driver Options ---------------------*- C++ -*-===//
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
10 #ifndef LLVM_OPTION_OPTION_H
11 #define LLVM_OPTION_OPTION_H
12
13 #include "llvm/ADT/SmallVector.h"
14 #include "llvm/ADT/StringRef.h"
15 #include "llvm/Option/OptTable.h"
16 #include "llvm/Support/ErrorHandling.h"
17
18 namespace llvm {
19 namespace opt {
20 class Arg;
21 class ArgList;
22 /// ArgStringList - Type used for constructing argv lists for subprocesses.
23 typedef SmallVector<const char*, 16> ArgStringList;
24
25 /// Base flags for all options. Custom flags may be added after.
26 enum DriverFlag {
27   HelpHidden       = (1 << 0),
28   RenderAsInput    = (1 << 1),
29   RenderJoined     = (1 << 2),
30   RenderSeparate   = (1 << 3)
31 };
32
33 /// Option - Abstract representation for a single form of driver
34 /// argument.
35 ///
36 /// An Option class represents a form of option that the driver
37 /// takes, for example how many arguments the option has and how
38 /// they can be provided. Individual option instances store
39 /// additional information about what group the option is a member
40 /// of (if any), if the option is an alias, and a number of
41 /// flags. At runtime the driver parses the command line into
42 /// concrete Arg instances, each of which corresponds to a
43 /// particular Option instance.
44 class Option {
45 public:
46   enum OptionClass {
47     GroupClass = 0,
48     InputClass,
49     UnknownClass,
50     FlagClass,
51     JoinedClass,
52     SeparateClass,
53     RemainingArgsClass,
54     CommaJoinedClass,
55     MultiArgClass,
56     JoinedOrSeparateClass,
57     JoinedAndSeparateClass
58   };
59
60   enum RenderStyleKind {
61     RenderCommaJoinedStyle,
62     RenderJoinedStyle,
63     RenderSeparateStyle,
64     RenderValuesStyle
65   };
66
67 protected:
68   const OptTable::Info *Info;
69   const OptTable *Owner;
70
71 public:
72   Option(const OptTable::Info *Info, const OptTable *Owner);
73
74   bool isValid() const {
75     return Info != nullptr;
76   }
77
78   unsigned getID() const {
79     assert(Info && "Must have a valid info!");
80     return Info->ID;
81   }
82
83   OptionClass getKind() const {
84     assert(Info && "Must have a valid info!");
85     return OptionClass(Info->Kind);
86   }
87
88   /// \brief Get the name of this option without any prefix.
89   StringRef getName() const {
90     assert(Info && "Must have a valid info!");
91     return Info->Name;
92   }
93
94   const Option getGroup() const {
95     assert(Info && "Must have a valid info!");
96     assert(Owner && "Must have a valid owner!");
97     return Owner->getOption(Info->GroupID);
98   }
99
100   const Option getAlias() const {
101     assert(Info && "Must have a valid info!");
102     assert(Owner && "Must have a valid owner!");
103     return Owner->getOption(Info->AliasID);
104   }
105
106   /// \brief Get the alias arguments as a \0 separated list.
107   /// E.g. ["foo", "bar"] would be returned as "foo\0bar\0".
108   const char *getAliasArgs() const {
109     assert(Info && "Must have a valid info!");
110     assert((!Info->AliasArgs || Info->AliasArgs[0] != 0) &&
111            "AliasArgs should be either 0 or non-empty.");
112
113     return Info->AliasArgs;
114   }
115
116   /// \brief Get the default prefix for this option.
117   StringRef getPrefix() const {
118     const char *Prefix = *Info->Prefixes;
119     return Prefix ? Prefix : StringRef();
120   }
121
122   /// \brief Get the name of this option with the default prefix.
123   std::string getPrefixedName() const {
124     std::string Ret = getPrefix();
125     Ret += getName();
126     return Ret;
127   }
128
129   unsigned getNumArgs() const { return Info->Param; }
130
131   bool hasNoOptAsInput() const { return Info->Flags & RenderAsInput;}
132
133   RenderStyleKind getRenderStyle() const {
134     if (Info->Flags & RenderJoined)
135       return RenderJoinedStyle;
136     if (Info->Flags & RenderSeparate)
137       return RenderSeparateStyle;
138     switch (getKind()) {
139     case GroupClass:
140     case InputClass:
141     case UnknownClass:
142       return RenderValuesStyle;
143     case JoinedClass:
144     case JoinedAndSeparateClass:
145       return RenderJoinedStyle;
146     case CommaJoinedClass:
147       return RenderCommaJoinedStyle;
148     case FlagClass:
149     case SeparateClass:
150     case MultiArgClass:
151     case JoinedOrSeparateClass:
152     case RemainingArgsClass:
153       return RenderSeparateStyle;
154     }
155     llvm_unreachable("Unexpected kind!");
156   }
157
158   /// Test if this option has the flag \a Val.
159   bool hasFlag(unsigned Val) const {
160     return Info->Flags & Val;
161   }
162
163   /// getUnaliasedOption - Return the final option this option
164   /// aliases (itself, if the option has no alias).
165   const Option getUnaliasedOption() const {
166     const Option Alias = getAlias();
167     if (Alias.isValid()) return Alias.getUnaliasedOption();
168     return *this;
169   }
170
171   /// getRenderName - Return the name to use when rendering this
172   /// option.
173   StringRef getRenderName() const {
174     return getUnaliasedOption().getName();
175   }
176
177   /// matches - Predicate for whether this option is part of the
178   /// given option (which may be a group).
179   ///
180   /// Note that matches against options which are an alias should never be
181   /// done -- aliases do not participate in matching and so such a query will
182   /// always be false.
183   bool matches(OptSpecifier ID) const;
184
185   /// accept - Potentially accept the current argument, returning a
186   /// new Arg instance, or 0 if the option does not accept this
187   /// argument (or the argument is missing values).
188   ///
189   /// If the option accepts the current argument, accept() sets
190   /// Index to the position where argument parsing should resume
191   /// (even if the argument is missing values).
192   ///
193   /// \param ArgSize The number of bytes taken up by the matched Option prefix
194   ///                and name. This is used to determine where joined values
195   ///                start.
196   Arg *accept(const ArgList &Args, unsigned &Index, unsigned ArgSize) const;
197
198   void print(raw_ostream &O) const;
199   void dump() const;
200 };
201
202 } // end namespace opt
203 } // end namespace llvm
204
205 #endif