haiku.git

/*
 * Copyright 2001-2024, Haiku, Inc. All rights reserved.
 * Copyright (c) 2003-4 Kian Duffy <myob@users.sourceforge.net>
 * Parts Copyright (C) 1998,99 Kazuho Okui and Takashi Murai.
 * Distributed under the terms of the MIT license.
 *
 * Authors:
 *		Kian Duffy, myob@users.sourceforge.net
 *		Simon South, simon@simonsouth.net
 *		Siarzhuk Zharski, zharik@gmx.li
 */


//! Escape sequence parse and character encoding.


#include "TermParse.h"

#include <ctype.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <string.h>
#include <unistd.h>

#include <Autolock.h>
#include <Beep.h>
#include <Catalog.h>
#include <Locale.h>
#include <Message.h>
#include <UTF8.h>

#include "Colors.h"
#include "TermConst.h"
#include "TerminalBuffer.h"
#include "VTparse.h"


extern int gUTF8GroundTable[];		/* UTF8 Ground table */
extern int gISO8859GroundTable[];	/* ISO8859 & EUC Ground table */
extern int gWinCPGroundTable[];		/* Windows cp1252, cp1251, koi-8r */
extern int gSJISGroundTable[];		/* Shift-JIS Ground table */

extern int gEscTable[];				/* ESC */
extern int gCsiTable[];				/* ESC [ */
extern int gDecTable[];				/* ESC [ ? */
extern int gScrTable[];				/* ESC # */
extern int gIgnoreTable[];			/* ignore table */
extern int gIesTable[];				/* ignore ESC table */
extern int gEscIgnoreTable[];		/* ESC ignore table */

extern const char* gLineDrawGraphSet[]; /* may be used for G0, G1, G2, G3 */

#define DEFAULT -1
#define NPARAM 10		// Max parameters


//! Get char from pty reader buffer.
inline uchar
TermParse::_NextParseChar()
{
	if (fParserBufferOffset >= fParserBufferSize) {
		// parser buffer empty
		status_t error = _ReadParserBuffer();
		if (error != B_OK)
			throw error;
	}

#ifdef USE_DEBUG_SNAPSHOTS
	fBuffer->CaptureChar(fParserBuffer[fParserBufferOffset]);
#endif

	return fParserBuffer[fParserBufferOffset++];
}


TermParse::TermParse(int fd)
	:
	fFd(fd),
	fParseThread(-1),
	fReaderThread(-1),
	fReaderSem(-1),
	fReaderLocker(-1),
	fBufferPosition(0),
	fReadBufferSize(0),
	fParserBufferSize(0),
	fParserBufferOffset(0),
	fBuffer(NULL),
	fQuitting(true)
{
	memset(fReadBuffer, 0, READ_BUF_SIZE);
	memset(fParserBuffer, 0, ESC_PARSER_BUFFER_SIZE);
}


TermParse::~TermParse()
{
	StopThreads();
}


status_t
TermParse::StartThreads(TerminalBuffer *buffer)
{
	if (fBuffer != NULL)
		return B_ERROR;

	fQuitting = false;
	fBuffer = buffer;

	status_t status = _InitPtyReader();
	if (status < B_OK) {
		fBuffer = NULL;
		return status;
	}

	status = _InitTermParse();
	if (status < B_OK) {
		_StopPtyReader();
		fBuffer = NULL;
		return status;
	}

	return B_OK;
}


status_t
TermParse::StopThreads()
{
	if (fBuffer == NULL)
		return B_ERROR;

	fQuitting = true;

	_StopPtyReader();
	_StopTermParse();

	fBuffer = NULL;

	return B_OK;
}


//! Initialize and spawn EscParse thread.
status_t
TermParse::_InitTermParse()
{
	if (fParseThread >= 0)
		return B_ERROR; // we might want to return B_OK instead ?

	fParseThread = spawn_thread(_escparse_thread, "EscParse",
		B_DISPLAY_PRIORITY, this);

	if (fParseThread < 0)
		return fParseThread;

	resume_thread(fParseThread);

	return B_OK;
}


//! Initialize and spawn PtyReader thread.
status_t
TermParse::_InitPtyReader()
{
	if (fReaderThread >= 0)
		return B_ERROR; // same as above

	fReaderSem = create_sem(0, "pty_reader_sem");
	if (fReaderSem < 0)
		return fReaderSem;

	fReaderLocker = create_sem(0, "pty_locker_sem");
	if (fReaderLocker < 0) {
		delete_sem(fReaderSem);
		fReaderSem = -1;
		return fReaderLocker;
	}

	fReaderThread = spawn_thread(_ptyreader_thread, "PtyReader",
		B_NORMAL_PRIORITY, this);
	if (fReaderThread < 0) {
		delete_sem(fReaderSem);
		fReaderSem = -1;
		delete_sem(fReaderLocker);
		fReaderLocker = -1;
		return fReaderThread;
	}

	resume_thread(fReaderThread);

	return B_OK;
}


void
TermParse::_StopTermParse()
{
	if (fParseThread >= 0) {
		status_t dummy;
		wait_for_thread(fParseThread, &dummy);
		fParseThread = -1;
	}
}


void
TermParse::_StopPtyReader()
{
	if (fReaderSem >= 0) {
		delete_sem(fReaderSem);
		fReaderSem = -1;
	}
	if (fReaderLocker >= 0) {
		delete_sem(fReaderLocker);
		fReaderLocker = -1;
	}

	if (fReaderThread >= 0) {
		suspend_thread(fReaderThread);

		status_t status;
		wait_for_thread(fReaderThread, &status);

		fReaderThread = -1;
	}
}


//! Get data from pty device.
int32
TermParse::PtyReader()
{
	int32 bufferSize = 0;
	int32 readPos = 0;
	while (!fQuitting) {
		// If Pty Buffer nearly full, snooze this thread, and continue.
		while (READ_BUF_SIZE - bufferSize < MIN_PTY_BUFFER_SPACE) {
			status_t status;
			do {
				status = acquire_sem(fReaderLocker);
			} while (status == B_INTERRUPTED);
			if (status < B_OK)
				return status;

			bufferSize = fReadBufferSize;
		}

		// Read PTY
		uchar buf[READ_BUF_SIZE];
		ssize_t nread = read(fFd, buf, READ_BUF_SIZE - bufferSize);
		if (nread <= 0) {
			fBuffer->NotifyQuit(errno);
			return B_OK;
		}

		// Copy read string to PtyBuffer.

		int32 left = READ_BUF_SIZE - readPos;

		if (nread >= left) {
			memcpy(fReadBuffer + readPos, buf, left);
			memcpy(fReadBuffer, buf + left, nread - left);
		} else
			memcpy(fReadBuffer + readPos, buf, nread);

		bufferSize = atomic_add(&fReadBufferSize, nread);
		if (bufferSize == 0)
			release_sem(fReaderSem);

		bufferSize += nread;
		readPos = (readPos + nread) % READ_BUF_SIZE;
	}

	return B_OK;
}


void
TermParse::DumpState(int *groundtable, int *parsestate, uchar c)
{
	static const struct {
		int *p;
		const char *name;
	} tables[] = {
#define T(t) \
	{ t, #t }
		T(gUTF8GroundTable),
		T(gISO8859GroundTable),
		T(gWinCPGroundTable),
		T(gSJISGroundTable),
		T(gEscTable),
		T(gCsiTable),
		T(gDecTable),
		T(gScrTable),
		T(gIgnoreTable),
		T(gIesTable),
		T(gEscIgnoreTable),
		{ NULL, NULL }
	};
	int i;
	fprintf(stderr, "groundtable: ");
	for (i = 0; tables[i].p; i++) {
		if (tables[i].p == groundtable)
			fprintf(stderr, "%s\t", tables[i].name);
	}
	fprintf(stderr, "parsestate: ");
	for (i = 0; tables[i].p; i++) {
		if (tables[i].p == parsestate)
			fprintf(stderr, "%s\t", tables[i].name);
	}
	fprintf(stderr, "char: 0x%02x (%d)\n", c, c);
}


int *
TermParse::_GuessGroundTable(int encoding)
{
	switch (encoding) {
		case B_ISO1_CONVERSION:
		case B_ISO2_CONVERSION:
		case B_ISO3_CONVERSION:
		case B_ISO4_CONVERSION:
		case B_ISO5_CONVERSION:
		case B_ISO6_CONVERSION:
		case B_ISO7_CONVERSION:
		case B_ISO8_CONVERSION:
		case B_ISO9_CONVERSION:
		case B_ISO10_CONVERSION:
		case B_ISO13_CONVERSION:
		case B_ISO14_CONVERSION:
		case B_ISO15_CONVERSION:
		case B_EUC_CONVERSION:
		case B_EUC_KR_CONVERSION:
		case B_JIS_CONVERSION:
		case B_BIG5_CONVERSION:
			return gISO8859GroundTable;

		case B_KOI8R_CONVERSION:
		case B_MS_WINDOWS_1251_CONVERSION:
		case B_MS_WINDOWS_CONVERSION:
		case B_MAC_ROMAN_CONVERSION:
		case B_MS_DOS_866_CONVERSION:
		case B_GBK_CONVERSION:
		case B_MS_DOS_CONVERSION:
			return gWinCPGroundTable;

		case B_SJIS_CONVERSION:
			return gSJISGroundTable;

		case M_UTF8:
		default:
			break;
	}

	return gUTF8GroundTable;
}


int32
TermParse::EscParse()
{
	int top = 0;
	int bottom = 0;

	char cbuf[4] = { 0 };
	char dstbuf[4] = { 0 };

	int currentEncoding = -1;

	int param[NPARAM];
	int nparam = 1;
	for (int i = 0; i < NPARAM; i++)
		param[i] = DEFAULT;

	int row = 0;
	int column = 0;

	// default encoding system is UTF8
	int *groundtable = gUTF8GroundTable;
	int *parsestate = gUTF8GroundTable;

	// handle alternative character sets G0 - G4
	const char** graphSets[4] = { NULL, NULL, NULL, NULL };
	int curGL = 0;
	int curGR = 0;

	BAutolock locker(fBuffer);

	while (!fQuitting) {
		try {
			uchar c = _NextParseChar();

			//DumpState(groundtable, parsestate, c);

			if (currentEncoding != fBuffer->Encoding()) {
				// Change coding, change parse table.
				groundtable = _GuessGroundTable(fBuffer->Encoding());
				parsestate = groundtable;
				currentEncoding = fBuffer->Encoding();
			}

	//debug_printf("TermParse: char: '%c' (%d), parse state: %d\n", c, c, parsestate[c]);
			int32 srcLen = 0;
			int32 dstLen = sizeof(dstbuf);
			int32 dummyState = 0;

			switch (parsestate[c]) {
				case CASE_PRINT:
				{
					int curGS = c < 128 ? curGL : curGR;
					const char** curGraphSet = graphSets[curGS];
					if (curGraphSet != NULL) {
						int offset = c - (c < 128 ? 0x20 : 0xA0);
						if (offset >= 0 && offset < 96
							&& curGraphSet[offset] != 0) {
							fBuffer->InsertChar(curGraphSet[offset]);
							break;
						}
					}
					fBuffer->InsertChar((char)c);
					break;
				}
				case CASE_PRINT_GR:
				{
					/* case iso8859 gr character, or euc */
					switch (currentEncoding) {
						case B_EUC_CONVERSION:
						case B_EUC_KR_CONVERSION:
						case B_JIS_CONVERSION:
						case B_BIG5_CONVERSION:
							cbuf[srcLen++] = c;
							c = _NextParseChar();
							cbuf[srcLen++] = c;
							break;

						case B_GBK_CONVERSION:
							cbuf[srcLen++] = c;
							do {
								// GBK-compatible codepoints are 2-bytes long
								c = _NextParseChar();
								cbuf[srcLen++] = c;

								// GB18030 extends GBK with 4-byte codepoints
								// using 2nd byte from range 0x30...0x39
								if (srcLen == 2 && (c < 0x30 || c > 0x39))
									break;
							} while (srcLen < 4);
							break;

						default: // ISO-8859-1...10 and MacRoman
							cbuf[srcLen++] = c;
							break;
					}

					if (srcLen > 0) {
						int encoding = currentEncoding == B_JIS_CONVERSION
							? B_EUC_CONVERSION : currentEncoding;

						convert_to_utf8(encoding, cbuf, &srcLen,
								dstbuf, &dstLen, &dummyState, '?');

						fBuffer->InsertChar(UTF8Char(dstbuf, dstLen));
					}
					break;
				}

				case CASE_LF:
					fBuffer->InsertLF();
					break;

				case CASE_CR:
					fBuffer->InsertCR();
					break;

				case CASE_INDEX:
					fBuffer->InsertLF();
					parsestate = groundtable;
					break;

				case CASE_NEXT_LINE:
					fBuffer->NextLine();
					parsestate = groundtable;
					break;

				case CASE_SJIS_KANA:
					cbuf[srcLen++] = c;
					convert_to_utf8(currentEncoding, cbuf, &srcLen,
							dstbuf, &dstLen, &dummyState, '?');
					fBuffer->InsertChar(UTF8Char(dstbuf, dstLen));
					break;

				case CASE_SJIS_INSTRING:
					cbuf[srcLen++] = c;
					c = _NextParseChar();
					cbuf[srcLen++] = c;

					convert_to_utf8(currentEncoding, cbuf, &srcLen,
							dstbuf, &dstLen, &dummyState, '?');
					fBuffer->InsertChar(UTF8Char(dstbuf, dstLen));
					break;

				case CASE_UTF8_2BYTE:
					cbuf[srcLen++] = c;
					c = _NextParseChar();
					if (groundtable[c] != CASE_UTF8_INSTRING)
						break;
					cbuf[srcLen++] = c;

					fBuffer->InsertChar(UTF8Char(cbuf, srcLen));
					break;

				case CASE_UTF8_3BYTE:
					cbuf[srcLen++] = c;

					do {
						c = _NextParseChar();
						if (groundtable[c] != CASE_UTF8_INSTRING) {
							srcLen = 0;
							break;
						}
						cbuf[srcLen++] = c;

					} while (srcLen != 3);

					if (srcLen > 0)
						fBuffer->InsertChar(UTF8Char(cbuf, srcLen));
					break;

				case CASE_SCS_STATE:
				{
					int set = -1;
					switch (c) {
						case '(':
							set = 0;
							break;
						case ')':
						case '-':
							set = 1;
							break;
						case '*':
						case '.':
							set = 2;
							break;
						case '+':
						case '/':
							set = 3;
							break;
						default:
							break;
					}

					if (set > -1) {
						char page = _NextParseChar();
						switch (page) {
							case '0':
								graphSets[set] = gLineDrawGraphSet;
								break;
							default:
								graphSets[set] = NULL;
								break;
						}
					}

					parsestate = groundtable;
					break;
				}

				case CASE_GROUND_STATE:
					/* exit ignore mode */
					parsestate = groundtable;
					break;

				case CASE_BELL:
					beep();
					break;

				case CASE_BS:
					fBuffer->MoveCursorLeft(1);
					break;

				case CASE_TAB:
					fBuffer->InsertTab();
					break;

				case CASE_ESC:
					/* escape */
					parsestate = gEscTable;
					break;

				case CASE_IGNORE_STATE:
					/* Ies: ignore anything else */
					parsestate = gIgnoreTable;
					break;

				case CASE_IGNORE_ESC:
					/* Ign: escape */
					parsestate = gIesTable;
					break;

				case CASE_IGNORE:
					/* Ignore character */
					break;

				case CASE_LS1:
					/* select G1 into GL */
					curGL = 1;
					parsestate = groundtable;
					break;

				case CASE_LS0:
					/* select G0 into GL */
					curGL = 0;
					parsestate = groundtable;
					break;

				case CASE_SCR_STATE:	// ESC #
					/* enter scr state */
					parsestate = gScrTable;
					break;

				case CASE_ESC_IGNORE:
					/* unknown escape sequence */
					parsestate = gEscIgnoreTable;
					break;

				case CASE_ESC_DIGIT:	// ESC [ number
					/* digit in csi or dec mode */
					if ((row = param[nparam - 1]) == DEFAULT)
						row = 0;
					param[nparam - 1] = 10 * row + (c - '0');
					break;

				case CASE_ESC_SEMI:		// ESC ;
					/* semicolon in csi or dec mode */
					if (nparam < NPARAM)
						param[nparam++] = DEFAULT;
					break;

				case CASE_CSI_SP: // ESC [N q
					// part of change cursor style DECSCUSR
					if (nparam < NPARAM)
						param[nparam++] = ' ';
					break;

				case CASE_CSI_EXCL: // ESC [N p
					// part of soft reset DECSTR
					if (nparam < NPARAM)
						param[nparam++] = '!';
					break;

				case CASE_DEC_DOL: // ESC [? N p
					// part of change cursor style DECRQM
					if (nparam < NPARAM)
						param[nparam++] = '$';
					break;

				case CASE_DEC_STATE:
					/* enter dec mode */
					parsestate = gDecTable;
					break;

				case CASE_ICH:		// ESC [@ insert charactor
					/* ICH */
					if ((row = param[0]) < 1)
						row = 1;
					fBuffer->InsertSpace(row);
					parsestate = groundtable;
					break;

				case CASE_CUU:		// ESC [A cursor up, up arrow key.
					/* CUU */
					if ((row = param[0]) < 1)
						row = 1;
					fBuffer->MoveCursorUp(row);
					parsestate = groundtable;
					break;

				case CASE_CUD:		// ESC [B cursor down, down arrow key.
					/* CUD */
					if ((row = param[0]) < 1)
						row = 1;
					fBuffer->MoveCursorDown(row);
					parsestate = groundtable;
					break;

				case CASE_CUF:		// ESC [C cursor forword
					/* CUF */
					if ((row = param[0]) < 1)
						row = 1;
					fBuffer->MoveCursorRight(row);
					parsestate = groundtable;
					break;

				case CASE_CUB:		// ESC [D cursor backword
					/* CUB */
					if ((row = param[0]) < 1)
						row = 1;
					fBuffer->MoveCursorLeft(row);
					parsestate = groundtable;
					break;

				case CASE_CUP:		// ESC [...H move cursor
					/* CUP | HVP */
					if ((row = param[0]) < 1)
						row = 1;
					if (nparam < 2 || (column = param[1]) < 1)
						column = 1;

					fBuffer->SetCursor(column - 1, row - 1 );
					parsestate = groundtable;
					break;

				case CASE_ED:		// ESC [ ...J clear screen
					/* ED */
					switch (param[0]) {
						case DEFAULT:
						case 0:
							fBuffer->EraseBelow();
							break;

						case 1:
							fBuffer->EraseAbove();
							break;

						case 2:
							fBuffer->EraseAll();
							break;

						case 3:
							fBuffer->EraseScrollback();
							break;
					}
					parsestate = groundtable;
					break;

				case CASE_EL:		// ESC [ ...K delete line
					/* EL */
					switch (param[0]) {
						case DEFAULT:
						case 0:
							fBuffer->DeleteColumns();
							break;

						case 1:
							fBuffer->EraseCharsFrom(0, fBuffer->Cursor().x + 1);
							break;

						case 2:
							fBuffer->DeleteColumnsFrom(0);
							break;
					}
					parsestate = groundtable;
					break;

				case CASE_IL:
					/* IL */
					if ((row = param[0]) < 1)
						row = 1;
					fBuffer->InsertLines(row);
					parsestate = groundtable;
					break;

				case CASE_DL:
					/* DL */
					if ((row = param[0]) < 1)
						row = 1;
					fBuffer->DeleteLines(row);
					parsestate = groundtable;
					break;

				case CASE_DCH:
					/* DCH */
					if ((row = param[0]) < 1)
						row = 1;
					fBuffer->DeleteChars(row);
					parsestate = groundtable;
					break;

				case CASE_SET:
					/* SET */
					if (param[0] == 4)
						fBuffer->SetInsertMode(MODE_INSERT);
					parsestate = groundtable;
					break;

				case CASE_RST:
					/* RST */
					if (param[0] == 4)
						fBuffer->SetInsertMode(MODE_OVER);
					parsestate = groundtable;
					break;

				case CASE_SGR:
				{
					/* SGR */
					Attributes attributes = fBuffer->GetAttributes();
					for (row = 0; row < nparam; ++row) {
						switch (param[row]) {
							case DEFAULT:
							case 0: /* Reset attribute */
								attributes.Reset();
								break;

							case 1: /* Bold     */
							case 5:
								attributes |= BOLD;
								break;

							case 4:	/* Underline	*/
								if ((row + 1) < nparam) {
									row++;
									switch (param[row]) {
										case 0:
											attributes.UnsetUnder();
											break;
										case 1:
											attributes.SetUnder(SINGLE_UNDERLINE);
											break;
										case 2:
											attributes.SetUnder(DOUBLE_UNDERLINE);
											break;
										case 3:
											attributes.SetUnder(CURLY_UNDERLINE);
											break;
										case 4:
											attributes.SetUnder(DOTTED_UNDERLINE);
											break;
										case 5:
											attributes.SetUnder(DASHED_UNDERLINE);
											break;
										default:
											row = nparam; // force exit of the parsing
											break;
									}
								} else
									attributes.SetUnder(SINGLE_UNDERLINE);
								break;

							case 7:	/* Inverse	*/
								attributes |= INVERSE;
								break;

							case 8:	/* Hidden	*/
								attributes |= HIDDEN;
								break;

							case 21:	/* Double Underline	*/
								attributes.SetUnder(DOUBLE_UNDERLINE);
								break;

							case 22:	/* Not Bold	*/
								attributes &= ~BOLD;
								break;

							case 24:	/* Not Underline	*/
								attributes.UnsetUnder();
								break;

							case 27:	/* Not Inverse	*/
								attributes &= ~INVERSE;
								break;

							case 28:	/* Not Hidden	*/
								attributes &= ~HIDDEN;
								break;

							case 53:	/* Overline	*/
								attributes |= OVERLINE;
								break;

							case 55:	/* Not Overline	*/
								attributes &= ~OVERLINE;
								break;

							case 90:
							case 91:
							case 92:
							case 93:
							case 94:
							case 95:
							case 96:
							case 97:
								param[row] -= 60;
							case 30:
							case 31:
							case 32:
							case 33:
							case 34:
							case 35:
							case 36:
							case 37:
								attributes.SetIndexedForeground(param[row] - 30);
								break;

							case 38:
							{
								if (nparam >= 3 && param[row+1] == 5) {
									attributes.SetIndexedForeground(param[row+2]);
									row += 2;
								} else if (nparam >= 5 && param[row+1] == 2) {
									attributes.SetDirectForeground(param[row+2], param[row+3], param[row+4]);
									row += 4;
								} else {
									row = nparam; // force exit of the parsing
								}

								break;
							}

							case 39:
								attributes.UnsetForeground();
								break;

							case 100:
							case 101:
							case 102:
							case 103:
							case 104:
							case 105:
							case 106:
							case 107:
								param[row] -= 60;
							case 40:
							case 41:
							case 42:
							case 43:
							case 44:
							case 45:
							case 46:
							case 47:
								attributes.SetIndexedBackground(param[row] - 40);
								break;

							case 48:
							{
								if (nparam >= 3 && param[row+1] == 5) {
									attributes.SetIndexedBackground(param[row+2]);
									row += 2;
								} else if (nparam >= 5 && param[row+1] == 2) {
									attributes.SetDirectBackground(param[row+2], param[row+3], param[row+4]);
									row += 4;
								} else {
									row = nparam; // force exit of the parsing
								}

								break;
							}

							case 49:
								attributes.UnsetBackground();
								break;

							case 58:
							{
								if (nparam >= 3 && param[row+1] == 5) {
									attributes.SetIndexedUnderline(param[row+2]);
									row += 2;
								} else if (nparam >= 5 && param[row+1] == 2) {
									attributes.SetDirectUnderline(param[row+2], param[row+3], param[row+4]);
									row += 4;
								} else {
									row = nparam; // force exit of the parsing
								}

								break;
							}

							case 59:
								attributes.UnsetUnderline();
								break;
						}
					}
					fBuffer->SetAttributes(attributes);
					parsestate = groundtable;
					break;
				}

				case CASE_CPR:
				// Q & D hack by Y.Hayakawa (hida@sawada.riec.tohoku.ac.jp)
				// 21-JUL-99
				_DeviceStatusReport(param[0]);
				parsestate = groundtable;
				break;

				case CASE_DA1:
				// DA - report device attributes
				if (param[0] < 1) {
					// claim to be a VT102
					write(fFd, "\033[?6c", 5);
				}
				parsestate = groundtable;
				break;

				case CASE_DECSTBM:
				/* DECSTBM - set scrolling region */

				if ((top = param[0]) < 1)
					top = 1;

				if (nparam < 2)
					bottom = fBuffer->Height();
				else
					bottom = param[1];

				top--;
					bottom--;

					if (bottom > top)
						fBuffer->SetScrollRegion(top, bottom);

					parsestate = groundtable;
					break;

				case CASE_DECSCUSR_ETC:
				// DECSCUSR - set cursor style VT520
					if (nparam == 2 && param[1] == ' ') {
						bool blinking = (param[0] & 0x01) != 0;
						int style = -1;
						switch (param[0]) {
							case 0:
								blinking = true;
							case 1:
							case 2:
								style = BLOCK_CURSOR;
								break;
							case 3:
							case 4:
								style = UNDERLINE_CURSOR;
								break;
							case 5:
							case 6:
								style = IBEAM_CURSOR;
								break;
						}

						if (style != -1) {
							fBuffer->SetCursorStyle(style);
							if (blinking)
								fBuffer->SetMode(MODE_CURSOR_BLINKING);
							else
								fBuffer->ResetMode(MODE_CURSOR_BLINKING);
						}
					}
					parsestate = groundtable;
					break;

				case CASE_DECREQTPARM:
					// DEXREQTPARM - request terminal parameters
					_DecReqTermParms(param[0]);
					parsestate = groundtable;
					break;

				case CASE_DECSET:
					/* DECSET */
					for (int i = 0; i < nparam; i++)
						_DecPrivateModeSet(param[i]);
					parsestate = groundtable;
					break;

				case CASE_DECRST:
					/* DECRST */
					for (int i = 0; i < nparam; i++)
						_DecPrivateModeReset(param[i]);
					parsestate = groundtable;
					break;

				case CASE_DECALN:
					/* DECALN */
					{
						Attributes attr;
						fBuffer->FillScreen(UTF8Char('E'), attr);
						parsestate = groundtable;
					}
					break;

					//	case CASE_GSETS:
					//		screen->gsets[scstype] = GSET(c) | cs96;
					//		parsestate = groundtable;
					//		break;

				case CASE_DECSC:
					/* DECSC */
					fBuffer->SaveCursor();
					parsestate = groundtable;
					break;

				case CASE_DECRC:
					/* DECRC */
					fBuffer->RestoreCursor();
					parsestate = groundtable;
					break;

				case CASE_HTS:
					/* HTS */
					fBuffer->SetTabStop(fBuffer->Cursor().x);
					parsestate = groundtable;
					break;

				case CASE_TBC:
					/* TBC */
					if (param[0] < 1)
						fBuffer->ClearTabStop(fBuffer->Cursor().x);
					else if (param[0] == 3)
						fBuffer->ClearAllTabStops();
					parsestate = groundtable;
					break;

				case CASE_RI:
					/* RI */
					fBuffer->InsertRI();
					parsestate = groundtable;
					break;

				case CASE_SS2:
					/* SS2 */
					parsestate = groundtable;
					break;

				case CASE_SS3:
					/* SS3 */
					parsestate = groundtable;
					break;

				case CASE_CSI_STATE:
					/* enter csi state */
					nparam = 1;
					param[0] = DEFAULT;
					parsestate = gCsiTable;
					break;

				case CASE_OSC:
					{
						/* Operating System Command: ESC ] */
						uchar params[512];
						// fill the buffer until BEL, ST or something else.
						bool isParsed = false;
						int32 skipCount = 0; // take care about UTF-8 characters
						for (uint i = 0; !isParsed && i < sizeof(params); i++) {
							params[i] = _NextParseChar();

							if (skipCount > 0) {
								skipCount--;
								continue;
							}

							skipCount = UTF8Char::ByteCount(params[i]) - 1;
							if (skipCount > 0)
								continue;

							switch (params[i]) {
								// BEL
								case 0x07:
									isParsed = true;
									break;
								// 8-bit ST
								case 0x9c:
									isParsed = true;
									break;
								// 7-bit ST is "ESC \"
								case '\\':
								// hm... Was \x1b replaced by 0 during parsing?
									if (i > 0 && params[i - 1] == 0) {
										isParsed = true;
										break;
									}
								default:
									if (!isprint(params[i] & 0x7f))
										break;
									continue;
							}
							params[i] = '\0';
						}

						// watchdog for the 'end of buffer' case
						params[sizeof(params) - 1] = '\0';

						if (isParsed)
							_ProcessOperatingSystemControls(params);

						parsestate = groundtable;
						break;
					}

				case CASE_RIS:		// ESC c ... Reset terminal.
					break;

				case CASE_LS2:
					/* select G2 into GL */
					curGL = 2;
					parsestate = groundtable;
					break;

				case CASE_LS3:
					/* select G3 into GL */
					curGL = 3;
					parsestate = groundtable;
					break;

				case CASE_LS3R:
					/* select G3 into GR */
					curGR = 3;
					parsestate = groundtable;
					break;

				case CASE_LS2R:
					/* select G2 into GR */
					curGR = 2;
					parsestate = groundtable;
					break;

				case CASE_LS1R:
					/* select G1 into GR */
					curGR = 1;
					parsestate = groundtable;
					break;

				case CASE_VPA:		// ESC [...d move cursor absolute vertical
					/* VPA (CV) */
					if ((row = param[0]) < 1)
						row = 1;

					// note beterm wants it 1-based unlike usual terminals
					fBuffer->SetCursorY(row - 1);
					parsestate = groundtable;
					break;

				case CASE_HPA:		// ESC [...G move cursor absolute horizontal
					/* HPA (CH) */
					if ((column = param[0]) < 1)
						column = 1;

					// note beterm wants it 1-based unlike usual terminals
					fBuffer->SetCursorX(column - 1);
					parsestate = groundtable;
					break;

				case CASE_SU:	// scroll screen up
					if ((row = param[0]) < 1)
						row = 1;
					fBuffer->ScrollBy(row);
					parsestate = groundtable;
					break;

				case CASE_SD:	// scroll screen down
					if ((row = param[0]) < 1)
						row = 1;
					fBuffer->ScrollBy(-row);
					parsestate = groundtable;
					break;


				case CASE_ECH:	// erase characters
					if ((column = param[0]) < 1)
						column = 1;
					fBuffer->EraseChars(column);
					parsestate = groundtable;
					break;

				case CASE_CBT:	// cursor back tab
					if ((column = param[0]) < 1)
						column = 1;
					fBuffer->InsertCursorBackTab(column);
					parsestate = groundtable;
					break;

				case CASE_CFT:	// cursor forward tab
					if ((column = param[0]) < 1)
						column = 1;
					for (int32 i = 0; i < column; ++i)
						fBuffer->InsertTab();
					parsestate = groundtable;
					break;

				case CASE_CNL:	// cursor next line
					if ((row = param[0]) < 1)
						row = 1;
					fBuffer->SetCursorX(0);
					fBuffer->MoveCursorDown(row);
					parsestate = groundtable;
					break;

				case CASE_CPL:	// cursor previous line
					if ((row = param[0]) < 1)
						row = 1;
					fBuffer->SetCursorX(0);
					fBuffer->MoveCursorUp(row);
					parsestate = groundtable;
					break;

				case CASE_REP:		// ESC [...b repeat last graphic char
				{
					int repetitions = param[0];
					if (repetitions < 1)
						repetitions = 1;
					int maxRepetitions = fBuffer->Width() * fBuffer->Height();
					if (repetitions > maxRepetitions)
						repetitions = maxRepetitions;
					for (int i = 0; i < repetitions; i++)
						fBuffer->InsertLastChar();
					parsestate = groundtable;
					break;
				}

				case CASE_DECRQM:	// DECRQM - request mode to terminal
					if (nparam == 2 && param[1] == '$') {
						_DecPrivateModeRequest(param[0]);
					}
					parsestate = groundtable;
					break;

				case CASE_DECSTR:	// DECSTR - soft terminal reset
					if (nparam == 2 && param[1] == '!') {
						Attributes attributes;
						fBuffer->SetAttributes(attributes);
					}
					parsestate = groundtable;
					break;

				default:
					break;
			}
		} catch (...) {
			break;
		}
	}

	return B_OK;
}


/*static*/ int32
TermParse::_ptyreader_thread(void *data)
{
	return reinterpret_cast<TermParse *>(data)->PtyReader();
}


/*static*/ int32
TermParse::_escparse_thread(void *data)
{
	return reinterpret_cast<TermParse *>(data)->EscParse();
}


status_t
TermParse::_ReadParserBuffer()
{
	// We have to unlock the terminal buffer while waiting for data from the
	// PTY. We don't have to unlock when we don't need to wait, but we do it
	// anyway, so that TermView won't be starved when trying to synchronize.
	fBuffer->Unlock();

	// wait for new input from pty
	if (atomic_get(&fReadBufferSize) == 0) {
		status_t status = B_OK;
		while (atomic_get(&fReadBufferSize) == 0 && status == B_OK) {
			do {
				status = acquire_sem(fReaderSem);
			} while (status == B_INTERRUPTED);

			// eat any sems that were released unconditionally
			int32 semCount;
			if (get_sem_count(fReaderSem, &semCount) == B_OK && semCount > 0)
				acquire_sem_etc(fReaderSem, semCount, B_RELATIVE_TIMEOUT, 0);
		}

		if (status < B_OK) {
			fBuffer->Lock();
			return status;
		}
	}

	int32 toRead = atomic_get(&fReadBufferSize);
	if (toRead > ESC_PARSER_BUFFER_SIZE)
		toRead = ESC_PARSER_BUFFER_SIZE;

	for (int32 i = 0; i < toRead; i++) {
		// TODO: This could be optimized using memcpy instead and
		// calculating space left as in the PtyReader().
		fParserBuffer[i] = fReadBuffer[fBufferPosition];
		fBufferPosition = (fBufferPosition + 1) % READ_BUF_SIZE;
	}

	int32 bufferSize = atomic_add(&fReadBufferSize, -toRead);

	// If the pty reader thread waits and we have made enough space in the
	// buffer now, let it run again.
	if (bufferSize > READ_BUF_SIZE - MIN_PTY_BUFFER_SPACE
			&& bufferSize - toRead <= READ_BUF_SIZE - MIN_PTY_BUFFER_SPACE) {
		release_sem(fReaderLocker);
	}

	fParserBufferSize = toRead;
	fParserBufferOffset = 0;

	fBuffer->Lock();
	return B_OK;
}


void
TermParse::_DeviceStatusReport(int n)
{
	char sbuf[16] ;
	int len;

	switch (n) {
		case 5:
			{
				// Device status report requested
				// reply with "no malfunction detected"
				const char* toWrite = "\033[0n";
				write(fFd, toWrite, strlen(toWrite));
				break ;
			}
		case 6:
			// Cursor position report requested
			len = snprintf(sbuf, sizeof(sbuf),
				"\033[%" B_PRId32 ";%" B_PRId32 "R",
				fBuffer->Cursor().y + 1,
				fBuffer->Cursor().x + 1);
			write(fFd, sbuf, len);
			break ;
		default:
			return;
	}
}


void
TermParse::_DecReqTermParms(int value)
{
	// Terminal parameters report:
	//   type (2 or 3);
	//   no parity (1);
	//   8 bits per character (1);
	//   transmit speed 38400bps (128);
	//   receive speed 38400bps (128);
	//   bit rate multiplier 16 (1);
	//   no flags (0)
	char parms[] = "\033[?;1;1;128;128;1;0x";

	if (value < 1)
		parms[2] = '2';
	else if (value == 1)
		parms[2] = '3';
	else
		return;

	write(fFd, parms, strlen(parms));
}


void
TermParse::_DecPrivateModeSet(int value)
{
	switch (value) {
		case 1:
			// Application Cursor Keys (whatever that means).
			// Not supported yet.
			break;
		case 5:
			// Reverse Video (inverses colors for the complete screen
			// -- when followed by normal video, that's shortly flashes the
			// screen).
			// Not supported yet.
			break;
		case 6:
			// Set Origin Mode.
			fBuffer->SetOriginMode(true);
			break;
		case 9:
			// Set Mouse X and Y on button press.
			fBuffer->SetMode(MODE_REPORT_X10_MOUSE_EVENT);
			break;
		case 12:
			// Start Blinking Cursor.
			fBuffer->SetMode(MODE_CURSOR_BLINKING);
			break;
		case 25:
			// Show Cursor.
			fBuffer->ResetMode(MODE_CURSOR_HIDDEN);
			break;
		case 47:
			// Use Alternate Screen Buffer.
			fBuffer->UseAlternateScreenBuffer(false);
			break;
		case 1000:
			// Send Mouse X & Y on button press and release.
			fBuffer->SetMode(MODE_REPORT_NORMAL_MOUSE_EVENT);
			break;
		case 1002:
			// Send Mouse X and Y on button press and release, and on motion
			// when the mouse enter a new cell
			fBuffer->SetMode(MODE_REPORT_BUTTON_MOUSE_EVENT);
			break;
		case 1003:
			// Use All Motion Mouse Tracking
			fBuffer->SetMode(MODE_REPORT_ANY_MOUSE_EVENT);
			break;
		case 1006:
			// Enable extended mouse coordinates with SGR scheme
			fBuffer->SetMode(MODE_EXTENDED_MOUSE_COORDINATES);
			break;
		case 1034:
			// Interpret "meta" key, sets eighth bit.
			fBuffer->SetMode(MODE_INTERPRET_META_KEY);
			break;
		case 1036:
			// Send ESC when Meta modifies a key
			fBuffer->SetMode(MODE_META_KEY_SENDS_ESCAPE);
			break;
		case 1039:
			// TODO: Send ESC when Alt modifies a key
			// Not supported yet.
			break;
		case 1049:
			// Save cursor as in DECSC and use Alternate Screen Buffer, clearing
			// it first.
			fBuffer->SaveCursor();
			fBuffer->UseAlternateScreenBuffer(true);
			break;
		case 2004:
			// Enable bracketed paste mode
			fBuffer->SetMode(MODE_BRACKETED_PASTE);
			break;
	}
}


void
TermParse::_DecPrivateModeReset(int value)
{
	switch (value) {
		case 1:
			// Normal Cursor Keys (whatever that means).
			// Not supported yet.
			break;
		case 3:
			// 80 Column Mode.
			// Not supported yet.
			break;
		case 4:
			// Jump (Fast) Scroll.
			// Not supported yet.
			break;
		case 5:
			// Normal Video (Leaves Reverse Video, cf. there).
			// Not supported yet.
			break;
		case 6:
			// Reset Origin Mode.
			fBuffer->SetOriginMode(false);
			break;
		case 9:
			// Disable Mouse X and Y on button press.
			fBuffer->ResetMode(MODE_REPORT_X10_MOUSE_EVENT);
			break;
		case 12:
			// Stop Blinking Cursor.
			fBuffer->ResetMode(MODE_CURSOR_BLINKING);
			break;
		case 25:
			// Hide Cursor
			fBuffer->SetMode(MODE_CURSOR_HIDDEN);
			break;
		case 47:
			// Use Normal Screen Buffer.
			fBuffer->UseNormalScreenBuffer();
			break;
		case 1000:
			// Don't send Mouse X & Y on button press and release.
			fBuffer->ResetMode(MODE_REPORT_NORMAL_MOUSE_EVENT);
			break;
		case 1002:
			// Don't send Mouse X and Y on button press and release, and on motion
			// when the mouse enter a new cell
			fBuffer->ResetMode(MODE_REPORT_BUTTON_MOUSE_EVENT);
			break;
		case 1003:
			// Disable All Motion Mouse Tracking.
			fBuffer->ResetMode(MODE_REPORT_ANY_MOUSE_EVENT);
			break;
		case 1006:
			// Disable extended mouse coordinates with SGR scheme
			fBuffer->ResetMode(MODE_EXTENDED_MOUSE_COORDINATES);
			break;
		case 1034:
			// Don't interpret "meta" key.
			fBuffer->ResetMode(MODE_INTERPRET_META_KEY);
			break;
		case 1036:
			// Don't send ESC when Meta modifies a key
			fBuffer->ResetMode(MODE_META_KEY_SENDS_ESCAPE);
			break;
		case 1039:
			// TODO: Don't send ESC when Alt modifies a key
			// Not supported yet.
			break;
		case 1049:
			// Use Normal Screen Buffer and restore cursor as in DECRC.
			fBuffer->UseNormalScreenBuffer();
			fBuffer->RestoreCursor();
			break;
		case 2004:
			// Disable bracketed paste mode
			fBuffer->ResetMode(MODE_BRACKETED_PASTE);
			break;
	}
}


void
TermParse::_DecPrivateModeRequest(int value)
{
	BString reply;
	switch (value) {
		case 12:
			// Request cursor blinking mode
			reply.SetToFormat("\033[?12;%u$y\033\\",
				fBuffer->IsMode(MODE_CURSOR_BLINKING) ? 1 : 2);
			break;
		case 1006:
			// Request extended mouse coordinates with SGR scheme
			reply.SetToFormat("\033[?1006;%u$y\033\\",
				fBuffer->IsMode(MODE_EXTENDED_MOUSE_COORDINATES) ? 1 : 2);
			break;
		case 2004:
			// Request bracketed paste mode
			reply.SetToFormat("\033[?2004;%u$y\033\\",
				fBuffer->IsMode(MODE_BRACKETED_PASTE) ? 1 : 2);
			break;
		default:
			return;
	}
	_WriteReply(reply);
}


void
TermParse::_ProcessOperatingSystemControls(uchar* params)
{
	int mode = 0;
	for (uchar c = *params; c != ';' && c != '\0'; c = *(++params)) {
		mode *= 10;
		mode += c - '0';
	}

	// eat the separator
	if (*params == ';')
		params++;

	static uint8 indexes[kTermColorCount];
	static rgb_color colors[kTermColorCount];

	switch (mode) {
		case 0: // icon name and window title
		case 2: // window title
			fBuffer->SetTitle((const char*)params);
			break;
		case 4: // set colors (0 - 255)
		case 104: // reset colors (0 - 255)
			{
				bool reset = (mode / 100) == 1;

				// colors can be in "idx1:name1;...;idxN:nameN;" sequence too!
				uint32 count = 0;
				char* p = strtok((char*)params, ";");
				while (p != NULL && count < kTermColorCount) {
					indexes[count] = atoi(p);

					if (!reset) {
						p = strtok(NULL, ";");
						if (p == NULL)
							break;

						if (gXColorsTable.LookUpColor(p, &colors[count]) == B_OK)
							count++;
					} else
						count++;

					p = strtok(NULL, ";");
				};

				if (count > 0) {
					if (!reset)
						fBuffer->SetColors(indexes, colors, count);
					else
						fBuffer->ResetColors(indexes, count);
				}
			}
			break;
		// set dynamic colors (10 - 19)
		case 10: // text foreground
		case 11: // text background
		case 12: // cursor back
			{
				int32 offset = mode - 10;
				int32 count = 0;
				if (strcmp((char*)params, "?") == 0) {
					fBuffer->GetColor(mode);
					break;
				}
				char* p = strtok((char*)params, ";");
				do {
					if (gXColorsTable.LookUpColor(p, &colors[count]) != B_OK) {
						// dyna-colors are pos-sensitive - no chance to continue
						break;
					}

					indexes[count] = 10 + offset + count;
					count++;
					p = strtok(NULL, ";");

				} while (p != NULL && (offset + count) < 10);

				if (count > 0) {
					fBuffer->SetColors(indexes, colors, count, true);
				}
			}
			break;
		// reset dynamic colors (10 - 19)
		case 110: // text foreground
		case 111: // text background
		case 112: // cursor back
			{
				indexes[0] = mode;
				fBuffer->ResetColors(indexes, 1, true);
			}
			break;
		// handle hyperlinks
		case 8:
		{
			char* id = NULL;
			char* start = (char*)params;
			char* end = strpbrk(start, ";:");
			for (; end != NULL; start = end + 1) {
				end = strpbrk(start, ";:");
				if (end == NULL)
					break;
				if (end - start > 3 && strncmp(start, "id=", 3) == 0)
					id = strndup(start + 3, end - start + 3);
				if (*end == ';')
					break;
			}
			if (end == NULL)
				break;
			BString uri(end + 1);
			Attributes attributes = fBuffer->GetAttributes();
			if (uri.IsEmpty()) {
				attributes.SetHyperlink(0);
			} else {
				attributes.SetHyperlink(fBuffer->PutHyperLink(id, uri));
			}
			free(id);
			fBuffer->SetAttributes(attributes);
			break;
		}
		default:
		//	printf("%d -> %s\n", mode, params);
			break;
	}
}


void
TermParse::_WriteReply(BString &reply)
{
	write(fFd, reply.String(), reply.Length());
}