utils/TableGen/LLVMCConfigurationEmitter.cpp

   1 //===- LLVMCConfigurationEmitter.cpp - Generate LLVMC config ----*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open
   6 // Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This tablegen backend is responsible for emitting LLVMC configuration code.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "LLVMCConfigurationEmitter.h"
  15 #include "Record.h"
  16
  17 #include "llvm/ADT/IntrusiveRefCntPtr.h"
  18 #include "llvm/ADT/SmallVector.h"
  19 #include "llvm/ADT/StringExtras.h"
  20 #include "llvm/ADT/StringMap.h"
  21 #include "llvm/ADT/StringSet.h"
  22 #include <algorithm>
  23 #include <cassert>
  24 #include <functional>
  25 #include <stdexcept>
  26 #include <string>
  27 #include <typeinfo>
  28
  29 using namespace llvm;
  30
  31 namespace {
  32
  33 //===----------------------------------------------------------------------===//
  34 /// Typedefs
  35
  36 typedef std::vector<Record*> RecordVector;
  37 typedef std::vector<std::string> StrVector;
  38
  39 //===----------------------------------------------------------------------===//
  40 /// Constants
  41
  42 // Indentation.
  43 unsigned TabWidth = 4;
  44 unsigned Indent1  = TabWidth*1;
  45 unsigned Indent2  = TabWidth*2;
  46 unsigned Indent3  = TabWidth*3;
  47
  48 // Default help string.
  49 const char * DefaultHelpString = "NO HELP MESSAGE PROVIDED";
  50
  51 // Name for the "sink" option.
  52 const char * SinkOptionName = "AutoGeneratedSinkOption";
  53
  54 //===----------------------------------------------------------------------===//
  55 /// Helper functions
  56
  57 /// Id - An 'identity' function object.
  58 struct Id {
  59   template<typename T0>
  60   void operator()(const T0&) const {
  61   }
  62   template<typename T0, typename T1>
  63   void operator()(const T0&, const T1&) const {
  64   }
  65   template<typename T0, typename T1, typename T2>
  66   void operator()(const T0&, const T1&, const T2&) const {
  67   }
  68 };
  69
  70 int InitPtrToInt(const Init* ptr) {
  71   const IntInit& val = dynamic_cast<const IntInit&>(*ptr);
  72   return val.getValue();
  73 }
  74
  75 const std::string& InitPtrToString(const Init* ptr) {
  76   const StringInit& val = dynamic_cast<const StringInit&>(*ptr);
  77   return val.getValue();
  78 }
  79
  80 const ListInit& InitPtrToList(const Init* ptr) {
  81   const ListInit& val = dynamic_cast<const ListInit&>(*ptr);
  82   return val;
  83 }
  84
  85 const DagInit& InitPtrToDag(const Init* ptr) {
  86   const DagInit& val = dynamic_cast<const DagInit&>(*ptr);
  87   return val;
  88 }
  89
  90 const std::string GetOperatorName(const DagInit* D) {
  91   return D->getOperator()->getAsString();
  92 }
  93
  94 const std::string GetOperatorName(const DagInit& D) {
  95   return GetOperatorName(&D);
  96 }
  97
  98 // checkNumberOfArguments - Ensure that the number of args in d is
  99 // greater than or equal to min_arguments, otherwise throw an exception.
 100 void checkNumberOfArguments (const DagInit* d, unsigned min_arguments) {
 101   if (!d || d->getNumArgs() < min_arguments)
 102     throw GetOperatorName(d) + ": too few arguments!";
 103 }
 104
 105 // isDagEmpty - is this DAG marked with an empty marker?
 106 bool isDagEmpty (const DagInit* d) {
 107   return GetOperatorName(d) == "empty_dag_marker";
 108 }
 109
 110 // EscapeVariableName - Escape commas and other symbols not allowed
 111 // in the C++ variable names. Makes it possible to use options named
 112 // like "Wa," (useful for prefix options).
 113 std::string EscapeVariableName(const std::string& Var) {
 114   std::string ret;
 115   for (unsigned i = 0; i != Var.size(); ++i) {
 116     char cur_char = Var[i];
 117     if (cur_char == ',') {
 118       ret += "_comma_";
 119     }
 120     else if (cur_char == '+') {
 121       ret += "_plus_";
 122     }
 123     else if (cur_char == '-') {
 124       ret += "_dash_";
 125     }
 126     else {
 127       ret.push_back(cur_char);
 128     }
 129   }
 130   return ret;
 131 }
 132
 133 /// oneOf - Does the input string contain this character?
 134 bool oneOf(const char* lst, char c) {
 135   while (*lst) {
 136     if (*lst++ == c)
 137       return true;
 138   }
 139   return false;
 140 }
 141
 142 template <class I, class S>
 143 void checkedIncrement(I& P, I E, S ErrorString) {
 144   ++P;
 145   if (P == E)
 146     throw ErrorString;
 147 }
 148
 149 //===----------------------------------------------------------------------===//
 150 /// Back-end specific code
 151
 152
 153 /// OptionType - One of six different option types. See the
 154 /// documentation for detailed description of differences.
 155 namespace OptionType {
 156
 157   enum OptionType { Alias, Switch, Parameter, ParameterList,
 158                     Prefix, PrefixList};
 159
 160   bool IsList (OptionType t) {
 161     return (t == ParameterList || t == PrefixList);
 162   }
 163
 164   bool IsSwitch (OptionType t) {
 165     return (t == Switch);
 166   }
 167
 168   bool IsParameter (OptionType t) {
 169     return (t == Parameter || t == Prefix);
 170   }
 171
 172 }
 173
 174 OptionType::OptionType stringToOptionType(const std::string& T) {
 175   if (T == "alias_option")
 176     return OptionType::Alias;
 177   else if (T == "switch_option")
 178     return OptionType::Switch;
 179   else if (T == "parameter_option")
 180     return OptionType::Parameter;
 181   else if (T == "parameter_list_option")
 182     return OptionType::ParameterList;
 183   else if (T == "prefix_option")
 184     return OptionType::Prefix;
 185   else if (T == "prefix_list_option")
 186     return OptionType::PrefixList;
 187   else
 188     throw "Unknown option type: " + T + '!';
 189 }
 190
 191 namespace OptionDescriptionFlags {
 192   enum OptionDescriptionFlags { Required = 0x1, Hidden = 0x2,
 193                                 ReallyHidden = 0x4, Extern = 0x8,
 194                                 OneOrMore = 0x10, ZeroOrOne = 0x20 };
 195 }
 196
 197 /// OptionDescription - Represents data contained in a single
 198 /// OptionList entry.
 199 struct OptionDescription {
 200   OptionType::OptionType Type;
 201   std::string Name;
 202   unsigned Flags;
 203   std::string Help;
 204   unsigned MultiVal;
 205   Init* InitVal;
 206
 207   OptionDescription(OptionType::OptionType t = OptionType::Switch,
 208                     const std::string& n = "",
 209                     const std::string& h = DefaultHelpString)
 210     : Type(t), Name(n), Flags(0x0), Help(h), MultiVal(1), InitVal(0)
 211   {}
 212
 213   /// GenTypeDeclaration - Returns the C++ variable type of this
 214   /// option.
 215   const char* GenTypeDeclaration() const;
 216
 217   /// GenVariableName - Returns the variable name used in the
 218   /// generated C++ code.
 219   std::string GenVariableName() const;
 220
 221   /// Merge - Merge two option descriptions.
 222   void Merge (const OptionDescription& other);
 223
 224   // Misc convenient getters/setters.
 225
 226   bool isAlias() const;
 227
 228   bool isMultiVal() const;
 229
 230   bool isExtern() const;
 231   void setExtern();
 232
 233   bool isRequired() const;
 234   void setRequired();
 235
 236   bool isOneOrMore() const;
 237   void setOneOrMore();
 238
 239   bool isZeroOrOne() const;
 240   void setZeroOrOne();
 241
 242   bool isHidden() const;
 243   void setHidden();
 244
 245   bool isReallyHidden() const;
 246   void setReallyHidden();
 247
 248   bool isParameter() const
 249   { return OptionType::IsParameter(this->Type); }
 250
 251   bool isSwitch() const
 252   { return OptionType::IsSwitch(this->Type); }
 253
 254   bool isList() const
 255   { return OptionType::IsList(this->Type); }
 256
 257 };
 258
 259 void OptionDescription::Merge (const OptionDescription& other)
 260 {
 261   if (other.Type != Type)
 262     throw "Conflicting definitions for the option " + Name + "!";
 263
 264   if (Help == other.Help || Help == DefaultHelpString)
 265     Help = other.Help;
 266   else if (other.Help != DefaultHelpString) {
 267     llvm::errs() << "Warning: several different help strings"
 268       " defined for option " + Name + "\n";
 269   }
 270
 271   Flags |= other.Flags;
 272 }
 273
 274 bool OptionDescription::isAlias() const {
 275   return Type == OptionType::Alias;
 276 }
 277
 278 bool OptionDescription::isMultiVal() const {
 279   return MultiVal > 1;
 280 }
 281
 282 bool OptionDescription::isExtern() const {
 283   return Flags & OptionDescriptionFlags::Extern;
 284 }
 285 void OptionDescription::setExtern() {
 286   Flags |= OptionDescriptionFlags::Extern;
 287 }
 288
 289 bool OptionDescription::isRequired() const {
 290   return Flags & OptionDescriptionFlags::Required;
 291 }
 292 void OptionDescription::setRequired() {
 293   Flags |= OptionDescriptionFlags::Required;
 294 }
 295
 296 bool OptionDescription::isOneOrMore() const {
 297   return Flags & OptionDescriptionFlags::OneOrMore;
 298 }
 299 void OptionDescription::setOneOrMore() {
 300   Flags |= OptionDescriptionFlags::OneOrMore;
 301 }
 302
 303 bool OptionDescription::isZeroOrOne() const {
 304   return Flags & OptionDescriptionFlags::ZeroOrOne;
 305 }
 306 void OptionDescription::setZeroOrOne() {
 307   Flags |= OptionDescriptionFlags::ZeroOrOne;
 308 }
 309
 310 bool OptionDescription::isHidden() const {
 311   return Flags & OptionDescriptionFlags::Hidden;
 312 }
 313 void OptionDescription::setHidden() {
 314   Flags |= OptionDescriptionFlags::Hidden;
 315 }
 316
 317 bool OptionDescription::isReallyHidden() const {
 318   return Flags & OptionDescriptionFlags::ReallyHidden;
 319 }
 320 void OptionDescription::setReallyHidden() {
 321   Flags |= OptionDescriptionFlags::ReallyHidden;
 322 }
 323
 324 const char* OptionDescription::GenTypeDeclaration() const {
 325   switch (Type) {
 326   case OptionType::Alias:
 327     return "cl::alias";
 328   case OptionType::PrefixList:
 329   case OptionType::ParameterList:
 330     return "cl::list<std::string>";
 331   case OptionType::Switch:
 332     return "cl::opt<bool>";
 333   case OptionType::Parameter:
 334   case OptionType::Prefix:
 335   default:
 336     return "cl::opt<std::string>";
 337   }
 338 }
 339
 340 std::string OptionDescription::GenVariableName() const {
 341   const std::string& EscapedName = EscapeVariableName(Name);
 342   switch (Type) {
 343   case OptionType::Alias:
 344     return "AutoGeneratedAlias_" + EscapedName;
 345   case OptionType::PrefixList:
 346   case OptionType::ParameterList:
 347     return "AutoGeneratedList_" + EscapedName;
 348   case OptionType::Switch:
 349     return "AutoGeneratedSwitch_" + EscapedName;
 350   case OptionType::Prefix:
 351   case OptionType::Parameter:
 352   default:
 353     return "AutoGeneratedParameter_" + EscapedName;
 354   }
 355 }
 356
 357 /// OptionDescriptions - An OptionDescription array plus some helper
 358 /// functions.
 359 class OptionDescriptions {
 360   typedef StringMap<OptionDescription> container_type;
 361
 362   /// Descriptions - A list of OptionDescriptions.
 363   container_type Descriptions;
 364
 365 public:
 366   /// FindOption - exception-throwing wrapper for find().
 367   const OptionDescription& FindOption(const std::string& OptName) const;
 368   /// FindSwitch - wrapper for FindOption that throws in case the option is not
 369   /// a switch.
 370   const OptionDescription& FindSwitch(const std::string& OptName) const;
 371
 372   /// insertDescription - Insert new OptionDescription into
 373   /// OptionDescriptions list
 374   void InsertDescription (const OptionDescription& o);
 375
 376   // Support for STL-style iteration
 377   typedef container_type::const_iterator const_iterator;
 378   const_iterator begin() const { return Descriptions.begin(); }
 379   const_iterator end() const { return Descriptions.end(); }
 380 };
 381
 382 const OptionDescription&
 383 OptionDescriptions::FindOption(const std::string& OptName) const
 384 {
 385   const_iterator I = Descriptions.find(OptName);
 386   if (I != Descriptions.end())
 387     return I->second;
 388   else
 389     throw OptName + ": no such option!";
 390 }
 391
 392 const OptionDescription&
 393 OptionDescriptions::FindSwitch(const std::string& OptName) const
 394 {
 395   const OptionDescription& OptDesc = this->FindOption(OptName);
 396   if (!OptDesc.isSwitch())
 397     throw OptName + ": incorrect option type - should be a switch!";
 398   return OptDesc;
 399 }
 400
 401 void OptionDescriptions::InsertDescription (const OptionDescription& o)
 402 {
 403   container_type::iterator I = Descriptions.find(o.Name);
 404   if (I != Descriptions.end()) {
 405     OptionDescription& D = I->second;
 406     D.Merge(o);
 407   }
 408   else {
 409     Descriptions[o.Name] = o;
 410   }
 411 }
 412
 413 /// HandlerTable - A base class for function objects implemented as
 414 /// 'tables of handlers'.
 415 template <class T>
 416 class HandlerTable {
 417 protected:
 418   // Implementation details.
 419
 420   /// Handler -
 421   typedef void (T::* Handler) (const DagInit*);
 422   /// HandlerMap - A map from property names to property handlers
 423   typedef StringMap<Handler> HandlerMap;
 424
 425   static HandlerMap Handlers_;
 426   static bool staticMembersInitialized_;
 427
 428   T* childPtr;
 429 public:
 430
 431   HandlerTable(T* cp) : childPtr(cp)
 432   {}
 433
 434   /// operator() - Just forwards to the corresponding property
 435   /// handler.
 436   void operator() (Init* i) {
 437     const DagInit& property = InitPtrToDag(i);
 438     const std::string& property_name = GetOperatorName(property);
 439     typename HandlerMap::iterator method = Handlers_.find(property_name);
 440
 441     if (method != Handlers_.end()) {
 442       Handler h = method->second;
 443       (childPtr->*h)(&property);
 444     }
 445     else {
 446       throw "No handler found for property " + property_name + "!";
 447     }
 448   }
 449
 450   void AddHandler(const char* Property, Handler Handl) {
 451     Handlers_[Property] = Handl;
 452   }
 453 };
 454
 455 template <class T> typename HandlerTable<T>::HandlerMap
 456 HandlerTable<T>::Handlers_;
 457 template <class T> bool HandlerTable<T>::staticMembersInitialized_ = false;
 458
 459
 460 /// CollectOptionProperties - Function object for iterating over an
 461 /// option property list.
 462 class CollectOptionProperties : public HandlerTable<CollectOptionProperties> {
 463 private:
 464
 465   /// optDescs_ - OptionDescriptions table. This is where the
 466   /// information is stored.
 467   OptionDescription& optDesc_;
 468
 469 public:
 470
 471   explicit CollectOptionProperties(OptionDescription& OD)
 472     : HandlerTable<CollectOptionProperties>(this), optDesc_(OD)
 473   {
 474     if (!staticMembersInitialized_) {
 475       AddHandler("extern", &CollectOptionProperties::onExtern);
 476       AddHandler("help", &CollectOptionProperties::onHelp);
 477       AddHandler("hidden", &CollectOptionProperties::onHidden);
 478       AddHandler("init", &CollectOptionProperties::onInit);
 479       AddHandler("multi_val", &CollectOptionProperties::onMultiVal);
 480       AddHandler("one_or_more", &CollectOptionProperties::onOneOrMore);
 481       AddHandler("really_hidden", &CollectOptionProperties::onReallyHidden);
 482       AddHandler("required", &CollectOptionProperties::onRequired);
 483       AddHandler("zero_or_one", &CollectOptionProperties::onZeroOrOne);
 484
 485       staticMembersInitialized_ = true;
 486     }
 487   }
 488
 489 private:
 490
 491   /// Option property handlers --
 492   /// Methods that handle option properties such as (help) or (hidden).
 493
 494   void onExtern (const DagInit* d) {
 495     checkNumberOfArguments(d, 0);
 496     optDesc_.setExtern();
 497   }
 498
 499   void onHelp (const DagInit* d) {
 500     checkNumberOfArguments(d, 1);
 501     optDesc_.Help = InitPtrToString(d->getArg(0));
 502   }
 503
 504   void onHidden (const DagInit* d) {
 505     checkNumberOfArguments(d, 0);
 506     optDesc_.setHidden();
 507   }
 508
 509   void onReallyHidden (const DagInit* d) {
 510     checkNumberOfArguments(d, 0);
 511     optDesc_.setReallyHidden();
 512   }
 513
 514   void onRequired (const DagInit* d) {
 515     checkNumberOfArguments(d, 0);
 516     if (optDesc_.isOneOrMore())
 517       throw std::string("An option can't have both (required) "
 518                         "and (one_or_more) properties!");
 519     optDesc_.setRequired();
 520   }
 521
 522   void onInit (const DagInit* d) {
 523     checkNumberOfArguments(d, 1);
 524     Init* i = d->getArg(0);
 525     const std::string& str = i->getAsString();
 526
 527     bool correct = optDesc_.isParameter() && dynamic_cast<StringInit*>(i);
 528     correct |= (optDesc_.isSwitch() && (str == "true" || str == "false"));
 529
 530     if (!correct)
 531       throw std::string("Incorrect usage of the 'init' option property!");
 532
 533     optDesc_.InitVal = i;
 534   }
 535
 536   void onOneOrMore (const DagInit* d) {
 537     checkNumberOfArguments(d, 0);
 538     if (optDesc_.isRequired() || optDesc_.isZeroOrOne())
 539       throw std::string("Only one of (required), (zero_or_one) or "
 540                         "(one_or_more) properties is allowed!");
 541     if (!OptionType::IsList(optDesc_.Type))
 542       llvm::errs() << "Warning: specifying the 'one_or_more' property "
 543         "on a non-list option will have no effect.\n";
 544     optDesc_.setOneOrMore();
 545   }
 546
 547   void onZeroOrOne (const DagInit* d) {
 548     checkNumberOfArguments(d, 0);
 549     if (optDesc_.isRequired() || optDesc_.isOneOrMore())
 550       throw std::string("Only one of (required), (zero_or_one) or "
 551                         "(one_or_more) properties is allowed!");
 552     if (!OptionType::IsList(optDesc_.Type))
 553       llvm::errs() << "Warning: specifying the 'zero_or_one' property"
 554         "on a non-list option will have no effect.\n";
 555     optDesc_.setZeroOrOne();
 556   }
 557
 558   void onMultiVal (const DagInit* d) {
 559     checkNumberOfArguments(d, 1);
 560     int val = InitPtrToInt(d->getArg(0));
 561     if (val < 2)
 562       throw std::string("Error in the 'multi_val' property: "
 563                         "the value must be greater than 1!");
 564     if (!OptionType::IsList(optDesc_.Type))
 565       throw std::string("The multi_val property is valid only "
 566                         "on list options!");
 567     optDesc_.MultiVal = val;
 568   }
 569
 570 };
 571
 572 /// AddOption - A function object that is applied to every option
 573 /// description. Used by CollectOptionDescriptions.
 574 class AddOption {
 575 private:
 576   OptionDescriptions& OptDescs_;
 577
 578 public:
 579   explicit AddOption(OptionDescriptions& OD) : OptDescs_(OD)
 580   {}
 581
 582   void operator()(const Init* i) {
 583     const DagInit& d = InitPtrToDag(i);
 584     checkNumberOfArguments(&d, 1);
 585
 586     const OptionType::OptionType Type =
 587       stringToOptionType(GetOperatorName(d));
 588     const std::string& Name = InitPtrToString(d.getArg(0));
 589
 590     OptionDescription OD(Type, Name);
 591
 592     if (!OD.isExtern())
 593       checkNumberOfArguments(&d, 2);
 594
 595     if (OD.isAlias()) {
 596       // Aliases store the aliased option name in the 'Help' field.
 597       OD.Help = InitPtrToString(d.getArg(1));
 598     }
 599     else if (!OD.isExtern()) {
 600       processOptionProperties(&d, OD);
 601     }
 602     OptDescs_.InsertDescription(OD);
 603   }
 604
 605 private:
 606   /// processOptionProperties - Go through the list of option
 607   /// properties and call a corresponding handler for each.
 608   static void processOptionProperties (const DagInit* d, OptionDescription& o) {
 609     checkNumberOfArguments(d, 2);
 610     DagInit::const_arg_iterator B = d->arg_begin();
 611     // Skip the first argument: it's always the option name.
 612     ++B;
 613     std::for_each(B, d->arg_end(), CollectOptionProperties(o));
 614   }
 615
 616 };
 617
 618 /// CollectOptionDescriptions - Collects option properties from all
 619 /// OptionLists.
 620 void CollectOptionDescriptions (RecordVector::const_iterator B,
 621                                 RecordVector::const_iterator E,
 622                                 OptionDescriptions& OptDescs)
 623 {
 624   // For every OptionList:
 625   for (; B!=E; ++B) {
 626     RecordVector::value_type T = *B;
 627     // Throws an exception if the value does not exist.
 628     ListInit* PropList = T->getValueAsListInit("options");
 629
 630     // For every option description in this list:
 631     // collect the information and
 632     std::for_each(PropList->begin(), PropList->end(), AddOption(OptDescs));
 633   }
 634 }
 635
 636 // Tool information record
 637
 638 namespace ToolFlags {
 639   enum ToolFlags { Join = 0x1, Sink = 0x2 };
 640 }
 641
 642 struct ToolDescription : public RefCountedBase<ToolDescription> {
 643   std::string Name;
 644   Init* CmdLine;
 645   Init* Actions;
 646   StrVector InLanguage;
 647   std::string OutLanguage;
 648   std::string OutputSuffix;
 649   unsigned Flags;
 650
 651   // Various boolean properties
 652   void setSink()      { Flags |= ToolFlags::Sink; }
 653   bool isSink() const { return Flags & ToolFlags::Sink; }
 654   void setJoin()      { Flags |= ToolFlags::Join; }
 655   bool isJoin() const { return Flags & ToolFlags::Join; }
 656
 657   // Default ctor here is needed because StringMap can only store
 658   // DefaultConstructible objects
 659   ToolDescription() : CmdLine(0), Actions(0), Flags(0) {}
 660   ToolDescription (const std::string& n)
 661   : Name(n), CmdLine(0), Actions(0), Flags(0)
 662   {}
 663 };
 664
 665 /// ToolDescriptions - A list of Tool information records.
 666 typedef std::vector<IntrusiveRefCntPtr<ToolDescription> > ToolDescriptions;
 667
 668
 669 /// CollectToolProperties - Function object for iterating over a list of
 670 /// tool property records.
 671 class CollectToolProperties : public HandlerTable<CollectToolProperties> {
 672 private:
 673
 674   /// toolDesc_ - Properties of the current Tool. This is where the
 675   /// information is stored.
 676   ToolDescription& toolDesc_;
 677
 678 public:
 679
 680   explicit CollectToolProperties (ToolDescription& d)
 681     : HandlerTable<CollectToolProperties>(this) , toolDesc_(d)
 682   {
 683     if (!staticMembersInitialized_) {
 684
 685       AddHandler("actions", &CollectToolProperties::onActions);
 686       AddHandler("cmd_line", &CollectToolProperties::onCmdLine);
 687       AddHandler("in_language", &CollectToolProperties::onInLanguage);
 688       AddHandler("join", &CollectToolProperties::onJoin);
 689       AddHandler("out_language", &CollectToolProperties::onOutLanguage);
 690       AddHandler("output_suffix", &CollectToolProperties::onOutputSuffix);
 691       AddHandler("sink", &CollectToolProperties::onSink);
 692
 693       staticMembersInitialized_ = true;
 694     }
 695   }
 696
 697 private:
 698
 699   /// Property handlers --
 700   /// Functions that extract information about tool properties from
 701   /// DAG representation.
 702
 703   void onActions (const DagInit* d) {
 704     checkNumberOfArguments(d, 1);
 705     Init* Case = d->getArg(0);
 706     if (typeid(*Case) != typeid(DagInit) ||
 707         GetOperatorName(static_cast<DagInit*>(Case)) != "case")
 708       throw
 709         std::string("The argument to (actions) should be a 'case' construct!");
 710     toolDesc_.Actions = Case;
 711   }
 712
 713   void onCmdLine (const DagInit* d) {
 714     checkNumberOfArguments(d, 1);
 715     toolDesc_.CmdLine = d->getArg(0);
 716   }
 717
 718   void onInLanguage (const DagInit* d) {
 719     checkNumberOfArguments(d, 1);
 720     Init* arg = d->getArg(0);
 721
 722     // Find out the argument's type.
 723     if (typeid(*arg) == typeid(StringInit)) {
 724       // It's a string.
 725       toolDesc_.InLanguage.push_back(InitPtrToString(arg));
 726     }
 727     else {
 728       // It's a list.
 729       const ListInit& lst = InitPtrToList(arg);
 730       StrVector& out = toolDesc_.InLanguage;
 731
 732       // Copy strings to the output vector.
 733       for (ListInit::const_iterator B = lst.begin(), E = lst.end();
 734            B != E; ++B) {
 735         out.push_back(InitPtrToString(*B));
 736       }
 737
 738       // Remove duplicates.
 739       std::sort(out.begin(), out.end());
 740       StrVector::iterator newE = std::unique(out.begin(), out.end());
 741       out.erase(newE, out.end());
 742     }
 743   }
 744
 745   void onJoin (const DagInit* d) {
 746     checkNumberOfArguments(d, 0);
 747     toolDesc_.setJoin();
 748   }
 749
 750   void onOutLanguage (const DagInit* d) {
 751     checkNumberOfArguments(d, 1);
 752     toolDesc_.OutLanguage = InitPtrToString(d->getArg(0));
 753   }
 754
 755   void onOutputSuffix (const DagInit* d) {
 756     checkNumberOfArguments(d, 1);
 757     toolDesc_.OutputSuffix = InitPtrToString(d->getArg(0));
 758   }
 759
 760   void onSink (const DagInit* d) {
 761     checkNumberOfArguments(d, 0);
 762     toolDesc_.setSink();
 763   }
 764
 765 };
 766
 767 /// CollectToolDescriptions - Gather information about tool properties
 768 /// from the parsed TableGen data (basically a wrapper for the
 769 /// CollectToolProperties function object).
 770 void CollectToolDescriptions (RecordVector::const_iterator B,
 771                               RecordVector::const_iterator E,
 772                               ToolDescriptions& ToolDescs)
 773 {
 774   // Iterate over a properties list of every Tool definition
 775   for (;B!=E;++B) {
 776     const Record* T = *B;
 777     // Throws an exception if the value does not exist.
 778     ListInit* PropList = T->getValueAsListInit("properties");
 779
 780     IntrusiveRefCntPtr<ToolDescription>
 781       ToolDesc(new ToolDescription(T->getName()));
 782
 783     std::for_each(PropList->begin(), PropList->end(),
 784                   CollectToolProperties(*ToolDesc));
 785     ToolDescs.push_back(ToolDesc);
 786   }
 787 }
 788
 789 /// FillInEdgeVector - Merge all compilation graph definitions into
 790 /// one single edge list.
 791 void FillInEdgeVector(RecordVector::const_iterator B,
 792                       RecordVector::const_iterator E, RecordVector& Out) {
 793   for (; B != E; ++B) {
 794     const ListInit* edges = (*B)->getValueAsListInit("edges");
 795
 796     for (unsigned i = 0; i < edges->size(); ++i)
 797       Out.push_back(edges->getElementAsRecord(i));
 798   }
 799 }
 800
 801 /// CalculatePriority - Calculate the priority of this plugin.
 802 int CalculatePriority(RecordVector::const_iterator B,
 803                       RecordVector::const_iterator E) {
 804   int priority = 0;
 805
 806   if (B != E) {
 807     priority  = static_cast<int>((*B)->getValueAsInt("priority"));
 808
 809     if (++B != E)
 810       throw std::string("More than one 'PluginPriority' instance found: "
 811                         "most probably an error!");
 812   }
 813
 814   return priority;
 815 }
 816
 817 /// NotInGraph - Helper function object for FilterNotInGraph.
 818 struct NotInGraph {
 819 private:
 820   const llvm::StringSet<>& ToolsInGraph_;
 821
 822 public:
 823   NotInGraph(const llvm::StringSet<>& ToolsInGraph)
 824   : ToolsInGraph_(ToolsInGraph)
 825   {}
 826
 827   bool operator()(const IntrusiveRefCntPtr<ToolDescription>& x) {
 828     return (ToolsInGraph_.count(x->Name) == 0);
 829   }
 830 };
 831
 832 /// FilterNotInGraph - Filter out from ToolDescs all Tools not
 833 /// mentioned in the compilation graph definition.
 834 void FilterNotInGraph (const RecordVector& EdgeVector,
 835                        ToolDescriptions& ToolDescs) {
 836
 837   // List all tools mentioned in the graph.
 838   llvm::StringSet<> ToolsInGraph;
 839
 840   for (RecordVector::const_iterator B = EdgeVector.begin(),
 841          E = EdgeVector.end(); B != E; ++B) {
 842
 843     const Record* Edge = *B;
 844     const std::string& NodeA = Edge->getValueAsString("a");
 845     const std::string& NodeB = Edge->getValueAsString("b");
 846
 847     if (NodeA != "root")
 848       ToolsInGraph.insert(NodeA);
 849     ToolsInGraph.insert(NodeB);
 850   }
 851
 852   // Filter ToolPropertiesList.
 853   ToolDescriptions::iterator new_end =
 854     std::remove_if(ToolDescs.begin(), ToolDescs.end(),
 855                    NotInGraph(ToolsInGraph));
 856   ToolDescs.erase(new_end, ToolDescs.end());
 857 }
 858
 859 /// FillInToolToLang - Fills in two tables that map tool names to
 860 /// (input, output) languages.  Helper function used by TypecheckGraph().
 861 void FillInToolToLang (const ToolDescriptions& ToolDescs,
 862                        StringMap<StringSet<> >& ToolToInLang,
 863                        StringMap<std::string>& ToolToOutLang) {
 864   for (ToolDescriptions::const_iterator B = ToolDescs.begin(),
 865          E = ToolDescs.end(); B != E; ++B) {
 866     const ToolDescription& D = *(*B);
 867     for (StrVector::const_iterator B = D.InLanguage.begin(),
 868            E = D.InLanguage.end(); B != E; ++B)
 869       ToolToInLang[D.Name].insert(*B);
 870     ToolToOutLang[D.Name] = D.OutLanguage;
 871   }
 872 }
 873
 874 /// TypecheckGraph - Check that names for output and input languages
 875 /// on all edges do match. This doesn't do much when the information
 876 /// about the whole graph is not available (i.e. when compiling most
 877 /// plugins).
 878 void TypecheckGraph (const RecordVector& EdgeVector,
 879                      const ToolDescriptions& ToolDescs) {
 880   StringMap<StringSet<> > ToolToInLang;
 881   StringMap<std::string> ToolToOutLang;
 882
 883   FillInToolToLang(ToolDescs, ToolToInLang, ToolToOutLang);
 884   StringMap<std::string>::iterator IAE = ToolToOutLang.end();
 885   StringMap<StringSet<> >::iterator IBE = ToolToInLang.end();
 886
 887   for (RecordVector::const_iterator B = EdgeVector.begin(),
 888          E = EdgeVector.end(); B != E; ++B) {
 889     const Record* Edge = *B;
 890     const std::string& NodeA = Edge->getValueAsString("a");
 891     const std::string& NodeB = Edge->getValueAsString("b");
 892     StringMap<std::string>::iterator IA = ToolToOutLang.find(NodeA);
 893     StringMap<StringSet<> >::iterator IB = ToolToInLang.find(NodeB);
 894
 895     if (NodeA != "root") {
 896       if (IA != IAE && IB != IBE && IB->second.count(IA->second) == 0)
 897         throw "Edge " + NodeA + "->" + NodeB
 898           + ": output->input language mismatch";
 899     }
 900
 901     if (NodeB == "root")
 902       throw std::string("Edges back to the root are not allowed!");
 903   }
 904 }
 905
 906 /// WalkCase - Walks the 'case' expression DAG and invokes
 907 /// TestCallback on every test, and StatementCallback on every
 908 /// statement. Handles 'case' nesting, but not the 'and' and 'or'
 909 /// combinators (that is, they are passed directly to TestCallback).
 910 /// TestCallback must have type 'void TestCallback(const DagInit*, unsigned
 911 /// IndentLevel, bool FirstTest)'.
 912 /// StatementCallback must have type 'void StatementCallback(const Init*,
 913 /// unsigned IndentLevel)'.
 914 template <typename F1, typename F2>
 915 void WalkCase(const Init* Case, F1 TestCallback, F2 StatementCallback,
 916               unsigned IndentLevel = 0)
 917 {
 918   const DagInit& d = InitPtrToDag(Case);
 919
 920   // Error checks.
 921   if (GetOperatorName(d) != "case")
 922     throw std::string("WalkCase should be invoked only on 'case' expressions!");
 923
 924   if (d.getNumArgs() < 2)
 925     throw "There should be at least one clause in the 'case' expression:\n"
 926       + d.getAsString();
 927
 928   // Main loop.
 929   bool even = false;
 930   const unsigned numArgs = d.getNumArgs();
 931   unsigned i = 1;
 932   for (DagInit::const_arg_iterator B = d.arg_begin(), E = d.arg_end();
 933        B != E; ++B) {
 934     Init* arg = *B;
 935
 936     if (!even)
 937     {
 938       // Handle test.
 939       const DagInit& Test = InitPtrToDag(arg);
 940
 941       if (GetOperatorName(Test) == "default" && (i+1 != numArgs))
 942         throw std::string("The 'default' clause should be the last in the"
 943                           "'case' construct!");
 944       if (i == numArgs)
 945         throw "Case construct handler: no corresponding action "
 946           "found for the test " + Test.getAsString() + '!';
 947
 948       TestCallback(&Test, IndentLevel, (i == 1));
 949     }
 950     else
 951     {
 952       if (dynamic_cast<DagInit*>(arg)
 953           && GetOperatorName(static_cast<DagInit*>(arg)) == "case") {
 954         // Nested 'case'.
 955         WalkCase(arg, TestCallback, StatementCallback, IndentLevel + Indent1);
 956       }
 957
 958       // Handle statement.
 959       StatementCallback(arg, IndentLevel);
 960     }
 961
 962     ++i;
 963     even = !even;
 964   }
 965 }
 966
 967 /// ExtractOptionNames - A helper function object used by
 968 /// CheckForSuperfluousOptions() to walk the 'case' DAG.
 969 class ExtractOptionNames {
 970   llvm::StringSet<>& OptionNames_;
 971
 972   void processDag(const Init* Statement) {
 973     const DagInit& Stmt = InitPtrToDag(Statement);
 974     const std::string& ActionName = GetOperatorName(Stmt);
 975     if (ActionName == "forward" || ActionName == "forward_as" ||
 976         ActionName == "unpack_values" || ActionName == "switch_on" ||
 977         ActionName == "parameter_equals" || ActionName == "element_in_list" ||
 978         ActionName == "not_empty" || ActionName == "empty") {
 979       checkNumberOfArguments(&Stmt, 1);
 980       const std::string& Name = InitPtrToString(Stmt.getArg(0));
 981       OptionNames_.insert(Name);
 982     }
 983     else if (ActionName == "and" || ActionName == "or") {
 984       for (unsigned i = 0, NumArgs = Stmt.getNumArgs(); i < NumArgs; ++i) {
 985         this->processDag(Stmt.getArg(i));
 986       }
 987     }
 988   }
 989
 990 public:
 991   ExtractOptionNames(llvm::StringSet<>& OptionNames) : OptionNames_(OptionNames)
 992   {}
 993
 994   void operator()(const Init* Statement) {
 995     if (typeid(*Statement) == typeid(ListInit)) {
 996       const ListInit& DagList = *static_cast<const ListInit*>(Statement);
 997       for (ListInit::const_iterator B = DagList.begin(), E = DagList.end();
 998            B != E; ++B)
 999         this->processDag(*B);
1000     }
1001     else {
1002       this->processDag(Statement);
1003     }
1004   }
1005
1006   void operator()(const DagInit* Test, unsigned, bool) {
1007     this->operator()(Test);
1008   }
1009   void operator()(const Init* Statement, unsigned) {
1010     this->operator()(Statement);
1011   }
1012 };
1013
1014 /// CheckForSuperfluousOptions - Check that there are no side
1015 /// effect-free options (specified only in the OptionList). Otherwise,
1016 /// output a warning.
1017 void CheckForSuperfluousOptions (const RecordVector& Edges,
1018                                  const ToolDescriptions& ToolDescs,
1019                                  const OptionDescriptions& OptDescs) {
1020   llvm::StringSet<> nonSuperfluousOptions;
1021
1022   // Add all options mentioned in the ToolDesc.Actions to the set of
1023   // non-superfluous options.
1024   for (ToolDescriptions::const_iterator B = ToolDescs.begin(),
1025          E = ToolDescs.end(); B != E; ++B) {
1026     const ToolDescription& TD = *(*B);
1027     ExtractOptionNames Callback(nonSuperfluousOptions);
1028     if (TD.Actions)
1029       WalkCase(TD.Actions, Callback, Callback);
1030   }
1031
1032   // Add all options mentioned in the 'case' clauses of the
1033   // OptionalEdges of the compilation graph to the set of
1034   // non-superfluous options.
1035   for (RecordVector::const_iterator B = Edges.begin(), E = Edges.end();
1036        B != E; ++B) {
1037     const Record* Edge = *B;
1038     DagInit* Weight = Edge->getValueAsDag("weight");
1039
1040     if (!isDagEmpty(Weight))
1041       WalkCase(Weight, ExtractOptionNames(nonSuperfluousOptions), Id());
1042   }
1043
1044   // Check that all options in OptDescs belong to the set of
1045   // non-superfluous options.
1046   for (OptionDescriptions::const_iterator B = OptDescs.begin(),
1047          E = OptDescs.end(); B != E; ++B) {
1048     const OptionDescription& Val = B->second;
1049     if (!nonSuperfluousOptions.count(Val.Name)
1050         && Val.Type != OptionType::Alias)
1051       llvm::errs() << "Warning: option '-" << Val.Name << "' has no effect! "
1052         "Probable cause: this option is specified only in the OptionList.\n";
1053   }
1054 }
1055
1056 /// EmitCaseTest0Args - Helper function used by EmitCaseConstructHandler().
1057 bool EmitCaseTest0Args(const std::string& TestName, raw_ostream& O) {
1058   if (TestName == "single_input_file") {
1059     O << "InputFilenames.size() == 1";
1060     return true;
1061   }
1062   else if (TestName == "multiple_input_files") {
1063     O << "InputFilenames.size() > 1";
1064     return true;
1065   }
1066
1067   return false;
1068 }
1069
1070 /// EmitCaseTest1ArgStr - Helper function used by EmitCaseTest1Arg();
1071 bool EmitCaseTest1ArgStr(const std::string& TestName,
1072                          const DagInit& d,
1073                          const OptionDescriptions& OptDescs,
1074                          raw_ostream& O) {
1075   const std::string& OptName = InitPtrToString(d.getArg(0));
1076
1077   if (TestName == "switch_on") {
1078     const OptionDescription& OptDesc = OptDescs.FindSwitch(OptName);
1079     O << OptDesc.GenVariableName();
1080     return true;
1081   }
1082   else if (TestName == "input_languages_contain") {
1083     O << "InLangs.count(\"" << OptName << "\") != 0";
1084     return true;
1085   }
1086   else if (TestName == "in_language") {
1087     // This works only for single-argument Tool::GenerateAction. Join
1088     // tools can process several files in different languages simultaneously.
1089
1090     // TODO: make this work with Edge::Weight (if possible).
1091     O << "LangMap.GetLanguage(inFile) == \"" << OptName << '\"';
1092     return true;
1093   }
1094   else if (TestName == "not_empty" || TestName == "empty") {
1095     const char* Test = (TestName == "empty") ? "" : "!";
1096
1097     if (OptName == "o") {
1098       O << Test << "OutputFilename.empty()";
1099       return true;
1100     }
1101     else {
1102       const OptionDescription& OptDesc = OptDescs.FindOption(OptName);
1103       if (OptDesc.isSwitch())
1104         throw OptName
1105           + ": incorrect option type - should be a list or parameter!";
1106       O << Test << OptDesc.GenVariableName() << ".empty()";
1107       return true;
1108     }
1109   }
1110
1111   return false;
1112 }
1113
1114 /// EmitCaseTest1ArgList - Helper function used by EmitCaseTest1Arg();
1115 bool EmitCaseTest1ArgList(const std::string& TestName,
1116                           const DagInit& d,
1117                           const OptionDescriptions& OptDescs,
1118                           raw_ostream& O) {
1119   const ListInit& L = *static_cast<ListInit*>(d.getArg(0));
1120
1121   if (TestName == "any_switch_on") {
1122     bool isFirst = true;
1123
1124     for (ListInit::const_iterator B = L.begin(), E = L.end(); B != E; ++B) {
1125       const std::string& OptName = InitPtrToString(*B);
1126       const OptionDescription& OptDesc = OptDescs.FindSwitch(OptName);
1127
1128       if (isFirst)
1129         isFirst = false;
1130       else
1131         O << " || ";
1132       O << OptDesc.GenVariableName();
1133     }
1134
1135     return true;
1136   }
1137
1138   // TODO: implement any_not_empty, any_empty, switch_on [..], empty [..]
1139
1140   return false;
1141 }
1142
1143 /// EmitCaseTest1Arg - Helper function used by EmitCaseConstructHandler();
1144 bool EmitCaseTest1Arg(const std::string& TestName,
1145                       const DagInit& d,
1146                       const OptionDescriptions& OptDescs,
1147                       raw_ostream& O) {
1148   checkNumberOfArguments(&d, 1);
1149   if (typeid(*d.getArg(0)) == typeid(ListInit))
1150     return EmitCaseTest1ArgList(TestName, d, OptDescs, O);
1151   else
1152     return EmitCaseTest1ArgStr(TestName, d, OptDescs, O);
1153 }
1154
1155 /// EmitCaseTest2Args - Helper function used by EmitCaseConstructHandler().
1156 bool EmitCaseTest2Args(const std::string& TestName,
1157                        const DagInit& d,
1158                        unsigned IndentLevel,
1159                        const OptionDescriptions& OptDescs,
1160                        raw_ostream& O) {
1161   checkNumberOfArguments(&d, 2);
1162   const std::string& OptName = InitPtrToString(d.getArg(0));
1163   const std::string& OptArg = InitPtrToString(d.getArg(1));
1164   const OptionDescription& OptDesc = OptDescs.FindOption(OptName);
1165
1166   if (TestName == "parameter_equals") {
1167     if (!OptDesc.isParameter())
1168       throw OptName + ": incorrect option type - should be a parameter!";
1169     O << OptDesc.GenVariableName() << " == \"" << OptArg << "\"";
1170     return true;
1171   }
1172   else if (TestName == "element_in_list") {
1173     if (!OptDesc.isList())
1174       throw OptName + ": incorrect option type - should be a list!";
1175     const std::string& VarName = OptDesc.GenVariableName();
1176     O << "std::find(" << VarName << ".begin(),\n";
1177     O.indent(IndentLevel + Indent1)
1178       << VarName << ".end(), \""
1179       << OptArg << "\") != " << VarName << ".end()";
1180     return true;
1181   }
1182
1183   return false;
1184 }
1185
1186 // Forward declaration.
1187 // EmitLogicalOperationTest and EmitCaseTest are mutually recursive.
1188 void EmitCaseTest(const DagInit& d, unsigned IndentLevel,
1189                   const OptionDescriptions& OptDescs,
1190                   raw_ostream& O);
1191
1192 /// EmitLogicalOperationTest - Helper function used by
1193 /// EmitCaseConstructHandler.
1194 void EmitLogicalOperationTest(const DagInit& d, const char* LogicOp,
1195                               unsigned IndentLevel,
1196                               const OptionDescriptions& OptDescs,
1197                               raw_ostream& O) {
1198   O << '(';
1199   for (unsigned j = 0, NumArgs = d.getNumArgs(); j < NumArgs; ++j) {
1200     const DagInit& InnerTest = InitPtrToDag(d.getArg(j));
1201     EmitCaseTest(InnerTest, IndentLevel, OptDescs, O);
1202     if (j != NumArgs - 1) {
1203       O << ")\n";
1204       O.indent(IndentLevel + Indent1) << ' ' << LogicOp << " (";
1205     }
1206     else {
1207       O << ')';
1208     }
1209   }
1210 }
1211
1212 void EmitLogicalNot(const DagInit& d, unsigned IndentLevel,
1213                     const OptionDescriptions& OptDescs, raw_ostream& O)
1214 {
1215   checkNumberOfArguments(&d, 1);
1216   const DagInit& InnerTest = InitPtrToDag(d.getArg(0));
1217   O << "! (";
1218   EmitCaseTest(InnerTest, IndentLevel, OptDescs, O);
1219   O << ")";
1220 }
1221
1222 /// EmitCaseTest - Helper function used by EmitCaseConstructHandler.
1223 void EmitCaseTest(const DagInit& d, unsigned IndentLevel,
1224                   const OptionDescriptions& OptDescs,
1225                   raw_ostream& O) {
1226   const std::string& TestName = GetOperatorName(d);
1227
1228   if (TestName == "and")
1229     EmitLogicalOperationTest(d, "&&", IndentLevel, OptDescs, O);
1230   else if (TestName == "or")
1231     EmitLogicalOperationTest(d, "||", IndentLevel, OptDescs, O);
1232   else if (TestName == "not")
1233     EmitLogicalNot(d, IndentLevel, OptDescs, O);
1234   else if (EmitCaseTest0Args(TestName, O))
1235     return;
1236   else if (EmitCaseTest1Arg(TestName, d, OptDescs, O))
1237     return;
1238   else if (EmitCaseTest2Args(TestName, d, IndentLevel, OptDescs, O))
1239     return;
1240   else
1241     throw TestName + ": unknown edge property!";
1242 }
1243
1244
1245 /// EmitCaseTestCallback - Callback used by EmitCaseConstructHandler.
1246 class EmitCaseTestCallback {
1247   bool EmitElseIf_;
1248   const OptionDescriptions& OptDescs_;
1249   raw_ostream& O_;
1250 public:
1251
1252   EmitCaseTestCallback(bool EmitElseIf,
1253                        const OptionDescriptions& OptDescs, raw_ostream& O)
1254     : EmitElseIf_(EmitElseIf), OptDescs_(OptDescs), O_(O)
1255   {}
1256
1257   void operator()(const DagInit* Test, unsigned IndentLevel, bool FirstTest)
1258   {
1259     if (GetOperatorName(Test) == "default") {
1260       O_.indent(IndentLevel) << "else {\n";
1261     }
1262     else {
1263       O_.indent(IndentLevel)
1264         << ((!FirstTest && EmitElseIf_) ? "else if (" : "if (");
1265       EmitCaseTest(*Test, IndentLevel, OptDescs_, O_);
1266       O_ << ") {\n";
1267     }
1268   }
1269 };
1270
1271 /// EmitCaseStatementCallback - Callback used by EmitCaseConstructHandler.
1272 template <typename F>
1273 class EmitCaseStatementCallback {
1274   F Callback_;
1275   raw_ostream& O_;
1276 public:
1277
1278   EmitCaseStatementCallback(F Callback, raw_ostream& O)
1279     : Callback_(Callback), O_(O)
1280   {}
1281
1282   // TODO: Handle lists here.
1283   void operator() (const Init* Statement, unsigned IndentLevel) {
1284     // Ignore nested 'case' DAG.
1285     if (!(dynamic_cast<const DagInit*>(Statement) &&
1286           GetOperatorName(static_cast<const DagInit*>(Statement)) == "case"))
1287       Callback_(Statement, (IndentLevel + Indent1), O_);
1288     O_.indent(IndentLevel) << "}\n";
1289   }
1290
1291 };
1292
1293 /// EmitCaseConstructHandler - Emit code that handles the 'case'
1294 /// construct. Takes a function object that should emit code for every case
1295 /// clause. Implemented on top of WalkCase.
1296 /// Callback's type is void F(Init* Statement, unsigned IndentLevel,
1297 /// raw_ostream& O).
1298 /// EmitElseIf parameter controls the type of condition that is emitted ('if
1299 /// (..) {..} else if (..) {} .. else {..}' vs. 'if (..) {..} if(..)  {..}
1300 /// .. else {..}').
1301 template <typename F>
1302 void EmitCaseConstructHandler(const Init* Case, unsigned IndentLevel,
1303                               F Callback, bool EmitElseIf,
1304                               const OptionDescriptions& OptDescs,
1305                               raw_ostream& O) {
1306   WalkCase(Case, EmitCaseTestCallback(EmitElseIf, OptDescs, O),
1307            EmitCaseStatementCallback<F>(Callback, O), IndentLevel);
1308 }
1309
1310 /// TokenizeCmdline - converts from "$CALL(HookName, 'Arg1', 'Arg2')/path" to
1311 /// ["$CALL(", "HookName", "Arg1", "Arg2", ")/path"] .
1312 /// Helper function used by EmitCmdLineVecFill and.
1313 void TokenizeCmdline(const std::string& CmdLine, StrVector& Out) {
1314   const char* Delimiters = " \t\n\v\f\r";
1315   enum TokenizerState
1316   { Normal, SpecialCommand, InsideSpecialCommand, InsideQuotationMarks }
1317   cur_st  = Normal;
1318
1319   if (CmdLine.empty())
1320     return;
1321   Out.push_back("");
1322
1323   std::string::size_type B = CmdLine.find_first_not_of(Delimiters),
1324     E = CmdLine.size();
1325
1326   for (; B != E; ++B) {
1327     char cur_ch = CmdLine[B];
1328
1329     switch (cur_st) {
1330     case Normal:
1331       if (cur_ch == '$') {
1332         cur_st = SpecialCommand;
1333         break;
1334       }
1335       if (oneOf(Delimiters, cur_ch)) {
1336         // Skip whitespace
1337         B = CmdLine.find_first_not_of(Delimiters, B);
1338         if (B == std::string::npos) {
1339           B = E-1;
1340           continue;
1341         }
1342         --B;
1343         Out.push_back("");
1344         continue;
1345       }
1346       break;
1347
1348
1349     case SpecialCommand:
1350       if (oneOf(Delimiters, cur_ch)) {
1351         cur_st = Normal;
1352         Out.push_back("");
1353         continue;
1354       }
1355       if (cur_ch == '(') {
1356         Out.push_back("");
1357         cur_st = InsideSpecialCommand;
1358         continue;
1359       }
1360       break;
1361
1362     case InsideSpecialCommand:
1363       if (oneOf(Delimiters, cur_ch)) {
1364         continue;
1365       }
1366       if (cur_ch == '\'') {
1367         cur_st = InsideQuotationMarks;
1368         Out.push_back("");
1369         continue;
1370       }
1371       if (cur_ch == ')') {
1372         cur_st = Normal;
1373         Out.push_back("");
1374       }
1375       if (cur_ch == ',') {
1376         continue;
1377       }
1378
1379       break;
1380
1381     case InsideQuotationMarks:
1382       if (cur_ch == '\'') {
1383         cur_st = InsideSpecialCommand;
1384         continue;
1385       }
1386       break;
1387     }
1388
1389     Out.back().push_back(cur_ch);
1390   }
1391 }
1392
1393 /// SubstituteSpecialCommands - Perform string substitution for $CALL
1394 /// and $ENV. Helper function used by EmitCmdLineVecFill().
1395 StrVector::const_iterator SubstituteSpecialCommands
1396 (StrVector::const_iterator Pos, StrVector::const_iterator End, raw_ostream& O)
1397 {
1398
1399   const std::string& cmd = *Pos;
1400
1401   if (cmd == "$CALL") {
1402     checkedIncrement(Pos, End, "Syntax error in $CALL invocation!");
1403     const std::string& CmdName = *Pos;
1404
1405     if (CmdName == ")")
1406       throw std::string("$CALL invocation: empty argument list!");
1407
1408     O << "hooks::";
1409     O << CmdName << "(";
1410
1411
1412     bool firstIteration = true;
1413     while (true) {
1414       checkedIncrement(Pos, End, "Syntax error in $CALL invocation!");
1415       const std::string& Arg = *Pos;
1416       assert(Arg.size() != 0);
1417
1418       if (Arg[0] == ')')
1419         break;
1420
1421       if (firstIteration)
1422         firstIteration = false;
1423       else
1424         O << ", ";
1425
1426       O << '"' << Arg << '"';
1427     }
1428
1429     O << ')';
1430
1431   }
1432   else if (cmd == "$ENV") {
1433     checkedIncrement(Pos, End, "Syntax error in $ENV invocation!");
1434     const std::string& EnvName = *Pos;
1435
1436     if (EnvName == ")")
1437       throw "$ENV invocation: empty argument list!";
1438
1439     O << "checkCString(std::getenv(\"";
1440     O << EnvName;
1441     O << "\"))";
1442
1443     checkedIncrement(Pos, End, "Syntax error in $ENV invocation!");
1444   }
1445   else {
1446     throw "Unknown special command: " + cmd;
1447   }
1448
1449   const std::string& Leftover = *Pos;
1450   assert(Leftover.at(0) == ')');
1451   if (Leftover.size() != 1)
1452     O << " + std::string(\"" << (Leftover.c_str() + 1) << "\")";
1453
1454   return Pos;
1455 }
1456
1457 /// EmitCmdLineVecFill - Emit code that fills in the command line
1458 /// vector. Helper function used by EmitGenerateActionMethod().
1459 void EmitCmdLineVecFill(const Init* CmdLine, const std::string& ToolName,
1460                         bool IsJoin, unsigned IndentLevel,
1461                         raw_ostream& O) {
1462   StrVector StrVec;
1463   TokenizeCmdline(InitPtrToString(CmdLine), StrVec);
1464
1465   if (StrVec.empty())
1466     throw "Tool '" + ToolName + "' has empty command line!";
1467
1468   StrVector::const_iterator I = StrVec.begin(), E = StrVec.end();
1469
1470   // If there is a hook invocation on the place of the first command, skip it.
1471   assert(!StrVec[0].empty());
1472   if (StrVec[0][0] == '$') {
1473     while (I != E && (*I)[0] != ')' )
1474       ++I;
1475
1476     // Skip the ')' symbol.
1477     ++I;
1478   }
1479   else {
1480     ++I;
1481   }
1482
1483   bool hasINFILE = false;
1484
1485   for (; I != E; ++I) {
1486     const std::string& cmd = *I;
1487     assert(!cmd.empty());
1488     O.indent(IndentLevel);
1489     if (cmd.at(0) == '$') {
1490       if (cmd == "$INFILE") {
1491         hasINFILE = true;
1492         if (IsJoin) {
1493           O << "for (PathVector::const_iterator B = inFiles.begin()"
1494             << ", E = inFiles.end();\n";
1495           O.indent(IndentLevel) << "B != E; ++B)\n";
1496           O.indent(IndentLevel + Indent1) << "vec.push_back(B->str());\n";
1497         }
1498         else {
1499           O << "vec.push_back(inFile.str());\n";
1500         }
1501       }
1502       else if (cmd == "$OUTFILE") {
1503         O << "vec.push_back(\"\");\n";
1504         O.indent(IndentLevel) << "out_file_index = vec.size()-1;\n";
1505       }
1506       else {
1507         O << "vec.push_back(";
1508         I = SubstituteSpecialCommands(I, E, O);
1509         O << ");\n";
1510       }
1511     }
1512     else {
1513       O << "vec.push_back(\"" << cmd << "\");\n";
1514     }
1515   }
1516   if (!hasINFILE)
1517     throw "Tool '" + ToolName + "' doesn't take any input!";
1518
1519   O.indent(IndentLevel) << "cmd = ";
1520   if (StrVec[0][0] == '$')
1521     SubstituteSpecialCommands(StrVec.begin(), StrVec.end(), O);
1522   else
1523     O << '"' << StrVec[0] << '"';
1524   O << ";\n";
1525 }
1526
1527 /// EmitCmdLineVecFillCallback - A function object wrapper around
1528 /// EmitCmdLineVecFill(). Used by EmitGenerateActionMethod() as an
1529 /// argument to EmitCaseConstructHandler().
1530 class EmitCmdLineVecFillCallback {
1531   bool IsJoin;
1532   const std::string& ToolName;
1533  public:
1534   EmitCmdLineVecFillCallback(bool J, const std::string& TN)
1535     : IsJoin(J), ToolName(TN) {}
1536
1537   void operator()(const Init* Statement, unsigned IndentLevel,
1538                   raw_ostream& O) const
1539   {
1540     EmitCmdLineVecFill(Statement, ToolName, IsJoin, IndentLevel, O);
1541   }
1542 };
1543
1544 /// EmitForwardOptionPropertyHandlingCode - Helper function used to
1545 /// implement EmitActionHandler. Emits code for
1546 /// handling the (forward) and (forward_as) option properties.
1547 void EmitForwardOptionPropertyHandlingCode (const OptionDescription& D,
1548                                             unsigned IndentLevel,
1549                                             const std::string& NewName,
1550                                             raw_ostream& O) {
1551   const std::string& Name = NewName.empty()
1552     ? ("-" + D.Name)
1553     : NewName;
1554   unsigned IndentLevel1 = IndentLevel + Indent1;
1555
1556   switch (D.Type) {
1557   case OptionType::Switch:
1558     O.indent(IndentLevel) << "vec.push_back(\"" << Name << "\");\n";
1559     break;
1560   case OptionType::Parameter:
1561     O.indent(IndentLevel) << "vec.push_back(\"" << Name << "\");\n";
1562     O.indent(IndentLevel) << "vec.push_back(" << D.GenVariableName() << ");\n";
1563     break;
1564   case OptionType::Prefix:
1565     O.indent(IndentLevel) << "vec.push_back(\"" << Name << "\" + "
1566                           << D.GenVariableName() << ");\n";
1567     break;
1568   case OptionType::PrefixList:
1569     O.indent(IndentLevel)
1570       << "for (" << D.GenTypeDeclaration()
1571       << "::iterator B = " << D.GenVariableName() << ".begin(),\n";
1572     O.indent(IndentLevel)
1573       << "E = " << D.GenVariableName() << ".end(); B != E;) {\n";
1574     O.indent(IndentLevel1) << "vec.push_back(\"" << Name << "\" + " << "*B);\n";
1575     O.indent(IndentLevel1) << "++B;\n";
1576
1577     for (int i = 1, j = D.MultiVal; i < j; ++i) {
1578       O.indent(IndentLevel1) << "vec.push_back(*B);\n";
1579       O.indent(IndentLevel1) << "++B;\n";
1580     }
1581
1582     O.indent(IndentLevel) << "}\n";
1583     break;
1584   case OptionType::ParameterList:
1585     O.indent(IndentLevel)
1586       << "for (" << D.GenTypeDeclaration() << "::iterator B = "
1587       << D.GenVariableName() << ".begin(),\n";
1588     O.indent(IndentLevel) << "E = " << D.GenVariableName()
1589                           << ".end() ; B != E;) {\n";
1590     O.indent(IndentLevel1) << "vec.push_back(\"" << Name << "\");\n";
1591
1592     for (int i = 0, j = D.MultiVal; i < j; ++i) {
1593       O.indent(IndentLevel1) << "vec.push_back(*B);\n";
1594       O.indent(IndentLevel1) << "++B;\n";
1595     }
1596
1597     O.indent(IndentLevel) << "}\n";
1598     break;
1599   case OptionType::Alias:
1600   default:
1601     throw std::string("Aliases are not allowed in tool option descriptions!");
1602   }
1603 }
1604
1605 /// EmitActionHandler - Emit code that handles actions. Used by
1606 /// EmitGenerateActionMethod() as an argument to
1607 /// EmitCaseConstructHandler().
1608 class EmitActionHandler {
1609   const OptionDescriptions& OptDescs;
1610
1611   void processActionDag(const Init* Statement, unsigned IndentLevel,
1612                         raw_ostream& O) const
1613   {
1614     const DagInit& Dag = InitPtrToDag(Statement);
1615     const std::string& ActionName = GetOperatorName(Dag);
1616
1617     if (ActionName == "append_cmd") {
1618       checkNumberOfArguments(&Dag, 1);
1619       const std::string& Cmd = InitPtrToString(Dag.getArg(0));
1620       StrVector Out;
1621       llvm::SplitString(Cmd, Out);
1622
1623       for (StrVector::const_iterator B = Out.begin(), E = Out.end();
1624            B != E; ++B)
1625         O.indent(IndentLevel) << "vec.push_back(\"" << *B << "\");\n";
1626     }
1627     else if (ActionName == "error") {
1628       O.indent(IndentLevel) << "throw std::runtime_error(\"" <<
1629         (Dag.getNumArgs() >= 1 ? InitPtrToString(Dag.getArg(0))
1630          : "Unknown error!")
1631         << "\");\n";
1632     }
1633     else if (ActionName == "forward") {
1634       checkNumberOfArguments(&Dag, 1);
1635       const std::string& Name = InitPtrToString(Dag.getArg(0));
1636       EmitForwardOptionPropertyHandlingCode(OptDescs.FindOption(Name),
1637                                             IndentLevel, "", O);
1638     }
1639     else if (ActionName == "forward_as") {
1640       checkNumberOfArguments(&Dag, 2);
1641       const std::string& Name = InitPtrToString(Dag.getArg(0));
1642       const std::string& NewName = InitPtrToString(Dag.getArg(1));
1643       EmitForwardOptionPropertyHandlingCode(OptDescs.FindOption(Name),
1644                                             IndentLevel, NewName, O);
1645     }
1646     else if (ActionName == "output_suffix") {
1647       checkNumberOfArguments(&Dag, 1);
1648       const std::string& OutSuf = InitPtrToString(Dag.getArg(0));
1649       O.indent(IndentLevel) << "output_suffix = \"" << OutSuf << "\";\n";
1650     }
1651     else if (ActionName == "stop_compilation") {
1652       O.indent(IndentLevel) << "stop_compilation = true;\n";
1653     }
1654     else if (ActionName == "unpack_values") {
1655       checkNumberOfArguments(&Dag, 1);
1656       const std::string& Name = InitPtrToString(Dag.getArg(0));
1657       const OptionDescription& D = OptDescs.FindOption(Name);
1658
1659       if (D.isMultiVal())
1660         throw std::string("Can't use unpack_values with multi-valued options!");
1661
1662       if (D.isList()) {
1663         O.indent(IndentLevel)
1664           << "for (" << D.GenTypeDeclaration()
1665           << "::iterator B = " << D.GenVariableName() << ".begin(),\n";
1666         O.indent(IndentLevel)
1667           << "E = " << D.GenVariableName() << ".end(); B != E; ++B)\n";
1668         O.indent(IndentLevel + Indent1)
1669           << "llvm::SplitString(*B, vec, \",\");\n";
1670       }
1671       else if (D.isParameter()){
1672         O.indent(IndentLevel) << "llvm::SplitString("
1673                               << D.GenVariableName() << ", vec, \",\");\n";
1674       }
1675       else {
1676         throw "Option '" + D.Name +
1677           "': switches can't have the 'unpack_values' property!";
1678       }
1679     }
1680     else {
1681       throw "Unknown action name: " + ActionName + "!";
1682     }
1683   }
1684  public:
1685   EmitActionHandler(const OptionDescriptions& OD)
1686     : OptDescs(OD) {}
1687
1688   void operator()(const Init* Statement, unsigned IndentLevel,
1689                   raw_ostream& O) const
1690   {
1691     if (typeid(*Statement) == typeid(ListInit)) {
1692       const ListInit& DagList = *static_cast<const ListInit*>(Statement);
1693       for (ListInit::const_iterator B = DagList.begin(), E = DagList.end();
1694            B != E; ++B)
1695         this->processActionDag(*B, IndentLevel, O);
1696     }
1697     else {
1698       this->processActionDag(Statement, IndentLevel, O);
1699     }
1700   }
1701 };
1702
1703 bool IsOutFileIndexCheckRequiredStr (const Init* CmdLine) {
1704   StrVector StrVec;
1705   TokenizeCmdline(InitPtrToString(CmdLine), StrVec);
1706
1707   for (StrVector::const_iterator I = StrVec.begin(), E = StrVec.end();
1708        I != E; ++I) {
1709     if (*I == "$OUTFILE")
1710       return false;
1711   }
1712
1713   return true;
1714 }
1715
1716 class IsOutFileIndexCheckRequiredStrCallback {
1717   bool* ret_;
1718
1719 public:
1720   IsOutFileIndexCheckRequiredStrCallback(bool* ret) : ret_(ret)
1721   {}
1722
1723   void operator()(const Init* CmdLine) {
1724     // Ignore nested 'case' DAG.
1725     if (typeid(*CmdLine) == typeid(DagInit))
1726       return;
1727
1728     if (IsOutFileIndexCheckRequiredStr(CmdLine))
1729       *ret_ = true;
1730   }
1731
1732   void operator()(const DagInit* Test, unsigned, bool) {
1733     this->operator()(Test);
1734   }
1735   void operator()(const Init* Statement, unsigned) {
1736     this->operator()(Statement);
1737   }
1738 };
1739
1740 bool IsOutFileIndexCheckRequiredCase (Init* CmdLine) {
1741   bool ret = false;
1742   WalkCase(CmdLine, Id(), IsOutFileIndexCheckRequiredStrCallback(&ret));
1743   return ret;
1744 }
1745
1746 /// IsOutFileIndexCheckRequired - Should we emit an "out_file_index != -1" check
1747 /// in EmitGenerateActionMethod() ?
1748 bool IsOutFileIndexCheckRequired (Init* CmdLine) {
1749   if (typeid(*CmdLine) == typeid(StringInit))
1750     return IsOutFileIndexCheckRequiredStr(CmdLine);
1751   else
1752     return IsOutFileIndexCheckRequiredCase(CmdLine);
1753 }
1754
1755 // EmitGenerateActionMethod - Emit either a normal or a "join" version of the
1756 // Tool::GenerateAction() method.
1757 void EmitGenerateActionMethod (const ToolDescription& D,
1758                                const OptionDescriptions& OptDescs,
1759                                bool IsJoin, raw_ostream& O) {
1760   if (IsJoin)
1761     O.indent(Indent1) << "Action GenerateAction(const PathVector& inFiles,\n";
1762   else
1763     O.indent(Indent1) << "Action GenerateAction(const sys::Path& inFile,\n";
1764
1765   O.indent(Indent2) << "bool HasChildren,\n";
1766   O.indent(Indent2) << "const llvm::sys::Path& TempDir,\n";
1767   O.indent(Indent2) << "const InputLanguagesSet& InLangs,\n";
1768   O.indent(Indent2) << "const LanguageMap& LangMap) const\n";
1769   O.indent(Indent1) << "{\n";
1770   O.indent(Indent2) << "std::string cmd;\n";
1771   O.indent(Indent2) << "std::vector<std::string> vec;\n";
1772   O.indent(Indent2) << "bool stop_compilation = !HasChildren;\n";
1773   O.indent(Indent2) << "const char* output_suffix = \""
1774                     << D.OutputSuffix << "\";\n";
1775
1776   if (!D.CmdLine)
1777     throw "Tool " + D.Name + " has no cmd_line property!";
1778
1779   bool IndexCheckRequired = IsOutFileIndexCheckRequired(D.CmdLine);
1780   O.indent(Indent2) << "int out_file_index"
1781                     << (IndexCheckRequired ? " = -1" : "")
1782                     << ";\n\n";
1783
1784   // Process the cmd_line property.
1785   if (typeid(*D.CmdLine) == typeid(StringInit))
1786     EmitCmdLineVecFill(D.CmdLine, D.Name, IsJoin, Indent2, O);
1787   else
1788     EmitCaseConstructHandler(D.CmdLine, Indent2,
1789                              EmitCmdLineVecFillCallback(IsJoin, D.Name),
1790                              true, OptDescs, O);
1791
1792   // For every understood option, emit handling code.
1793   if (D.Actions)
1794     EmitCaseConstructHandler(D.Actions, Indent2, EmitActionHandler(OptDescs),
1795                              false, OptDescs, O);
1796
1797   O << '\n';
1798   O.indent(Indent2)
1799     << "std::string out_file = OutFilename("
1800     << (IsJoin ? "sys::Path(),\n" : "inFile,\n");
1801   O.indent(Indent3) << "TempDir, stop_compilation, output_suffix).str();\n\n";
1802
1803   if (IndexCheckRequired)
1804     O.indent(Indent2) << "if (out_file_index != -1)\n";
1805   O.indent(IndexCheckRequired ? Indent3 : Indent2)
1806     << "vec[out_file_index] = out_file;\n";
1807
1808   // Handle the Sink property.
1809   if (D.isSink()) {
1810     O.indent(Indent2) << "if (!" << SinkOptionName << ".empty()) {\n";
1811     O.indent(Indent3) << "vec.insert(vec.end(), "
1812                       << SinkOptionName << ".begin(), " << SinkOptionName
1813                       << ".end());\n";
1814     O.indent(Indent2) << "}\n";
1815   }
1816
1817   O.indent(Indent2) << "return Action(cmd, vec, stop_compilation, out_file);\n";
1818   O.indent(Indent1) << "}\n\n";
1819 }
1820
1821 /// EmitGenerateActionMethods - Emit two GenerateAction() methods for
1822 /// a given Tool class.
1823 void EmitGenerateActionMethods (const ToolDescription& ToolDesc,
1824                                 const OptionDescriptions& OptDescs,
1825                                 raw_ostream& O) {
1826   if (!ToolDesc.isJoin()) {
1827     O.indent(Indent1) << "Action GenerateAction(const PathVector& inFiles,\n";
1828     O.indent(Indent2) << "bool HasChildren,\n";
1829     O.indent(Indent2) << "const llvm::sys::Path& TempDir,\n";
1830     O.indent(Indent2) << "const InputLanguagesSet& InLangs,\n";
1831     O.indent(Indent2) << "const LanguageMap& LangMap) const\n";
1832     O.indent(Indent1) << "{\n";
1833     O.indent(Indent2) << "throw std::runtime_error(\"" << ToolDesc.Name
1834                       << " is not a Join tool!\");\n";
1835     O.indent(Indent1) << "}\n\n";
1836   }
1837   else {
1838     EmitGenerateActionMethod(ToolDesc, OptDescs, true, O);
1839   }
1840
1841   EmitGenerateActionMethod(ToolDesc, OptDescs, false, O);
1842 }
1843
1844 /// EmitInOutLanguageMethods - Emit the [Input,Output]Language()
1845 /// methods for a given Tool class.
1846 void EmitInOutLanguageMethods (const ToolDescription& D, raw_ostream& O) {
1847   O.indent(Indent1) << "const char** InputLanguages() const {\n";
1848   O.indent(Indent2) << "return InputLanguages_;\n";
1849   O.indent(Indent1) << "}\n\n";
1850
1851   if (D.OutLanguage.empty())
1852     throw "Tool " + D.Name + " has no 'out_language' property!";
1853
1854   O.indent(Indent1) << "const char* OutputLanguage() const {\n";
1855   O.indent(Indent2) << "return \"" << D.OutLanguage << "\";\n";
1856   O.indent(Indent1) << "}\n\n";
1857 }
1858
1859 /// EmitNameMethod - Emit the Name() method for a given Tool class.
1860 void EmitNameMethod (const ToolDescription& D, raw_ostream& O) {
1861   O.indent(Indent1) << "const char* Name() const {\n";
1862   O.indent(Indent2) << "return \"" << D.Name << "\";\n";
1863   O.indent(Indent1) << "}\n\n";
1864 }
1865
1866 /// EmitIsJoinMethod - Emit the IsJoin() method for a given Tool
1867 /// class.
1868 void EmitIsJoinMethod (const ToolDescription& D, raw_ostream& O) {
1869   O.indent(Indent1) << "bool IsJoin() const {\n";
1870   if (D.isJoin())
1871     O.indent(Indent2) << "return true;\n";
1872   else
1873     O.indent(Indent2) << "return false;\n";
1874   O.indent(Indent1) << "}\n\n";
1875 }
1876
1877 /// EmitStaticMemberDefinitions - Emit static member definitions for a
1878 /// given Tool class.
1879 void EmitStaticMemberDefinitions(const ToolDescription& D, raw_ostream& O) {
1880   if (D.InLanguage.empty())
1881     throw "Tool " + D.Name + " has no 'in_language' property!";
1882
1883   O << "const char* " << D.Name << "::InputLanguages_[] = {";
1884   for (StrVector::const_iterator B = D.InLanguage.begin(),
1885          E = D.InLanguage.end(); B != E; ++B)
1886     O << '\"' << *B << "\", ";
1887   O << "0};\n\n";
1888 }
1889
1890 /// EmitToolClassDefinition - Emit a Tool class definition.
1891 void EmitToolClassDefinition (const ToolDescription& D,
1892                               const OptionDescriptions& OptDescs,
1893                               raw_ostream& O) {
1894   if (D.Name == "root")
1895     return;
1896
1897   // Header
1898   O << "class " << D.Name << " : public ";
1899   if (D.isJoin())
1900     O << "JoinTool";
1901   else
1902     O << "Tool";
1903
1904   O << "{\nprivate:\n";
1905   O.indent(Indent1) << "static const char* InputLanguages_[];\n\n";
1906
1907   O << "public:\n";
1908   EmitNameMethod(D, O);
1909   EmitInOutLanguageMethods(D, O);
1910   EmitIsJoinMethod(D, O);
1911   EmitGenerateActionMethods(D, OptDescs, O);
1912
1913   // Close class definition
1914   O << "};\n";
1915
1916   EmitStaticMemberDefinitions(D, O);
1917
1918 }
1919
1920 /// EmitOptionDefinitions - Iterate over a list of option descriptions
1921 /// and emit registration code.
1922 void EmitOptionDefinitions (const OptionDescriptions& descs,
1923                             bool HasSink, bool HasExterns,
1924                             raw_ostream& O)
1925 {
1926   std::vector<OptionDescription> Aliases;
1927
1928   // Emit static cl::Option variables.
1929   for (OptionDescriptions::const_iterator B = descs.begin(),
1930          E = descs.end(); B!=E; ++B) {
1931     const OptionDescription& val = B->second;
1932
1933     if (val.Type == OptionType::Alias) {
1934       Aliases.push_back(val);
1935       continue;
1936     }
1937
1938     if (val.isExtern())
1939       O << "extern ";
1940
1941     O << val.GenTypeDeclaration() << ' '
1942       << val.GenVariableName();
1943
1944     if (val.isExtern()) {
1945       O << ";\n";
1946       continue;
1947     }
1948
1949     O << "(\"" << val.Name << "\"\n";
1950
1951     if (val.Type == OptionType::Prefix || val.Type == OptionType::PrefixList)
1952       O << ", cl::Prefix";
1953
1954     if (val.isRequired()) {
1955       if (val.isList() && !val.isMultiVal())
1956         O << ", cl::OneOrMore";
1957       else
1958         O << ", cl::Required";
1959     }
1960     else if (val.isOneOrMore() && val.isList()) {
1961         O << ", cl::OneOrMore";
1962     }
1963     else if (val.isZeroOrOne() && val.isList()) {
1964         O << ", cl::ZeroOrOne";
1965     }
1966
1967     if (val.isReallyHidden()) {
1968       O << ", cl::ReallyHidden";
1969     }
1970     else if (val.isHidden()) {
1971       O << ", cl::Hidden";
1972     }
1973
1974     if (val.MultiVal > 1)
1975       O << ", cl::multi_val(" << val.MultiVal << ')';
1976
1977     if (val.InitVal) {
1978       const std::string& str = val.InitVal->getAsString();
1979       O << ", cl::init(" << str << ')';
1980     }
1981
1982     if (!val.Help.empty())
1983       O << ", cl::desc(\"" << val.Help << "\")";
1984
1985     O << ");\n\n";
1986   }
1987
1988   // Emit the aliases (they should go after all the 'proper' options).
1989   for (std::vector<OptionDescription>::const_iterator
1990          B = Aliases.begin(), E = Aliases.end(); B != E; ++B) {
1991     const OptionDescription& val = *B;
1992
1993     O << val.GenTypeDeclaration() << ' '
1994       << val.GenVariableName()
1995       << "(\"" << val.Name << '\"';
1996
1997     const OptionDescription& D = descs.FindOption(val.Help);
1998     O << ", cl::aliasopt(" << D.GenVariableName() << ")";
1999
2000     O << ", cl::desc(\"" << "An alias for -" + val.Help  << "\"));\n";
2001   }
2002
2003   // Emit the sink option.
2004   if (HasSink)
2005     O << (HasExterns ? "extern cl" : "cl")
2006       << "::list<std::string> " << SinkOptionName
2007       << (HasExterns ? ";\n" : "(cl::Sink);\n");
2008
2009   O << '\n';
2010 }
2011
2012 /// PreprocessOptionsCallback - Helper function passed to
2013 /// EmitCaseConstructHandler() by EmitPreprocessOptions().
2014 class PreprocessOptionsCallback {
2015   const OptionDescriptions& OptDescs_;
2016
2017   void onUnsetOption(Init* i, unsigned IndentLevel, raw_ostream& O) {
2018     const std::string& OptName = InitPtrToString(i);
2019     const OptionDescription& OptDesc = OptDescs_.FindOption(OptName);
2020     const OptionType::OptionType OptType = OptDesc.Type;
2021
2022     if (OptType == OptionType::Switch) {
2023       O.indent(IndentLevel) << OptDesc.GenVariableName() << " = false;\n";
2024     }
2025     else if (OptType == OptionType::Parameter
2026              || OptType == OptionType::Prefix) {
2027       O.indent(IndentLevel) << OptDesc.GenVariableName() << " = \"\";\n";
2028     }
2029     else {
2030       throw std::string("'unset_option' can only be applied to "
2031                         "switches or parameter/prefix options.");
2032     }
2033   }
2034
2035   void processDag(const Init* I, unsigned IndentLevel, raw_ostream& O)
2036   {
2037     const DagInit& d = InitPtrToDag(I);
2038     const std::string& OpName = GetOperatorName(d);
2039
2040     // TOFIX: there is some duplication between this function and
2041     // EmitActionHandler.
2042     if (OpName == "warning") {
2043       checkNumberOfArguments(&d, 1);
2044       O.indent(IndentLevel) << "llvm::errs() << \""
2045                             << InitPtrToString(d.getArg(0)) << "\";\n";
2046     }
2047     else if (OpName == "error") {
2048       checkNumberOfArguments(&d, 1);
2049       O.indent(IndentLevel) << "throw std::runtime_error(\""
2050                             << InitPtrToString(d.getArg(0))
2051                             << "\");\n";
2052     }
2053     else if (OpName == "unset_option") {
2054       checkNumberOfArguments(&d, 1);
2055       Init* I = d.getArg(0);
2056       if (typeid(*I) == typeid(ListInit)) {
2057         const ListInit& DagList = *static_cast<const ListInit*>(I);
2058         for (ListInit::const_iterator B = DagList.begin(), E = DagList.end();
2059              B != E; ++B)
2060           this->onUnsetOption(*B, IndentLevel, O);
2061       }
2062       else {
2063         this->onUnsetOption(I, IndentLevel, O);
2064       }
2065     }
2066     else {
2067       throw "Unknown operator in the option preprocessor: '" + OpName + "'!"
2068         "\nOnly 'warning', 'error' and 'unset_option' are allowed.";
2069     }
2070   }
2071
2072 public:
2073
2074   // TODO: Remove duplication.
2075   void operator()(const Init* I, unsigned IndentLevel, raw_ostream& O) {
2076     if (typeid(*I) == typeid(ListInit)) {
2077       const ListInit& DagList = *static_cast<const ListInit*>(I);
2078       for (ListInit::const_iterator B = DagList.begin(), E = DagList.end();
2079            B != E; ++B)
2080         this->processDag(*B, IndentLevel, O);
2081     }
2082     else {
2083       this->processDag(I, IndentLevel, O);
2084     }
2085   }
2086
2087   PreprocessOptionsCallback(const OptionDescriptions& OptDescs)
2088   : OptDescs_(OptDescs)
2089   {}
2090 };
2091
2092 /// EmitPreprocessOptions - Emit the PreprocessOptionsLocal() function.
2093 void EmitPreprocessOptions (const RecordKeeper& Records,
2094                             const OptionDescriptions& OptDecs, raw_ostream& O)
2095 {
2096   O << "void PreprocessOptionsLocal() {\n";
2097
2098   const RecordVector& OptionPreprocessors =
2099     Records.getAllDerivedDefinitions("OptionPreprocessor");
2100
2101   for (RecordVector::const_iterator B = OptionPreprocessors.begin(),
2102          E = OptionPreprocessors.end(); B!=E; ++B) {
2103     DagInit* Case = (*B)->getValueAsDag("preprocessor");
2104     EmitCaseConstructHandler(Case, Indent1, PreprocessOptionsCallback(OptDecs),
2105                              false, OptDecs, O);
2106   }
2107
2108   O << "}\n\n";
2109 }
2110
2111 /// EmitPopulateLanguageMap - Emit the PopulateLanguageMapLocal() function.
2112 void EmitPopulateLanguageMap (const RecordKeeper& Records, raw_ostream& O)
2113 {
2114   O << "void PopulateLanguageMapLocal(LanguageMap& langMap) {\n";
2115
2116   // Get the relevant field out of RecordKeeper
2117   const Record* LangMapRecord = Records.getDef("LanguageMap");
2118
2119   // It is allowed for a plugin to have no language map.
2120   if (LangMapRecord) {
2121
2122     ListInit* LangsToSuffixesList = LangMapRecord->getValueAsListInit("map");
2123     if (!LangsToSuffixesList)
2124       throw std::string("Error in the language map definition!");
2125
2126     for (unsigned i = 0; i < LangsToSuffixesList->size(); ++i) {
2127       const Record* LangToSuffixes = LangsToSuffixesList->getElementAsRecord(i);
2128
2129       const std::string& Lang = LangToSuffixes->getValueAsString("lang");
2130       const ListInit* Suffixes = LangToSuffixes->getValueAsListInit("suffixes");
2131
2132       for (unsigned i = 0; i < Suffixes->size(); ++i)
2133         O.indent(Indent1) << "langMap[\""
2134                           << InitPtrToString(Suffixes->getElement(i))
2135                           << "\"] = \"" << Lang << "\";\n";
2136     }
2137   }
2138
2139   O << "}\n\n";
2140 }
2141
2142 /// IncDecWeight - Helper function passed to EmitCaseConstructHandler()
2143 /// by EmitEdgeClass().
2144 void IncDecWeight (const Init* i, unsigned IndentLevel,
2145                    raw_ostream& O) {
2146   const DagInit& d = InitPtrToDag(i);
2147   const std::string& OpName = GetOperatorName(d);
2148
2149   if (OpName == "inc_weight") {
2150     O.indent(IndentLevel) << "ret += ";
2151   }
2152   else if (OpName == "dec_weight") {
2153     O.indent(IndentLevel) << "ret -= ";
2154   }
2155   else if (OpName == "error") {
2156     checkNumberOfArguments(&d, 1);
2157     O.indent(IndentLevel) << "throw std::runtime_error(\""
2158                           << InitPtrToString(d.getArg(0))
2159                           << "\");\n";
2160     return;
2161   }
2162   else {
2163     throw "Unknown operator in edge properties list: '" + OpName + "'!"
2164       "\nOnly 'inc_weight', 'dec_weight' and 'error' are allowed.";
2165   }
2166
2167   if (d.getNumArgs() > 0)
2168     O << InitPtrToInt(d.getArg(0)) << ";\n";
2169   else
2170     O << "2;\n";
2171
2172 }
2173
2174 /// EmitEdgeClass - Emit a single Edge# class.
2175 void EmitEdgeClass (unsigned N, const std::string& Target,
2176                     DagInit* Case, const OptionDescriptions& OptDescs,
2177                     raw_ostream& O) {
2178
2179   // Class constructor.
2180   O << "class Edge" << N << ": public Edge {\n"
2181     << "public:\n";
2182   O.indent(Indent1) << "Edge" << N << "() : Edge(\"" << Target
2183                     << "\") {}\n\n";
2184
2185   // Function Weight().
2186   O.indent(Indent1)
2187     << "unsigned Weight(const InputLanguagesSet& InLangs) const {\n";
2188   O.indent(Indent2) << "unsigned ret = 0;\n";
2189
2190   // Handle the 'case' construct.
2191   EmitCaseConstructHandler(Case, Indent2, IncDecWeight, false, OptDescs, O);
2192
2193   O.indent(Indent2) << "return ret;\n";
2194   O.indent(Indent1) << "};\n\n};\n\n";
2195 }
2196
2197 /// EmitEdgeClasses - Emit Edge* classes that represent graph edges.
2198 void EmitEdgeClasses (const RecordVector& EdgeVector,
2199                       const OptionDescriptions& OptDescs,
2200                       raw_ostream& O) {
2201   int i = 0;
2202   for (RecordVector::const_iterator B = EdgeVector.begin(),
2203          E = EdgeVector.end(); B != E; ++B) {
2204     const Record* Edge = *B;
2205     const std::string& NodeB = Edge->getValueAsString("b");
2206     DagInit* Weight = Edge->getValueAsDag("weight");
2207
2208     if (!isDagEmpty(Weight))
2209       EmitEdgeClass(i, NodeB, Weight, OptDescs, O);
2210     ++i;
2211   }
2212 }
2213
2214 /// EmitPopulateCompilationGraph - Emit the PopulateCompilationGraphLocal()
2215 /// function.
2216 void EmitPopulateCompilationGraph (const RecordVector& EdgeVector,
2217                                    const ToolDescriptions& ToolDescs,
2218                                    raw_ostream& O)
2219 {
2220   O << "void PopulateCompilationGraphLocal(CompilationGraph& G) {\n";
2221
2222   for (ToolDescriptions::const_iterator B = ToolDescs.begin(),
2223          E = ToolDescs.end(); B != E; ++B)
2224     O.indent(Indent1) << "G.insertNode(new " << (*B)->Name << "());\n";
2225
2226   O << '\n';
2227
2228   // Insert edges.
2229
2230   int i = 0;
2231   for (RecordVector::const_iterator B = EdgeVector.begin(),
2232          E = EdgeVector.end(); B != E; ++B) {
2233     const Record* Edge = *B;
2234     const std::string& NodeA = Edge->getValueAsString("a");
2235     const std::string& NodeB = Edge->getValueAsString("b");
2236     DagInit* Weight = Edge->getValueAsDag("weight");
2237
2238     O.indent(Indent1) << "G.insertEdge(\"" << NodeA << "\", ";
2239
2240     if (isDagEmpty(Weight))
2241       O << "new SimpleEdge(\"" << NodeB << "\")";
2242     else
2243       O << "new Edge" << i << "()";
2244
2245     O << ");\n";
2246     ++i;
2247   }
2248
2249   O << "}\n\n";
2250 }
2251
2252 /// ExtractHookNames - Extract the hook names from all instances of
2253 /// $CALL(HookName) in the provided command line string. Helper
2254 /// function used by FillInHookNames().
2255 class ExtractHookNames {
2256   llvm::StringMap<unsigned>& HookNames_;
2257 public:
2258   ExtractHookNames(llvm::StringMap<unsigned>& HookNames)
2259   : HookNames_(HookNames) {}
2260
2261   void operator()(const Init* CmdLine) {
2262     StrVector cmds;
2263
2264     // Ignore nested 'case' DAG.
2265     if (typeid(*CmdLine) == typeid(DagInit))
2266       return;
2267
2268     TokenizeCmdline(InitPtrToString(CmdLine), cmds);
2269     for (StrVector::const_iterator B = cmds.begin(), E = cmds.end();
2270          B != E; ++B) {
2271       const std::string& cmd = *B;
2272
2273       if (cmd == "$CALL") {
2274         unsigned NumArgs = 0;
2275         checkedIncrement(B, E, "Syntax error in $CALL invocation!");
2276         const std::string& HookName = *B;
2277
2278
2279         if (HookName.at(0) == ')')
2280           throw "$CALL invoked with no arguments!";
2281
2282         while (++B != E && B->at(0) != ')') {
2283           ++NumArgs;
2284         }
2285
2286         StringMap<unsigned>::const_iterator H = HookNames_.find(HookName);
2287
2288         if (H != HookNames_.end() && H->second != NumArgs)
2289           throw "Overloading of hooks is not allowed. Overloaded hook: "
2290             + HookName;
2291         else
2292           HookNames_[HookName] = NumArgs;
2293
2294       }
2295     }
2296   }
2297
2298   void operator()(const DagInit* Test, unsigned, bool) {
2299     this->operator()(Test);
2300   }
2301   void operator()(const Init* Statement, unsigned) {
2302     this->operator()(Statement);
2303   }
2304 };
2305
2306 /// FillInHookNames - Actually extract the hook names from all command
2307 /// line strings. Helper function used by EmitHookDeclarations().
2308 void FillInHookNames(const ToolDescriptions& ToolDescs,
2309                      llvm::StringMap<unsigned>& HookNames)
2310 {
2311   // For all command lines:
2312   for (ToolDescriptions::const_iterator B = ToolDescs.begin(),
2313          E = ToolDescs.end(); B != E; ++B) {
2314     const ToolDescription& D = *(*B);
2315     if (!D.CmdLine)
2316       continue;
2317     if (dynamic_cast<StringInit*>(D.CmdLine))
2318       // This is a string.
2319       ExtractHookNames(HookNames).operator()(D.CmdLine);
2320     else
2321       // This is a 'case' construct.
2322       WalkCase(D.CmdLine, Id(), ExtractHookNames(HookNames));
2323   }
2324 }
2325
2326 /// EmitHookDeclarations - Parse CmdLine fields of all the tool
2327 /// property records and emit hook function declaration for each
2328 /// instance of $CALL(HookName).
2329 void EmitHookDeclarations(const ToolDescriptions& ToolDescs, raw_ostream& O) {
2330   llvm::StringMap<unsigned> HookNames;
2331
2332   FillInHookNames(ToolDescs, HookNames);
2333   if (HookNames.empty())
2334     return;
2335
2336   O << "namespace hooks {\n";
2337   for (StringMap<unsigned>::const_iterator B = HookNames.begin(),
2338          E = HookNames.end(); B != E; ++B) {
2339     O.indent(Indent1) << "std::string " << B->first() << "(";
2340
2341     for (unsigned i = 0, j = B->second; i < j; ++i) {
2342       O << "const char* Arg" << i << (i+1 == j ? "" : ", ");
2343     }
2344
2345     O <<");\n";
2346   }
2347   O << "}\n\n";
2348 }
2349
2350 /// EmitRegisterPlugin - Emit code to register this plugin.
2351 void EmitRegisterPlugin(int Priority, raw_ostream& O) {
2352   O << "struct Plugin : public llvmc::BasePlugin {\n\n";
2353   O.indent(Indent1) << "int Priority() const { return "
2354                     << Priority << "; }\n\n";
2355   O.indent(Indent1) << "void PreprocessOptions() const\n";
2356   O.indent(Indent1) << "{ PreprocessOptionsLocal(); }\n\n";
2357   O.indent(Indent1) << "void PopulateLanguageMap(LanguageMap& langMap) const\n";
2358   O.indent(Indent1) << "{ PopulateLanguageMapLocal(langMap); }\n\n";
2359   O.indent(Indent1)
2360     << "void PopulateCompilationGraph(CompilationGraph& graph) const\n";
2361   O.indent(Indent1) << "{ PopulateCompilationGraphLocal(graph); }\n"
2362                     << "};\n\n"
2363                     << "static llvmc::RegisterPlugin<Plugin> RP;\n\n";
2364 }
2365
2366 /// EmitIncludes - Emit necessary #include directives and some
2367 /// additional declarations.
2368 void EmitIncludes(raw_ostream& O) {
2369   O << "#include \"llvm/CompilerDriver/BuiltinOptions.h\"\n"
2370     << "#include \"llvm/CompilerDriver/CompilationGraph.h\"\n"
2371     << "#include \"llvm/CompilerDriver/ForceLinkageMacros.h\"\n"
2372     << "#include \"llvm/CompilerDriver/Plugin.h\"\n"
2373     << "#include \"llvm/CompilerDriver/Tool.h\"\n\n"
2374
2375     << "#include \"llvm/ADT/StringExtras.h\"\n"
2376     << "#include \"llvm/Support/CommandLine.h\"\n"
2377     << "#include \"llvm/Support/raw_ostream.h\"\n\n"
2378
2379     << "#include <cstdlib>\n"
2380     << "#include <stdexcept>\n\n"
2381
2382     << "using namespace llvm;\n"
2383     << "using namespace llvmc;\n\n"
2384
2385     << "extern cl::opt<std::string> OutputFilename;\n\n"
2386
2387     << "inline const char* checkCString(const char* s)\n"
2388     << "{ return s == NULL ? \"\" : s; }\n\n";
2389 }
2390
2391
2392 /// PluginData - Holds all information about a plugin.
2393 struct PluginData {
2394   OptionDescriptions OptDescs;
2395   bool HasSink;
2396   bool HasExterns;
2397   ToolDescriptions ToolDescs;
2398   RecordVector Edges;
2399   int Priority;
2400 };
2401
2402 /// HasSink - Go through the list of tool descriptions and check if
2403 /// there are any with the 'sink' property set.
2404 bool HasSink(const ToolDescriptions& ToolDescs) {
2405   for (ToolDescriptions::const_iterator B = ToolDescs.begin(),
2406          E = ToolDescs.end(); B != E; ++B)
2407     if ((*B)->isSink())
2408       return true;
2409
2410   return false;
2411 }
2412
2413 /// HasExterns - Go through the list of option descriptions and check
2414 /// if there are any external options.
2415 bool HasExterns(const OptionDescriptions& OptDescs) {
2416  for (OptionDescriptions::const_iterator B = OptDescs.begin(),
2417          E = OptDescs.end(); B != E; ++B)
2418     if (B->second.isExtern())
2419       return true;
2420
2421   return false;
2422 }
2423
2424 /// CollectPluginData - Collect tool and option properties,
2425 /// compilation graph edges and plugin priority from the parse tree.
2426 void CollectPluginData (const RecordKeeper& Records, PluginData& Data) {
2427   // Collect option properties.
2428   const RecordVector& OptionLists =
2429     Records.getAllDerivedDefinitions("OptionList");
2430   CollectOptionDescriptions(OptionLists.begin(), OptionLists.end(),
2431                             Data.OptDescs);
2432
2433   // Collect tool properties.
2434   const RecordVector& Tools = Records.getAllDerivedDefinitions("Tool");
2435   CollectToolDescriptions(Tools.begin(), Tools.end(), Data.ToolDescs);
2436   Data.HasSink = HasSink(Data.ToolDescs);
2437   Data.HasExterns = HasExterns(Data.OptDescs);
2438
2439   // Collect compilation graph edges.
2440   const RecordVector& CompilationGraphs =
2441     Records.getAllDerivedDefinitions("CompilationGraph");
2442   FillInEdgeVector(CompilationGraphs.begin(), CompilationGraphs.end(),
2443                    Data.Edges);
2444
2445   // Calculate the priority of this plugin.
2446   const RecordVector& Priorities =
2447     Records.getAllDerivedDefinitions("PluginPriority");
2448   Data.Priority = CalculatePriority(Priorities.begin(), Priorities.end());
2449 }
2450
2451 /// CheckPluginData - Perform some sanity checks on the collected data.
2452 void CheckPluginData(PluginData& Data) {
2453   // Filter out all tools not mentioned in the compilation graph.
2454   FilterNotInGraph(Data.Edges, Data.ToolDescs);
2455
2456   // Typecheck the compilation graph.
2457   TypecheckGraph(Data.Edges, Data.ToolDescs);
2458
2459   // Check that there are no options without side effects (specified
2460   // only in the OptionList).
2461   CheckForSuperfluousOptions(Data.Edges, Data.ToolDescs, Data.OptDescs);
2462
2463 }
2464
2465 void EmitPluginCode(const PluginData& Data, raw_ostream& O) {
2466   // Emit file header.
2467   EmitIncludes(O);
2468
2469   // Emit global option registration code.
2470   EmitOptionDefinitions(Data.OptDescs, Data.HasSink, Data.HasExterns, O);
2471
2472   // Emit hook declarations.
2473   EmitHookDeclarations(Data.ToolDescs, O);
2474
2475   O << "namespace {\n\n";
2476
2477   // Emit PreprocessOptionsLocal() function.
2478   EmitPreprocessOptions(Records, Data.OptDescs, O);
2479
2480   // Emit PopulateLanguageMapLocal() function
2481   // (language map maps from file extensions to language names).
2482   EmitPopulateLanguageMap(Records, O);
2483
2484   // Emit Tool classes.
2485   for (ToolDescriptions::const_iterator B = Data.ToolDescs.begin(),
2486          E = Data.ToolDescs.end(); B!=E; ++B)
2487     EmitToolClassDefinition(*(*B), Data.OptDescs, O);
2488
2489   // Emit Edge# classes.
2490   EmitEdgeClasses(Data.Edges, Data.OptDescs, O);
2491
2492   // Emit PopulateCompilationGraphLocal() function.
2493   EmitPopulateCompilationGraph(Data.Edges, Data.ToolDescs, O);
2494
2495   // Emit code for plugin registration.
2496   EmitRegisterPlugin(Data.Priority, O);
2497
2498   O << "} // End anonymous namespace.\n\n";
2499
2500   // Force linkage magic.
2501   O << "namespace llvmc {\n";
2502   O << "LLVMC_FORCE_LINKAGE_DECL(LLVMC_PLUGIN_NAME) {}\n";
2503   O << "}\n";
2504
2505   // EOF
2506 }
2507
2508
2509 // End of anonymous namespace
2510 }
2511
2512 /// run - The back-end entry point.
2513 void LLVMCConfigurationEmitter::run (raw_ostream &O) {
2514   try {
2515   PluginData Data;
2516
2517   CollectPluginData(Records, Data);
2518   CheckPluginData(Data);
2519
2520   EmitSourceFileHeader("LLVMC Configuration Library", O);
2521   EmitPluginCode(Data, O);
2522
2523   } catch (std::exception& Error) {
2524     throw Error.what() + std::string(" - usually this means a syntax error.");
2525   }
2526 }