haiku.git

/*
 * Copyright 2003-2005, Axel Dörfler, axeld@pinc-software.de.
 * Copyright 2010 Andreas Färber <andreas.faerber@web.de>
 * All rights reserved. Distributed under the terms of the MIT License.
 */


#include "console.h"

#include <string.h>

#include <SupportDefs.h>

#include <boot/stage2.h>
#include <platform/openfirmware/openfirmware.h>
#include <util/kernel_cpp.h>

#include "Handle.h"


class Console : public ConsoleNode {
	public:
		Console();

		void SetHandles(intptr_t readHandle, intptr_t writeHandle, bool takeOwnership = true);

		virtual ssize_t ReadAt(void *cookie, off_t pos, void *buffer,
			size_t bufferSize);
		virtual ssize_t WriteAt(void *cookie, off_t pos, const void *buffer,
			size_t bufferSize);

		virtual void	ClearScreen();
		virtual int32	Width();
		virtual int32	Height();
		virtual void	SetCursor(int32 x, int32 y);
		virtual void	SetCursorVisible(bool visible);
		virtual void	SetColors(int32 foreground, int32 background);

		void PutBackChar(char c);
		void PutBackChars(const char *buffer, int count);
		char GetChar();

	private:
		Handle fReadHandle, fWriteHandle;

		enum { BUFFER_SIZE = 32 };
		char	fReadBuffer[BUFFER_SIZE];
		int		fStart;
		int		fCount;
};


extern ConsoleNode* gConsoleNode;
static Console sConsole;
FILE *stdin, *stdout, *stderr;


Console::Console()
	:
	ConsoleNode()
{
}


void
Console::SetHandles(intptr_t readHandle, intptr_t writeHandle, bool takeOwnership)
{
	fReadHandle.SetHandle(readHandle, takeOwnership);
	fWriteHandle.SetHandle(writeHandle, takeOwnership);
}


ssize_t
Console::ReadAt(void */*cookie*/, off_t /*pos*/, void *_buffer,
	size_t bufferSize)
{
	char *buffer = (char*)_buffer;

	// copy buffered bytes first
	int bytesTotal = 0;
	while (bufferSize > 0 && fCount > 0) {
		*buffer++ = GetChar();
		bytesTotal++;
		bufferSize--;
	}

	// read from console
	if (bufferSize > 0) {
		ssize_t bytesRead = fReadHandle.ReadAt(NULL, -1, buffer, bufferSize);
		if (bytesRead < 0)
			return bytesRead;
		bytesTotal += bytesRead;
	}

	return bytesTotal;
}


ssize_t
Console::WriteAt(void */*cookie*/, off_t /*pos*/, const void *buffer,
	size_t bufferSize)
{
	const char *string = (const char *)buffer;

	// If the frame buffer is enabled, don't write to the chosen stdout.
	// On Apple's OpenFirmware this would overwrite parts of the frame buffer.
	if (gKernelArgs.frame_buffer.enabled)
		return bufferSize;

	// be nice to our audience and replace single "\n" with "\r\n"

	while (bufferSize > 0) {
		bool newLine = false;
		size_t length = 0;

		for (; length < bufferSize; length++) {
			if (string[length] == '\r' && length + 1 < bufferSize) {
				length += 2;
			} else if (string[length] == '\n') {
				newLine = true;
				break;
			}
		}

		if (length > 0) {
			fWriteHandle.WriteAt(NULL, -1, string, length);
			string += length;
			bufferSize -= length;
		}

		if (newLine) {
			// this code replaces a single '\n' with '\r\n', so it
			// bumps the string/bufferSize only a single character
			fWriteHandle.WriteAt(NULL, -1, "\r\n", 2);
			string++;
			bufferSize--;
		}
	}

	return string - (char *)buffer;
}


void
Console::PutBackChar(char c)
{
	if (fCount >= BUFFER_SIZE)
		return;

	int pos = (fStart + fCount) % BUFFER_SIZE;
	fReadBuffer[pos] = c;
	fCount++;
}


void
Console::PutBackChars(const char *buffer, int count)
{
	for (int i = 0; i < count; i++)
		PutBackChar(buffer[i]);
}


char
Console::GetChar()
{
	if (fCount == 0)
		return 0;

	fCount--;
	char c = fReadBuffer[fStart];
	fStart = (fStart + 1) % BUFFER_SIZE;
	return c;
}


//	#pragma mark -


status_t
console_init(void)
{
	unsigned int input, output;
	if (of_getprop(gChosen, "stdin", &input, sizeof(input)) != sizeof(input))
		return B_ERROR;
	if (of_getprop(gChosen, "stdout", &output, sizeof(output))
			!= sizeof(output)) {
		return B_ERROR;
	}

	sConsole.SetHandles(input, output);
	gConsoleNode = &sConsole;

	// now that we're initialized, enable stdio functionality
	stdin = (FILE *)gConsoleNode;
	stdout = stderr = (FILE *)gConsoleNode;

	return B_OK;
}


// #pragma mark -


void
Console::ClearScreen()
{
#ifdef __sparc__
	// Send both a clear screen (for serial terminal) and a vertical form
	// feed for on-screen console
	Write("\014\033[2J", 5);
#else
	of_interpret("erase-screen", 0, 0);
#endif
}


int32
Console::Width()
{
	intptr_t columnCount;
#ifdef __sparc__
	if (of_interpret("screen-#columns", 0, 1, &columnCount) == OF_FAILED)
#else
	if (of_interpret("#columns", 0, 1, &columnCount) == OF_FAILED)
#endif
		return 0;
	return columnCount;
}


int32
Console::Height()
{
	intptr_t lineCount;
#ifdef __sparc__
	if (of_interpret("screen-#rows", 0, 1, &lineCount) == OF_FAILED)
#else
	if (of_interpret("#lines", 0, 1, &lineCount) == OF_FAILED)
#endif
		return 0;
	return lineCount;
}


void
Console::SetCursor(int32 x, int32 y)
{
#ifdef __sparc__
	char buffer[11];
	int len = snprintf(buffer, sizeof(buffer),
		"\033[%" B_PRId32 ";%" B_PRId32 "H", y, x);
	Write(buffer, len);
#else
	// Note: We toggle the cursor temporarily to prevent a cursor artifact at
	// at the old location.
	of_interpret("toggle-cursor"
		" to line#"
		" to column#"
		" toggle-cursor",
		2, 0, y, x);
#endif
}


void
Console::SetCursorVisible(bool visible)
{
}


#ifndef __sparc__
static int
translate_color(int32 color)
{
	/*
			r	g	b
		0:	0	0	0		// black
		1:	0	0	aa		// dark blue
		2:	0	aa	0		// dark green
		3:	0	aa	aa		// cyan
		4:	aa	0	0		// dark red
		5:	aa	0	aa		// purple
		6:	aa	55	0		// brown
		7:	aa	aa	aa		// light gray
		8:	55	55	55		// dark gray
		9:	55	55	ff		// light blue
		a:	55	ff	55		// light green
		b:	55	ff	ff		// light cyan
		c:	ff	55	55		// light red
		d:	ff	55	ff		// magenta
		e:	ff	ff	55		// yellow
		f:	ff	ff	ff		// white
	*/
	if (color >= 0 && color < 16)
		return color;
	return 0;
}
#endif


void
Console::SetColors(int32 foreground, int32 background)
{
#ifdef __sparc__
	// Sadly it seems we can only get inverse video, nothing else seems to work
	if (background != 0)
		Write("\033[7m", 4);
	else
		Write("\033[0m", 4);
#else
	// Note: Toggling the cursor doesn't seem to help. We still get cursor
	// artifacts.
	of_interpret("toggle-cursor"
		" to foreground-color"
		" to background-color"
		" toggle-cursor",
		2, 0, translate_color(foreground), translate_color(background));
#endif
}


static int
translate_key(char escapeCode)
{
	switch (escapeCode) {
		case 65:
			return TEXT_CONSOLE_KEY_UP;
		case 66:
			return TEXT_CONSOLE_KEY_DOWN;
		case 67:
			return TEXT_CONSOLE_KEY_RIGHT;
		case 68:
			return TEXT_CONSOLE_KEY_LEFT;
// TODO: Translate the codes for the following keys. Unfortunately my OF just
// returns a '\0' character. :-/
// 			TEXT_CONSOLE_KEY_PAGE_UP,
// 			TEXT_CONSOLE_KEY_PAGE_DOWN,
// 			TEXT_CONSOLE_KEY_HOME,
// 			TEXT_CONSOLE_KEY_END,

		default:
			return 0;
	}
}


int
console_wait_for_key(void)
{
	// wait for a key
	char buffer[3];
	ssize_t bytesRead;
	do {
		bytesRead = sConsole.ReadAt(NULL, 0, buffer, 3);
		if (bytesRead < 0)
			return 0;
	} while (bytesRead == 0);

	// translate the ESC sequences for cursor keys
	if (bytesRead == 3 && buffer[0] == 27 && buffer[1] == 91) {
		int key = translate_key(buffer[2]);
		if (key != 0)
			return key;
	}

	// put back unread chars
	if (bytesRead > 1)
		sConsole.PutBackChars(buffer + 1, bytesRead - 1);

	return buffer[0];
}


int
console_check_for_key(void)
{
	char buffer[3];
	ssize_t bytesRead = sConsole.ReadAt(NULL, 0, buffer, 3);
	if (bytesRead <= 0)
		return 0;

	// translate the ESC sequences for cursor keys
	if (bytesRead == 3 && buffer[0] == 27 && buffer[1] == 91) {
		int key = translate_key(buffer[2]);
		if (key != 0)
			return key;
	}

	// put back unread chars
	if (bytesRead > 1)
		sConsole.PutBackChars(buffer + 1, bytesRead - 1);

	return buffer[0];
}