LCOV - code coverage report
Current view: top level - include/llvm/Option - Option.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 27 28 96.4 %
Date: 2017-09-14 15:23:50 Functions: 9 9 100.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.13