1 files changed, 85 insertions, 59 deletions

diff --git a/src/core/BufferedCharReader.cpp b/src/core/BufferedCharReader.cpp
index 15aa6c0..cf481df 100644
--- a/src/core/BufferedCharReader.cpp
+++ b/src/core/BufferedCharReader.cpp
@@ -16,6 +16,8 @@
     along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+#include <array>
+
 #include "BufferedCharReader.hpp"
 
 namespace ousia {
@@ -28,14 +30,18 @@ static const uint8_t LB_STATE_CR = 0x20;
 static const uint8_t LB_STATE_MASK_CNT = 0x0F;
 static const uint8_t LB_STATE_MASK_TYPE = 0xF0;
 
-/*******************************************************************************
- * Struct BufferedCharReader::ReadCursor
- ******************************************************************************/
-
-BufferedCharReader::ReadCursor::ReadCursor(const bool destructive) :
-		destructive(destructive)
+/* Struct BufferedCharReader::ReadCursor */
+
+BufferedCharReader::ReadCursor::ReadCursor(unsigned int line,
+                                           unsigned int column,
+                                           bool destructive)
+    : line(line),
+      column(column),
+      bufferElem(0),
+      bufferPos(0),
+      destructive(destructive),
+      lbState(LB_STATE_NONE)
 {
-	reset();
 }
 
 void BufferedCharReader::ReadCursor::assign(const ReadCursor &cursor)
@@ -47,51 +53,50 @@ void BufferedCharReader::ReadCursor::assign(const ReadCursor &cursor)
 	this->lbState = cursor.lbState;
 }
 
-void BufferedCharReader::ReadCursor::reset()
+/* Class BufferedCharReader */
+
+BufferedCharReader::BufferedCharReader(int line, int column)
+    : inputStream(nullptr),
+      readCursor(line, column, true),
+      peekCursor(line, column, false),
+      depleted(false)
 {
-	this->line = 1;
-	this->column = 1;
-	this->bufferElem = 0;
-	this->bufferPos = 0;
-	this->lbState = LB_STATE_NONE;
 }
 
-/*******************************************************************************
- * Class BufferedCharReader
- ******************************************************************************/
-
-BufferedCharReader::BufferedCharReader() :
-	readCursor(true), peekCursor(false)
+BufferedCharReader::BufferedCharReader(const std::string &str, int line,
+                                       int column)
+    : inputStream(nullptr),
+      readCursor(line, column, true),
+      peekCursor(line, column, false),
+      depleted(true)
 {
-	reset();
+	buffer.push_back(str);
 }
 
-void BufferedCharReader::reset()
+BufferedCharReader::BufferedCharReader(std::istream &inputStream, int line,
+                                       int column)
+    : inputStream(&inputStream),
+      readCursor(line, column, true),
+      peekCursor(line, column, false),
+      depleted(false)
 {
-	readCursor.reset();
-	peekCursor.reset();
-	buffer.clear();
-	closed = false;
 }
 
-bool BufferedCharReader::feed(const std::string &data)
+void BufferedCharReader::feed(const std::string &data)
 {
-	// Abort if the BufferedCharReader was closed
-	if (closed) {
-		return false;
+	if (!depleted && !inputStream) {
+		buffer.push_back(data);
 	}
-
-	// Append the data onto the queue
-	buffer.push_back(data);
-	return true;
 }
 
 void BufferedCharReader::close()
 {
-	closed = true;
+	if (!inputStream) {
+		depleted = true;
+	}
 }
 
-bool BufferedCharReader::substituteLinebreaks(ReadCursor *cursor, char *c)
+bool BufferedCharReader::substituteLinebreaks(ReadCursor &cursor, char *c)
 {
 	// Handle line breaks, inserts breakes after the following character
 	// combinations: \n, \r, \n\r, \r\n TODO: Change behaviour to \n, \n\r, \r\n
@@ -100,11 +105,11 @@ bool BufferedCharReader::substituteLinebreaks(ReadCursor *cursor, char *c)
 		const uint8_t type = (*c == '\n') ? LB_STATE_LF : LB_STATE_CR;
 
 		// Read the last count and the last type from the state
-		const uint8_t lastCount = cursor->lbState & LB_STATE_MASK_CNT;
-		const uint8_t lastType = cursor->lbState & LB_STATE_MASK_TYPE;
+		const uint8_t lastCount = cursor.lbState & LB_STATE_MASK_CNT;
+		const uint8_t lastType = cursor.lbState & LB_STATE_MASK_TYPE;
 
 		// Set the current linebreak type and counter in the state
-		cursor->lbState = ((lastCount + 1) & 1) | type;
+		cursor.lbState = ((lastCount + 1) & 1) | type;
 
 		// If either this is the first instance of this character or the same
 		// return character is repeated
@@ -116,40 +121,61 @@ bool BufferedCharReader::substituteLinebreaks(ReadCursor *cursor, char *c)
 	}
 
 	// Find the state
-	cursor->lbState = LB_STATE_NONE;
+	cursor.lbState = LB_STATE_NONE;
 	return true;
 }
 
-bool BufferedCharReader::readCharacterAtCursor(ReadCursor *cursor,
-		char *c)
+bool BufferedCharReader::readCharacterAtCursor(ReadCursor &cursor, char *c)
 {
 	bool hasChar = false;
 	while (!hasChar) {
 		// Abort if the current buffer element does not point to a valid entry
-		// in the buffer -- we must wait until another data block has been fed
-		// into the buffer
-		if (cursor->bufferElem >= buffer.size()) {
-			return false;
+		// in the buffer -- we must try to feed another data block into the
+		// internal buffer
+		if (cursor.bufferElem >= buffer.size()) {
+			// Abort if there is no more data or no input stream is set
+			if (depleted || !inputStream) {
+				return false;
+			}
+
+			// Read a buffer of the specified size
+			constexpr std::streamsize BUFFER_SIZE = 1024;
+			std::array<char, BUFFER_SIZE> buf;
+			const std::streamsize cnt =
+			    (*inputStream).read(buf.data(), BUFFER_SIZE).gcount();
+
+			// If data has been read, append it to the input buffer and try
+			// again
+			if (cnt > 0) {
+				buffer.emplace_back(buf.data());
+				continue;
+			}
+
+			// End of file handling
+			if (inputStream->fail() || inputStream->eof()) {
+				depleted = true;
+				return false;
+			}
 		}
 
 		// Fetch the current element the peek pointer points to
-		const std::string &data = buffer[cursor->bufferElem];
+		const std::string &data = buffer[cursor.bufferElem];
 
 		// Handle the "no data" case -- either in a destructive or
 		// non-destructive manner.
-		if (cursor->bufferPos >= data.length()) {
-			if (cursor->destructive) {
+		if (cursor.bufferPos >= data.length()) {
+			if (cursor.destructive) {
 				buffer.pop_front();
 			} else {
-				cursor->bufferElem++;
+				cursor.bufferElem++;
 			}
-			cursor->bufferPos = 0;
+			cursor.bufferPos = 0;
 			continue;
 		}
 
 		// Read the character, advance the buffer position
-		*c = *(data.data() + cursor->bufferPos);
-		cursor->bufferPos++;
+		*c = *(data.data() + cursor.bufferPos);
+		cursor.bufferPos++;
 
 		// Substitute linebreaks with a single LF (0x0A)
 		hasChar = substituteLinebreaks(cursor, c);
@@ -157,12 +183,12 @@ bool BufferedCharReader::readCharacterAtCursor(ReadCursor *cursor,
 
 	// Update the position counter
 	if (*c == '\n') {
-		cursor->line++;
-		cursor->column = 1;
+		cursor.line++;
+		cursor.column = 1;
 	} else {
 		// Ignore UTF-8 continuation bytes
 		if (!((*c & 0x80) && !(*c & 0x40))) {
-			cursor->column++;
+			cursor.column++;
 		}
 	}
 
@@ -171,13 +197,13 @@ bool BufferedCharReader::readCharacterAtCursor(ReadCursor *cursor,
 
 bool BufferedCharReader::peek(char *c)
 {
-	return readCharacterAtCursor(&peekCursor, c);
+	return readCharacterAtCursor(peekCursor, c);
 }
 
 bool BufferedCharReader::read(char *c)
 {
 	resetPeek();
-	return readCharacterAtCursor(&readCursor, c);
+	return readCharacterAtCursor(readCursor, c);
 }
 
 void BufferedCharReader::consumePeek()
@@ -200,7 +226,7 @@ void BufferedCharReader::resetPeek()
 
 bool BufferedCharReader::atEnd()
 {
-	if (closed) {
+	if (depleted || !inputStream) {
 		if (buffer.size() <= 0) {
 			return true;
 		} else if (buffer.size() == 1) {
@@ -209,5 +235,5 @@ bool BufferedCharReader::atEnd()
 	}
 	return false;
 }
-
 }
+