haiku.git

/*
 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */

#include "SourceFile.h"

#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>

#include <new>


static const int32 kMaxSourceFileSize = 10 * 1024 * 1024;


// #pragma mark - SourceFileOwner


SourceFileOwner::~SourceFileOwner()
{
}


// #pragma mark - SourceFile


SourceFile::SourceFile(SourceFileOwner* owner)
	:
	fOwner(owner),
	fFileContent(NULL),
	fLineOffsets(NULL),
	fLineCount(0)
{
}


SourceFile::~SourceFile()
{
	free(fFileContent);
	delete[] fLineOffsets;
	fOwner->SourceFileDeleted(this);
}


status_t
SourceFile::Init(const char* path)
{
	// open the file
	int fd = open(path, O_RDONLY);
	if (fd < 0)
		return errno;

	// stat the file to get its size
	struct stat st;
	if (fstat(fd, &st) < 0) {
		close(fd);
		return errno;
	}

	if (st.st_size > kMaxSourceFileSize) {
		close(fd);
		return B_FILE_TOO_LARGE;
	}
	size_t fileSize = st.st_size;

	if (fileSize == 0) {
		close(fd);
		return B_BAD_VALUE;
	}

	// allocate the content buffer
	fFileContent = (char*)malloc(fileSize + 1);
		// one more byte for a terminating null
	if (fFileContent == NULL) {
		close(fd);
		return B_NO_MEMORY;
	}

	// read the file
	ssize_t bytesRead = read(fd, fFileContent, fileSize);
	close(fd);
	if (bytesRead < 0 || (size_t)bytesRead != fileSize)
		return bytesRead < 0 ? errno : B_FILE_ERROR;

	// null-terminate
	fFileContent[fileSize] = '\0';

	// count lines
	fLineCount = 1;
	for (size_t i = 0; i < fileSize; i++) {
		if (fFileContent[i] == '\n')
			fLineCount++;
	}

	// allocate line offset array
	fLineOffsets = new(std::nothrow) int32[fLineCount + 1];
	if (fLineOffsets == NULL)
		return B_NO_MEMORY;

	// get the line offsets and null-terminate the lines
	int32 lineIndex = 0;
	fLineOffsets[lineIndex++] = 0;
	for (size_t i = 0; i < fileSize; i++) {
		if (fFileContent[i] == '\n') {
			fFileContent[i] = '\0';
			fLineOffsets[lineIndex++] = i + 1;
		}
	}
	fLineOffsets[fLineCount] = fileSize + 1;

	return B_OK;
}


int32
SourceFile::CountLines() const
{
	return fLineCount;
}


const char*
SourceFile::LineAt(int32 index) const
{
	return index >= 0 && index < fLineCount
		? fFileContent + fLineOffsets[index] : NULL;
}


int32
SourceFile::LineLengthAt(int32 index) const
{
	return index >= 0 && index < fLineCount
		? fLineOffsets[index + 1] - fLineOffsets[index] - 1: 0;
}

void
SourceFile::LastReferenceReleased()
{
	fOwner->SourceFileUnused(this);
	delete this;
}