/* This module makes GNU readline available to Python.  It has ideas

 * contributed by Lee Busby, LLNL, and William Magro, Cornell Theory

 * Center.  The completer interface was inspired by Lele Gaifax.  More

 * recently, it was largely rewritten by Guido van Rossum.

 */

/* Standard definitions */

#include "Python.h"

#include <setjmp.h>

#include <signal.h>

#include <errno.h>

#include <sys/time.h>

#if defined(HAVE_SETLOCALE)

/* GNU readline() mistakenly sets the LC_CTYPE locale.

 * This is evil.  Only the user or the app's main() should do this!

 * We must save and restore the locale around the rl_initialize() call.

 */

#define SAVE_LOCALE

#include <locale.h>

#endif

#ifdef SAVE_LOCALE

#  define RESTORE_LOCALE(sl) { setlocale(LC_CTYPE, sl); free(sl); }

#else

#  define RESTORE_LOCALE(sl) 

#endif

/* GNU readline definitions */

#undef HAVE_CONFIG_H /* Else readline/chardefs.h includes strings.h */

#include <readline/readline.h>

#include <readline/history.h>

#ifdef HAVE_RL_COMPLETION_MATCHES

#define completion_matches(x, y) \

	rl_completion_matches((x), ((rl_compentry_func_t *)(y)))

#else

#if defined(_RL_FUNCTION_TYPEDEF)

extern char **completion_matches(char *, rl_compentry_func_t *);

#else

extern char **completion_matches(char *, CPFunction *);

#endif

#endif

static void

on_completion_display_matches_hook(char **matches,

				   int num_matches, int max_length);

/* Exported function to send one line to readline's init file parser */

static PyObject *

parse_and_bind(PyObject *self, PyObject *args)

{

	char *s, *copy;

	if (!PyArg_ParseTuple(args, "s:parse_and_bind", &s))

		return NULL;

	/* Make a copy -- rl_parse_and_bind() modifies its argument */

	/* Bernard Herzog */

	copy = malloc(1 + strlen(s));

	if (copy == NULL)

		return PyErr_NoMemory();

	strcpy(copy, s);

	rl_parse_and_bind(copy);

	free(copy); /* Free the copy */

	Py_RETURN_NONE;

}

PyDoc_STRVAR(doc_parse_and_bind,

"parse_and_bind(string) -> None\n\

Parse and execute single line of a readline init file.");

/* Exported function to parse a readline init file */

static PyObject *

read_init_file(PyObject *self, PyObject *args)

{

	char *s = NULL;

	if (!PyArg_ParseTuple(args, "|z:read_init_file", &s))

		return NULL;

	errno = rl_read_init_file(s);

	if (errno)

		return PyErr_SetFromErrno(PyExc_IOError);

	Py_RETURN_NONE;

}

PyDoc_STRVAR(doc_read_init_file,

"read_init_file([filename]) -> None\n\

Parse a readline initialization file.\n\

The default filename is the last filename used.");

/* Exported function to load a readline history file */

static PyObject *

read_history_file(PyObject *self, PyObject *args)

{

	char *s = NULL;

	if (!PyArg_ParseTuple(args, "|z:read_history_file", &s))

		return NULL;

	errno = read_history(s);

	if (errno)

		return PyErr_SetFromErrno(PyExc_IOError);

	Py_RETURN_NONE;

}

static int _history_length = -1; /* do not truncate history by default */

PyDoc_STRVAR(doc_read_history_file,

"read_history_file([filename]) -> None\n\

Load a readline history file.\n\

The default filename is ~/.history.");

/* Exported function to save a readline history file */

static PyObject *

write_history_file(PyObject *self, PyObject *args)

{

	char *s = NULL;

	if (!PyArg_ParseTuple(args, "|z:write_history_file", &s))

		return NULL;

	errno = write_history(s);

	if (!errno && _history_length >= 0)

		history_truncate_file(s, _history_length);

	if (errno)

		return PyErr_SetFromErrno(PyExc_IOError);

	Py_RETURN_NONE;

}

PyDoc_STRVAR(doc_write_history_file,

"write_history_file([filename]) -> None\n\

Save a readline history file.\n\

The default filename is ~/.history.");

/* Set history length */

static PyObject*

set_history_length(PyObject *self, PyObject *args)

{

	int length = _history_length;

	if (!PyArg_ParseTuple(args, "i:set_history_length", &length))

		return NULL;

	_history_length = length;

	Py_RETURN_NONE;

}

PyDoc_STRVAR(set_history_length_doc,

"set_history_length(length) -> None\n\

set the maximal number of items which will be written to\n\

the history file. A negative length is used to inhibit\n\

history truncation.");

/* Get history length */

static PyObject*

get_history_length(PyObject *self, PyObject *noarg)

{

	return PyInt_FromLong(_history_length);

}

PyDoc_STRVAR(get_history_length_doc,

"get_history_length() -> int\n\

return the maximum number of items that will be written to\n\

the history file.");

/* Generic hook function setter */

static PyObject *

set_hook(const char *funcname, PyObject **hook_var, PyObject *args)

{

	PyObject *function = Py_None;

	char buf[80];

	PyOS_snprintf(buf, sizeof(buf), "|O:set_%.50s", funcname);

	if (!PyArg_ParseTuple(args, buf, &function))

		return NULL;

	if (function == Py_None) {

		Py_XDECREF(*hook_var);

		*hook_var = NULL;

	}

	else if (PyCallable_Check(function)) {

		PyObject *tmp = *hook_var;

		Py_INCREF(function);

		*hook_var = function;

		Py_XDECREF(tmp);

	}

	else {

		PyOS_snprintf(buf, sizeof(buf),

			      "set_%.50s(func): argument not callable",

			      funcname);

		PyErr_SetString(PyExc_TypeError, buf);

		return NULL;

	}

	Py_RETURN_NONE;

}

/* Exported functions to specify hook functions in Python */

static PyObject *completion_display_matches_hook = NULL;

static PyObject *startup_hook = NULL;

#ifdef HAVE_RL_PRE_INPUT_HOOK

static PyObject *pre_input_hook = NULL;

#endif

static PyObject *

set_completion_display_matches_hook(PyObject *self, PyObject *args)

{

	PyObject *result = set_hook("completion_display_matches_hook",

			&completion_display_matches_hook, args);

#ifdef HAVE_RL_COMPLETION_DISPLAY_MATCHES_HOOK

	/* We cannot set this hook globally, since it replaces the

	   default completion display. */

	rl_completion_display_matches_hook =

		completion_display_matches_hook ?

#if defined(_RL_FUNCTION_TYPEDEF)

		(rl_compdisp_func_t *)on_completion_display_matches_hook : 0;

#else

		(VFunction *)on_completion_display_matches_hook : 0;

#endif

#endif

	return result;

}

PyDoc_STRVAR(doc_set_completion_display_matches_hook,

"set_completion_display_matches_hook([function]) -> None\n\

Set or remove the completion display function.\n\

The function is called as\n\

  function(substitution, [matches], longest_match_length)\n\

once each time matches need to be displayed.");

static PyObject *

set_startup_hook(PyObject *self, PyObject *args)

{

	return set_hook("startup_hook", &startup_hook, args);

}

PyDoc_STRVAR(doc_set_startup_hook,

"set_startup_hook([function]) -> None\n\

Set or remove the startup_hook function.\n\

The function is called with no arguments just\n\

before readline prints the first prompt.");

#ifdef HAVE_RL_PRE_INPUT_HOOK

/* Set pre-input hook */

static PyObject *

set_pre_input_hook(PyObject *self, PyObject *args)

{

	return set_hook("pre_input_hook", &pre_input_hook, args);

}

PyDoc_STRVAR(doc_set_pre_input_hook,

"set_pre_input_hook([function]) -> None\n\

Set or remove the pre_input_hook function.\n\

The function is called with no arguments after the first prompt\n\

has been printed and just before readline starts reading input\n\

characters.");

#endif

/* Exported function to specify a word completer in Python */

static PyObject *completer = NULL;

static PyObject *begidx = NULL;

static PyObject *endidx = NULL;

/* Get the completion type for the scope of the tab-completion */

static PyObject *

get_completion_type(PyObject *self, PyObject *noarg)

{

  return PyInt_FromLong(rl_completion_type);

}

PyDoc_STRVAR(doc_get_completion_type,

"get_completion_type() -> int\n\

Get the type of completion being attempted.");

/* Get the beginning index for the scope of the tab-completion */

static PyObject *

get_begidx(PyObject *self, PyObject *noarg)

{

	Py_INCREF(begidx);

	return begidx;

}

PyDoc_STRVAR(doc_get_begidx,

"get_begidx() -> int\n\

get the beginning index of the readline tab-completion scope");

/* Get the ending index for the scope of the tab-completion */

static PyObject *

get_endidx(PyObject *self, PyObject *noarg)

{

	Py_INCREF(endidx);

	return endidx;

}

PyDoc_STRVAR(doc_get_endidx,

"get_endidx() -> int\n\

get the ending index of the readline tab-completion scope");

/* Set the tab-completion word-delimiters that readline uses */

static PyObject *

set_completer_delims(PyObject *self, PyObject *args)

{

	char *break_chars;

	if(!PyArg_ParseTuple(args, "s:set_completer_delims", &break_chars)) {

		return NULL;

	}

	free((void*)rl_completer_word_break_characters);

	rl_completer_word_break_characters = strdup(break_chars);

	Py_RETURN_NONE;

}

PyDoc_STRVAR(doc_set_completer_delims,

"set_completer_delims(string) -> None\n\

set the readline word delimiters for tab-completion");

static PyObject *

py_remove_history(PyObject *self, PyObject *args)

{

	int entry_number;

	HIST_ENTRY *entry;

	if (!PyArg_ParseTuple(args, "i:remove_history", &entry_number))

		return NULL;

	if (entry_number < 0) {

		PyErr_SetString(PyExc_ValueError,

				"History index cannot be negative");

		return NULL;

	}

	entry = remove_history(entry_number);

	if (!entry) {

		PyErr_Format(PyExc_ValueError,

			     "No history item at position %d",

			      entry_number);

		return NULL;

	}

	/* free memory allocated for the history entry */

	if (entry->line)

		free(entry->line);

	if (entry->data)

		free(entry->data);

	free(entry);

	Py_RETURN_NONE;

}

PyDoc_STRVAR(doc_remove_history,

"remove_history_item(pos) -> None\n\

remove history item given by its position");

static PyObject *

py_replace_history(PyObject *self, PyObject *args)

{

	int entry_number;

	char *line;

	HIST_ENTRY *old_entry;

	if (!PyArg_ParseTuple(args, "is:replace_history", &entry_number,

	      		      &line)) {

		return NULL;

	}

	if (entry_number < 0) {

		PyErr_SetString(PyExc_ValueError,

				"History index cannot be negative");

		return NULL;

	}

	old_entry = replace_history_entry(entry_number, line, (void *)NULL);

	if (!old_entry) {

		PyErr_Format(PyExc_ValueError,

			     "No history item at position %d",

			     entry_number);

		return NULL;

	}

	/* free memory allocated for the old history entry */

	if (old_entry->line)

	    free(old_entry->line);

	if (old_entry->data)

	    free(old_entry->data);

	free(old_entry);

	Py_RETURN_NONE;

}

PyDoc_STRVAR(doc_replace_history,

"replace_history_item(pos, line) -> None\n\

replaces history item given by its position with contents of line");

/* Add a line to the history buffer */

static PyObject *

py_add_history(PyObject *self, PyObject *args)

{

	char *line;

	if(!PyArg_ParseTuple(args, "s:add_history", &line)) {

		return NULL;

	}

	add_history(line);

	Py_RETURN_NONE;

}

PyDoc_STRVAR(doc_add_history,

"add_history(string) -> None\n\

add a line to the history buffer");

/* Get the tab-completion word-delimiters that readline uses */

static PyObject *

get_completer_delims(PyObject *self, PyObject *noarg)

{

	return PyString_FromString(rl_completer_word_break_characters);

}

PyDoc_STRVAR(doc_get_completer_delims,

"get_completer_delims() -> string\n\

get the readline word delimiters for tab-completion");

/* Set the completer function */

static PyObject *

set_completer(PyObject *self, PyObject *args)

{

	return set_hook("completer", &completer, args);

}

PyDoc_STRVAR(doc_set_completer,

"set_completer([function]) -> None\n\

Set or remove the completer function.\n\

The function is called as function(text, state),\n\

for state in 0, 1, 2, ..., until it returns a non-string.\n\

It should return the next possible completion starting with 'text'.");

static PyObject *

get_completer(PyObject *self, PyObject *noargs)

{

	if (completer == NULL) {

		Py_RETURN_NONE;

	}

	Py_INCREF(completer);

	return completer;

}

PyDoc_STRVAR(doc_get_completer,

"get_completer() -> function\n\

\n\

Returns current completer function.");

/* Exported function to get any element of history */

static PyObject *

get_history_item(PyObject *self, PyObject *args)

{

	int idx = 0;

	HIST_ENTRY *hist_ent;

	if (!PyArg_ParseTuple(args, "i:index", &idx))

		return NULL;

	if ((hist_ent = history_get(idx)))

		return PyString_FromString(hist_ent->line);

	else {

		Py_RETURN_NONE;

	}

}

PyDoc_STRVAR(doc_get_history_item,

"get_history_item() -> string\n\

return the current contents of history item at index.");

/* Exported function to get current length of history */

static PyObject *

get_current_history_length(PyObject *self, PyObject *noarg)

{

	HISTORY_STATE *hist_st;

	hist_st = history_get_history_state();

	return PyInt_FromLong(hist_st ? (long) hist_st->length : (long) 0);

}

PyDoc_STRVAR(doc_get_current_history_length,

"get_current_history_length() -> integer\n\

return the current (not the maximum) length of history.");

/* Exported function to read the current line buffer */

static PyObject *

get_line_buffer(PyObject *self, PyObject *noarg)

{

	return PyString_FromString(rl_line_buffer);

}

PyDoc_STRVAR(doc_get_line_buffer,

"get_line_buffer() -> string\n\

return the current contents of the line buffer.");

#ifdef HAVE_RL_COMPLETION_APPEND_CHARACTER

/* Exported function to clear the current history */

static PyObject *

py_clear_history(PyObject *self, PyObject *noarg)

{

	clear_history();