Driver: More Option implementation.
- Add Options.def file, collects option information.
- Actual option instantiation is handled lazily by OptTable to allow
the driver to not need to instantiate all options.
- cast<> support for Option, other minor tweaks.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@66028 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/lib/Driver/OptTable.cpp b/lib/Driver/OptTable.cpp
new file mode 100644
index 0000000..7313348
--- /dev/null
+++ b/lib/Driver/OptTable.cpp
@@ -0,0 +1,117 @@
+//===--- Options.cpp - Option info table --------------------------------*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang/Driver/Options.h"
+
+#include "clang/Driver/Option.h"
+#include <cassert>
+
+using namespace clang;
+using namespace clang::driver;
+using namespace clang::driver::options;
+
+struct Info {
+ Option::OptionClass Kind;
+ const char *Name;
+ unsigned GroupID;
+ unsigned AliasID;
+ const char *Flags;
+ unsigned Param;
+};
+
+static Info OptionInfos[] = {
+#define OPTION(ID, KIND, NAME, GROUP, ALIAS, FLAGS, PARAM) \
+ { Option::KIND##Class, NAME, GROUP, ALIAS, FLAGS, PARAM },
+#include "clang/Driver/Options.def"
+};
+static const unsigned numOptions = sizeof(OptionInfos) / sizeof(OptionInfos[0]);
+
+static Info &getInfo(unsigned id) {
+ assert(id > 0 && id - 1 < numOptions && "Invalid Option ID.");
+ return OptionInfos[id - 1];
+}
+
+OptTable::OptTable() : Options(new Option*[numOptions]) {
+}
+
+OptTable::~OptTable() {
+ for (unsigned i=0; i<numOptions; ++i)
+ delete Options[i];
+ delete[] Options;
+}
+
+unsigned OptTable::getNumOptions() const {
+ return numOptions;
+}
+
+const char *OptTable::getOptionName(options::ID id) const {
+ return getInfo(id).Name;
+}
+
+const Option *OptTable::getOption(options::ID id) const {
+ if (id == 0)
+ return 0;
+
+ assert((unsigned) (id - 1) < numOptions && "Invalid ID.");
+
+ Option *&Entry = Options[id - 1];
+ if (!Entry)
+ Entry = constructOption(id);
+
+ return Entry;
+}
+
+Option *OptTable::constructOption(options::ID id) const {
+ Info &info = getInfo(id);
+ const OptionGroup *Group =
+ cast_or_null<OptionGroup>(getOption((options::ID) info.GroupID));
+ const Option *Alias = getOption((options::ID) info.AliasID);
+
+ Option *Opt = 0;
+ switch (info.Kind) {
+ default:
+ assert(0 && "Invalid option kind.");
+ case Option::GroupClass:
+ Opt = new OptionGroup(info.Name, Group); break;
+ case Option::FlagClass:
+ Opt = new FlagOption(info.Name, Group, Alias); break;
+ case Option::JoinedClass:
+ Opt = new JoinedOption(info.Name, Group, Alias); break;
+ case Option::SeparateClass:
+ Opt = new SeparateOption(info.Name, Group, Alias); break;
+ case Option::CommaJoinedClass:
+ Opt = new CommaJoinedOption(info.Name, Group, Alias); break;
+ case Option::MultiArgClass:
+ Opt = new MultiArgOption(info.Name, Group, Alias, info.Param); break;
+ case Option::JoinedOrSeparateClass:
+ Opt = new JoinedOrSeparateOption(info.Name, Group, Alias); break;
+ case Option::JoinedAndSeparateClass:
+ Opt = new JoinedAndSeparateOption(info.Name, Group, Alias); break;
+ }
+
+ // FIXME: Set flags.
+ for (const char *s = info.Flags; *s; ++s) {
+ switch (*s) {
+ default:
+ assert(0 && "Invalid option flag.");
+ case 'l':
+ break;
+ case 'i':
+ break;
+ case 'J':
+ break;
+ case 'S':
+ break;
+ case 'U':
+ break;
+ }
+ }
+
+ return Opt;
+}
diff --git a/lib/Driver/Option.cpp b/lib/Driver/Option.cpp
index 46b5c41..ce31b8e 100644
--- a/lib/Driver/Option.cpp
+++ b/lib/Driver/Option.cpp
@@ -8,12 +8,13 @@
//===----------------------------------------------------------------------===//
#include "clang/Driver/Option.h"
+#include "llvm/Support/raw_ostream.h"
#include <cassert>
using namespace clang;
using namespace clang::driver;
Option::Option(OptionClass _Kind, const char *_Name,
- OptionGroup *_Group, Option *_Alias)
+ const OptionGroup *_Group, const Option *_Alias)
: Kind(_Kind), Name(_Name), Group(_Group), Alias(_Alias) {
// Multi-level aliases are not supported, and alias options cannot
@@ -23,6 +24,46 @@
"Multi-level aliases and aliases with groups are unsupported.");
}
+Option::~Option() {
+}
+
+void Option::dump() const {
+ llvm::errs() << "<";
+ switch (Kind) {
+ default:
+ assert(0 && "Invalid kind");
+#define P(N) case N: llvm::errs() << #N; break
+ P(GroupClass);
+ P(InputClass);
+ P(UnknownClass);
+ P(FlagClass);
+ P(JoinedClass);
+ P(SeparateClass);
+ P(CommaJoinedClass);
+ P(MultiArgClass);
+ P(JoinedOrSeparateClass);
+ P(JoinedAndSeparateClass);
+#undef P
+ }
+
+ llvm::errs() << " Name:\"" << Name << '"';
+
+ if (Group) {
+ llvm::errs() << " Group:";
+ Group->dump();
+ }
+
+ if (Alias) {
+ llvm::errs() << " Alias:";
+ Alias->dump();
+ }
+
+ if (const MultiArgOption *MOA = dyn_cast<MultiArgOption>(this))
+ llvm::errs() << " NumArgs:" << MOA->getNumArgs();
+
+ llvm::errs() << ">\n";
+}
+
bool Option::matches(const Option *Opt) const {
// Aliases are never considered in matching.
if (Opt->getAlias())
@@ -38,52 +79,102 @@
return false;
}
-OptionGroup::OptionGroup(const char *Name, OptionGroup *Group)
- : Option(Option::GroupOption, Name, Group, 0) {
+OptionGroup::OptionGroup(const char *Name, const OptionGroup *Group)
+ : Option(Option::GroupClass, Name, Group, 0) {
+}
+
+Arg *OptionGroup::accept(ArgList &Args, unsigned Index) const {
+ assert(0 && "FIXME");
+ return 0;
}
InputOption::InputOption()
- : Option(Option::InputOption, "<input>", 0, 0) {
+ : Option(Option::InputClass, "<input>", 0, 0) {
+}
+
+Arg *InputOption::accept(ArgList &Args, unsigned Index) const {
+ assert(0 && "FIXME");
+ return 0;
}
UnknownOption::UnknownOption()
- : Option(Option::UnknownOption, "<unknown>", 0, 0) {
+ : Option(Option::UnknownClass, "<unknown>", 0, 0) {
}
-FlagOption::FlagOption(const char *Name, OptionGroup *Group, Option *Alias)
- : Option(Option::FlagOption, Name, Group, Alias) {
+Arg *UnknownOption::accept(ArgList &Args, unsigned Index) const {
+ assert(0 && "FIXME");
+ return 0;
}
-
-JoinedOption::JoinedOption(const char *Name, OptionGroup *Group, Option *Alias)
- : Option(Option::JoinedOption, Name, Group, Alias) {
+FlagOption::FlagOption(const char *Name, const OptionGroup *Group,
+ const Option *Alias)
+ : Option(Option::FlagClass, Name, Group, Alias) {
}
-CommaJoinedOption::CommaJoinedOption(const char *Name, OptionGroup *Group,
- Option *Alias)
- : Option(Option::CommaJoinedOption, Name, Group, Alias) {
+Arg *FlagOption::accept(ArgList &Args, unsigned Index) const {
+ assert(0 && "FIXME");
+ return 0;
}
-SeparateOption::SeparateOption(const char *Name, OptionGroup *Group,
- Option *Alias)
- : Option(Option::SeparateOption, Name, Group, Alias) {
+JoinedOption::JoinedOption(const char *Name, const OptionGroup *Group,
+ const Option *Alias)
+ : Option(Option::JoinedClass, Name, Group, Alias) {
}
-MultiArgOption::MultiArgOption(const char *Name, OptionGroup *Group,
- Option *Alias, unsigned _NumArgs)
- : Option(Option::MultiArgOption, Name, Group, Alias), NumArgs(_NumArgs) {
+Arg *JoinedOption::accept(ArgList &Args, unsigned Index) const {
+ assert(0 && "FIXME");
+ return 0;
+}
+
+CommaJoinedOption::CommaJoinedOption(const char *Name, const OptionGroup *Group,
+ const Option *Alias)
+ : Option(Option::CommaJoinedClass, Name, Group, Alias) {
+}
+
+Arg *CommaJoinedOption::accept(ArgList &Args, unsigned Index) const {
+ assert(0 && "FIXME");
+ return 0;
+}
+
+SeparateOption::SeparateOption(const char *Name, const OptionGroup *Group,
+ const Option *Alias)
+ : Option(Option::SeparateClass, Name, Group, Alias) {
+}
+
+Arg *SeparateOption::accept(ArgList &Args, unsigned Index) const {
+ assert(0 && "FIXME");
+ return 0;
+}
+
+MultiArgOption::MultiArgOption(const char *Name, const OptionGroup *Group,
+ const Option *Alias, unsigned _NumArgs)
+ : Option(Option::MultiArgClass, Name, Group, Alias), NumArgs(_NumArgs) {
+}
+
+Arg *MultiArgOption::accept(ArgList &Args, unsigned Index) const {
+ assert(0 && "FIXME");
+ return 0;
}
JoinedOrSeparateOption::JoinedOrSeparateOption(const char *Name,
- OptionGroup *Group,
- Option *Alias)
- : Option(Option::JoinedOrSeparateOption, Name, Group, Alias) {
+ const OptionGroup *Group,
+ const Option *Alias)
+ : Option(Option::JoinedOrSeparateClass, Name, Group, Alias) {
+}
+
+Arg *JoinedOrSeparateOption::accept(ArgList &Args, unsigned Index) const {
+ assert(0 && "FIXME");
+ return 0;
}
JoinedAndSeparateOption::JoinedAndSeparateOption(const char *Name,
- OptionGroup *Group,
- Option *Alias)
- : Option(Option::JoinedAndSeparateOption, Name, Group, Alias) {
+ const OptionGroup *Group,
+ const Option *Alias)
+ : Option(Option::JoinedAndSeparateClass, Name, Group, Alias) {
}
+Arg *JoinedAndSeparateOption::accept(ArgList &Args, unsigned Index) const {
+ assert(0 && "FIXME");
+ return 0;
+}