Implemented SourceFile.readline/readlines()

Author: Ayuto

src/core/modules/filesystem/filesystem.cpp

@@ -28,6 +28,7 @@
 // Includes.
 //---------------------------------------------------------------------------------
 // Source.Python
+#include "modules/memory/memory_alloc.h"
 #include "utilities/wrap_macros.h"
 #include "filesystem.h"
 
@@ -37,6 +38,9 @@
 //---------------------------------------------------------------------------------
 extern IFileSystem* filesystem;
 
+// Chunk size for InternalReadline()
+#define CHUNK_SIZE 128
+
 
 //---------------------------------------------------------------------------------
 // Functions
@@ -96,41 +100,99 @@ PyObject* SourceFile::Read(int size)
 		size = filesystem->Size(m_handle);
 	}
 
-	void* pOutput = new char[size+1];
+	char* pOutput = new char[size+1];
 	int bytesRead = filesystem->Read(pOutput, size, m_handle);
 	return ConsumeBuffer(pOutput, bytesRead);
 }
 
-object SourceFile::Readline(int size)
+PyObject* SourceFile::Readline(int size)
 {
 	CheckClosed();
 	CheckReadable();
-	// TODO
-	BOOST_RAISE_EXCEPTION(PyExc_NotImplementedError, "Not implemented yet.")
-	return object();
+
+	int bytesRead = 0;
+	return InternalReadline(IsBinaryMode(), size, bytesRead);
+}
+
+PyObject* SourceFile::InternalReadline(bool binaryMode, int size, int& outBytesRead)
+{
+	int bytesPut = 0;
+	char* buffer = (char*) UTIL_Alloc(CHUNK_SIZE);
+
+	while (size < 0 || bytesPut < size) {
+		char temp[1];
+
+		// EOF?
+		if (filesystem->Read(temp, 1, m_handle) != 1) {
+			break;
+		}
+
+		// Ignore \r in text mode
+		if (!binaryMode && temp[0] == '\r') {
+			continue;
+		}
+		
+		if (temp[0] == '\0') {
+			buffer[bytesPut] = '\n';
+		}
+		else {
+			buffer[bytesPut] = temp[0];
+		}
+		++bytesPut;
+		++outBytesRead;
+
+		if (temp[0] == '\n') {
+			break;
+		}
+
+		if (bytesPut >= CHUNK_SIZE) {
+			buffer = (char*) UTIL_Realloc(buffer, bytesPut + CHUNK_SIZE);
+			if (buffer == NULL)
+				BOOST_RAISE_EXCEPTION(PyExc_MemoryError, "Failed to reallocate the buffer.")
+		}
+	}
+	
+	PyObject* result = NULL;
+	if (IsBinaryMode()) {
+		result = PyBytes_FromStringAndSize(buffer, bytesPut);
+	}
+	else {
+		result = PyUnicode_FromStringAndSize(buffer, bytesPut);
+	}
+
+	return result;
 }
 
 list SourceFile::Readlines(int hint)
 {
 	CheckClosed();
 	CheckReadable();
 
+	bool binaryMode = IsBinaryMode();
+
 	list result;
 
-	// TODO
+	int bytesRead = 0;
+	while (true) {
+		PyObject* line = InternalReadline(binaryMode, -1, bytesRead);
+		result.append(handle<>(borrowed(line)));
+		if (EndOfFile() ||  (hint > 0 && bytesRead > hint)) {
+			break;
+		}
+	}
 
 	return result;
 }
 
 // internal
-PyObject* SourceFile::ConsumeBuffer(void* buffer, int bytesRead)
-{	
+PyObject* SourceFile::ConsumeBuffer(char* buffer, int bytesRead)
+{
 	PyObject* result = NULL;
 	if (IsBinaryMode()) {
-		result = PyBytes_FromStringAndSize((char*) buffer, bytesRead);
+		result = PyBytes_FromStringAndSize(buffer, bytesRead);
 	}
 	else {
-		result = PyUnicode_FromStringAndSize((char*) buffer, bytesRead);
+		result = PyUnicode_FromStringAndSize(buffer, bytesRead);
 	}
 
 	delete buffer;
@@ -278,6 +340,11 @@ bool SourceFile::Closed()
 	return m_handle == NULL;
 }
 
+bool SourceFile::EndOfFile()
+{
+	return filesystem->EndOfFile(m_handle);
+}
+
 
 //---------------------------------------------------------------------------------
 // SourceFile - internal

src/core/modules/filesystem/filesystem.h

@@ -57,7 +57,7 @@ class SourceFile
 	bool			Closed();
 	bool			Readable();
 	bool			Writeable();
-	object			Readline(int size=-1);
+	PyObject*		Readline(int size=-1);
 	// TODO
 	//__iter__
 	// __next__
@@ -73,16 +73,18 @@ class SourceFile
 	// TODO
 	// void			Delete();
 	// void			Rename();
+	bool			EndOfFile();
 
 	static SourceFile* Open(const char* pFileName, const char* pMode, const char* pathID=0);
 
 private:
-	PyObject*		ConsumeBuffer(void* buffer, int bytesRead);
+	PyObject*		ConsumeBuffer(char* buffer, int bytesRead);
 	void			CheckClosed();
 	void			WriteData(PyObject* data);
 	bool			IsBinaryMode();
 	void			CheckReadable();
 	void			CheckWriteable();
+	PyObject*		InternalReadline(bool binaryMode, int size, int& outBytesRead);
 
 private:
 	FileHandle_t m_handle;

src/core/modules/filesystem/filesystem_wrap.cpp

@@ -168,6 +168,11 @@ void export_source_file(scope _filesystem)
 		"handle",
 		make_function(&SourceFile::GetHandle, return_by_value_policy())
 	);
+
+	_SourceFile.add_property(
+		"eof",
+		&SourceFile::EndOfFile
+	);
 
 	_SourceFile.def(
 		"open",