external/bsd/llvm/dist/clang/lib/Format/BreakableToken.h

   1 //===--- BreakableToken.h - Format C++ code -------------------------------===//
   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 /// \file
  11 /// \brief Declares BreakableToken, BreakableStringLiteral, and
  12 /// BreakableBlockComment classes, that contain token type-specific logic to
  13 /// break long lines in tokens.
  14 ///
  15 //===----------------------------------------------------------------------===//
  16
  17 #ifndef LLVM_CLANG_LIB_FORMAT_BREAKABLETOKEN_H
  18 #define LLVM_CLANG_LIB_FORMAT_BREAKABLETOKEN_H
  19
  20 #include "Encoding.h"
  21 #include "TokenAnnotator.h"
  22 #include "WhitespaceManager.h"
  23 #include <utility>
  24
  25 namespace clang {
  26 namespace format {
  27
  28 struct FormatStyle;
  29
  30 /// \brief Base class for strategies on how to break tokens.
  31 ///
  32 /// FIXME: The interface seems set in stone, so we might want to just pull the
  33 /// strategy into the class, instead of controlling it from the outside.
  34 class BreakableToken {
  35 public:
  36   /// \brief Contains starting character index and length of split.
  37   typedef std::pair<StringRef::size_type, unsigned> Split;
  38
  39   virtual ~BreakableToken() {}
  40
  41   /// \brief Returns the number of lines in this token in the original code.
  42   virtual unsigned getLineCount() const = 0;
  43
  44   /// \brief Returns the number of columns required to format the piece of line
  45   /// at \p LineIndex, from byte offset \p Offset with length \p Length.
  46   ///
  47   /// Note that previous breaks are not taken into account. \p Offset is always
  48   /// specified from the start of the (original) line.
  49   /// \p Length can be set to StringRef::npos, which means "to the end of line".
  50   virtual unsigned
  51   getLineLengthAfterSplit(unsigned LineIndex, unsigned Offset,
  52                           StringRef::size_type Length) const = 0;
  53
  54   /// \brief Returns a range (offset, length) at which to break the line at
  55   /// \p LineIndex, if previously broken at \p TailOffset. If possible, do not
  56   /// violate \p ColumnLimit.
  57   virtual Split getSplit(unsigned LineIndex, unsigned TailOffset,
  58                          unsigned ColumnLimit) const = 0;
  59
  60   /// \brief Emits the previously retrieved \p Split via \p Whitespaces.
  61   virtual void insertBreak(unsigned LineIndex, unsigned TailOffset, Split Split,
  62                            WhitespaceManager &Whitespaces) = 0;
  63
  64   /// \brief Replaces the whitespace range described by \p Split with a single
  65   /// space.
  66   virtual void replaceWhitespace(unsigned LineIndex, unsigned TailOffset,
  67                                  Split Split,
  68                                  WhitespaceManager &Whitespaces) = 0;
  69
  70   /// \brief Replaces the whitespace between \p LineIndex-1 and \p LineIndex.
  71   virtual void replaceWhitespaceBefore(unsigned LineIndex,
  72                                        WhitespaceManager &Whitespaces) {}
  73
  74 protected:
  75   BreakableToken(const FormatToken &Tok, unsigned IndentLevel,
  76                  bool InPPDirective, encoding::Encoding Encoding,
  77                  const FormatStyle &Style)
  78       : Tok(Tok), IndentLevel(IndentLevel), InPPDirective(InPPDirective),
  79         Encoding(Encoding), Style(Style) {}
  80
  81   const FormatToken &Tok;
  82   const unsigned IndentLevel;
  83   const bool InPPDirective;
  84   const encoding::Encoding Encoding;
  85   const FormatStyle &Style;
  86 };
  87
  88 /// \brief Base class for single line tokens that can be broken.
  89 ///
  90 /// \c getSplit() needs to be implemented by child classes.
  91 class BreakableSingleLineToken : public BreakableToken {
  92 public:
  93   unsigned getLineCount() const override;
  94   unsigned getLineLengthAfterSplit(unsigned LineIndex, unsigned TailOffset,
  95                                    StringRef::size_type Length) const override;
  96
  97 protected:
  98   BreakableSingleLineToken(const FormatToken &Tok, unsigned IndentLevel,
  99                            unsigned StartColumn, StringRef Prefix,
 100                            StringRef Postfix, bool InPPDirective,
 101                            encoding::Encoding Encoding,
 102                            const FormatStyle &Style);
 103
 104   // The column in which the token starts.
 105   unsigned StartColumn;
 106   // The prefix a line needs after a break in the token.
 107   StringRef Prefix;
 108   // The postfix a line needs before introducing a break.
 109   StringRef Postfix;
 110   // The token text excluding the prefix and postfix.
 111   StringRef Line;
 112 };
 113
 114 class BreakableStringLiteral : public BreakableSingleLineToken {
 115 public:
 116   /// \brief Creates a breakable token for a single line string literal.
 117   ///
 118   /// \p StartColumn specifies the column in which the token will start
 119   /// after formatting.
 120   BreakableStringLiteral(const FormatToken &Tok, unsigned IndentLevel,
 121                          unsigned StartColumn, StringRef Prefix,
 122                          StringRef Postfix, bool InPPDirective,
 123                          encoding::Encoding Encoding, const FormatStyle &Style);
 124
 125   Split getSplit(unsigned LineIndex, unsigned TailOffset,
 126                  unsigned ColumnLimit) const override;
 127   void insertBreak(unsigned LineIndex, unsigned TailOffset, Split Split,
 128                    WhitespaceManager &Whitespaces) override;
 129   void replaceWhitespace(unsigned LineIndex, unsigned TailOffset, Split Split,
 130                          WhitespaceManager &Whitespaces) override {}
 131 };
 132
 133 class BreakableLineComment : public BreakableSingleLineToken {
 134 public:
 135   /// \brief Creates a breakable token for a line comment.
 136   ///
 137   /// \p StartColumn specifies the column in which the comment will start
 138   /// after formatting.
 139   BreakableLineComment(const FormatToken &Token, unsigned IndentLevel,
 140                        unsigned StartColumn, bool InPPDirective,
 141                        encoding::Encoding Encoding, const FormatStyle &Style);
 142
 143   Split getSplit(unsigned LineIndex, unsigned TailOffset,
 144                  unsigned ColumnLimit) const override;
 145   void insertBreak(unsigned LineIndex, unsigned TailOffset, Split Split,
 146                    WhitespaceManager &Whitespaces) override;
 147   void replaceWhitespace(unsigned LineIndex, unsigned TailOffset, Split Split,
 148                          WhitespaceManager &Whitespaces) override;
 149   void replaceWhitespaceBefore(unsigned LineIndex,
 150                                WhitespaceManager &Whitespaces) override;
 151
 152 private:
 153   // The prefix without an additional space if one was added.
 154   StringRef OriginalPrefix;
 155 };
 156
 157 class BreakableBlockComment : public BreakableToken {
 158 public:
 159   /// \brief Creates a breakable token for a block comment.
 160   ///
 161   /// \p StartColumn specifies the column in which the comment will start
 162   /// after formatting, while \p OriginalStartColumn specifies in which
 163   /// column the comment started before formatting.
 164   /// If the comment starts a line after formatting, set \p FirstInLine to true.
 165   BreakableBlockComment(const FormatToken &Token, unsigned IndentLevel,
 166                         unsigned StartColumn, unsigned OriginaStartColumn,
 167                         bool FirstInLine, bool InPPDirective,
 168                         encoding::Encoding Encoding, const FormatStyle &Style);
 169
 170   unsigned getLineCount() const override;
 171   unsigned getLineLengthAfterSplit(unsigned LineIndex, unsigned TailOffset,
 172                                    StringRef::size_type Length) const override;
 173   Split getSplit(unsigned LineIndex, unsigned TailOffset,
 174                  unsigned ColumnLimit) const override;
 175   void insertBreak(unsigned LineIndex, unsigned TailOffset, Split Split,
 176                    WhitespaceManager &Whitespaces) override;
 177   void replaceWhitespace(unsigned LineIndex, unsigned TailOffset, Split Split,
 178                          WhitespaceManager &Whitespaces) override;
 179   void replaceWhitespaceBefore(unsigned LineIndex,
 180                                WhitespaceManager &Whitespaces) override;
 181
 182 private:
 183   // Rearranges the whitespace between Lines[LineIndex-1] and Lines[LineIndex],
 184   // so that all whitespace between the lines is accounted to Lines[LineIndex]
 185   // as leading whitespace:
 186   // - Lines[LineIndex] points to the text after that whitespace
 187   // - Lines[LineIndex-1] shrinks by its trailing whitespace
 188   // - LeadingWhitespace[LineIndex] is updated with the complete whitespace
 189   //   between the end of the text of Lines[LineIndex-1] and Lines[LineIndex]
 190   //
 191   // Sets StartOfLineColumn to the intended column in which the text at
 192   // Lines[LineIndex] starts (note that the decoration, if present, is not
 193   // considered part of the text).
 194   void adjustWhitespace(unsigned LineIndex, int IndentDelta);
 195
 196   // Returns the column at which the text in line LineIndex starts, when broken
 197   // at TailOffset. Note that the decoration (if present) is not considered part
 198   // of the text.
 199   unsigned getContentStartColumn(unsigned LineIndex, unsigned TailOffset) const;
 200
 201   // Contains the text of the lines of the block comment, excluding the leading
 202   // /* in the first line and trailing */ in the last line, and excluding all
 203   // trailing whitespace between the lines. Note that the decoration (if
 204   // present) is also not considered part of the text.
 205   SmallVector<StringRef, 16> Lines;
 206
 207   // LeadingWhitespace[i] is the number of characters regarded as whitespace in
 208   // front of Lines[i]. Note that this can include "* " sequences, which we
 209   // regard as whitespace when all lines have a "*" prefix.
 210   SmallVector<unsigned, 16> LeadingWhitespace;
 211
 212   // StartOfLineColumn[i] is the target column at which Line[i] should be.
 213   // Note that this excludes a leading "* " or "*" in case all lines have
 214   // a "*" prefix.
 215   // The first line's target column is always positive. The remaining lines'
 216   // target columns are relative to the first line to allow correct indentation
 217   // of comments in \c WhitespaceManager. Thus they can be negative as well (in
 218   // case the first line needs to be unindented more than there's actual
 219   // whitespace in another line).
 220   SmallVector<int, 16> StartOfLineColumn;
 221
 222   // The column at which the text of a broken line should start.
 223   // Note that an optional decoration would go before that column.
 224   // IndentAtLineBreak is a uniform position for all lines in a block comment,
 225   // regardless of their relative position.
 226   // FIXME: Revisit the decision to do this; the main reason was to support
 227   // patterns like
 228   // /**************//**
 229   //  * Comment
 230   // We could also support such patterns by special casing the first line
 231   // instead.
 232   unsigned IndentAtLineBreak;
 233
 234   // This is to distinguish between the case when the last line was empty and
 235   // the case when it started with a decoration ("*" or "* ").
 236   bool LastLineNeedsDecoration;
 237
 238   // Either "* " if all lines begin with a "*", or empty.
 239   StringRef Decoration;
 240 };
 241
 242 } // namespace format
 243 } // namespace clang
 244
 245 #endif