| // Copyright 2014 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "crazy_linker_line_reader.h" |
| |
| #include "crazy_linker_debug.h" |
| |
| // Set to 1 to enable debug logs here. |
| #define DEBUG_LINE_READER 0 |
| |
| #define LLOG(...) LOG_IF(DEBUG_LINE_READER, __VA_ARGS__) |
| |
| namespace crazy { |
| |
| LineReader::LineReader() : fd_(), buff_(NULL) { |
| Reset(true); |
| } |
| |
| LineReader::LineReader(const char* path) : fd_(), buff_(NULL) { |
| Open(path); |
| } |
| |
| LineReader::~LineReader() { |
| ::free(buff_); |
| } |
| |
| void LineReader::Open(const char* path) { |
| Reset(!fd_.OpenReadOnly(path)); |
| } |
| |
| void LineReader::Reset(bool eof) { |
| eof_ = eof; |
| line_start_ = 0; |
| line_len_ = 0; |
| buff_size_ = 0; |
| buff_capacity_ = 128; |
| buff_ = static_cast<char*>(::realloc(buff_, buff_capacity_)); |
| } |
| |
| bool LineReader::GetNextLine() { |
| // Eat previous line. |
| line_start_ += line_len_; |
| line_len_ = 0; |
| |
| for (;;) { |
| LLOG("%s: LOOP line_start=%d buff_size=%d buff_capacity=%d\n", |
| __FUNCTION__, |
| line_start_, |
| buff_size_, |
| buff_capacity_); |
| |
| // Find the end of the current line in the current buffer. The result |
| // of memchr(_,_,0) is undefined, treated as not-found. |
| const char* line = buff_ + line_start_; |
| const size_t range = buff_size_ - line_start_; |
| const char* line_end; |
| if (range > 0) |
| line_end = reinterpret_cast<const char*>(::memchr(line, '\n', range)); |
| else |
| line_end = NULL; |
| if (line_end != NULL) { |
| // Found one, return it directly. |
| line_len_ = static_cast<size_t>(line_end + 1 - line); |
| LLOG("%s: LINE line_start=%d line_len=%d '%.*s'\n", |
| __FUNCTION__, |
| line_start_, |
| line_len_, |
| line_len_, |
| buff_ + line_start_); |
| return true; |
| } |
| |
| // Eat the start of the buffer |
| if (line_start_ > 0) { |
| ::memmove(buff_, buff_ + line_start_, buff_size_ - line_start_); |
| buff_size_ -= line_start_; |
| line_start_ = 0; |
| LLOG("%s: MOVE buff_size=%d\n", __FUNCTION__, buff_size_); |
| } |
| |
| // Handle end of input now. |
| if (eof_) { |
| // If there is a last line that isn't terminated by a newline, and |
| // there is room for it in the buffer. Manually add a \n and return |
| // the line. |
| if (buff_size_ > 0 && buff_size_ < buff_capacity_) { |
| buff_[buff_size_++] = '\n'; |
| line_len_ = buff_size_; |
| LLOG("%s: EOF_LINE buff_size=%d '%.*s'\n", |
| __FUNCTION__, |
| buff_size_, |
| buff_size_, |
| buff_); |
| return true; |
| } |
| // Otherwise, ignore the last line. |
| LLOG("%s: EOF\n", __FUNCTION__); |
| return false; |
| } |
| |
| // Before reading more data, grow the buffer if needed. |
| if (buff_size_ == buff_capacity_) { |
| buff_capacity_ *= 2; |
| buff_ = static_cast<char*>(::realloc(buff_, buff_capacity_)); |
| |
| LLOG("%s: GROW buff_size=%d buff_capacity=%d '%.*s'\n", |
| __FUNCTION__, |
| buff_size_, |
| buff_capacity_, |
| buff_size_, |
| buff_); |
| } |
| |
| // Try to fill the rest of buffer after current content. |
| size_t avail = buff_capacity_ - buff_size_; |
| int ret = fd_.Read(buff_ + buff_size_, avail); |
| LLOG("%s: READ buff_size=%d buff_capacity=%d avail=%d ret=%d\n", |
| __FUNCTION__, |
| buff_size_, |
| buff_capacity_, |
| avail, |
| ret); |
| if (ret <= 0) { |
| eof_ = true; |
| ret = 0; |
| } |
| buff_size_ += static_cast<size_t>(ret); |
| } |
| } |
| |
| const char* LineReader::line() const { return buff_ + line_start_; } |
| |
| size_t LineReader::length() const { return line_len_; } |
| |
| } // namespace crazy |