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/StringMap.h"
  19 #include "llvm/ADT/StringSet.h"
  20
  21 #include <algorithm>
  22 #include <cassert>
  23 #include <functional>
  24 #include <stdexcept>
  25 #include <string>
  26 #include <typeinfo>
  27
  28 using namespace llvm;
  29
  30 namespace {
  31
  32 //===----------------------------------------------------------------------===//
  33 /// Typedefs
  34
  35 typedef std::vector<Record*> RecordVector;
  36 typedef std::vector<const DagInit*> DagVector;
  37 typedef std::vector<std::string> StrVector;
  38
  39 //===----------------------------------------------------------------------===//
  40 /// Constants
  41
  42 // Indentation.
  43 const unsigned TabWidth = 4;
  44 const unsigned Indent1  = TabWidth*1;
  45 const unsigned Indent2  = TabWidth*2;
  46 const unsigned Indent3  = TabWidth*3;
  47 const unsigned Indent4  = TabWidth*4;
  48
  49 // Default help string.
  50 const char * const DefaultHelpString = "NO HELP MESSAGE PROVIDED";
  51
  52 // Name for the "sink" option.
  53 const char * const SinkOptionName = "SinkOption";
  54
  55 //===----------------------------------------------------------------------===//
  56 /// Helper functions
  57
  58 /// Id - An 'identity' function object.
  59 struct Id {
  60   template<typename T0>
  61   void operator()(const T0&) const {
  62   }
  63   template<typename T0, typename T1>
  64   void operator()(const T0&, const T1&) const {
  65   }
  66   template<typename T0, typename T1, typename T2>
  67   void operator()(const T0&, const T1&, const T2&) const {
  68   }
  69 };
  70
  71 int InitPtrToInt(const Init* ptr) {
  72   const IntInit& val = dynamic_cast<const IntInit&>(*ptr);
  73   return val.getValue();
  74 }
  75
  76 const std::string& InitPtrToString(const Init* ptr) {
  77   const StringInit& val = dynamic_cast<const StringInit&>(*ptr);
  78   return val.getValue();
  79 }
  80
  81 const ListInit& InitPtrToList(const Init* ptr) {
  82   const ListInit& val = dynamic_cast<const ListInit&>(*ptr);
  83   return val;
  84 }
  85
  86 const DagInit& InitPtrToDag(const Init* ptr) {
  87   const DagInit& val = dynamic_cast<const DagInit&>(*ptr);
  88   return val;
  89 }
  90
  91 const std::string GetOperatorName(const DagInit& D) {
  92   return D.getOperator()->getAsString();
  93 }
  94
  95 /// CheckBooleanConstant - Check that the provided value is a boolean constant.
  96 void CheckBooleanConstant(const Init* I) {
  97   const DefInit& val = dynamic_cast<const DefInit&>(*I);
  98   const std::string& str = val.getAsString();
  99
 100   if (str != "true" && str != "false") {
 101     throw "Incorrect boolean value: '" + str +
 102       "': must be either 'true' or 'false'";
 103   }
 104 }
 105
 106 // CheckNumberOfArguments - Ensure that the number of args in d is
 107 // greater than or equal to min_arguments, otherwise throw an exception.
 108 void CheckNumberOfArguments (const DagInit& d, unsigned minArgs) {
 109   if (d.getNumArgs() < minArgs)
 110     throw GetOperatorName(d) + ": too few arguments!";
 111 }
 112
 113 // EscapeVariableName - Escape commas and other symbols not allowed
 114 // in the C++ variable names. Makes it possible to use options named
 115 // like "Wa," (useful for prefix options).
 116 std::string EscapeVariableName (const std::string& Var) {
 117   std::string ret;
 118   for (unsigned i = 0; i != Var.size(); ++i) {
 119     char cur_char = Var[i];
 120     if (cur_char == ',') {
 121       ret += "_comma_";
 122     }
 123     else if (cur_char == '+') {
 124       ret += "_plus_";
 125     }
 126     else if (cur_char == '-') {
 127       ret += "_dash_";
 128     }
 129     else {
 130       ret.push_back(cur_char);
 131     }
 132   }
 133   return ret;
 134 }
 135
 136 /// EscapeQuotes - Replace '"' with '\"'.
 137 std::string EscapeQuotes (const std::string& Var) {
 138   std::string ret;
 139   for (unsigned i = 0; i != Var.size(); ++i) {
 140     char cur_char = Var[i];
 141     if (cur_char == '"') {
 142       ret += "\\\"";
 143     }
 144     else {
 145       ret.push_back(cur_char);
 146     }
 147   }
 148   return ret;
 149 }
 150
 151 /// OneOf - Does the input string contain this character?
 152 bool OneOf(const char* lst, char c) {
 153   while (*lst) {
 154     if (*lst++ == c)
 155       return true;
 156   }
 157   return false;
 158 }
 159
 160 template <class I, class S>
 161 void CheckedIncrement(I& P, I E, S ErrorString) {
 162   ++P;
 163   if (P == E)
 164     throw ErrorString;
 165 }
 166
 167 // apply is needed because C++'s syntax doesn't let us construct a function
 168 // object and call it in the same statement.
 169 template<typename F, typename T0>
 170 void apply(F Fun, T0& Arg0) {
 171   return Fun(Arg0);
 172 }
 173
 174 template<typename F, typename T0, typename T1>
 175 void apply(F Fun, T0& Arg0, T1& Arg1) {
 176   return Fun(Arg0, Arg1);
 177 }
 178
 179 //===----------------------------------------------------------------------===//
 180 /// Back-end specific code
 181
 182
 183 /// OptionType - One of six different option types. See the
 184 /// documentation for detailed description of differences.
 185 namespace OptionType {
 186
 187   enum OptionType { Alias, Switch, SwitchList,
 188                     Parameter, ParameterList, Prefix, PrefixList };
 189
 190   bool IsAlias(OptionType t) {
 191     return (t == Alias);
 192   }
 193
 194   bool IsList (OptionType t) {
 195     return (t == SwitchList || t == ParameterList || t == PrefixList);
 196   }
 197
 198   bool IsSwitch (OptionType t) {
 199     return (t == Switch);
 200   }
 201
 202   bool IsSwitchList (OptionType t) {
 203     return (t == SwitchList);
 204   }
 205
 206   bool IsParameter (OptionType t) {
 207     return (t == Parameter || t == Prefix);
 208   }
 209
 210 }
 211
 212 OptionType::OptionType stringToOptionType(const std::string& T) {
 213   if (T == "alias_option")
 214     return OptionType::Alias;
 215   else if (T == "switch_option")
 216     return OptionType::Switch;
 217   else if (T == "switch_list_option")
 218     return OptionType::SwitchList;
 219   else if (T == "parameter_option")
 220     return OptionType::Parameter;
 221   else if (T == "parameter_list_option")
 222     return OptionType::ParameterList;
 223   else if (T == "prefix_option")
 224     return OptionType::Prefix;
 225   else if (T == "prefix_list_option")
 226     return OptionType::PrefixList;
 227   else
 228     throw "Unknown option type: " + T + '!';
 229 }
 230
 231 namespace OptionDescriptionFlags {
 232   enum OptionDescriptionFlags { Required = 0x1, Hidden = 0x2,
 233                                 ReallyHidden = 0x4, OneOrMore = 0x8,
 234                                 Optional = 0x10, CommaSeparated = 0x20,
 235                                 ForwardNotSplit = 0x40, ZeroOrMore = 0x80 };
 236 }
 237
 238 /// OptionDescription - Represents data contained in a single
 239 /// OptionList entry.
 240 struct OptionDescription {
 241   OptionType::OptionType Type;
 242   std::string Name;
 243   unsigned Flags;
 244   std::string Help;
 245   unsigned MultiVal;
 246   Init* InitVal;
 247
 248   OptionDescription(OptionType::OptionType t = OptionType::Switch,
 249                     const std::string& n = "",
 250                     const std::string& h = DefaultHelpString)
 251     : Type(t), Name(n), Flags(0x0), Help(h), MultiVal(1), InitVal(0)
 252   {}
 253
 254   /// GenTypeDeclaration - Returns the C++ variable type of this
 255   /// option.
 256   const char* GenTypeDeclaration() const;
 257
 258   /// GenVariableName - Returns the variable name used in the
 259   /// generated C++ code.
 260   std::string GenVariableName() const
 261   { return "autogenerated::" + GenOptionType() + EscapeVariableName(Name); }
 262
 263   /// GenPlainVariableName - Returns the variable name without the namespace
 264   /// prefix.
 265   std::string GenPlainVariableName() const
 266   { return GenOptionType() + EscapeVariableName(Name); }
 267
 268   /// Merge - Merge two option descriptions.
 269   void Merge (const OptionDescription& other);
 270
 271   /// CheckConsistency - Check that the flags are consistent.
 272   void CheckConsistency() const;
 273
 274   // Misc convenient getters/setters.
 275
 276   bool isAlias() const;
 277
 278   bool isMultiVal() const;
 279
 280   bool isCommaSeparated() const;
 281   void setCommaSeparated();
 282
 283   bool isForwardNotSplit() const;
 284   void setForwardNotSplit();
 285
 286   bool isRequired() const;
 287   void setRequired();
 288
 289   bool isOneOrMore() const;
 290   void setOneOrMore();
 291
 292   bool isZeroOrMore() const;
 293   void setZeroOrMore();
 294
 295   bool isOptional() const;
 296   void setOptional();
 297
 298   bool isHidden() const;
 299   void setHidden();
 300
 301   bool isReallyHidden() const;
 302   void setReallyHidden();
 303
 304   bool isSwitch() const
 305   { return OptionType::IsSwitch(this->Type); }
 306
 307   bool isSwitchList() const
 308   { return OptionType::IsSwitchList(this->Type); }
 309
 310   bool isParameter() const
 311   { return OptionType::IsParameter(this->Type); }
 312
 313   bool isList() const
 314   { return OptionType::IsList(this->Type); }
 315
 316   bool isParameterList() const
 317   { return (OptionType::IsList(this->Type)
 318             && !OptionType::IsSwitchList(this->Type)); }
 319
 320 private:
 321
 322   // GenOptionType - Helper function used by GenVariableName().
 323   std::string GenOptionType() const;
 324 };
 325
 326 void OptionDescription::CheckConsistency() const {
 327   unsigned i = 0;
 328
 329   i += this->isRequired();
 330   i += this->isOptional();
 331   i += this->isOneOrMore();
 332   i += this->isZeroOrMore();
 333
 334   if (i > 1) {
 335     throw "Only one of (required), (optional), (one_or_more) or "
 336       "(zero_or_more) properties is allowed!";
 337   }
 338 }
 339
 340 void OptionDescription::Merge (const OptionDescription& other)
 341 {
 342   if (other.Type != Type)
 343     throw "Conflicting definitions for the option " + Name + "!";
 344
 345   if (Help == other.Help || Help == DefaultHelpString)
 346     Help = other.Help;
 347   else if (other.Help != DefaultHelpString) {
 348     llvm::errs() << "Warning: several different help strings"
 349       " defined for option " + Name + "\n";
 350   }
 351
 352   Flags |= other.Flags;
 353 }
 354
 355 bool OptionDescription::isAlias() const {
 356   return OptionType::IsAlias(this->Type);
 357 }
 358
 359 bool OptionDescription::isMultiVal() const {
 360   return MultiVal > 1;
 361 }
 362
 363 bool OptionDescription::isCommaSeparated() const {
 364   return Flags & OptionDescriptionFlags::CommaSeparated;
 365 }
 366 void OptionDescription::setCommaSeparated() {
 367   Flags |= OptionDescriptionFlags::CommaSeparated;
 368 }
 369
 370 bool OptionDescription::isForwardNotSplit() const {
 371   return Flags & OptionDescriptionFlags::ForwardNotSplit;
 372 }
 373 void OptionDescription::setForwardNotSplit() {
 374   Flags |= OptionDescriptionFlags::ForwardNotSplit;
 375 }
 376
 377 bool OptionDescription::isRequired() const {
 378   return Flags & OptionDescriptionFlags::Required;
 379 }
 380 void OptionDescription::setRequired() {
 381   Flags |= OptionDescriptionFlags::Required;
 382 }
 383
 384 bool OptionDescription::isOneOrMore() const {
 385   return Flags & OptionDescriptionFlags::OneOrMore;
 386 }
 387 void OptionDescription::setOneOrMore() {
 388   Flags |= OptionDescriptionFlags::OneOrMore;
 389 }
 390
 391 bool OptionDescription::isZeroOrMore() const {
 392   return Flags & OptionDescriptionFlags::ZeroOrMore;
 393 }
 394 void OptionDescription::setZeroOrMore() {
 395   Flags |= OptionDescriptionFlags::ZeroOrMore;
 396 }
 397
 398 bool OptionDescription::isOptional() const {
 399   return Flags & OptionDescriptionFlags::Optional;
 400 }
 401 void OptionDescription::setOptional() {
 402   Flags |= OptionDescriptionFlags::Optional;
 403 }
 404
 405 bool OptionDescription::isHidden() const {
 406   return Flags & OptionDescriptionFlags::Hidden;
 407 }
 408 void OptionDescription::setHidden() {
 409   Flags |= OptionDescriptionFlags::Hidden;
 410 }
 411
 412 bool OptionDescription::isReallyHidden() const {
 413   return Flags & OptionDescriptionFlags::ReallyHidden;
 414 }
 415 void OptionDescription::setReallyHidden() {
 416   Flags |= OptionDescriptionFlags::ReallyHidden;
 417 }
 418
 419 const char* OptionDescription::GenTypeDeclaration() const {
 420   switch (Type) {
 421   case OptionType::Alias:
 422     return "cl::alias";
 423   case OptionType::PrefixList:
 424   case OptionType::ParameterList:
 425     return "cl::list<std::string>";
 426   case OptionType::Switch:
 427     return "cl::opt<bool>";
 428   case OptionType::SwitchList:
 429     return "cl::list<bool>";
 430   case OptionType::Parameter:
 431   case OptionType::Prefix:
 432   default:
 433     return "cl::opt<std::string>";
 434   }
 435 }
 436
 437 std::string OptionDescription::GenOptionType() const {
 438   switch (Type) {
 439   case OptionType::Alias:
 440     return "Alias_";
 441   case OptionType::PrefixList:
 442   case OptionType::ParameterList:
 443     return "List_";
 444   case OptionType::Switch:
 445     return "Switch_";
 446   case OptionType::SwitchList:
 447     return "SwitchList_";
 448   case OptionType::Prefix:
 449   case OptionType::Parameter:
 450   default:
 451     return "Parameter_";
 452   }
 453 }
 454
 455 /// OptionDescriptions - An OptionDescription array plus some helper
 456 /// functions.
 457 class OptionDescriptions {
 458   typedef StringMap<OptionDescription> container_type;
 459
 460   /// Descriptions - A list of OptionDescriptions.
 461   container_type Descriptions;
 462
 463 public:
 464   /// FindOption - exception-throwing wrapper for find().
 465   const OptionDescription& FindOption(const std::string& OptName) const;
 466
 467   // Wrappers for FindOption that throw an exception in case the option has a
 468   // wrong type.
 469   const OptionDescription& FindSwitch(const std::string& OptName) const;
 470   const OptionDescription& FindParameter(const std::string& OptName) const;
 471   const OptionDescription& FindParameterList(const std::string& OptName) const;
 472   const OptionDescription&
 473   FindListOrParameter(const std::string& OptName) const;
 474   const OptionDescription&
 475   FindParameterListOrParameter(const std::string& OptName) const;
 476
 477   /// insertDescription - Insert new OptionDescription into
 478   /// OptionDescriptions list
 479   void InsertDescription (const OptionDescription& o);
 480
 481   // Support for STL-style iteration
 482   typedef container_type::const_iterator const_iterator;
 483   const_iterator begin() const { return Descriptions.begin(); }
 484   const_iterator end() const { return Descriptions.end(); }
 485 };
 486
 487 const OptionDescription&
 488 OptionDescriptions::FindOption(const std::string& OptName) const {
 489   const_iterator I = Descriptions.find(OptName);
 490   if (I != Descriptions.end())
 491     return I->second;
 492   else
 493     throw OptName + ": no such option!";
 494 }
 495
 496 const OptionDescription&
 497 OptionDescriptions::FindSwitch(const std::string& OptName) const {
 498   const OptionDescription& OptDesc = this->FindOption(OptName);
 499   if (!OptDesc.isSwitch())
 500     throw OptName + ": incorrect option type - should be a switch!";
 501   return OptDesc;
 502 }
 503
 504 const OptionDescription&
 505 OptionDescriptions::FindParameterList(const std::string& OptName) const {
 506   const OptionDescription& OptDesc = this->FindOption(OptName);
 507   if (!OptDesc.isList() || OptDesc.isSwitchList())
 508     throw OptName + ": incorrect option type - should be a parameter list!";
 509   return OptDesc;
 510 }
 511
 512 const OptionDescription&
 513 OptionDescriptions::FindParameter(const std::string& OptName) const {
 514   const OptionDescription& OptDesc = this->FindOption(OptName);
 515   if (!OptDesc.isParameter())
 516     throw OptName + ": incorrect option type - should be a parameter!";
 517   return OptDesc;
 518 }
 519
 520 const OptionDescription&
 521 OptionDescriptions::FindListOrParameter(const std::string& OptName) const {
 522   const OptionDescription& OptDesc = this->FindOption(OptName);
 523   if (!OptDesc.isList() && !OptDesc.isParameter())
 524     throw OptName
 525       + ": incorrect option type - should be a list or parameter!";
 526   return OptDesc;
 527 }
 528
 529 const OptionDescription&
 530 OptionDescriptions::FindParameterListOrParameter
 531 (const std::string& OptName) const {
 532   const OptionDescription& OptDesc = this->FindOption(OptName);
 533   if ((!OptDesc.isList() && !OptDesc.isParameter()) || OptDesc.isSwitchList())
 534     throw OptName
 535       + ": incorrect option type - should be a parameter list or parameter!";
 536   return OptDesc;
 537 }
 538
 539 void OptionDescriptions::InsertDescription (const OptionDescription& o) {
 540   container_type::iterator I = Descriptions.find(o.Name);
 541   if (I != Descriptions.end()) {
 542     OptionDescription& D = I->second;
 543     D.Merge(o);
 544   }
 545   else {
 546     Descriptions[o.Name] = o;
 547   }
 548 }
 549
 550 /// HandlerTable - A base class for function objects implemented as
 551 /// 'tables of handlers'.
 552 template <typename Handler>
 553 class HandlerTable {
 554 protected:
 555   // Implementation details.
 556
 557   /// HandlerMap - A map from property names to property handlers
 558   typedef StringMap<Handler> HandlerMap;
 559
 560   static HandlerMap Handlers_;
 561   static bool staticMembersInitialized_;
 562
 563 public:
 564
 565   Handler GetHandler (const std::string& HandlerName) const {
 566     typename HandlerMap::iterator method = Handlers_.find(HandlerName);
 567
 568     if (method != Handlers_.end()) {
 569       Handler h = method->second;
 570       return h;
 571     }
 572     else {
 573       throw "No handler found for property " + HandlerName + "!";
 574     }
 575   }
 576
 577   void AddHandler(const char* Property, Handler H) {
 578     Handlers_[Property] = H;
 579   }
 580
 581 };
 582
 583 template <class Handler, class FunctionObject>
 584 Handler GetHandler(FunctionObject* Obj, const DagInit& Dag) {
 585   const std::string& HandlerName = GetOperatorName(Dag);
 586   return Obj->GetHandler(HandlerName);
 587 }
 588
 589 template <class FunctionObject>
 590 void InvokeDagInitHandler(FunctionObject* Obj, Init* I) {
 591   typedef void (FunctionObject::*Handler) (const DagInit&);
 592
 593   const DagInit& Dag = InitPtrToDag(I);
 594   Handler h = GetHandler<Handler>(Obj, Dag);
 595
 596   ((Obj)->*(h))(Dag);
 597 }
 598
 599 template <class FunctionObject>
 600 void InvokeDagInitHandler(const FunctionObject* const Obj,
 601                           const Init* I, unsigned IndentLevel, raw_ostream& O)
 602 {
 603   typedef void (FunctionObject::*Handler)
 604     (const DagInit&, unsigned IndentLevel, raw_ostream& O) const;
 605
 606   const DagInit& Dag = InitPtrToDag(I);
 607   Handler h = GetHandler<Handler>(Obj, Dag);
 608
 609   ((Obj)->*(h))(Dag, IndentLevel, O);
 610 }
 611
 612 template <typename H>
 613 typename HandlerTable<H>::HandlerMap HandlerTable<H>::Handlers_;
 614
 615 template <typename H>
 616 bool HandlerTable<H>::staticMembersInitialized_ = false;
 617
 618
 619 /// CollectOptionProperties - Function object for iterating over an
 620 /// option property list.
 621 class CollectOptionProperties;
 622 typedef void (CollectOptionProperties::* CollectOptionPropertiesHandler)
 623 (const DagInit&);
 624
 625 class CollectOptionProperties
 626 : public HandlerTable<CollectOptionPropertiesHandler>
 627 {
 628 private:
 629
 630   /// optDescs_ - OptionDescriptions table. This is where the
 631   /// information is stored.
 632   OptionDescription& optDesc_;
 633
 634 public:
 635
 636   explicit CollectOptionProperties(OptionDescription& OD)
 637     : optDesc_(OD)
 638   {
 639     if (!staticMembersInitialized_) {
 640       AddHandler("help", &CollectOptionProperties::onHelp);
 641       AddHandler("hidden", &CollectOptionProperties::onHidden);
 642       AddHandler("init", &CollectOptionProperties::onInit);
 643       AddHandler("multi_val", &CollectOptionProperties::onMultiVal);
 644       AddHandler("one_or_more", &CollectOptionProperties::onOneOrMore);
 645       AddHandler("zero_or_more", &CollectOptionProperties::onZeroOrMore);
 646       AddHandler("really_hidden", &CollectOptionProperties::onReallyHidden);
 647       AddHandler("required", &CollectOptionProperties::onRequired);
 648       AddHandler("optional", &CollectOptionProperties::onOptional);
 649       AddHandler("comma_separated", &CollectOptionProperties::onCommaSeparated);
 650       AddHandler("forward_not_split",
 651                  &CollectOptionProperties::onForwardNotSplit);
 652
 653       staticMembersInitialized_ = true;
 654     }
 655   }
 656
 657   /// operator() - Just forwards to the corresponding property
 658   /// handler.
 659   void operator() (Init* I) {
 660     InvokeDagInitHandler(this, I);
 661   }
 662
 663 private:
 664
 665   /// Option property handlers --
 666   /// Methods that handle option properties such as (help) or (hidden).
 667
 668   void onHelp (const DagInit& d) {
 669     CheckNumberOfArguments(d, 1);
 670     optDesc_.Help = EscapeQuotes(InitPtrToString(d.getArg(0)));
 671   }
 672
 673   void onHidden (const DagInit& d) {
 674     CheckNumberOfArguments(d, 0);
 675     optDesc_.setHidden();
 676   }
 677
 678   void onReallyHidden (const DagInit& d) {
 679     CheckNumberOfArguments(d, 0);
 680     optDesc_.setReallyHidden();
 681   }
 682
 683   void onCommaSeparated (const DagInit& d) {
 684     CheckNumberOfArguments(d, 0);
 685     if (!optDesc_.isParameterList())
 686       throw "'comma_separated' is valid only on parameter list options!";
 687     optDesc_.setCommaSeparated();
 688   }
 689
 690   void onForwardNotSplit (const DagInit& d) {
 691     CheckNumberOfArguments(d, 0);
 692     if (!optDesc_.isParameter())
 693       throw "'forward_not_split' is valid only for parameter options!";
 694     optDesc_.setForwardNotSplit();
 695   }
 696
 697   void onRequired (const DagInit& d) {
 698     CheckNumberOfArguments(d, 0);
 699
 700     optDesc_.setRequired();
 701     optDesc_.CheckConsistency();
 702   }
 703
 704   void onInit (const DagInit& d) {
 705     CheckNumberOfArguments(d, 1);
 706     Init* i = d.getArg(0);
 707     const std::string& str = i->getAsString();
 708
 709     bool correct = optDesc_.isParameter() && dynamic_cast<StringInit*>(i);
 710     correct |= (optDesc_.isSwitch() && (str == "true" || str == "false"));
 711
 712     if (!correct)
 713       throw "Incorrect usage of the 'init' option property!";
 714
 715     optDesc_.InitVal = i;
 716   }
 717
 718   void onOneOrMore (const DagInit& d) {
 719     CheckNumberOfArguments(d, 0);
 720
 721     optDesc_.setOneOrMore();
 722     optDesc_.CheckConsistency();
 723   }
 724
 725   void onZeroOrMore (const DagInit& d) {
 726     CheckNumberOfArguments(d, 0);
 727
 728     if (optDesc_.isList())
 729       llvm::errs() << "Warning: specifying the 'zero_or_more' property "
 730         "on a list option has no effect.\n";
 731
 732     optDesc_.setZeroOrMore();
 733     optDesc_.CheckConsistency();
 734   }
 735
 736   void onOptional (const DagInit& d) {
 737     CheckNumberOfArguments(d, 0);
 738
 739     if (!optDesc_.isList())
 740       llvm::errs() << "Warning: specifying the 'optional' property"
 741         "on a non-list option has no effect.\n";
 742
 743     optDesc_.setOptional();
 744     optDesc_.CheckConsistency();
 745   }
 746
 747   void onMultiVal (const DagInit& d) {
 748     CheckNumberOfArguments(d, 1);
 749     int val = InitPtrToInt(d.getArg(0));
 750     if (val < 2)
 751       throw "Error in the 'multi_val' property: "
 752         "the value must be greater than 1!";
 753     if (!optDesc_.isParameterList())
 754       throw "The multi_val property is valid only on list options!";
 755     optDesc_.MultiVal = val;
 756   }
 757
 758 };
 759
 760 /// AddOption - A function object that is applied to every option
 761 /// description. Used by CollectOptionDescriptions.
 762 class AddOption {
 763 private:
 764   OptionDescriptions& OptDescs_;
 765
 766 public:
 767   explicit AddOption(OptionDescriptions& OD) : OptDescs_(OD)
 768   {}
 769
 770   void operator()(const Init* i) {
 771     const DagInit& d = InitPtrToDag(i);
 772     CheckNumberOfArguments(d, 1);
 773
 774     const OptionType::OptionType Type =
 775       stringToOptionType(GetOperatorName(d));
 776     const std::string& Name = InitPtrToString(d.getArg(0));
 777
 778     OptionDescription OD(Type, Name);
 779
 780     CheckNumberOfArguments(d, 2);
 781
 782     if (OD.isAlias()) {
 783       // Aliases store the aliased option name in the 'Help' field.
 784       OD.Help = InitPtrToString(d.getArg(1));
 785     }
 786     else {
 787       processOptionProperties(d, OD);
 788     }
 789
 790     OptDescs_.InsertDescription(OD);
 791   }
 792
 793 private:
 794   /// processOptionProperties - Go through the list of option
 795   /// properties and call a corresponding handler for each.
 796   static void processOptionProperties (const DagInit& d, OptionDescription& o) {
 797     CheckNumberOfArguments(d, 2);
 798     DagInit::const_arg_iterator B = d.arg_begin();
 799     // Skip the first argument: it's always the option name.
 800     ++B;
 801     std::for_each(B, d.arg_end(), CollectOptionProperties(o));
 802   }
 803
 804 };
 805
 806 /// CollectOptionDescriptions - Collects option properties from all
 807 /// OptionLists.
 808 void CollectOptionDescriptions (const RecordVector& V,
 809                                 OptionDescriptions& OptDescs)
 810 {
 811   // For every OptionList:
 812   for (RecordVector::const_iterator B = V.begin(),
 813          E = V.end(); B!=E; ++B) {
 814     // Throws an exception if the value does not exist.
 815     ListInit* PropList = (*B)->getValueAsListInit("options");
 816
 817     // For every option description in this list:
 818     // collect the information and
 819     std::for_each(PropList->begin(), PropList->end(), AddOption(OptDescs));
 820   }
 821 }
 822
 823 // Tool information record
 824
 825 namespace ToolFlags {
 826   enum ToolFlags { Join = 0x1, Sink = 0x2 };
 827 }
 828
 829 struct ToolDescription : public RefCountedBase<ToolDescription> {
 830   std::string Name;
 831   Init* CmdLine;
 832   Init* Actions;
 833   StrVector InLanguage;
 834   std::string InFileOption;
 835   std::string OutFileOption;
 836   StrVector OutLanguage;
 837   std::string OutputSuffix;
 838   unsigned Flags;
 839   const Init* OnEmpty;
 840
 841   // Various boolean properties
 842   void setSink()      { Flags |= ToolFlags::Sink; }
 843   bool isSink() const { return Flags & ToolFlags::Sink; }
 844   void setJoin()      { Flags |= ToolFlags::Join; }
 845   bool isJoin() const { return Flags & ToolFlags::Join; }
 846
 847   // Default ctor here is needed because StringMap can only store
 848   // DefaultConstructible objects
 849   ToolDescription (const std::string &n = "")
 850     : Name(n), CmdLine(0), Actions(0), OutFileOption("-o"),
 851       Flags(0), OnEmpty(0)
 852   {}
 853 };
 854
 855 /// ToolDescriptions - A list of Tool information records.
 856 typedef std::vector<IntrusiveRefCntPtr<ToolDescription> > ToolDescriptions;
 857
 858
 859 /// CollectToolProperties - Function object for iterating over a list of
 860 /// tool property records.
 861
 862 class CollectToolProperties;
 863 typedef void (CollectToolProperties::* CollectToolPropertiesHandler)
 864 (const DagInit&);
 865
 866 class CollectToolProperties : public HandlerTable<CollectToolPropertiesHandler>
 867 {
 868 private:
 869
 870   /// toolDesc_ - Properties of the current Tool. This is where the
 871   /// information is stored.
 872   ToolDescription& toolDesc_;
 873
 874 public:
 875
 876   explicit CollectToolProperties (ToolDescription& d)
 877     : toolDesc_(d)
 878   {
 879     if (!staticMembersInitialized_) {
 880
 881       AddHandler("actions", &CollectToolProperties::onActions);
 882       AddHandler("command", &CollectToolProperties::onCommand);
 883       AddHandler("in_language", &CollectToolProperties::onInLanguage);
 884       AddHandler("join", &CollectToolProperties::onJoin);
 885       AddHandler("out_language", &CollectToolProperties::onOutLanguage);
 886
 887       AddHandler("out_file_option", &CollectToolProperties::onOutFileOption);
 888       AddHandler("in_file_option", &CollectToolProperties::onInFileOption);
 889
 890       AddHandler("output_suffix", &CollectToolProperties::onOutputSuffix);
 891       AddHandler("sink", &CollectToolProperties::onSink);
 892       AddHandler("works_on_empty", &CollectToolProperties::onWorksOnEmpty);
 893
 894       staticMembersInitialized_ = true;
 895     }
 896   }
 897
 898   void operator() (Init* I) {
 899     InvokeDagInitHandler(this, I);
 900   }
 901
 902 private:
 903
 904   /// Property handlers --
 905   /// Functions that extract information about tool properties from
 906   /// DAG representation.
 907
 908   void onActions (const DagInit& d) {
 909     CheckNumberOfArguments(d, 1);
 910     Init* Case = d.getArg(0);
 911     if (typeid(*Case) != typeid(DagInit) ||
 912         GetOperatorName(static_cast<DagInit&>(*Case)) != "case")
 913       throw "The argument to (actions) should be a 'case' construct!";
 914     toolDesc_.Actions = Case;
 915   }
 916
 917   void onCommand (const DagInit& d) {
 918     CheckNumberOfArguments(d, 1);
 919     toolDesc_.CmdLine = d.getArg(0);
 920   }
 921
 922   /// onInOutLanguage - Common implementation of on{In,Out}Language().
 923   void onInOutLanguage (const DagInit& d, StrVector& OutVec) {
 924     CheckNumberOfArguments(d, 1);
 925     Init* arg = d.getArg(0);
 926
 927     // Find out the argument's type.
 928     if (typeid(*arg) == typeid(StringInit)) {
 929       // It's a string.
 930       OutVec.push_back(InitPtrToString(arg));
 931     }
 932     else {
 933       // It's a list.
 934       const ListInit& lst = InitPtrToList(arg);
 935
 936       // Copy strings to the output vector.
 937       for (ListInit::const_iterator B = lst.begin(), E = lst.end(); B != E; ++B)
 938         OutVec.push_back(InitPtrToString(*B));
 939
 940       // Remove duplicates.
 941       std::sort(OutVec.begin(), OutVec.end());
 942       StrVector::iterator newE = std::unique(OutVec.begin(), OutVec.end());
 943       OutVec.erase(newE, OutVec.end());
 944     }
 945   }
 946
 947
 948   void onInLanguage (const DagInit& d) {
 949     this->onInOutLanguage(d, toolDesc_.InLanguage);
 950   }
 951
 952   void onJoin (const DagInit& d) {
 953     CheckNumberOfArguments(d, 0);
 954     toolDesc_.setJoin();
 955   }
 956
 957   void onOutLanguage (const DagInit& d) {
 958     this->onInOutLanguage(d, toolDesc_.OutLanguage);
 959   }
 960
 961   void onOutFileOption (const DagInit& d) {
 962     CheckNumberOfArguments(d, 1);
 963     toolDesc_.OutFileOption = InitPtrToString(d.getArg(0));
 964   }
 965
 966   void onInFileOption (const DagInit& d) {
 967     CheckNumberOfArguments(d, 1);
 968     toolDesc_.InFileOption = InitPtrToString(d.getArg(0));
 969   }
 970
 971   void onOutputSuffix (const DagInit& d) {
 972     CheckNumberOfArguments(d, 1);
 973     toolDesc_.OutputSuffix = InitPtrToString(d.getArg(0));
 974   }
 975
 976   void onSink (const DagInit& d) {
 977     CheckNumberOfArguments(d, 0);
 978     toolDesc_.setSink();
 979   }
 980
 981   void onWorksOnEmpty (const DagInit& d) {
 982     toolDesc_.OnEmpty = d.getArg(0);
 983   }
 984
 985 };
 986
 987 /// CollectToolDescriptions - Gather information about tool properties
 988 /// from the parsed TableGen data (basically a wrapper for the
 989 /// CollectToolProperties function object).
 990 void CollectToolDescriptions (const RecordVector& Tools,
 991                               ToolDescriptions& ToolDescs)
 992 {
 993   // Iterate over a properties list of every Tool definition
 994   for (RecordVector::const_iterator B = Tools.begin(),
 995          E = Tools.end(); B!=E; ++B) {
 996     const Record* T = *B;
 997     // Throws an exception if the value does not exist.
 998     ListInit* PropList = T->getValueAsListInit("properties");
 999
1000     IntrusiveRefCntPtr<ToolDescription>
1001       ToolDesc(new ToolDescription(T->getName()));
1002
1003     std::for_each(PropList->begin(), PropList->end(),
1004                   CollectToolProperties(*ToolDesc));
1005     ToolDescs.push_back(ToolDesc);
1006   }
1007 }
1008
1009 /// FillInEdgeVector - Merge all compilation graph definitions into
1010 /// one single edge list.
1011 void FillInEdgeVector(const RecordVector& CompilationGraphs,
1012                       DagVector& Out) {
1013   for (RecordVector::const_iterator B = CompilationGraphs.begin(),
1014          E = CompilationGraphs.end(); B != E; ++B) {
1015     const ListInit* Edges = (*B)->getValueAsListInit("edges");
1016
1017     for (ListInit::const_iterator B = Edges->begin(),
1018            E = Edges->end(); B != E; ++B) {
1019       Out.push_back(&InitPtrToDag(*B));
1020     }
1021   }
1022 }
1023
1024 /// NotInGraph - Helper function object for FilterNotInGraph.
1025 struct NotInGraph {
1026 private:
1027   const llvm::StringSet<>& ToolsInGraph_;
1028
1029 public:
1030   NotInGraph(const llvm::StringSet<>& ToolsInGraph)
1031   : ToolsInGraph_(ToolsInGraph)
1032   {}
1033
1034   bool operator()(const IntrusiveRefCntPtr<ToolDescription>& x) {
1035     return (ToolsInGraph_.count(x->Name) == 0);
1036   }
1037 };
1038
1039 /// FilterNotInGraph - Filter out from ToolDescs all Tools not
1040 /// mentioned in the compilation graph definition.
1041 void FilterNotInGraph (const DagVector& EdgeVector,
1042                        ToolDescriptions& ToolDescs) {
1043
1044   // List all tools mentioned in the graph.
1045   llvm::StringSet<> ToolsInGraph;
1046
1047   for (DagVector::const_iterator B = EdgeVector.begin(),
1048          E = EdgeVector.end(); B != E; ++B) {
1049
1050     const DagInit* Edge = *B;
1051     const std::string& NodeA = InitPtrToString(Edge->getArg(0));
1052     const std::string& NodeB = InitPtrToString(Edge->getArg(1));
1053
1054     if (NodeA != "root")
1055       ToolsInGraph.insert(NodeA);
1056     ToolsInGraph.insert(NodeB);
1057   }
1058
1059   // Filter ToolPropertiesList.
1060   ToolDescriptions::iterator new_end =
1061     std::remove_if(ToolDescs.begin(), ToolDescs.end(),
1062                    NotInGraph(ToolsInGraph));
1063   ToolDescs.erase(new_end, ToolDescs.end());
1064 }
1065
1066 /// FillInToolToLang - Fills in two tables that map tool names to
1067 /// input & output language names.  Helper function used by TypecheckGraph().
1068 void FillInToolToLang (const ToolDescriptions& ToolDescs,
1069                        StringMap<StringSet<> >& ToolToInLang,
1070                        StringMap<StringSet<> >& ToolToOutLang) {
1071   for (ToolDescriptions::const_iterator B = ToolDescs.begin(),
1072          E = ToolDescs.end(); B != E; ++B) {
1073     const ToolDescription& D = *(*B);
1074     for (StrVector::const_iterator B = D.InLanguage.begin(),
1075            E = D.InLanguage.end(); B != E; ++B)
1076       ToolToInLang[D.Name].insert(*B);
1077     for (StrVector::const_iterator B = D.OutLanguage.begin(),
1078            E = D.OutLanguage.end(); B != E; ++B)
1079       ToolToOutLang[D.Name].insert(*B);
1080   }
1081 }
1082
1083 /// Intersect - Is set intersection non-empty?
1084 bool Intersect (const StringSet<>& S1, const StringSet<>& S2) {
1085   for (StringSet<>::const_iterator B = S1.begin(), E = S1.end(); B != E; ++B) {
1086     if (S2.count(B->first()) != 0)
1087       return true;
1088   }
1089   return false;
1090 }
1091
1092 /// TypecheckGraph - Check that names for output and input languages
1093 /// on all edges do match.
1094 void TypecheckGraph (const DagVector& EdgeVector,
1095                      const ToolDescriptions& ToolDescs) {
1096   StringMap<StringSet<> > ToolToInLang;
1097   StringMap<StringSet<> > ToolToOutLang;
1098
1099   FillInToolToLang(ToolDescs, ToolToInLang, ToolToOutLang);
1100
1101   for (DagVector::const_iterator B = EdgeVector.begin(),
1102          E = EdgeVector.end(); B != E; ++B) {
1103     const DagInit* Edge = *B;
1104     const std::string& NodeA = InitPtrToString(Edge->getArg(0));
1105     const std::string& NodeB = InitPtrToString(Edge->getArg(1));
1106     StringMap<StringSet<> >::iterator IA = ToolToOutLang.find(NodeA);
1107     StringMap<StringSet<> >::iterator IB = ToolToInLang.find(NodeB);
1108
1109     if (NodeB == "root")
1110       throw "Edges back to the root are not allowed!";
1111
1112     if (NodeA != "root") {
1113       if (IA == ToolToOutLang.end())
1114         throw NodeA + ": no output language defined!";
1115       if (IB == ToolToInLang.end())
1116         throw NodeB + ": no input language defined!";
1117
1118       if (!Intersect(IA->second, IB->second)) {
1119         throw "Edge " + NodeA + "->" + NodeB
1120           + ": output->input language mismatch";
1121       }
1122     }
1123   }
1124 }
1125
1126 /// WalkCase - Walks the 'case' expression DAG and invokes
1127 /// TestCallback on every test, and StatementCallback on every
1128 /// statement. Handles 'case' nesting, but not the 'and' and 'or'
1129 /// combinators (that is, they are passed directly to TestCallback).
1130 /// TestCallback must have type 'void TestCallback(const DagInit*, unsigned
1131 /// IndentLevel, bool FirstTest)'.
1132 /// StatementCallback must have type 'void StatementCallback(const Init*,
1133 /// unsigned IndentLevel)'.
1134 template <typename F1, typename F2>
1135 void WalkCase(const Init* Case, F1 TestCallback, F2 StatementCallback,
1136               unsigned IndentLevel = 0)
1137 {
1138   const DagInit& d = InitPtrToDag(Case);
1139
1140   // Error checks.
1141   if (GetOperatorName(d) != "case")
1142     throw "WalkCase should be invoked only on 'case' expressions!";
1143
1144   if (d.getNumArgs() < 2)
1145     throw "There should be at least one clause in the 'case' expression:\n"
1146       + d.getAsString();
1147
1148   // Main loop.
1149   bool even = false;
1150   const unsigned numArgs = d.getNumArgs();
1151   unsigned i = 1;
1152   for (DagInit::const_arg_iterator B = d.arg_begin(), E = d.arg_end();
1153        B != E; ++B) {
1154     Init* arg = *B;
1155
1156     if (!even)
1157     {
1158       // Handle test.
1159       const DagInit& Test = InitPtrToDag(arg);
1160
1161       if (GetOperatorName(Test) == "default" && (i+1 != numArgs))
1162         throw "The 'default' clause should be the last in the "
1163           "'case' construct!";
1164       if (i == numArgs)
1165         throw "Case construct handler: no corresponding action "
1166           "found for the test " + Test.getAsString() + '!';
1167
1168       TestCallback(Test, IndentLevel, (i == 1));
1169     }
1170     else
1171     {
1172       if (dynamic_cast<DagInit*>(arg)
1173           && GetOperatorName(static_cast<DagInit&>(*arg)) == "case") {
1174         // Nested 'case'.
1175         WalkCase(arg, TestCallback, StatementCallback, IndentLevel + Indent1);
1176       }
1177
1178       // Handle statement.
1179       StatementCallback(arg, IndentLevel);
1180     }
1181
1182     ++i;
1183     even = !even;
1184   }
1185 }
1186
1187 /// ExtractOptionNames - A helper function object used by
1188 /// CheckForSuperfluousOptions() to walk the 'case' DAG.
1189 class ExtractOptionNames {
1190   llvm::StringSet<>& OptionNames_;
1191
1192   void processDag(const Init* Statement) {
1193     const DagInit& Stmt = InitPtrToDag(Statement);
1194     const std::string& ActionName = GetOperatorName(Stmt);
1195     if (ActionName == "forward" || ActionName == "forward_as" ||
1196         ActionName == "forward_value" ||
1197         ActionName == "forward_transformed_value" ||
1198         ActionName == "switch_on" || ActionName == "any_switch_on" ||
1199         ActionName == "parameter_equals" ||
1200         ActionName == "element_in_list" || ActionName == "not_empty" ||
1201         ActionName == "empty") {
1202       CheckNumberOfArguments(Stmt, 1);
1203
1204       Init* Arg = Stmt.getArg(0);
1205       if (typeid(*Arg) == typeid(StringInit)) {
1206         const std::string& Name = InitPtrToString(Arg);
1207         OptionNames_.insert(Name);
1208       }
1209       else {
1210         // It's a list.
1211         const ListInit& List = InitPtrToList(Arg);
1212         for (ListInit::const_iterator B = List.begin(), E = List.end();
1213              B != E; ++B) {
1214           const std::string& Name = InitPtrToString(*B);
1215           OptionNames_.insert(Name);
1216         }
1217       }
1218     }
1219     else if (ActionName == "and" || ActionName == "or" || ActionName == "not") {
1220       for (unsigned i = 0, NumArgs = Stmt.getNumArgs(); i < NumArgs; ++i) {
1221         this->processDag(Stmt.getArg(i));
1222       }
1223     }
1224   }
1225
1226 public:
1227   ExtractOptionNames(llvm::StringSet<>& OptionNames) : OptionNames_(OptionNames)
1228   {}
1229
1230   void operator()(const Init* Statement) {
1231     if (typeid(*Statement) == typeid(ListInit)) {
1232       const ListInit& DagList = *static_cast<const ListInit*>(Statement);
1233       for (ListInit::const_iterator B = DagList.begin(), E = DagList.end();
1234            B != E; ++B)
1235         this->processDag(*B);
1236     }
1237     else {
1238       this->processDag(Statement);
1239     }
1240   }
1241
1242   void operator()(const DagInit& Test, unsigned, bool) {
1243     this->operator()(&Test);
1244   }
1245   void operator()(const Init* Statement, unsigned) {
1246     this->operator()(Statement);
1247   }
1248 };
1249
1250 /// IsOptionalEdge - Validate that the 'optional_edge' has proper structure.
1251 bool IsOptionalEdge (const DagInit& Edg) {
1252   return (GetOperatorName(Edg) == "optional_edge") && (Edg.getNumArgs() > 2);
1253 }
1254
1255 /// CheckForSuperfluousOptions - Check that there are no side
1256 /// effect-free options (specified only in the OptionList). Otherwise,
1257 /// output a warning.
1258 void CheckForSuperfluousOptions (const DagVector& EdgeVector,
1259                                  const ToolDescriptions& ToolDescs,
1260                                  const OptionDescriptions& OptDescs) {
1261   llvm::StringSet<> nonSuperfluousOptions;
1262
1263   // Add all options mentioned in the ToolDesc.Actions to the set of
1264   // non-superfluous options.
1265   for (ToolDescriptions::const_iterator B = ToolDescs.begin(),
1266          E = ToolDescs.end(); B != E; ++B) {
1267     const ToolDescription& TD = *(*B);
1268     ExtractOptionNames Callback(nonSuperfluousOptions);
1269     if (TD.Actions)
1270       WalkCase(TD.Actions, Callback, Callback);
1271   }
1272
1273   // Add all options mentioned in the 'case' clauses of the
1274   // OptionalEdges of the compilation graph to the set of
1275   // non-superfluous options.
1276   for (DagVector::const_iterator B = EdgeVector.begin(),
1277          E = EdgeVector.end(); B != E; ++B) {
1278     const DagInit& Edge = **B;
1279     if (IsOptionalEdge(Edge)) {
1280       const DagInit& Weight = InitPtrToDag(Edge.getArg(2));
1281       WalkCase(&Weight, ExtractOptionNames(nonSuperfluousOptions), Id());
1282     }
1283   }
1284
1285   // Check that all options in OptDescs belong to the set of
1286   // non-superfluous options.
1287   for (OptionDescriptions::const_iterator B = OptDescs.begin(),
1288          E = OptDescs.end(); B != E; ++B) {
1289     const OptionDescription& Val = B->second;
1290     if (!nonSuperfluousOptions.count(Val.Name)
1291         && Val.Type != OptionType::Alias)
1292       llvm::errs() << "Warning: option '-" << Val.Name << "' has no effect! "
1293         "Probable cause: this option is specified only in the OptionList.\n";
1294   }
1295 }
1296
1297 /// EmitCaseTest0Args - Helper function used by EmitCaseConstructHandler().
1298 bool EmitCaseTest0Args(const std::string& TestName, raw_ostream& O) {
1299   if (TestName == "single_input_file") {
1300     O << "InputFilenames.size() == 1";
1301     return true;
1302   }
1303   else if (TestName == "multiple_input_files") {
1304     O << "InputFilenames.size() > 1";
1305     return true;
1306   }
1307
1308   return false;
1309 }
1310
1311 /// EmitListTest - Helper function used by EmitCaseTest1ArgList().
1312 template <typename F>
1313 void EmitListTest(const ListInit& L, const char* LogicOp,
1314                   F Callback, raw_ostream& O)
1315 {
1316   // This is a lot like EmitLogicalOperationTest, but works on ListInits instead
1317   // of Dags...
1318   bool isFirst = true;
1319   for (ListInit::const_iterator B = L.begin(), E = L.end(); B != E; ++B) {
1320     if (isFirst)
1321       isFirst = false;
1322     else
1323       O << ' ' << LogicOp << ' ';
1324     Callback(InitPtrToString(*B), O);
1325   }
1326 }
1327
1328 // Callbacks for use with EmitListTest.
1329
1330 class EmitSwitchOn {
1331   const OptionDescriptions& OptDescs_;
1332 public:
1333   EmitSwitchOn(const OptionDescriptions& OptDescs) : OptDescs_(OptDescs)
1334   {}
1335
1336   void operator()(const std::string& OptName, raw_ostream& O) const {
1337     const OptionDescription& OptDesc = OptDescs_.FindSwitch(OptName);
1338     O << OptDesc.GenVariableName();
1339   }
1340 };
1341
1342 class EmitEmptyTest {
1343   bool EmitNegate_;
1344   const OptionDescriptions& OptDescs_;
1345 public:
1346   EmitEmptyTest(bool EmitNegate, const OptionDescriptions& OptDescs)
1347     : EmitNegate_(EmitNegate), OptDescs_(OptDescs)
1348   {}
1349
1350   void operator()(const std::string& OptName, raw_ostream& O) const {
1351     const char* Neg = (EmitNegate_ ? "!" : "");
1352     if (OptName == "o") {
1353       O << Neg << "OutputFilename.empty()";
1354     }
1355     else if (OptName == "save-temps") {
1356       O << Neg << "(SaveTemps == SaveTempsEnum::Unset)";
1357     }
1358     else {
1359       const OptionDescription& OptDesc = OptDescs_.FindListOrParameter(OptName);
1360       O << Neg << OptDesc.GenVariableName() << ".empty()";
1361     }
1362   }
1363 };
1364
1365
1366 /// EmitCaseTest1ArgList - Helper function used by EmitCaseTest1Arg();
1367 bool EmitCaseTest1ArgList(const std::string& TestName,
1368                           const DagInit& d,
1369                           const OptionDescriptions& OptDescs,
1370                           raw_ostream& O) {
1371   const ListInit& L = InitPtrToList(d.getArg(0));
1372
1373   if (TestName == "any_switch_on") {
1374     EmitListTest(L, "||", EmitSwitchOn(OptDescs), O);
1375     return true;
1376   }
1377   else if (TestName == "switch_on") {
1378     EmitListTest(L, "&&", EmitSwitchOn(OptDescs), O);
1379     return true;
1380   }
1381   else if (TestName == "any_not_empty") {
1382     EmitListTest(L, "||", EmitEmptyTest(true, OptDescs), O);
1383     return true;
1384   }
1385   else if (TestName == "any_empty") {
1386     EmitListTest(L, "||", EmitEmptyTest(false, OptDescs), O);
1387     return true;
1388   }
1389   else if (TestName == "not_empty") {
1390     EmitListTest(L, "&&", EmitEmptyTest(true, OptDescs), O);
1391     return true;
1392   }
1393   else if (TestName == "empty") {
1394     EmitListTest(L, "&&", EmitEmptyTest(false, OptDescs), O);
1395     return true;
1396   }
1397
1398   return false;
1399 }
1400
1401 /// EmitCaseTest1ArgStr - Helper function used by EmitCaseTest1Arg();
1402 bool EmitCaseTest1ArgStr(const std::string& TestName,
1403                          const DagInit& d,
1404                          const OptionDescriptions& OptDescs,
1405                          raw_ostream& O) {
1406   const std::string& OptName = InitPtrToString(d.getArg(0));
1407
1408   if (TestName == "switch_on") {
1409     apply(EmitSwitchOn(OptDescs), OptName, O);
1410     return true;
1411   }
1412   else if (TestName == "input_languages_contain") {
1413     O << "InLangs.count(\"" << OptName << "\") != 0";
1414     return true;
1415   }
1416   else if (TestName == "in_language") {
1417     // This works only for single-argument Tool::GenerateAction. Join
1418     // tools can process several files in different languages simultaneously.
1419
1420     // TODO: make this work with Edge::Weight (if possible).
1421     O << "LangMap.GetLanguage(inFile) == \"" << OptName << '\"';
1422     return true;
1423   }
1424   else if (TestName == "not_empty" || TestName == "empty") {
1425     bool EmitNegate = (TestName == "not_empty");
1426     apply(EmitEmptyTest(EmitNegate, OptDescs), OptName, O);
1427     return true;
1428   }
1429
1430   return false;
1431 }
1432
1433 /// EmitCaseTest1Arg - Helper function used by EmitCaseConstructHandler();
1434 bool EmitCaseTest1Arg(const std::string& TestName,
1435                       const DagInit& d,
1436                       const OptionDescriptions& OptDescs,
1437                       raw_ostream& O) {
1438   CheckNumberOfArguments(d, 1);
1439   if (typeid(*d.getArg(0)) == typeid(ListInit))
1440     return EmitCaseTest1ArgList(TestName, d, OptDescs, O);
1441   else
1442     return EmitCaseTest1ArgStr(TestName, d, OptDescs, O);
1443 }
1444
1445 /// EmitCaseTest2Args - Helper function used by EmitCaseConstructHandler().
1446 bool EmitCaseTest2Args(const std::string& TestName,
1447                        const DagInit& d,
1448                        unsigned IndentLevel,
1449                        const OptionDescriptions& OptDescs,
1450                        raw_ostream& O) {
1451   CheckNumberOfArguments(d, 2);
1452   const std::string& OptName = InitPtrToString(d.getArg(0));
1453   const std::string& OptArg = InitPtrToString(d.getArg(1));
1454
1455   if (TestName == "parameter_equals") {
1456     const OptionDescription& OptDesc = OptDescs.FindParameter(OptName);
1457     O << OptDesc.GenVariableName() << " == \"" << OptArg << "\"";
1458     return true;
1459   }
1460   else if (TestName == "element_in_list") {
1461     const OptionDescription& OptDesc = OptDescs.FindParameterList(OptName);
1462     const std::string& VarName = OptDesc.GenVariableName();
1463     O << "std::find(" << VarName << ".begin(),\n";
1464     O.indent(IndentLevel + Indent1)
1465       << VarName << ".end(), \""
1466       << OptArg << "\") != " << VarName << ".end()";
1467     return true;
1468   }
1469
1470   return false;
1471 }
1472
1473 // Forward declaration.
1474 // EmitLogicalOperationTest and EmitCaseTest are mutually recursive.
1475 void EmitCaseTest(const DagInit& d, unsigned IndentLevel,
1476                   const OptionDescriptions& OptDescs,
1477                   raw_ostream& O);
1478
1479 /// EmitLogicalOperationTest - Helper function used by
1480 /// EmitCaseConstructHandler.
1481 void EmitLogicalOperationTest(const DagInit& d, const char* LogicOp,
1482                               unsigned IndentLevel,
1483                               const OptionDescriptions& OptDescs,
1484                               raw_ostream& O) {
1485   O << '(';
1486   for (unsigned j = 0, NumArgs = d.getNumArgs(); j < NumArgs; ++j) {
1487     const DagInit& InnerTest = InitPtrToDag(d.getArg(j));
1488     EmitCaseTest(InnerTest, IndentLevel, OptDescs, O);
1489     if (j != NumArgs - 1) {
1490       O << ")\n";
1491       O.indent(IndentLevel + Indent1) << ' ' << LogicOp << " (";
1492     }
1493     else {
1494       O << ')';
1495     }
1496   }
1497 }
1498
1499 void EmitLogicalNot(const DagInit& d, unsigned IndentLevel,
1500                     const OptionDescriptions& OptDescs, raw_ostream& O)
1501 {
1502   CheckNumberOfArguments(d, 1);
1503   const DagInit& InnerTest = InitPtrToDag(d.getArg(0));
1504   O << "! (";
1505   EmitCaseTest(InnerTest, IndentLevel, OptDescs, O);
1506   O << ")";
1507 }
1508
1509 /// EmitCaseTest - Helper function used by EmitCaseConstructHandler.
1510 void EmitCaseTest(const DagInit& d, unsigned IndentLevel,
1511                   const OptionDescriptions& OptDescs,
1512                   raw_ostream& O) {
1513   const std::string& TestName = GetOperatorName(d);
1514
1515   if (TestName == "and")
1516     EmitLogicalOperationTest(d, "&&", IndentLevel, OptDescs, O);
1517   else if (TestName == "or")
1518     EmitLogicalOperationTest(d, "||", IndentLevel, OptDescs, O);
1519   else if (TestName == "not")
1520     EmitLogicalNot(d, IndentLevel, OptDescs, O);
1521   else if (EmitCaseTest0Args(TestName, O))
1522     return;
1523   else if (EmitCaseTest1Arg(TestName, d, OptDescs, O))
1524     return;
1525   else if (EmitCaseTest2Args(TestName, d, IndentLevel, OptDescs, O))
1526     return;
1527   else
1528     throw "Unknown test '" + TestName + "' used in the 'case' construct!";
1529 }
1530
1531
1532 /// EmitCaseTestCallback - Callback used by EmitCaseConstructHandler.
1533 class EmitCaseTestCallback {
1534   bool EmitElseIf_;
1535   const OptionDescriptions& OptDescs_;
1536   raw_ostream& O_;
1537 public:
1538
1539   EmitCaseTestCallback(bool EmitElseIf,
1540                        const OptionDescriptions& OptDescs, raw_ostream& O)
1541     : EmitElseIf_(EmitElseIf), OptDescs_(OptDescs), O_(O)
1542   {}
1543
1544   void operator()(const DagInit& Test, unsigned IndentLevel, bool FirstTest)
1545   {
1546     if (GetOperatorName(Test) == "default") {
1547       O_.indent(IndentLevel) << "else {\n";
1548     }
1549     else {
1550       O_.indent(IndentLevel)
1551         << ((!FirstTest && EmitElseIf_) ? "else if (" : "if (");
1552       EmitCaseTest(Test, IndentLevel, OptDescs_, O_);
1553       O_ << ") {\n";
1554     }
1555   }
1556 };
1557
1558 /// EmitCaseStatementCallback - Callback used by EmitCaseConstructHandler.
1559 template <typename F>
1560 class EmitCaseStatementCallback {
1561   F Callback_;
1562   raw_ostream& O_;
1563 public:
1564
1565   EmitCaseStatementCallback(F Callback, raw_ostream& O)
1566     : Callback_(Callback), O_(O)
1567   {}
1568
1569   void operator() (const Init* Statement, unsigned IndentLevel) {
1570
1571     // Ignore nested 'case' DAG.
1572     if (!(dynamic_cast<const DagInit*>(Statement) &&
1573           GetOperatorName(static_cast<const DagInit&>(*Statement)) == "case")) {
1574       if (typeid(*Statement) == typeid(ListInit)) {
1575         const ListInit& DagList = *static_cast<const ListInit*>(Statement);
1576         for (ListInit::const_iterator B = DagList.begin(), E = DagList.end();
1577              B != E; ++B)
1578           Callback_(*B, (IndentLevel + Indent1), O_);
1579       }
1580       else {
1581         Callback_(Statement, (IndentLevel + Indent1), O_);
1582       }
1583     }
1584     O_.indent(IndentLevel) << "}\n";
1585   }
1586
1587 };
1588
1589 /// EmitCaseConstructHandler - Emit code that handles the 'case'
1590 /// construct. Takes a function object that should emit code for every case
1591 /// clause. Implemented on top of WalkCase.
1592 /// Callback's type is void F(const Init* Statement, unsigned IndentLevel,
1593 /// raw_ostream& O).
1594 /// EmitElseIf parameter controls the type of condition that is emitted ('if
1595 /// (..) {..} else if (..) {} .. else {..}' vs. 'if (..) {..} if(..)  {..}
1596 /// .. else {..}').
1597 template <typename F>
1598 void EmitCaseConstructHandler(const Init* Case, unsigned IndentLevel,
1599                               F Callback, bool EmitElseIf,
1600                               const OptionDescriptions& OptDescs,
1601                               raw_ostream& O) {
1602   WalkCase(Case, EmitCaseTestCallback(EmitElseIf, OptDescs, O),
1603            EmitCaseStatementCallback<F>(Callback, O), IndentLevel);
1604 }
1605
1606 /// TokenizeCmdLine - converts from
1607 /// "$CALL(HookName, 'Arg1', 'Arg2')/path -arg1 -arg2" to
1608 /// ["$CALL(", "HookName", "Arg1", "Arg2", ")/path", "-arg1", "-arg2"].
1609 void TokenizeCmdLine(const std::string& CmdLine, StrVector& Out) {
1610   const char* Delimiters = " \t\n\v\f\r";
1611   enum TokenizerState
1612   { Normal, SpecialCommand, InsideSpecialCommand, InsideQuotationMarks }
1613   cur_st  = Normal;
1614
1615   if (CmdLine.empty())
1616     return;
1617   Out.push_back("");
1618
1619   std::string::size_type B = CmdLine.find_first_not_of(Delimiters),
1620     E = CmdLine.size();
1621
1622   for (; B != E; ++B) {
1623     char cur_ch = CmdLine[B];
1624
1625     switch (cur_st) {
1626     case Normal:
1627       if (cur_ch == '$') {
1628         cur_st = SpecialCommand;
1629         break;
1630       }
1631       if (OneOf(Delimiters, cur_ch)) {
1632         // Skip whitespace
1633         B = CmdLine.find_first_not_of(Delimiters, B);
1634         if (B == std::string::npos) {
1635           B = E-1;
1636           continue;
1637         }
1638         --B;
1639         Out.push_back("");
1640         continue;
1641       }
1642       break;
1643
1644
1645     case SpecialCommand:
1646       if (OneOf(Delimiters, cur_ch)) {
1647         cur_st = Normal;
1648         Out.push_back("");
1649         continue;
1650       }
1651       if (cur_ch == '(') {
1652         Out.push_back("");
1653         cur_st = InsideSpecialCommand;
1654         continue;
1655       }
1656       break;
1657
1658     case InsideSpecialCommand:
1659       if (OneOf(Delimiters, cur_ch)) {
1660         continue;
1661       }
1662       if (cur_ch == '\'') {
1663         cur_st = InsideQuotationMarks;
1664         Out.push_back("");
1665         continue;
1666       }
1667       if (cur_ch == ')') {
1668         cur_st = Normal;
1669         Out.push_back("");
1670       }
1671       if (cur_ch == ',') {
1672         continue;
1673       }
1674
1675       break;
1676
1677     case InsideQuotationMarks:
1678       if (cur_ch == '\'') {
1679         cur_st = InsideSpecialCommand;
1680         continue;
1681       }
1682       break;
1683     }
1684
1685     Out.back().push_back(cur_ch);
1686   }
1687 }
1688
1689 /// SubstituteCall - Given "$CALL(HookName, [Arg1 [, Arg2 [...]]])", output
1690 /// "hooks::HookName([Arg1 [, Arg2 [, ...]]])". Helper function used by
1691 /// SubstituteSpecialCommands().
1692 StrVector::const_iterator
1693 SubstituteCall (StrVector::const_iterator Pos,
1694                 StrVector::const_iterator End,
1695                 bool IsJoin, raw_ostream& O)
1696 {
1697   const char* errorMessage = "Syntax error in $CALL invocation!";
1698   CheckedIncrement(Pos, End, errorMessage);
1699   const std::string& CmdName = *Pos;
1700
1701   if (CmdName == ")")
1702     throw "$CALL invocation: empty argument list!";
1703
1704   O << "hooks::";
1705   O << CmdName << "(";
1706
1707
1708   bool firstIteration = true;
1709   while (true) {
1710     CheckedIncrement(Pos, End, errorMessage);
1711     const std::string& Arg = *Pos;
1712     assert(Arg.size() != 0);
1713
1714     if (Arg[0] == ')')
1715       break;
1716
1717     if (firstIteration)
1718       firstIteration = false;
1719     else
1720       O << ", ";
1721
1722     if (Arg == "$INFILE") {
1723       if (IsJoin)
1724         throw "$CALL(Hook, $INFILE) can't be used with a Join tool!";
1725       else
1726         O << "inFile.c_str()";
1727     }
1728     else {
1729       O << '"' << Arg << '"';
1730     }
1731   }
1732
1733   O << ')';
1734
1735   return Pos;
1736 }
1737
1738 /// SubstituteEnv - Given '$ENV(VAR_NAME)', output 'getenv("VAR_NAME")'. Helper
1739 /// function used by SubstituteSpecialCommands().
1740 StrVector::const_iterator
1741 SubstituteEnv (StrVector::const_iterator Pos,
1742                StrVector::const_iterator End, raw_ostream& O)
1743 {
1744   const char* errorMessage = "Syntax error in $ENV invocation!";
1745   CheckedIncrement(Pos, End, errorMessage);
1746   const std::string& EnvName = *Pos;
1747
1748   if (EnvName == ")")
1749     throw "$ENV invocation: empty argument list!";
1750
1751   O << "checkCString(std::getenv(\"";
1752   O << EnvName;
1753   O << "\"))";
1754
1755   CheckedIncrement(Pos, End, errorMessage);
1756
1757   return Pos;
1758 }
1759
1760 /// SubstituteSpecialCommands - Given an invocation of $CALL or $ENV, output
1761 /// handler code. Helper function used by EmitCmdLineVecFill().
1762 StrVector::const_iterator
1763 SubstituteSpecialCommands (StrVector::const_iterator Pos,
1764                            StrVector::const_iterator End,
1765                            bool IsJoin, raw_ostream& O)
1766 {
1767
1768   const std::string& cmd = *Pos;
1769
1770   // Perform substitution.
1771   if (cmd == "$CALL") {
1772     Pos = SubstituteCall(Pos, End, IsJoin, O);
1773   }
1774   else if (cmd == "$ENV") {
1775     Pos = SubstituteEnv(Pos, End, O);
1776   }
1777   else {
1778     throw "Unknown special command: " + cmd;
1779   }
1780
1781   // Handle '$CMD(ARG)/additional/text'.
1782   const std::string& Leftover = *Pos;
1783   assert(Leftover.at(0) == ')');
1784   if (Leftover.size() != 1)
1785     O << " + std::string(\"" << (Leftover.c_str() + 1) << "\")";
1786
1787   return Pos;
1788 }
1789
1790 /// EmitCmdLineVecFill - Emit code that fills in the command line
1791 /// vector. Helper function used by EmitGenerateActionMethod().
1792 void EmitCmdLineVecFill(const Init* CmdLine, const std::string& ToolName,
1793                         bool IsJoin, unsigned IndentLevel,
1794                         raw_ostream& O) {
1795   StrVector StrVec;
1796   TokenizeCmdLine(InitPtrToString(CmdLine), StrVec);
1797
1798   if (StrVec.empty())
1799     throw "Tool '" + ToolName + "' has empty command line!";
1800
1801   StrVector::const_iterator B = StrVec.begin(), E = StrVec.end();
1802
1803   // Emit the command itself.
1804   assert(!StrVec[0].empty());
1805   O.indent(IndentLevel) << "cmd = ";
1806   if (StrVec[0][0] == '$') {
1807     B = SubstituteSpecialCommands(B, E, IsJoin, O);
1808     ++B;
1809   }
1810   else {
1811     O << '"' << StrVec[0] << '"';
1812     ++B;
1813   }
1814   O << ";\n";
1815
1816   // Go through the command arguments.
1817   assert(B <= E);
1818   for (; B != E; ++B) {
1819     const std::string& cmd = *B;
1820
1821     assert(!cmd.empty());
1822     O.indent(IndentLevel);
1823
1824     if (cmd.at(0) == '$') {
1825       O << "vec.push_back(std::make_pair(0, ";
1826       B = SubstituteSpecialCommands(B, E, IsJoin, O);
1827       O << "));\n";
1828     }
1829     else {
1830       O << "vec.push_back(std::make_pair(0, \"" << cmd << "\"));\n";
1831     }
1832   }
1833
1834 }
1835
1836 /// EmitForEachListElementCycleHeader - Emit common code for iterating through
1837 /// all elements of a list. Helper function used by
1838 /// EmitForwardOptionPropertyHandlingCode.
1839 void EmitForEachListElementCycleHeader (const OptionDescription& D,
1840                                         unsigned IndentLevel,
1841                                         raw_ostream& O) {
1842   unsigned IndentLevel1 = IndentLevel + Indent1;
1843
1844   O.indent(IndentLevel)
1845     << "for (" << D.GenTypeDeclaration()
1846     << "::iterator B = " << D.GenVariableName() << ".begin(),\n";
1847   O.indent(IndentLevel)
1848     << "E = " << D.GenVariableName() << ".end(); B != E;) {\n";
1849   O.indent(IndentLevel1) << "unsigned pos = " << D.GenVariableName()
1850                          << ".getPosition(B - " << D.GenVariableName()
1851                          << ".begin());\n";
1852 }
1853
1854 /// EmitForwardOptionPropertyHandlingCode - Helper function used to
1855 /// implement EmitActionHandler. Emits code for
1856 /// handling the (forward) and (forward_as) option properties.
1857 void EmitForwardOptionPropertyHandlingCode (const OptionDescription& D,
1858                                             unsigned IndentLevel,
1859                                             const std::string& NewName,
1860                                             raw_ostream& O) {
1861   const std::string& Name = NewName.empty()
1862     ? ("-" + D.Name)
1863     : NewName;
1864   unsigned IndentLevel1 = IndentLevel + Indent1;
1865
1866   switch (D.Type) {
1867   case OptionType::Switch:
1868     O.indent(IndentLevel)
1869       << "vec.push_back(std::make_pair(" << D.GenVariableName()
1870       << ".getPosition(), \"" << Name << "\"));\n";
1871     break;
1872   case OptionType::Parameter:
1873     O.indent(IndentLevel) << "vec.push_back(std::make_pair("
1874                           << D.GenVariableName()
1875                           <<".getPosition(), \"" << Name;
1876
1877     if (!D.isForwardNotSplit()) {
1878       O << "\"));\n";
1879       O.indent(IndentLevel) << "vec.push_back(std::make_pair("
1880                             << D.GenVariableName() << ".getPosition(), "
1881                             << D.GenVariableName() << "));\n";
1882     }
1883     else {
1884       O << "=\" + " << D.GenVariableName() << "));\n";
1885     }
1886     break;
1887   case OptionType::Prefix:
1888     O.indent(IndentLevel) << "vec.push_back(std::make_pair("
1889                           << D.GenVariableName() << ".getPosition(), \""
1890                           << Name << "\" + "
1891                           << D.GenVariableName() << "));\n";
1892     break;
1893   case OptionType::PrefixList:
1894     EmitForEachListElementCycleHeader(D, IndentLevel, O);
1895     O.indent(IndentLevel1) << "vec.push_back(std::make_pair(pos, \""
1896                            << Name << "\" + " << "*B));\n";
1897     O.indent(IndentLevel1) << "++B;\n";
1898
1899     for (int i = 1, j = D.MultiVal; i < j; ++i) {
1900       O.indent(IndentLevel1) << "vec.push_back(std::make_pair(pos, *B));\n";
1901       O.indent(IndentLevel1) << "++B;\n";
1902     }
1903
1904     O.indent(IndentLevel) << "}\n";
1905     break;
1906   case OptionType::ParameterList:
1907     EmitForEachListElementCycleHeader(D, IndentLevel, O);
1908     O.indent(IndentLevel1) << "vec.push_back(std::make_pair(pos, \""
1909                            << Name << "\"));\n";
1910
1911     for (int i = 0, j = D.MultiVal; i < j; ++i) {
1912       O.indent(IndentLevel1) << "vec.push_back(std::make_pair(pos, *B));\n";
1913       O.indent(IndentLevel1) << "++B;\n";
1914     }
1915
1916     O.indent(IndentLevel) << "}\n";
1917     break;
1918   case OptionType::SwitchList:
1919     EmitForEachListElementCycleHeader(D, IndentLevel, O);
1920     O.indent(IndentLevel1) << "vec.push_back(std::make_pair(pos, \""
1921                            << Name << "\"));\n";
1922     O.indent(IndentLevel1) << "++B;\n";
1923     O.indent(IndentLevel) << "}\n";
1924     break;
1925   case OptionType::Alias:
1926   default:
1927     throw "Aliases are not allowed in tool option descriptions!";
1928   }
1929 }
1930
1931 /// ActionHandlingCallbackBase - Base class of EmitActionHandlersCallback and
1932 /// EmitPreprocessOptionsCallback.
1933 struct ActionHandlingCallbackBase
1934 {
1935
1936   void onErrorDag(const DagInit& d,
1937                   unsigned IndentLevel, raw_ostream& O) const
1938   {
1939     O.indent(IndentLevel)
1940       << "PrintError(\""
1941       << (d.getNumArgs() >= 1 ? InitPtrToString(d.getArg(0)) : "Unknown error!")
1942       << "\");\n";
1943     O.indent(IndentLevel) << "return 1;\n";
1944   }
1945
1946   void onWarningDag(const DagInit& d,
1947                     unsigned IndentLevel, raw_ostream& O) const
1948   {
1949     CheckNumberOfArguments(d, 1);
1950     O.indent(IndentLevel) << "llvm::errs() << \""
1951                           << InitPtrToString(d.getArg(0)) << "\";\n";
1952   }
1953
1954 };
1955
1956 /// EmitActionHandlersCallback - Emit code that handles actions. Used by
1957 /// EmitGenerateActionMethod() as an argument to EmitCaseConstructHandler().
1958 class EmitActionHandlersCallback;
1959
1960 typedef void (EmitActionHandlersCallback::* EmitActionHandlersCallbackHandler)
1961 (const DagInit&, unsigned, raw_ostream&) const;
1962
1963 class EmitActionHandlersCallback :
1964   public ActionHandlingCallbackBase,
1965   public HandlerTable<EmitActionHandlersCallbackHandler>
1966 {
1967   typedef EmitActionHandlersCallbackHandler Handler;
1968
1969   const OptionDescriptions& OptDescs;
1970
1971   /// EmitHookInvocation - Common code for hook invocation from actions. Used by
1972   /// onAppendCmd and onOutputSuffix.
1973   void EmitHookInvocation(const std::string& Str,
1974                           const char* BlockOpen, const char* BlockClose,
1975                           unsigned IndentLevel, raw_ostream& O) const
1976   {
1977     StrVector Out;
1978     TokenizeCmdLine(Str, Out);
1979
1980     for (StrVector::const_iterator B = Out.begin(), E = Out.end();
1981          B != E; ++B) {
1982       const std::string& cmd = *B;
1983
1984       O.indent(IndentLevel) << BlockOpen;
1985
1986       if (cmd.at(0) == '$')
1987         B = SubstituteSpecialCommands(B, E,  /* IsJoin = */ true, O);
1988       else
1989         O << '"' << cmd << '"';
1990
1991       O << BlockClose;
1992     }
1993   }
1994
1995   void onAppendCmd (const DagInit& Dag,
1996                     unsigned IndentLevel, raw_ostream& O) const
1997   {
1998     CheckNumberOfArguments(Dag, 1);
1999     this->EmitHookInvocation(InitPtrToString(Dag.getArg(0)),
2000                              "vec.push_back(std::make_pair(65536, ", "));\n",
2001                              IndentLevel, O);
2002   }
2003
2004   void onForward (const DagInit& Dag,
2005                   unsigned IndentLevel, raw_ostream& O) const
2006   {
2007     CheckNumberOfArguments(Dag, 1);
2008     const std::string& Name = InitPtrToString(Dag.getArg(0));
2009     EmitForwardOptionPropertyHandlingCode(OptDescs.FindOption(Name),
2010                                           IndentLevel, "", O);
2011   }
2012
2013   void onForwardAs (const DagInit& Dag,
2014                     unsigned IndentLevel, raw_ostream& O) const
2015   {
2016     CheckNumberOfArguments(Dag, 2);
2017     const std::string& Name = InitPtrToString(Dag.getArg(0));
2018     const std::string& NewName = InitPtrToString(Dag.getArg(1));
2019     EmitForwardOptionPropertyHandlingCode(OptDescs.FindOption(Name),
2020                                           IndentLevel, NewName, O);
2021   }
2022
2023   void onForwardValue (const DagInit& Dag,
2024                        unsigned IndentLevel, raw_ostream& O) const
2025   {
2026     CheckNumberOfArguments(Dag, 1);
2027     const std::string& Name = InitPtrToString(Dag.getArg(0));
2028     const OptionDescription& D = OptDescs.FindParameterListOrParameter(Name);
2029
2030     if (D.isSwitchList()) {
2031       throw std::runtime_error
2032         ("forward_value is not allowed with switch_list");
2033     }
2034
2035     if (D.isParameter()) {
2036       O.indent(IndentLevel) << "vec.push_back(std::make_pair("
2037                             << D.GenVariableName() << ".getPosition(), "
2038                             << D.GenVariableName() << "));\n";
2039     }
2040     else {
2041       O.indent(IndentLevel) << "for (" << D.GenTypeDeclaration()
2042                             << "::iterator B = " << D.GenVariableName()
2043                             << ".begin(), \n";
2044       O.indent(IndentLevel + Indent1) << " E = " << D.GenVariableName()
2045                                       << ".end(); B != E; ++B)\n";
2046       O.indent(IndentLevel) << "{\n";
2047       O.indent(IndentLevel + Indent1)
2048         << "unsigned pos = " << D.GenVariableName()
2049         << ".getPosition(B - " << D.GenVariableName()
2050         << ".begin());\n";
2051       O.indent(IndentLevel + Indent1)
2052         << "vec.push_back(std::make_pair(pos, *B));\n";
2053       O.indent(IndentLevel) << "}\n";
2054     }
2055   }
2056
2057   void onForwardTransformedValue (const DagInit& Dag,
2058                                   unsigned IndentLevel, raw_ostream& O) const
2059   {
2060     CheckNumberOfArguments(Dag, 2);
2061     const std::string& Name = InitPtrToString(Dag.getArg(0));
2062     const std::string& Hook = InitPtrToString(Dag.getArg(1));
2063     const OptionDescription& D = OptDescs.FindParameterListOrParameter(Name);
2064
2065     O.indent(IndentLevel) << "vec.push_back(std::make_pair("
2066                           << D.GenVariableName() << ".getPosition("
2067                           << (D.isList() ? "0" : "") << "), "
2068                           << "hooks::" << Hook << "(" << D.GenVariableName()
2069                           << (D.isParameter() ? ".c_str()" : "") << ")));\n";
2070   }
2071
2072   void onNoOutFile (const DagInit& Dag,
2073                     unsigned IndentLevel, raw_ostream& O) const
2074   {
2075     CheckNumberOfArguments(Dag, 0);
2076     O.indent(IndentLevel) << "no_out_file = true;\n";
2077   }
2078
2079   void onOutputSuffix (const DagInit& Dag,
2080                        unsigned IndentLevel, raw_ostream& O) const
2081   {
2082     CheckNumberOfArguments(Dag, 1);
2083     this->EmitHookInvocation(InitPtrToString(Dag.getArg(0)),
2084                              "output_suffix = ", ";\n", IndentLevel, O);
2085   }
2086
2087   void onStopCompilation (const DagInit& Dag,
2088                           unsigned IndentLevel, raw_ostream& O) const
2089   {
2090     O.indent(IndentLevel) << "stop_compilation = true;\n";
2091   }
2092
2093
2094   void onUnpackValues (const DagInit& Dag,
2095                        unsigned IndentLevel, raw_ostream& O) const
2096   {
2097     throw "'unpack_values' is deprecated. "
2098       "Use 'comma_separated' + 'forward_value' instead!";
2099   }
2100
2101  public:
2102
2103   explicit EmitActionHandlersCallback(const OptionDescriptions& OD)
2104     : OptDescs(OD)
2105   {
2106     if (!staticMembersInitialized_) {
2107       AddHandler("error", &EmitActionHandlersCallback::onErrorDag);
2108       AddHandler("warning", &EmitActionHandlersCallback::onWarningDag);
2109       AddHandler("append_cmd", &EmitActionHandlersCallback::onAppendCmd);
2110       AddHandler("forward", &EmitActionHandlersCallback::onForward);
2111       AddHandler("forward_as", &EmitActionHandlersCallback::onForwardAs);
2112       AddHandler("forward_value", &EmitActionHandlersCallback::onForwardValue);
2113       AddHandler("forward_transformed_value",
2114                  &EmitActionHandlersCallback::onForwardTransformedValue);
2115       AddHandler("no_out_file",
2116                  &EmitActionHandlersCallback::onNoOutFile);
2117       AddHandler("output_suffix", &EmitActionHandlersCallback::onOutputSuffix);
2118       AddHandler("stop_compilation",
2119                  &EmitActionHandlersCallback::onStopCompilation);
2120       AddHandler("unpack_values",
2121                  &EmitActionHandlersCallback::onUnpackValues);
2122
2123
2124       staticMembersInitialized_ = true;
2125     }
2126   }
2127
2128   void operator()(const Init* I,
2129                   unsigned IndentLevel, raw_ostream& O) const
2130   {
2131     InvokeDagInitHandler(this, I, IndentLevel, O);
2132   }
2133 };
2134
2135 void EmitGenerateActionMethodHeader(const ToolDescription& D,
2136                                     bool IsJoin, bool Naked,
2137                                     raw_ostream& O)
2138 {
2139   O.indent(Indent1) << "int GenerateAction(Action& Out,\n";
2140
2141   if (IsJoin)
2142     O.indent(Indent2) << "const PathVector& inFiles,\n";
2143   else
2144     O.indent(Indent2) << "const sys::Path& inFile,\n";
2145
2146   O.indent(Indent2) << "const bool HasChildren,\n";
2147   O.indent(Indent2) << "const llvm::sys::Path& TempDir,\n";
2148   O.indent(Indent2) << "const InputLanguagesSet& InLangs,\n";
2149   O.indent(Indent2) << "const LanguageMap& LangMap) const\n";
2150   O.indent(Indent1) << "{\n";
2151
2152   if (!Naked) {
2153     O.indent(Indent2) << "std::string cmd;\n";
2154     O.indent(Indent2) << "std::string out_file;\n";
2155     O.indent(Indent2)
2156       << "std::vector<std::pair<unsigned, std::string> > vec;\n";
2157     O.indent(Indent2) << "bool stop_compilation = !HasChildren;\n";
2158     O.indent(Indent2) << "bool no_out_file = false;\n";
2159     O.indent(Indent2) << "std::string output_suffix(\""
2160                       << D.OutputSuffix << "\");\n";
2161   }
2162 }
2163
2164 // EmitGenerateActionMethod - Emit either a normal or a "join" version of the
2165 // Tool::GenerateAction() method.
2166 void EmitGenerateActionMethod (const ToolDescription& D,
2167                                const OptionDescriptions& OptDescs,
2168                                bool IsJoin, raw_ostream& O) {
2169
2170   EmitGenerateActionMethodHeader(D, IsJoin, /* Naked = */ false, O);
2171
2172   if (!D.CmdLine)
2173     throw "Tool " + D.Name + " has no cmd_line property!";
2174
2175   // Process the 'command' property.
2176   O << '\n';
2177   EmitCmdLineVecFill(D.CmdLine, D.Name, IsJoin, Indent2, O);
2178   O << '\n';
2179
2180   // Process the 'actions' list of this tool.
2181   if (D.Actions)
2182     EmitCaseConstructHandler(D.Actions, Indent2,
2183                              EmitActionHandlersCallback(OptDescs),
2184                              false, OptDescs, O);
2185   O << '\n';
2186
2187   // Input file (s)
2188   if (!D.InFileOption.empty()) {
2189     O.indent(Indent2)
2190       << "vec.push_back(std::make_pair(InputFilenames.getPosition(0), \""
2191       << D.InFileOption << "\");\n";
2192   }
2193
2194   if (IsJoin) {
2195     O.indent(Indent2)
2196       << "for (PathVector::const_iterator B = inFiles.begin(),\n";
2197     O.indent(Indent3) << "E = inFiles.end(); B != E; ++B)\n";
2198     O.indent(Indent2) << "{\n";
2199     O.indent(Indent3) << "vec.push_back(std::make_pair("
2200                       << "InputFilenames.getPosition(B - inFiles.begin()), "
2201                       << "B->str()));\n";
2202     O.indent(Indent2) << "}\n";
2203   }
2204   else {
2205     O.indent(Indent2) << "vec.push_back(std::make_pair("
2206                       << "InputFilenames.getPosition(0), inFile.str()));\n";
2207   }
2208
2209   // Output file
2210   O.indent(Indent2) << "if (!no_out_file) {\n";
2211   if (!D.OutFileOption.empty())
2212     O.indent(Indent3) << "vec.push_back(std::make_pair(65536, \""
2213                       << D.OutFileOption << "\"));\n";
2214
2215   O.indent(Indent3) << "out_file = this->OutFilename("
2216                     << (IsJoin ? "sys::Path(),\n" : "inFile,\n");
2217   O.indent(Indent4) <<
2218     "TempDir, stop_compilation, output_suffix.c_str()).str();\n\n";
2219   O.indent(Indent3) << "vec.push_back(std::make_pair(65536, out_file));\n";
2220
2221   O.indent(Indent2) << "}\n\n";
2222
2223   // Handle the Sink property.
2224   std::string SinkOption("autogenerated::");
2225   SinkOption += SinkOptionName;
2226   if (D.isSink()) {
2227     O.indent(Indent2) << "if (!" << SinkOption << ".empty()) {\n";
2228     O.indent(Indent3) << "for (cl::list<std::string>::iterator B = "
2229                       << SinkOption << ".begin(), E = " << SinkOption
2230                       << ".end(); B != E; ++B)\n";
2231     O.indent(Indent4) << "vec.push_back(std::make_pair(" << SinkOption
2232                       << ".getPosition(B - " << SinkOption
2233                       <<  ".begin()), *B));\n";
2234     O.indent(Indent2) << "}\n";
2235   }
2236
2237   O.indent(Indent2) << "Out.Construct(cmd, this->SortArgs(vec), "
2238                     << "stop_compilation, out_file);\n";
2239   O.indent(Indent2) << "return 0;\n";
2240   O.indent(Indent1) << "}\n\n";
2241 }
2242
2243 /// EmitGenerateActionMethods - Emit two GenerateAction() methods for
2244 /// a given Tool class.
2245 void EmitGenerateActionMethods (const ToolDescription& ToolDesc,
2246                                 const OptionDescriptions& OptDescs,
2247                                 raw_ostream& O) {
2248   if (!ToolDesc.isJoin()) {
2249     EmitGenerateActionMethodHeader(ToolDesc, /* IsJoin = */ true,
2250                                    /* Naked = */ true, O);
2251     O.indent(Indent2) << "PrintError(\"" << ToolDesc.Name
2252                       << " is not a Join tool!\");\n";
2253     O.indent(Indent2) << "return -1;\n";
2254     O.indent(Indent1) << "}\n\n";
2255   }
2256   else {
2257     EmitGenerateActionMethod(ToolDesc, OptDescs, true, O);
2258   }
2259
2260   EmitGenerateActionMethod(ToolDesc, OptDescs, false, O);
2261 }
2262
2263 /// EmitInOutLanguageMethods - Emit the [Input,Output]Language()
2264 /// methods for a given Tool class.
2265 void EmitInOutLanguageMethods (const ToolDescription& D, raw_ostream& O) {
2266   O.indent(Indent1) << "const char** InputLanguages() const {\n";
2267   O.indent(Indent2) << "return InputLanguages_;\n";
2268   O.indent(Indent1) << "}\n\n";
2269
2270   O.indent(Indent1) << "const char** OutputLanguages() const {\n";
2271   O.indent(Indent2) << "return OutputLanguages_;\n";
2272   O.indent(Indent1) << "}\n\n";
2273 }
2274
2275 /// EmitNameMethod - Emit the Name() method for a given Tool class.
2276 void EmitNameMethod (const ToolDescription& D, raw_ostream& O) {
2277   O.indent(Indent1) << "const char* Name() const {\n";
2278   O.indent(Indent2) << "return \"" << D.Name << "\";\n";
2279   O.indent(Indent1) << "}\n\n";
2280 }
2281
2282 /// EmitIsJoinMethod - Emit the IsJoin() method for a given Tool
2283 /// class.
2284 void EmitIsJoinMethod (const ToolDescription& D, raw_ostream& O) {
2285   O.indent(Indent1) << "bool IsJoin() const {\n";
2286   if (D.isJoin())
2287     O.indent(Indent2) << "return true;\n";
2288   else
2289     O.indent(Indent2) << "return false;\n";
2290   O.indent(Indent1) << "}\n\n";
2291 }
2292
2293 /// EmitWorksOnEmptyCallback - Callback used by EmitWorksOnEmptyMethod in
2294 /// conjunction with EmitCaseConstructHandler.
2295 void EmitWorksOnEmptyCallback (const Init* Value,
2296                                unsigned IndentLevel, raw_ostream& O) {
2297   CheckBooleanConstant(Value);
2298   O.indent(IndentLevel) << "return " << Value->getAsString() << ";\n";
2299 }
2300
2301 /// EmitWorksOnEmptyMethod - Emit the WorksOnEmpty() method for a given Tool
2302 /// class.
2303 void EmitWorksOnEmptyMethod (const ToolDescription& D,
2304                              const OptionDescriptions& OptDescs,
2305                              raw_ostream& O)
2306 {
2307   O.indent(Indent1) << "bool WorksOnEmpty() const {\n";
2308   if (D.OnEmpty == 0)
2309     O.indent(Indent2) << "return false;\n";
2310   else
2311     EmitCaseConstructHandler(D.OnEmpty, Indent2, EmitWorksOnEmptyCallback,
2312                              /*EmitElseIf = */ true, OptDescs, O);
2313   O.indent(Indent1) << "}\n\n";
2314 }
2315
2316 /// EmitStrArray - Emit definition of a 'const char**' static member
2317 /// variable. Helper used by EmitStaticMemberDefinitions();
2318 void EmitStrArray(const std::string& Name, const std::string& VarName,
2319                   const StrVector& StrVec, raw_ostream& O) {
2320   O << "const char* " << Name << "::" << VarName << "[] = {";
2321   for (StrVector::const_iterator B = StrVec.begin(), E = StrVec.end();
2322        B != E; ++B)
2323     O << '\"' << *B << "\", ";
2324   O << "0};\n";
2325 }
2326
2327 /// EmitStaticMemberDefinitions - Emit static member definitions for a
2328 /// given Tool class.
2329 void EmitStaticMemberDefinitions(const ToolDescription& D, raw_ostream& O) {
2330   if (D.InLanguage.empty())
2331     throw "Tool " + D.Name + " has no 'in_language' property!";
2332   if (D.OutLanguage.empty())
2333     throw "Tool " + D.Name + " has no 'out_language' property!";
2334
2335   EmitStrArray(D.Name, "InputLanguages_", D.InLanguage, O);
2336   EmitStrArray(D.Name, "OutputLanguages_", D.OutLanguage, O);
2337   O << '\n';
2338 }
2339
2340 /// EmitToolClassDefinition - Emit a Tool class definition.
2341 void EmitToolClassDefinition (const ToolDescription& D,
2342                               const OptionDescriptions& OptDescs,
2343                               raw_ostream& O) {
2344   if (D.Name == "root")
2345     return;
2346
2347   // Header
2348   O << "class " << D.Name << " : public ";
2349   if (D.isJoin())
2350     O << "JoinTool";
2351   else
2352     O << "Tool";
2353
2354   O << " {\nprivate:\n";
2355   O.indent(Indent1) << "static const char* InputLanguages_[];\n";
2356   O.indent(Indent1) << "static const char* OutputLanguages_[];\n\n";
2357
2358   O << "public:\n";
2359   EmitNameMethod(D, O);
2360   EmitInOutLanguageMethods(D, O);
2361   EmitIsJoinMethod(D, O);
2362   EmitWorksOnEmptyMethod(D, OptDescs, O);
2363   EmitGenerateActionMethods(D, OptDescs, O);
2364
2365   // Close class definition
2366   O << "};\n";
2367
2368   EmitStaticMemberDefinitions(D, O);
2369
2370 }
2371
2372 /// EmitOptionDefinitions - Iterate over a list of option descriptions
2373 /// and emit registration code.
2374 void EmitOptionDefinitions (const OptionDescriptions& descs,
2375                             bool HasSink, raw_ostream& O)
2376 {
2377   std::vector<OptionDescription> Aliases;
2378
2379   // Emit static cl::Option variables.
2380   for (OptionDescriptions::const_iterator B = descs.begin(),
2381          E = descs.end(); B!=E; ++B) {
2382     const OptionDescription& val = B->second;
2383
2384     if (val.Type == OptionType::Alias) {
2385       Aliases.push_back(val);
2386       continue;
2387     }
2388
2389     O << val.GenTypeDeclaration() << ' '
2390       << val.GenPlainVariableName();
2391
2392     O << "(\"" << val.Name << "\"\n";
2393
2394     if (val.Type == OptionType::Prefix || val.Type == OptionType::PrefixList)
2395       O << ", cl::Prefix";
2396
2397     if (val.isRequired()) {
2398       if (val.isList() && !val.isMultiVal())
2399         O << ", cl::OneOrMore";
2400       else
2401         O << ", cl::Required";
2402     }
2403
2404     if (val.isOptional())
2405         O << ", cl::Optional";
2406
2407     if (val.isOneOrMore())
2408         O << ", cl::OneOrMore";
2409
2410     if (val.isZeroOrMore())
2411         O << ", cl::ZeroOrMore";
2412
2413     if (val.isReallyHidden())
2414       O << ", cl::ReallyHidden";
2415     else if (val.isHidden())
2416       O << ", cl::Hidden";
2417
2418     if (val.isCommaSeparated())
2419       O << ", cl::CommaSeparated";
2420
2421     if (val.MultiVal > 1)
2422       O << ", cl::multi_val(" << val.MultiVal << ')';
2423
2424     if (val.InitVal) {
2425       const std::string& str = val.InitVal->getAsString();
2426       O << ", cl::init(" << str << ')';
2427     }
2428
2429     if (!val.Help.empty())
2430       O << ", cl::desc(\"" << val.Help << "\")";
2431
2432     O << ");\n\n";
2433   }
2434
2435   // Emit the aliases (they should go after all the 'proper' options).
2436   for (std::vector<OptionDescription>::const_iterator
2437          B = Aliases.begin(), E = Aliases.end(); B != E; ++B) {
2438     const OptionDescription& val = *B;
2439
2440     O << val.GenTypeDeclaration() << ' '
2441       << val.GenPlainVariableName()
2442       << "(\"" << val.Name << '\"';
2443
2444     const OptionDescription& D = descs.FindOption(val.Help);
2445     O << ", cl::aliasopt(" << D.GenVariableName() << ")";
2446
2447     O << ", cl::desc(\"" << "An alias for -" + val.Help  << "\"));\n";
2448   }
2449
2450   // Emit the sink option.
2451   if (HasSink)
2452     O << "cl::list<std::string> " << SinkOptionName << "(cl::Sink);\n";
2453
2454   O << '\n';
2455 }
2456
2457 /// EmitPreprocessOptionsCallback - Helper function passed to
2458 /// EmitCaseConstructHandler() by EmitPreprocessOptions().
2459
2460 class EmitPreprocessOptionsCallback;
2461
2462 typedef void
2463 (EmitPreprocessOptionsCallback::* EmitPreprocessOptionsCallbackHandler)
2464 (const DagInit&, unsigned, raw_ostream&) const;
2465
2466 class EmitPreprocessOptionsCallback :
2467   public ActionHandlingCallbackBase,
2468   public HandlerTable<EmitPreprocessOptionsCallbackHandler>
2469 {
2470   typedef EmitPreprocessOptionsCallbackHandler Handler;
2471   typedef void
2472   (EmitPreprocessOptionsCallback::* HandlerImpl)
2473   (const Init*, unsigned, raw_ostream&) const;
2474
2475   const OptionDescriptions& OptDescs_;
2476
2477   void onListOrDag(const DagInit& d, HandlerImpl h,
2478                    unsigned IndentLevel, raw_ostream& O) const
2479   {
2480     CheckNumberOfArguments(d, 1);
2481     const Init* I = d.getArg(0);
2482
2483     // If I is a list, apply h to each element.
2484     if (typeid(*I) == typeid(ListInit)) {
2485       const ListInit& L = *static_cast<const ListInit*>(I);
2486       for (ListInit::const_iterator B = L.begin(), E = L.end(); B != E; ++B)
2487         ((this)->*(h))(*B, IndentLevel, O);
2488     }
2489     // Otherwise, apply h to I.
2490     else {
2491       ((this)->*(h))(I, IndentLevel, O);
2492     }
2493   }
2494
2495   void onUnsetOptionImpl(const Init* I,
2496                          unsigned IndentLevel, raw_ostream& O) const
2497   {
2498     const std::string& OptName = InitPtrToString(I);
2499     const OptionDescription& OptDesc = OptDescs_.FindOption(OptName);
2500
2501     if (OptDesc.isSwitch()) {
2502       O.indent(IndentLevel) << OptDesc.GenVariableName() << " = false;\n";
2503     }
2504     else if (OptDesc.isParameter()) {
2505       O.indent(IndentLevel) << OptDesc.GenVariableName() << " = \"\";\n";
2506     }
2507     else if (OptDesc.isList()) {
2508       O.indent(IndentLevel) << OptDesc.GenVariableName() << ".clear();\n";
2509     }
2510     else {
2511       throw "Can't apply 'unset_option' to alias option '" + OptName + "'!";
2512     }
2513   }
2514
2515   void onUnsetOption(const DagInit& d,
2516                      unsigned IndentLevel, raw_ostream& O) const
2517   {
2518     this->onListOrDag(d, &EmitPreprocessOptionsCallback::onUnsetOptionImpl,
2519                       IndentLevel, O);
2520   }
2521
2522   void onSetOptionImpl(const DagInit& d,
2523                        unsigned IndentLevel, raw_ostream& O) const {
2524     CheckNumberOfArguments(d, 2);
2525     const std::string& OptName = InitPtrToString(d.getArg(0));
2526     const Init* Value = d.getArg(1);
2527     const OptionDescription& OptDesc = OptDescs_.FindOption(OptName);
2528
2529     if (OptDesc.isList()) {
2530       const ListInit& List = InitPtrToList(Value);
2531
2532       O.indent(IndentLevel) << OptDesc.GenVariableName() << ".clear();\n";
2533       for (ListInit::const_iterator B = List.begin(), E = List.end();
2534            B != E; ++B) {
2535         const Init* CurElem = *B;
2536         if (OptDesc.isSwitchList())
2537           CheckBooleanConstant(CurElem);
2538
2539         O.indent(IndentLevel)
2540           << OptDesc.GenVariableName() << ".push_back(\""
2541           << (OptDesc.isSwitchList() ? CurElem->getAsString()
2542               : InitPtrToString(CurElem))
2543           << "\");\n";
2544       }
2545     }
2546     else if (OptDesc.isSwitch()) {
2547       CheckBooleanConstant(Value);
2548       O.indent(IndentLevel) << OptDesc.GenVariableName()
2549                             << " = " << Value->getAsString() << ";\n";
2550     }
2551     else if (OptDesc.isParameter()) {
2552       const std::string& Str = InitPtrToString(Value);
2553       O.indent(IndentLevel) << OptDesc.GenVariableName()
2554                             << " = \"" << Str << "\";\n";
2555     }
2556     else {
2557       throw "Can't apply 'set_option' to alias option -" + OptName + " !";
2558     }
2559   }
2560
2561   void onSetSwitch(const Init* I,
2562                    unsigned IndentLevel, raw_ostream& O) const {
2563     const std::string& OptName = InitPtrToString(I);
2564     const OptionDescription& OptDesc = OptDescs_.FindOption(OptName);
2565
2566     if (OptDesc.isSwitch())
2567       O.indent(IndentLevel) << OptDesc.GenVariableName() << " = true;\n";
2568     else
2569       throw "set_option: -" + OptName + " is not a switch option!";
2570   }
2571
2572   void onSetOption(const DagInit& d,
2573                    unsigned IndentLevel, raw_ostream& O) const
2574   {
2575     CheckNumberOfArguments(d, 1);
2576
2577     // Two arguments: (set_option "parameter", VALUE), where VALUE can be a
2578     // boolean, a string or a string list.
2579     if (d.getNumArgs() > 1)
2580       this->onSetOptionImpl(d, IndentLevel, O);
2581     // One argument: (set_option "switch")
2582     // or (set_option ["switch1", "switch2", ...])
2583     else
2584       this->onListOrDag(d, &EmitPreprocessOptionsCallback::onSetSwitch,
2585                         IndentLevel, O);
2586   }
2587
2588 public:
2589
2590   EmitPreprocessOptionsCallback(const OptionDescriptions& OptDescs)
2591   : OptDescs_(OptDescs)
2592   {
2593     if (!staticMembersInitialized_) {
2594       AddHandler("error", &EmitPreprocessOptionsCallback::onErrorDag);
2595       AddHandler("warning", &EmitPreprocessOptionsCallback::onWarningDag);
2596       AddHandler("unset_option", &EmitPreprocessOptionsCallback::onUnsetOption);
2597       AddHandler("set_option", &EmitPreprocessOptionsCallback::onSetOption);
2598
2599       staticMembersInitialized_ = true;
2600     }
2601   }
2602
2603   void operator()(const Init* I,
2604                   unsigned IndentLevel, raw_ostream& O) const
2605   {
2606     InvokeDagInitHandler(this, I, IndentLevel, O);
2607   }
2608
2609 };
2610
2611 /// EmitPreprocessOptions - Emit the PreprocessOptions() function.
2612 void EmitPreprocessOptions (const RecordKeeper& Records,
2613                             const OptionDescriptions& OptDecs, raw_ostream& O)
2614 {
2615   O << "int PreprocessOptions () {\n";
2616
2617   const RecordVector& OptionPreprocessors =
2618     Records.getAllDerivedDefinitions("OptionPreprocessor");
2619
2620   for (RecordVector::const_iterator B = OptionPreprocessors.begin(),
2621          E = OptionPreprocessors.end(); B!=E; ++B) {
2622     DagInit* Case = (*B)->getValueAsDag("preprocessor");
2623     EmitCaseConstructHandler(Case, Indent1,
2624                              EmitPreprocessOptionsCallback(OptDecs),
2625                              false, OptDecs, O);
2626   }
2627
2628   O << '\n';
2629   O.indent(Indent1) << "return 0;\n";
2630   O << "}\n\n";
2631 }
2632
2633 class DoEmitPopulateLanguageMap;
2634 typedef void (DoEmitPopulateLanguageMap::* DoEmitPopulateLanguageMapHandler)
2635 (const DagInit& D);
2636
2637 class DoEmitPopulateLanguageMap
2638 : public HandlerTable<DoEmitPopulateLanguageMapHandler>
2639 {
2640 private:
2641   raw_ostream& O_;
2642
2643 public:
2644
2645   explicit DoEmitPopulateLanguageMap (raw_ostream& O) : O_(O) {
2646     if (!staticMembersInitialized_) {
2647       AddHandler("lang_to_suffixes",
2648                  &DoEmitPopulateLanguageMap::onLangToSuffixes);
2649
2650       staticMembersInitialized_ = true;
2651     }
2652   }
2653
2654   void operator() (Init* I) {
2655     InvokeDagInitHandler(this, I);
2656   }
2657
2658 private:
2659
2660   void onLangToSuffixes (const DagInit& d) {
2661     CheckNumberOfArguments(d, 2);
2662
2663     const std::string& Lang = InitPtrToString(d.getArg(0));
2664     Init* Suffixes = d.getArg(1);
2665
2666     // Second argument to lang_to_suffixes is either a single string...
2667     if (typeid(*Suffixes) == typeid(StringInit)) {
2668       O_.indent(Indent1) << "langMap[\"" << InitPtrToString(Suffixes)
2669                          << "\"] = \"" << Lang << "\";\n";
2670     }
2671     // ...or a list of strings.
2672     else {
2673       const ListInit& Lst = InitPtrToList(Suffixes);
2674       assert(Lst.size() != 0);
2675       for (ListInit::const_iterator B = Lst.begin(), E = Lst.end();
2676            B != E; ++B) {
2677         O_.indent(Indent1) << "langMap[\"" << InitPtrToString(*B)
2678                            << "\"] = \"" << Lang << "\";\n";
2679       }
2680     }
2681   }
2682
2683 };
2684
2685 /// EmitPopulateLanguageMap - Emit the PopulateLanguageMap() function.
2686 void EmitPopulateLanguageMap (const RecordKeeper& Records, raw_ostream& O)
2687 {
2688   O << "int PopulateLanguageMap (LanguageMap& langMap) {\n";
2689
2690   // For each LangMap:
2691   const RecordVector& LangMaps =
2692     Records.getAllDerivedDefinitions("LanguageMap");
2693
2694   for (RecordVector::const_iterator B = LangMaps.begin(),
2695          E = LangMaps.end(); B!=E; ++B) {
2696     ListInit* LangMap = (*B)->getValueAsListInit("map");
2697     std::for_each(LangMap->begin(), LangMap->end(),
2698                   DoEmitPopulateLanguageMap(O));
2699   }
2700
2701   O << '\n';
2702   O.indent(Indent1) << "return 0;\n";
2703   O << "}\n\n";
2704 }
2705
2706 /// EmitEdgePropertyHandlerCallback - Emits code that handles edge
2707 /// properties. Helper function passed to EmitCaseConstructHandler() by
2708 /// EmitEdgeClass().
2709 void EmitEdgePropertyHandlerCallback (const Init* i, unsigned IndentLevel,
2710                                       raw_ostream& O) {
2711   const DagInit& d = InitPtrToDag(i);
2712   const std::string& OpName = GetOperatorName(d);
2713
2714   if (OpName == "inc_weight") {
2715     O.indent(IndentLevel) << "ret += ";
2716   }
2717   else if (OpName == "error") {
2718     CheckNumberOfArguments(d, 1);
2719     O.indent(IndentLevel) << "PrintError(\""
2720                           << InitPtrToString(d.getArg(0))
2721                           << "\");\n";
2722     O.indent(IndentLevel) << "return -1;\n";
2723     return;
2724   }
2725   else {
2726     throw "Unknown operator in edge properties list: '" + OpName + "'!"
2727       "\nOnly 'inc_weight', 'dec_weight' and 'error' are allowed.";
2728   }
2729
2730   if (d.getNumArgs() > 0)
2731     O << InitPtrToInt(d.getArg(0)) << ";\n";
2732   else
2733     O << "2;\n";
2734
2735 }
2736
2737 /// EmitEdgeClass - Emit a single Edge# class.
2738 void EmitEdgeClass (unsigned N, const std::string& Target,
2739                     const DagInit& Case, const OptionDescriptions& OptDescs,
2740                     raw_ostream& O) {
2741
2742   // Class constructor.
2743   O << "class Edge" << N << ": public Edge {\n"
2744     << "public:\n";
2745   O.indent(Indent1) << "Edge" << N << "() : Edge(\"" << Target
2746                     << "\") {}\n\n";
2747
2748   // Function Weight().
2749   O.indent(Indent1)
2750     << "int Weight(const InputLanguagesSet& InLangs) const {\n";
2751   O.indent(Indent2) << "unsigned ret = 0;\n";
2752
2753   // Handle the 'case' construct.
2754   EmitCaseConstructHandler(&Case, Indent2, EmitEdgePropertyHandlerCallback,
2755                            false, OptDescs, O);
2756
2757   O.indent(Indent2) << "return ret;\n";
2758   O.indent(Indent1) << "}\n\n};\n\n";
2759 }
2760
2761 /// EmitEdgeClasses - Emit Edge* classes that represent graph edges.
2762 void EmitEdgeClasses (const DagVector& EdgeVector,
2763                       const OptionDescriptions& OptDescs,
2764                       raw_ostream& O) {
2765   int i = 0;
2766   for (DagVector::const_iterator B = EdgeVector.begin(),
2767          E = EdgeVector.end(); B != E; ++B) {
2768     const DagInit& Edge = **B;
2769     const std::string& Name = GetOperatorName(Edge);
2770
2771     if (Name == "optional_edge") {
2772       assert(IsOptionalEdge(Edge));
2773       const std::string& NodeB = InitPtrToString(Edge.getArg(1));
2774
2775       const DagInit& Weight = InitPtrToDag(Edge.getArg(2));
2776       EmitEdgeClass(i, NodeB, Weight, OptDescs, O);
2777     }
2778     else if (Name != "edge") {
2779       throw "Unknown edge class: '" + Name + "'!";
2780     }
2781
2782     ++i;
2783   }
2784 }
2785
2786 /// EmitPopulateCompilationGraph - Emit the PopulateCompilationGraph() function.
2787 void EmitPopulateCompilationGraph (const DagVector& EdgeVector,
2788                                    const ToolDescriptions& ToolDescs,
2789                                    raw_ostream& O)
2790 {
2791   O << "int PopulateCompilationGraph (CompilationGraph& G) {\n";
2792
2793   for (ToolDescriptions::const_iterator B = ToolDescs.begin(),
2794          E = ToolDescs.end(); B != E; ++B)
2795     O.indent(Indent1) << "G.insertNode(new " << (*B)->Name << "());\n";
2796
2797   O << '\n';
2798
2799   // Insert edges.
2800
2801   int i = 0;
2802   for (DagVector::const_iterator B = EdgeVector.begin(),
2803          E = EdgeVector.end(); B != E; ++B) {
2804     const DagInit& Edge = **B;
2805     const std::string& NodeA = InitPtrToString(Edge.getArg(0));
2806     const std::string& NodeB = InitPtrToString(Edge.getArg(1));
2807
2808     O.indent(Indent1) << "if (int ret = G.insertEdge(\"" << NodeA << "\", ";
2809
2810     if (IsOptionalEdge(Edge))
2811       O << "new Edge" << i << "()";
2812     else
2813       O << "new SimpleEdge(\"" << NodeB << "\")";
2814
2815     O << "))\n";
2816     O.indent(Indent2) << "return ret;\n";
2817
2818     ++i;
2819   }
2820
2821   O << '\n';
2822   O.indent(Indent1) << "return 0;\n";
2823   O << "}\n\n";
2824 }
2825
2826 /// HookInfo - Information about the hook type and number of arguments.
2827 struct HookInfo {
2828
2829   // A hook can either have a single parameter of type std::vector<std::string>,
2830   // or NumArgs parameters of type const char*.
2831   enum HookType { ListHook, ArgHook };
2832
2833   HookType Type;
2834   unsigned NumArgs;
2835
2836   HookInfo() : Type(ArgHook), NumArgs(1)
2837   {}
2838
2839   HookInfo(HookType T) : Type(T), NumArgs(1)
2840   {}
2841
2842   HookInfo(unsigned N) : Type(ArgHook), NumArgs(N)
2843   {}
2844 };
2845
2846 typedef llvm::StringMap<HookInfo> HookInfoMap;
2847
2848 /// ExtractHookNames - Extract the hook names from all instances of
2849 /// $CALL(HookName) in the provided command line string/action. Helper
2850 /// function used by FillInHookNames().
2851 class ExtractHookNames {
2852   HookInfoMap& HookNames_;
2853   const OptionDescriptions& OptDescs_;
2854 public:
2855   ExtractHookNames(HookInfoMap& HookNames, const OptionDescriptions& OptDescs)
2856     : HookNames_(HookNames), OptDescs_(OptDescs)
2857   {}
2858
2859   void onAction (const DagInit& Dag) {
2860     const std::string& Name = GetOperatorName(Dag);
2861
2862     if (Name == "forward_transformed_value") {
2863       CheckNumberOfArguments(Dag, 2);
2864       const std::string& OptName = InitPtrToString(Dag.getArg(0));
2865       const std::string& HookName = InitPtrToString(Dag.getArg(1));
2866       const OptionDescription& D =
2867         OptDescs_.FindParameterListOrParameter(OptName);
2868
2869       HookNames_[HookName] = HookInfo(D.isList() ? HookInfo::ListHook
2870                                       : HookInfo::ArgHook);
2871     }
2872     else if (Name == "append_cmd" || Name == "output_suffix") {
2873       CheckNumberOfArguments(Dag, 1);
2874       this->onCmdLine(InitPtrToString(Dag.getArg(0)));
2875     }
2876   }
2877
2878   void onCmdLine(const std::string& Cmd) {
2879     StrVector cmds;
2880     TokenizeCmdLine(Cmd, cmds);
2881
2882     for (StrVector::const_iterator B = cmds.begin(), E = cmds.end();
2883          B != E; ++B) {
2884       const std::string& cmd = *B;
2885
2886       if (cmd == "$CALL") {
2887         unsigned NumArgs = 0;
2888         CheckedIncrement(B, E, "Syntax error in $CALL invocation!");
2889         const std::string& HookName = *B;
2890
2891         if (HookName.at(0) == ')')
2892           throw "$CALL invoked with no arguments!";
2893
2894         while (++B != E && B->at(0) != ')') {
2895           ++NumArgs;
2896         }
2897
2898         HookInfoMap::const_iterator H = HookNames_.find(HookName);
2899
2900         if (H != HookNames_.end() && H->second.NumArgs != NumArgs &&
2901             H->second.Type != HookInfo::ArgHook)
2902           throw "Overloading of hooks is not allowed. Overloaded hook: "
2903             + HookName;
2904         else
2905           HookNames_[HookName] = HookInfo(NumArgs);
2906       }
2907     }
2908   }
2909
2910   void operator()(const Init* Arg) {
2911
2912     // We're invoked on an action (either a dag or a dag list).
2913     if (typeid(*Arg) == typeid(DagInit)) {
2914       const DagInit& Dag = InitPtrToDag(Arg);
2915       this->onAction(Dag);
2916       return;
2917     }
2918     else if (typeid(*Arg) == typeid(ListInit)) {
2919       const ListInit& List = InitPtrToList(Arg);
2920       for (ListInit::const_iterator B = List.begin(), E = List.end(); B != E;
2921            ++B) {
2922         const DagInit& Dag = InitPtrToDag(*B);
2923         this->onAction(Dag);
2924       }
2925       return;
2926     }
2927
2928     // We're invoked on a command line.
2929     this->onCmdLine(InitPtrToString(Arg));
2930   }
2931
2932   void operator()(const Init* Statement, unsigned) {
2933     this->operator()(Statement);
2934   }
2935 };
2936
2937 /// FillInHookNames - Actually extract the hook names from all command
2938 /// line strings. Helper function used by EmitHookDeclarations().
2939 void FillInHookNames(const ToolDescriptions& ToolDescs,
2940                      const OptionDescriptions& OptDescs,
2941                      HookInfoMap& HookNames)
2942 {
2943   // For all tool descriptions:
2944   for (ToolDescriptions::const_iterator B = ToolDescs.begin(),
2945          E = ToolDescs.end(); B != E; ++B) {
2946     const ToolDescription& D = *(*B);
2947
2948     // Look for 'forward_transformed_value' in 'actions'.
2949     if (D.Actions)
2950       WalkCase(D.Actions, Id(), ExtractHookNames(HookNames, OptDescs));
2951
2952     // Look for hook invocations in 'cmd_line'.
2953     if (!D.CmdLine)
2954       continue;
2955     if (dynamic_cast<StringInit*>(D.CmdLine))
2956       // This is a string.
2957       ExtractHookNames(HookNames, OptDescs).operator()(D.CmdLine);
2958     else
2959       // This is a 'case' construct.
2960       WalkCase(D.CmdLine, Id(), ExtractHookNames(HookNames, OptDescs));
2961   }
2962 }
2963
2964 /// EmitHookDeclarations - Parse CmdLine fields of all the tool
2965 /// property records and emit hook function declaration for each
2966 /// instance of $CALL(HookName).
2967 void EmitHookDeclarations(const ToolDescriptions& ToolDescs,
2968                           const OptionDescriptions& OptDescs, raw_ostream& O) {
2969   HookInfoMap HookNames;
2970
2971   FillInHookNames(ToolDescs, OptDescs, HookNames);
2972   if (HookNames.empty())
2973     return;
2974
2975   for (HookInfoMap::const_iterator B = HookNames.begin(),
2976          E = HookNames.end(); B != E; ++B) {
2977     const char* HookName = B->first();
2978     const HookInfo& Info = B->second;
2979
2980     O.indent(Indent1) << "std::string " << HookName << "(";
2981
2982     if (Info.Type == HookInfo::ArgHook) {
2983       for (unsigned i = 0, j = Info.NumArgs; i < j; ++i) {
2984         O << "const char* Arg" << i << (i+1 == j ? "" : ", ");
2985       }
2986     }
2987     else {
2988       O << "const std::vector<std::string>& Arg";
2989     }
2990
2991     O <<");\n";
2992   }
2993 }
2994
2995 /// EmitIncludes - Emit necessary #include directives and some
2996 /// additional declarations.
2997 void EmitIncludes(raw_ostream& O) {
2998   O << "#include \"llvm/CompilerDriver/BuiltinOptions.h\"\n"
2999     << "#include \"llvm/CompilerDriver/CompilationGraph.h\"\n"
3000     << "#include \"llvm/CompilerDriver/Error.h\"\n"
3001     << "#include \"llvm/CompilerDriver/Tool.h\"\n\n"
3002
3003     << "#include \"llvm/Support/CommandLine.h\"\n"
3004     << "#include \"llvm/Support/raw_ostream.h\"\n\n"
3005
3006     << "#include <algorithm>\n"
3007     << "#include <cstdlib>\n"
3008     << "#include <iterator>\n"
3009     << "#include <stdexcept>\n\n"
3010
3011     << "using namespace llvm;\n"
3012     << "using namespace llvmc;\n\n"
3013
3014     << "inline const char* checkCString(const char* s)\n"
3015     << "{ return s == NULL ? \"\" : s; }\n\n";
3016 }
3017
3018
3019 /// DriverData - Holds all information about the driver.
3020 struct DriverData {
3021   OptionDescriptions OptDescs;
3022   ToolDescriptions ToolDescs;
3023   DagVector Edges;
3024   bool HasSink;
3025 };
3026
3027 /// HasSink - Go through the list of tool descriptions and check if
3028 /// there are any with the 'sink' property set.
3029 bool HasSink(const ToolDescriptions& ToolDescs) {
3030   for (ToolDescriptions::const_iterator B = ToolDescs.begin(),
3031          E = ToolDescs.end(); B != E; ++B)
3032     if ((*B)->isSink())
3033       return true;
3034
3035   return false;
3036 }
3037
3038 /// CollectDriverData - Collect compilation graph edges, tool properties and
3039 /// option properties from the parse tree.
3040 void CollectDriverData (const RecordKeeper& Records, DriverData& Data) {
3041   // Collect option properties.
3042   const RecordVector& OptionLists =
3043     Records.getAllDerivedDefinitions("OptionList");
3044   CollectOptionDescriptions(OptionLists, Data.OptDescs);
3045
3046   // Collect tool properties.
3047   const RecordVector& Tools = Records.getAllDerivedDefinitions("Tool");
3048   CollectToolDescriptions(Tools, Data.ToolDescs);
3049   Data.HasSink = HasSink(Data.ToolDescs);
3050
3051   // Collect compilation graph edges.
3052   const RecordVector& CompilationGraphs =
3053     Records.getAllDerivedDefinitions("CompilationGraph");
3054   FillInEdgeVector(CompilationGraphs, Data.Edges);
3055 }
3056
3057 /// CheckDriverData - Perform some sanity checks on the collected data.
3058 void CheckDriverData(DriverData& Data) {
3059   // Filter out all tools not mentioned in the compilation graph.
3060   FilterNotInGraph(Data.Edges, Data.ToolDescs);
3061
3062   // Typecheck the compilation graph.
3063   TypecheckGraph(Data.Edges, Data.ToolDescs);
3064
3065   // Check that there are no options without side effects (specified
3066   // only in the OptionList).
3067   CheckForSuperfluousOptions(Data.Edges, Data.ToolDescs, Data.OptDescs);
3068 }
3069
3070 void EmitDriverCode(const DriverData& Data, raw_ostream& O) {
3071   // Emit file header.
3072   EmitIncludes(O);
3073
3074   // Emit global option registration code.
3075   O << "namespace llvmc {\n"
3076     << "namespace autogenerated {\n\n";
3077   EmitOptionDefinitions(Data.OptDescs, Data.HasSink, O);
3078   O << "} // End namespace autogenerated.\n"
3079     << "} // End namespace llvmc.\n\n";
3080
3081   // Emit hook declarations.
3082   O << "namespace hooks {\n";
3083   EmitHookDeclarations(Data.ToolDescs, Data.OptDescs, O);
3084   O << "} // End namespace hooks.\n\n";
3085
3086   O << "namespace {\n\n";
3087   O << "using namespace llvmc::autogenerated;\n\n";
3088
3089   // Emit Tool classes.
3090   for (ToolDescriptions::const_iterator B = Data.ToolDescs.begin(),
3091          E = Data.ToolDescs.end(); B!=E; ++B)
3092     EmitToolClassDefinition(*(*B), Data.OptDescs, O);
3093
3094   // Emit Edge# classes.
3095   EmitEdgeClasses(Data.Edges, Data.OptDescs, O);
3096
3097   O << "} // End anonymous namespace.\n\n";
3098
3099   O << "namespace llvmc {\n";
3100   O << "namespace autogenerated {\n\n";
3101
3102   // Emit PreprocessOptions() function.
3103   EmitPreprocessOptions(Records, Data.OptDescs, O);
3104
3105   // Emit PopulateLanguageMap() function
3106   // (language map maps from file extensions to language names).
3107   EmitPopulateLanguageMap(Records, O);
3108
3109   // Emit PopulateCompilationGraph() function.
3110   EmitPopulateCompilationGraph(Data.Edges, Data.ToolDescs, O);
3111
3112   O << "} // End namespace autogenerated.\n";
3113   O << "} // End namespace llvmc.\n\n";
3114
3115   // EOF
3116 }
3117
3118
3119 // End of anonymous namespace
3120 }
3121
3122 /// run - The back-end entry point.
3123 void LLVMCConfigurationEmitter::run (raw_ostream &O) {
3124   try {
3125     DriverData Data;
3126
3127     CollectDriverData(Records, Data);
3128     CheckDriverData(Data);
3129
3130     this->EmitSourceFileHeader("llvmc-based driver: auto-generated code", O);
3131     EmitDriverCode(Data, O);
3132
3133   } catch (std::exception& Error) {
3134     throw Error.what() + std::string(" - usually this means a syntax error.");
3135   }
3136 }