X-Git-Url: http://cgit.babelmonkeys.de/?p=jubjub.git;a=blobdiff_plain;f=src%2Fgui%2Fcli%2Flinenoise.m;fp=src%2Fgui%2Fcli%2Flinenoise.m;h=4bfd7df954a238efc3467b051e68ba92af0360ec;hp=0000000000000000000000000000000000000000;hb=74bc901b59ed844b3308224b7acdb78a9446d27a;hpb=1a38d433f22f577feb4007160d7a591b00518c9f

diff --git a/src/gui/cli/linenoise.m b/src/gui/cli/linenoise.m
new file mode 100644
index 0000000..4bfd7df
--- /dev/null
+++ b/src/gui/cli/linenoise.m
@@ -0,0 +1,869 @@
+/* linenoise.m -- guerrilla line editing library against the idea that a
+ * line editing lib needs to be 20,000 lines of C code.
+ *
+ * You can find the latest source code at:
+ *
+ *	 http://github.com/antirez/linenoise
+ *
+ * Does a number of crazy assumptions that happen to be true in 99.9999% of
+ * the 2010 UNIX computers around.
+ *
+ * ------------------------------------------------------------------------
+ *
+ * Copyright (c) 2010-2013, Salvatore Sanfilippo <antirez at gmail dot com>
+ * Copyright (c) 2010-2013, Pieter Noordhuis <pcnoordhuis at gmail dot com>
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *	* Redistributions of source code must retain the above copyright
+ *	  notice, this list of conditions and the following disclaimer.
+ *
+ *	* Redistributions in binary form must reproduce the above copyright
+ *	  notice, this list of conditions and the following disclaimer in the
+ *	  documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * ------------------------------------------------------------------------
+ *
+ * References:
+ * - http://invisible-island.net/xterm/ctlseqs/ctlseqs.html
+ * - http://www.3waylabs.com/nw/WWW/products/wizcon/vt220.html
+ *
+ * Todo list:
+ * - Filter bogus Ctrl+<char> combinations.
+ * - Win32 support
+ *
+ * Bloat:
+ * - History search like Ctrl+r in readline?
+ *
+ * List of escape sequences used by this program, we do everything just
+ * with three sequences. In order to be so cheap we may have some
+ * flickering effect with some slow terminal, but the lesser sequences
+ * the more compatible.
+ *
+ * CHA (Cursor Horizontal Absolute)
+ *	Sequence: ESC [ n G
+ *	Effect: moves cursor to column n
+ *
+ * EL (Erase Line)
+ *	Sequence: ESC [ n K
+ *	Effect: if n is 0 or missing, clear from cursor to end of line
+ *	Effect: if n is 1, clear from beginning of line to cursor
+ *	Effect: if n is 2, clear entire line
+ *
+ * CUF (CUrsor Forward)
+ *	Sequence: ESC [ n C
+ *	Effect: moves cursor forward of n chars
+ *
+ * When multi line mode is enabled, we also use an additional escape
+ * sequence. However multi line editing is disabled by default.
+ *
+ * CUU (Cursor Up)
+ *	Sequence: ESC [ n A
+ *	Effect: moves cursor up of n chars.
+ *
+ * CUD (Cursor Down)
+ *	Sequence: ESC [ n B
+ *	Effect: moves cursor down of n chars.
+ *
+ * The following are used to clear the screen: ESC [ H ESC [ 2 J
+ * This is actually composed of two sequences:
+ *
+ * cursorhome
+ *	Sequence: ESC [ H
+ *	Effect: moves the cursor to upper left corner
+ *
+ * ED2 (Clear entire screen)
+ *	Sequence: ESC [ 2 J
+ *	Effect: clear the whole screen
+ *
+ */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/ioctl.h>
+
+#import "linenoise.h"
+
+#define LINENOISE_DEFAULT_HISTORY_MAX_LEN 100
+#define LINENOISE_MAX_LINE 4096
+
+static Linenoise *instance = nil;
+
+// At exit we'll try to fix the terminal to the initial conditions.
+static void linenoiseAtExit(void)
+{
+	[instance LN_disableRawModeForFD: STDIN_FILENO];
+}
+
+
+@implementation Linenoise
+@synthesize multiline = _multiline;
+@synthesize completionCallback = _completionCallback;
+
++ (Linenoise*)sharedLinenoise
+{
+	return instance;
+}
+
++ (void)initialize
+{
+	static bool initialized = false;
+	if (!initialized) {
+		initialized = true;
+		instance = [[self alloc] init];
+		atexit(linenoiseAtExit);
+	}
+}
+
+- init
+{
+	self = [super init];
+
+	_maximalHistoryLength = LINENOISE_DEFAULT_HISTORY_MAX_LEN;
+	_history =
+	    [[OFMutableArray alloc] initWithCapacity: _maximalHistoryLength];
+
+	return self;
+}
+
+- (void)dealloc
+{
+	[_history release];
+
+	[super dealloc];
+}
+
+/* =========================== Line editing ================================= */
+
+
+/* Insert the character 'c' at cursor current position.
+ *
+ * On error writing to the terminal -1 is returned, otherwise 0. */
+- (int)LN_editInsertCharacter: (int)c
+{
+	static char tmp[7];
+	static int fill = 0;
+	tmp[fill++] = c;
+	tmp[fill] = '\0';
+	OFString *ins;
+
+	@try {
+		ins = @(tmp);
+	}
+	@catch (id e) {
+		return 0;
+	}
+
+	fill = 0;
+	[_buf insertString: ins
+		   atIndex: _pos++];
+	[self refreshLine];
+
+	return 0;
+}
+
+/* Move cursor on the left. */
+- (void)LN_editMoveLeft
+{
+	if (_pos > 0) {
+		_pos--;
+		[self refreshLine];
+	}
+}
+
+/* Move cursor on the right. */
+- (void)LN_editMoveRight
+{
+	if (_pos != [_buf length]) {
+		_pos++;
+		[self refreshLine];
+	}
+}
+
+/* Substitute the currently edited line with the next or previous history
+ * entry as specified by 'dir'. */
+- (void)LN_editHistoryNextInDirection: (enum linenoiseDirection)dir
+{
+	size_t count = [_history count];
+	if (count > 1) {
+		/* Update the current history entry before to
+		 * overwrite it with the next one. */
+		_history[count - 1 - _historyIndex] = _buf;
+		// Show the new entry
+		_historyIndex += (dir == LINENOISE_HISTORY_PREV) ? 1 : -1;
+		if (_historyIndex < 0) {
+			_historyIndex = 0;
+			return;
+		} else if (_historyIndex >= count) {
+			_historyIndex = count - 1;
+			return;
+		}
+		[_buf release];
+		_buf = [_history[count - 1 - _historyIndex] mutableCopy];
+		_pos = [_buf length];
+		[self refreshLine];
+	}
+}
+
+/* Delete the character at the right of the cursor without altering the cursor
+ * position. Basically this is what happens with the "Delete" keyboard key. */
+- (void)LN_editDelete
+{
+	size_t len = [_buf length];
+	if (len > 0 && _pos < len) {
+		[_buf deleteCharactersInRange: of_range(_pos, 1)];
+		[self refreshLine];
+	}
+}
+
+/* Backspace implementation. */
+- (void)LN_editBackspace
+{
+	size_t len = [_buf length];
+	if (_pos > 0 && len > 0) {
+		_pos--;
+		[_buf deleteCharactersInRange: of_range(_pos, 1)];
+		[self refreshLine];
+	}
+}
+
+/* Delete the previosu word, maintaining the cursor at the start of the
+ * current word. */
+- (void)LN_editDeletePreviousWord
+{
+	size_t old_pos = _pos;
+
+	while (_pos > 0 && [_buf characterAtIndex: _pos - 1] == ' ')
+		_pos--;
+	while (_pos > 0 && [_buf characterAtIndex: _pos - 1] != ' ')
+		_pos--;
+
+	[_buf deleteCharactersInRange: of_range(_pos, old_pos - _pos)];
+	[self refreshLine];
+}
+
+/* This function is the core of the line editing capability of linenoise.
+ * It expects 'fd' to be already in "raw mode" so that every key pressed
+ * will be returned ASAP to read().
+ *
+ * The resulting string is put into 'buf' when the user type enter, or
+ * when ctrl+d is typed.
+ *
+ * The function returns the length of the current buffer. */
+- (OFString*)LN_editWithFD: (int)fd
+		    prompt: (OFString*)prompt
+{
+	/* Populate the linenoise state that we pass to functions implementing
+	 * specific editing functionalities. */
+	_term = [OFFile fileWithFileDescriptor: fd];
+	_buf = [@"" mutableCopy];
+	_prompt = prompt;
+	_oldpos = _pos = 0;
+	_cols = [self LN_getColumns];
+	_maxrows = 0;
+	_historyIndex = 0;
+
+	/* The latest history entry is always our current buffer, that
+	 * initially is just an empty string. */
+	[self addHistoryItem: @""];
+
+	[_term writeString: prompt];
+
+	while (1) {
+		char c;
+		size_t nread;
+		char seq[2], seq2[2];
+
+		nread = [_term readIntoBuffer: &c
+				      length: 1];
+		if (nread == 0) {
+			return [_buf autorelease];
+		}
+
+		/* Only autocomplete when the callback is set.
+		 * It returns < 0 when there was an error reading from fd.
+		 * Otherwise it will return the character that should be
+		 * handled next. */
+		if (c == 9 && _completionCallback != NULL) {
+			c = [self LN_completeLine];
+			// Return on errors
+			if (c < 0) {
+				return [_buf autorelease];
+			}
+			// Read next character when 0
+			if (c == 0)
+				continue;
+		}
+
+		switch (c) {
+		case 13: // enter
+			[_history removeLastObject];
+			return [_buf autorelease];
+		case 3: // ctrl-c
+			errno = EAGAIN;
+			return nil;
+		case 8:   // ctrl-h
+		case 127: // backspace
+			[self LN_editBackspace];
+			break;
+		case 4: // ctrl-d
+			/* remove char at right of cursor, or if the
+			 * line is empty, act as end-of-file. */
+			if ([_buf length] > 0) {
+				[self LN_editDelete];
+			} else {
+				[_history removeLastObject];
+				return nil;
+			}
+			break;
+		case 20: { // ctrl-t, swaps current character with previous.
+			size_t pos = _pos;
+			if (pos <= 0 || pos >= [_buf length])
+			        break;
+
+			OFMutableString *reverse =
+			    [[_buf substringWithRange: of_range(pos - 1, 2)]
+			    mutableCopy];
+			[reverse reverse];
+
+			[_buf replaceCharactersInRange: of_range(pos - 1, 2)
+					    withString: reverse];
+
+			if (pos != [_buf length])
+			        _pos++;
+			[self refreshLine];
+			break;
+		 }
+		case 2: // ctrl-b
+			[self LN_editMoveLeft];
+			break;
+		case 6: // ctrl-f
+			[self LN_editMoveRight];
+			break;
+		case 16: // ctrl-p
+			[self LN_editHistoryNextInDirection:
+			    LINENOISE_HISTORY_PREV];
+			break;
+		case 14: // ctrl-n
+			[self LN_editHistoryNextInDirection:
+			    LINENOISE_HISTORY_NEXT];
+			break;
+		case 27: // escape sequence
+			/* Read the next two bytes representing the
+			 * escape sequence. */
+			if ([_term readIntoBuffer: seq
+					  length: 2] != 2)
+				break;
+
+			if (seq[0] == 91 && seq[1] == 68) {
+				/* Left arrow */
+				[self LN_editMoveLeft];
+			} else if (seq[0] == 91 && seq[1] == 67) {
+				/* Right arrow */
+				[self LN_editMoveRight];
+			} else if (seq[0] == 91 &&
+			    (seq[1] == 65 || seq[1] == 66)) {
+				/* Up and Down arrows */
+				[self LN_editHistoryNextInDirection:
+				    (seq[1] == 65) ? LINENOISE_HISTORY_PREV
+						   : LINENOISE_HISTORY_NEXT];
+			} else if (seq[0] == 91 && seq[1] > 48 && seq[1] < 55) {
+				// extended escape, read additional two bytes.
+				if ([_term readIntoBuffer: seq2
+						   length: 2] < 1)
+					break;
+				if (seq[1] == 51 && seq2[0] == 126) {
+					/* Delete key. */
+					[self LN_editDelete];
+				}
+			}
+			break;
+		default:
+			if ([self LN_editInsertCharacter: c])
+			        return nil;
+			break;
+		case 21: // Ctrl+u, delete the whole line.
+			_buf = [@"" mutableCopy];
+			_pos = 0;
+			[self refreshLine];
+			break;
+		case 11: { // Ctrl+k, delete from current to end of line.
+			size_t pos = _pos;
+			size_t diff = [_buf length] - pos;
+			[_buf deleteCharactersInRange:
+			    of_range(pos, diff)];
+			[self refreshLine];
+			break;
+		}
+		case 1: // Ctrl+a, go to the start of the line
+			_pos = 0;
+			[self refreshLine];
+			break;
+		case 5: // ctrl+e, go to the end of the line
+			_pos = [_buf length];
+			[self refreshLine];
+			break;
+		case 12: // ctrl+l, clear screen
+			[self clearScreen];
+			[self refreshLine];
+			break;
+		case 23: // ctrl+w, delete previous word
+			[self LN_editDeletePreviousWord];
+			break;
+		}
+	}
+	return [_buf autorelease];
+}
+
+/* This function calls the line editing function linenoiseEdit() using
+ * the STDIN file descriptor set in raw mode. */
+- (OFString*)LN_editRawWithPrompt: (OFString*)prompt
+{
+	OFString *ret;
+	int fd = [of_stdin fileDescriptorForReading];
+
+	if (!isatty(fd))
+		return [of_stdin readLine];
+
+	if ([self LN_enableRawModeForFD: fd] == -1)
+		return nil;
+	ret = [self LN_editWithFD: fd
+			   prompt: prompt];
+	[self LN_disableRawModeForFD: fd];
+	[of_stdout writeString: @"\n"];
+
+	return ret;
+}
+
+/* The high level function that is the main API of the linenoise library.
+ * This function checks if the terminal has basic capabilities, just checking
+ * for a blacklist of stupid terminals, and later either calls the line
+ * editing function or uses dummy fgets() so that you will be able to type
+ * something even in the most desperate of the conditions. */
+- (OFString*)readInputWithPrompt: (OFString*)prompt
+{
+	if ([self LN_isUnsupportedTerm]) {
+		OFString *ret;
+
+		_prompt = [prompt retain];
+
+		[of_stdout writeString: prompt];
+		[of_stdout flushWriteBuffer];
+
+		ret = [of_stdin readLine];
+
+		[_prompt release];
+		_prompt = nil;
+
+		return ret;
+	} else
+		return [self LN_editRawWithPrompt: prompt];
+}
+
+
+/* ============================== Completion ================================ */
+
+/* This is an helper function for linenoiseEdit() and is called when the
+ * user types the <tab> key in order to complete the string currently in the
+ * input.
+ *
+ * The state of the editing is encapsulated into the pointed linenoiseState
+ * structure as described in the structure definition. */
+- (int)LN_completeLine
+{
+	OFList *lc = [OFList new];
+	int nread;
+	char c = 0;
+
+	_completionCallback(_buf, lc);
+	if ([lc count] == 0) {
+		[self LN_beep];
+	} else {
+		bool stop = false;
+		size_t i = 0;
+		of_list_object_t *completion = [lc firstListObject];
+		size_t count = [lc count];
+
+		while (!stop) {
+			// Show completion or original buffer
+			if (i < count) {
+				size_t saved_pos = _pos;
+				OFMutableString *saved_buf = _buf;
+
+				_buf = [completion->object mutableCopy];
+				_pos = [_buf length];
+				[self refreshLine];
+				_pos = saved_pos;
+				_buf = saved_buf;
+			} else {
+				[self refreshLine];
+			}
+
+			nread = [_term readIntoBuffer: &c
+					       length: 1];
+			if (nread == 0) {
+				[lc release];
+				return -1;
+			}
+
+			switch (c) {
+			case 9: // tab
+				i = (i + 1) % (count + 1);
+				if (i == count) {
+					[self LN_beep];
+					break;
+				}
+
+				completion = completion->next;
+				if (completion == NULL)
+					completion = [lc firstListObject];
+				break;
+			case 27: // escape
+				// Re-show original buffer
+				if (i < count)
+					[self refreshLine];
+				stop = true;
+				break;
+			default:
+				// Update buffer and return
+				if (i < count) {
+					[_buf release];
+					_buf =
+					    [completion->object mutableCopy];
+					_pos =
+					    [_buf length];
+				}
+				stop = true;
+				break;
+			}
+		}
+	}
+
+	[lc release];
+	return c; // Return last read character
+}
+
+/* ================================ History ================================= */
+
+// Using a circular buffer is smarter, but a bit more complex to handle.
+- (int)addHistoryItem: (OFString*)line
+{
+	if (_maximalHistoryLength == 0)
+		return 0;
+
+	size_t len = [_history count];
+
+	if (len == _maximalHistoryLength) {
+		for (size_t i = 0; i < len - 1; i++)
+			_history[i] = _history[i+1];
+		[_history removeLastObject];
+	}
+
+	[_history addObject: line];
+	return 1;
+}
+
+/* Set the maximum length for the history. This function can be called even
+ * if there is already some history, the function will make sure to retain
+ * just the latest 'len' elements if the new history length value is smaller
+ * than the amount of items already inside the history. */
+- (void)setMaximalHistoryLength: (size_t)len
+{
+	if (len < 1)
+		@throw [OFInvalidArgumentException
+		    exceptionWithClass: [self class]
+			      selector: _cmd];
+
+	OFMutableArray *old = _history, *new;
+	int tocopy = len < [old count] ? len : [old count];
+
+	new = [[OFMutableArray alloc] initWithCapacity: len];
+
+	for (int i = 0; i < tocopy; i++)
+		[new addObject: old[i]];
+
+	_history = new;
+	[old release];
+
+	_maximalHistoryLength = len;
+}
+
+- (size_t)maximalHistoryLength
+{
+	return _maximalHistoryLength;
+}
+
+/* Save the history in the specified file. On success 0 is returned
+ * otherwise -1 is returned. */
+- (void)saveHistoryToFile: (OFString*)filename
+{
+	OFFile *file = [OFFile fileWithPath: filename
+				       mode: @"w"];
+	for (int j = 0; j < [_history count]; j++)
+		[file writeLine: _history[j]];
+	[file close];
+}
+
+/* Load the history from the specified file. If the file does not exist
+ * zero is returned and no operation is performed.
+ *
+ * If the file exists and the operation succeeded 0 is returned, otherwise
+ * on error -1 is returned. */
+- (void)loadHistoryFromFile: (OFString*)filename
+{
+	OFFile *file = [OFFile fileWithPath: filename
+				       mode: @"r"];
+	OFString *line;
+	while ((line = [file readLine]) != nil)
+		[self addHistoryItem: line];
+	[file close];
+}
+
+
+/* =========================== Line editing ================================= */
+
+// Clear the screen. Used to handle ctrl+l
+- (void)clearScreen
+{
+	[of_stdout writeString: @"\x1b[H\x1b[2J"];
+}
+
+/* Calls the two low level functions LN_refreshSingleLine or
+ * LN_refreshMultiLine according to the selected mode. */
+- (void)refreshLine
+{
+	if (_buf == nil)
+		return;
+
+	if (_multiline)
+		[self LN_refreshMultiLine];
+	else
+		[self LN_refreshSingleLine];
+}
+
+/* Single line low level line refresh.
+ *
+ * Rewrite the currently edited line accordingly to the buffer content,
+ * cursor position, and number of columns of the terminal. */
+- (void)LN_refreshSingleLine;
+{
+	size_t plen = [_prompt length];
+	size_t pos = _pos;
+	OFString *buf = _buf;
+
+	if ((plen + pos) >= _cols) {
+		size_t offset = (plen + pos) - _cols;
+		size_t buflen = [buf length] - offset;
+		buf = [buf substringWithRange: of_range(offset, buflen)];
+		pos -= offset;
+	}
+
+	// Cursor to left edge
+	[_term writeString: @"\x1b[0G"];
+	// Write the prompt and the current buffer content
+	[_term writeString: _prompt];
+	[_term writeString: buf];
+	// Erase to right
+	[_term writeString: @"\x1b[0K"];
+	// Move cursor to original position
+	[_term writeFormat: @"\x1b[0G\x1b[%zdC", pos + plen];
+}
+
+/* Multi line low level line refresh.
+ *
+ * Rewrite the currently edited line accordingly to the buffer content,
+ * cursor position, and number of columns of the terminal. */
+- (void)LN_refreshMultiLine
+{
+	size_t plen = [_prompt length];
+
+	// rows used by current buf.
+	size_t rows = (plen + [_buf length] + _cols - 1) / _cols;
+	// cursor relative row.
+	size_t rpos = (plen + _oldpos + _cols) / _cols;
+	// rpos after refresh.
+	size_t rpos2;
+	ssize_t old_rows = _maxrows, j;
+
+	// Update maxrows if needed.
+	if (rows > _maxrows)
+		_maxrows = rows;
+
+#ifdef LN_DEBUG
+	OFFile *file = [OFFile fileWithPath: @"/tmp/debug.txt"
+				       mode: @"a"];
+	[file writeFormat: @"[%zd %zd %zd] p: %zd, rows: %zd, rpos: %zd, "
+	    @"max: %zd, oldmax: %zd", [_buf length], _pos, _oldpos, plen, rows,
+	    rpos, _maxrows, old_rows];
+#endif
+
+	/* First step: clear all the lines used before. To do so start by
+	 * going to the last row. */
+	if (old_rows > rpos) {
+#ifdef LN_DEBUG
+		[file writeFormat: @", go down %zd", old_rows - rpos];
+#endif
+		[_term writeFormat: @"\x1b[%zdB", old_rows - rpos];
+	}
+
+	// Now for every row clear it, go up.
+	for (j = 0; j < old_rows - 1; j++) {
+#ifdef LN_DEBUG
+		[file writeString: @", clear+up"];
+#endif
+		[_term writeString: @"\x1b[0G\x1b[0K\x1b[1A"];
+	}
+
+	// Clean the top line.
+#ifdef LN_DEBUG
+	[file writeString: @", clear"];
+#endif
+	[_term writeString: @"\x1b[0G\x1b[0K"];
+
+	// Write the prompt and the current buffer content
+	[_term writeString: _prompt];
+	[_term writeString: _buf];
+
+	/* If we are at the very end of the screen with our prompt, we need to
+	 * emit a newline and move the prompt to the first column. */
+	if (_pos && _pos == [_buf length] && (_pos + plen) % _cols == 0) {
+#ifdef LN_DEBUG
+		[file writeString: @", <newline>"];
+#endif
+		[_term writeString: @"\n\x1b[0G"];
+		rows++;
+		if (rows > _maxrows)
+			_maxrows = rows;
+	}
+
+	// Move cursor to right position.
+	rpos2 = (plen + _pos + _cols) / _cols;
+	// current cursor relative row.
+#ifdef LN_DEBUG
+	[file writeFormat: @", rpos2 %zd", rpos2];
+#endif
+	// Go up till we reach the expected positon.
+	if (rows - rpos2 > 0) {
+#ifdef LN_DEBUG
+		[file writeFormat: @", go-up %zd", rows - rpos2];
+#endif
+		[_term writeFormat: @"\x1b[%zdA", rows - rpos2];
+	}
+	/* Set column. */
+#ifdef LN_DEBUG
+	[file writeFormat: @", set col %zd", 1 + ((plen + _pos) % _cols)];
+#endif
+	[_term writeFormat: @"\x1b[%zdG", 1 + ((plen + _pos) % _cols)];
+
+	_oldpos = _pos;
+
+#ifdef LN_DEBUG
+	[file writeString: @"\n"];
+	[file close];
+#endif
+}
+
+/* ======================= Low level terminal handling ====================== */
+
+/* Return true if the terminal name is in the list of terminals we know are
+ * not able to understand basic escape sequences. */
+
+- (bool)LN_isUnsupportedTerm
+{
+	static char *unsupported_term[] = { "dumb", "cons25", NULL };
+	char *term = getenv("TERM");
+	int j;
+
+	if (term == NULL)
+		return false;
+	for (j = 0; unsupported_term[j]; j++)
+		if (!strcasecmp(term, unsupported_term[j]))
+			return true;
+	return false;
+}
+
+/* Raw mode: 1960 magic shit. */
+- (int)LN_enableRawModeForFD: (int)fd
+{
+	struct termios raw;
+
+	if (!isatty(STDIN_FILENO))
+		goto fatal;
+	if (tcgetattr(fd, &_orig_termios) == -1)
+		goto fatal;
+
+	// modify the original mode
+	raw = _orig_termios;
+
+	/* input modes: no break, no CR to NL, no parity check, no strip char,
+	 * no start/stop output control. */
+	raw.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
+	// output modes - disable post processing
+	raw.c_oflag &= ~(OPOST);
+	// control modes - set 8 bit chars
+	raw.c_cflag |= (CS8);
+	/* local modes - choing off, canonical off, no extended functions,
+	 * no signal chars (^Z, ^C) */
+	raw.c_lflag &= ~(ECHO | ICANON | IEXTEN | ISIG);
+	/* control chars - set return condition: min number of bytes and timer.
+	 * We want read to return every single byte, without timeout. */
+	raw.c_cc[VMIN] = 1;
+	// 1 byte, no timer
+	raw.c_cc[VTIME] = 0;
+
+	// put terminal in raw mode after flushing
+	if (tcsetattr(fd, TCSAFLUSH, &raw) < 0)
+		goto fatal;
+	_rawmode = true;
+	return 0;
+
+fatal:
+	errno = ENOTTY;
+	return -1;
+}
+
+- (void)LN_disableRawModeForFD: (int)fd
+{
+	if (_rawmode && tcsetattr(fd, TCSAFLUSH, &_orig_termios) != -1)
+		_rawmode = false;
+}
+
+/* Try to get the number of columns in the current terminal, or assume 80
+ * if it fails. */
+- (int)LN_getColumns
+{
+	struct winsize ws;
+
+	if (ioctl(1, TIOCGWINSZ, &ws) == -1 || ws.ws_col == 0)
+		return 80;
+	return ws.ws_col;
+}
+
+/* Beep, used for completion when there is nothing to complete or when all
+ * the choices were already shown. */
+- (void)LN_beep
+{
+	fprintf(stderr, "\x7");
+	fflush(stderr);
+}
+@end