Line data    Source code

       1             : //===- LineIterator.cpp - Implementation of line iteration ----------------===//
       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             : #include "llvm/Support/LineIterator.h"
      11             : #include "llvm/Support/MemoryBuffer.h"
      12             : 
      13             : using namespace llvm;
      14             : 
      15             : static bool isAtLineEnd(const char *P) {
      16    16906419 :   if (*P == '\n')
      17             :     return true;
      18    16391745 :   if (*P == '\r' && *(P + 1) == '\n')
      19             :     return true;
      20             :   return false;
      21             : }
      22             : 
      23             : static bool skipIfAtLineEnd(const char *&P) {
      24      858555 :   if (*P == '\n') {
      25      453073 :     ++P;
      26             :     return true;
      27             :   }
      28      405482 :   if (*P == '\r' && *(P + 1) == '\n') {
      29           2 :     P += 2;
      30             :     return true;
      31             :   }
      32             :   return false;
      33             : }
      34             : 
      35        7256 : line_iterator::line_iterator(const MemoryBuffer &Buffer, bool SkipBlanks,
      36        7256 :                              char CommentMarker)
      37        7256 :     : Buffer(Buffer.getBufferSize() ? &Buffer : nullptr),
      38             :       CommentMarker(CommentMarker), SkipBlanks(SkipBlanks), LineNumber(1),
      39        7256 :       CurrentLine(Buffer.getBufferSize() ? Buffer.getBufferStart() : nullptr,
      40        7256 :                   0) {
      41             :   // Ensure that if we are constructed on a non-empty memory buffer that it is
      42             :   // a null terminated buffer.
      43        7256 :   if (Buffer.getBufferSize()) {
      44             :     assert(Buffer.getBufferEnd()[0] == '\0');
      45             :     // Make sure we don't skip a leading newline if we're keeping blanks
      46        7225 :     if (SkipBlanks || !isAtLineEnd(Buffer.getBufferStart()))
      47        7222 :       advance();
      48             :   }
      49        7256 : }
      50             : 
      51      458985 : void line_iterator::advance() {
      52             :   assert(Buffer && "Cannot advance past the end!");
      53             : 
      54      458985 :   const char *Pos = CurrentLine.end();
      55             :   assert(Pos == Buffer->getBufferStart() || isAtLineEnd(Pos) || *Pos == '\0');
      56             : 
      57             :   if (skipIfAtLineEnd(Pos))
      58      451767 :     ++LineNumber;
      59      458985 :   if (!SkipBlanks && isAtLineEnd(Pos)) {
      60             :     // Nothing to do for a blank line.
      61      398263 :   } else if (CommentMarker == '\0') {
      62             :     // If we're not stripping comments, this is simpler.
      63          12 :     while (skipIfAtLineEnd(Pos))
      64          12 :       ++LineNumber;
      65             :   } else {
      66             :     // Skip comments and count line numbers, which is a bit more complex.
      67             :     for (;;) {
      68         291 :       if (isAtLineEnd(Pos) && !SkipBlanks)
      69             :         break;
      70        4400 :       if (*Pos == CommentMarker)
      71             :         do {
      72       30424 :           ++Pos;
      73       30424 :         } while (*Pos != '\0' && !isAtLineEnd(Pos));
      74        4400 :       if (!skipIfAtLineEnd(Pos))
      75             :         break;
      76        1296 :       ++LineNumber;
      77             :     }
      78             :   }
      79             : 
      80      458985 :   if (*Pos == '\0') {
      81             :     // We've hit the end of the buffer, reset ourselves to the end state.
      82        6315 :     Buffer = nullptr;
      83        6315 :     CurrentLine = StringRef();
      84             :     return;
      85             :   }
      86             : 
      87             :   // Measure the line.
      88             :   size_t Length = 0;
      89    16408908 :   while (Pos[Length] != '\0' && !isAtLineEnd(&Pos[Length])) {
      90    15956238 :     ++Length;
      91             :   }
      92             : 
      93      452670 :   CurrentLine = StringRef(Pos, Length);
      94             : }