#include "Python.h"

#include <stddef.h>

#include <setjmp.h>

#include <signal.h>

#include <errno.h>

#include <sys/time.h>

#if defined(HAVE_SETLOCALE)

#define SAVE_LOCALE

#include <locale.h>

#ifdef SAVE_LOCALE

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

# define RESTORE_LOCALE(sl)

#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)))

#if defined(_RL_FUNCTION_TYPEDEF)

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

#if !defined(__APPLE__)

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

#ifdef __APPLE__

static int using_libedit_emulation = 0;

static const char libedit_version_tag[] = "EditLine wrapper";

static int libedit_history_start = 0;

#endif /* __APPLE__ */

#ifdef HAVE_RL_COMPLETION_DISPLAY_MATCHES_HOOK

static void

on_completion_display_matches_hook(char **matches,

int num_matches, int max_length);

static char *completer_word_break_characters;

typedef struct {

/* Specify hook functions in Python */

PyObject *completion_display_matches_hook;

PyObject *startup_hook;

PyObject *pre_input_hook;

PyObject *completer; /* Specify a word completer in Python */

PyObject *begidx;

PyObject *endidx;

} readlinestate;

#define readline_state(o) ((readlinestate *)PyModule_GetState(o))

static int

readline_clear(PyObject *m)

{

readlinestate *state = readline_state(m);

Py_CLEAR(state->completion_display_matches_hook);

Py_CLEAR(state->startup_hook);

Py_CLEAR(state->pre_input_hook);

Py_CLEAR(state->completer);

Py_CLEAR(state->begidx);

Py_CLEAR(state->endidx);

return 0;

}

static int

readline_traverse(PyObject *m, visitproc visit, void *arg)

{

readlinestate *state = readline_state(m);

Py_VISIT(state->completion_display_matches_hook);

Py_VISIT(state->startup_hook);

Py_VISIT(state->pre_input_hook);

Py_VISIT(state->completer);

Py_VISIT(state->begidx);

Py_VISIT(state->endidx);

return 0;

}

static void

readline_free(void *m)

{

readline_clear((PyObject *)m);

}

static PyModuleDef readlinemodule;

#define readlinestate_global ((readlinestate *)PyModule_GetState(PyState_FindModule(&readlinemodule)))

static PyObject *

encode(PyObject *b)

{

return PyUnicode_EncodeLocale(b, "surrogateescape");

}

static PyObject *

decode(const char *s)

{

return PyUnicode_DecodeLocale(s, "surrogateescape");

}

static PyObject *

parse_and_bind(PyObject *self, PyObject *string)

{

char *copy;

PyObject *encoded = encode(string);

if (encoded == NULL) {

return NULL;

}

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

/* Bernard Herzog */

copy = PyMem_Malloc(1 + PyBytes_GET_SIZE(encoded));

if (copy == NULL) {

Py_DECREF(encoded);

return PyErr_NoMemory();

}

strcpy(copy, PyBytes_AS_STRING(encoded));

Py_DECREF(encoded);

rl_parse_and_bind(copy);

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

Py_RETURN_NONE;

}

PyDoc_STRVAR(doc_parse_and_bind,

Execute the init line provided in the string argument.");

static PyObject *

read_init_file(PyObject *self, PyObject *args)

{

PyObject *filename_obj = Py_None, *filename_bytes;

if (!PyArg_ParseTuple(args, "|O:read_init_file", &filename_obj))

return NULL;

if (filename_obj != Py_None) {

if (!PyUnicode_FSConverter(filename_obj, &filename_bytes))

return NULL;

errno = rl_read_init_file(PyBytes_AsString(filename_bytes));

Py_DECREF(filename_bytes);

} else

errno = rl_read_init_file(NULL);

if (errno)

return PyErr_SetFromErrno(PyExc_OSError);

Py_RETURN_NONE;

}

PyDoc_STRVAR(doc_read_init_file,

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

static PyObject *

read_history_file(PyObject *self, PyObject *args)

{

PyObject *filename_obj = Py_None, *filename_bytes;

if (!PyArg_ParseTuple(args, "|O:read_history_file", &filename_obj))

return NULL;

if (filename_obj != Py_None) {

if (!PyUnicode_FSConverter(filename_obj, &filename_bytes))

return NULL;

errno = read_history(PyBytes_AsString(filename_bytes));

Py_DECREF(filename_bytes);

} else

errno = read_history(NULL);

if (errno)

return PyErr_SetFromErrno(PyExc_OSError);

Py_RETURN_NONE;

}

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

PyDoc_STRVAR(doc_read_history_file,

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

static PyObject *

write_history_file(PyObject *self, PyObject *args)

{

PyObject *filename_obj = Py_None, *filename_bytes;

char *filename;

int err;

if (!PyArg_ParseTuple(args, "|O:write_history_file", &filename_obj))

return NULL;

if (filename_obj != Py_None) {

if (!PyUnicode_FSConverter(filename_obj, &filename_bytes))

return NULL;

filename = PyBytes_AsString(filename_bytes);

} else {

filename_bytes = NULL;

filename = NULL;

}

errno = err = write_history(filename);

if (!err && _history_length >= 0)

history_truncate_file(filename, _history_length);

Py_XDECREF(filename_bytes);

errno = err;

if (errno)

return PyErr_SetFromErrno(PyExc_OSError);

Py_RETURN_NONE;

}

PyDoc_STRVAR(doc_write_history_file,

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

#ifdef HAVE_RL_APPEND_HISTORY

static PyObject *

append_history_file(PyObject *self, PyObject *args)

{

int nelements;

PyObject *filename_obj = Py_None, *filename_bytes;

char *filename;

int err;

if (!PyArg_ParseTuple(args, "i|O:append_history_file", &nelements, &filename_obj))

return NULL;

if (filename_obj != Py_None) {

if (!PyUnicode_FSConverter(filename_obj, &filename_bytes))

return NULL;

filename = PyBytes_AsString(filename_bytes);

} else {

filename_bytes = NULL;

filename = NULL;

}

errno = err = append_history(nelements, filename);

if (!err && _history_length >= 0)

history_truncate_file(filename, _history_length);

Py_XDECREF(filename_bytes);

errno = err;

if (errno)

return PyErr_SetFromErrno(PyExc_OSError);

Py_RETURN_NONE;

}

PyDoc_STRVAR(doc_append_history_file,

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

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,

history truncation.");

static PyObject*

get_history_length(PyObject *self, PyObject *noarg)

{

return PyLong_FromLong(_history_length);

}

PyDoc_STRVAR(get_history_length_doc,

the history file.");

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_CLEAR(*hook_var);

}

else if (PyCallable_Check(function)) {

Py_INCREF(function);

Py_XSETREF(*hook_var, function);

}

else {

PyErr_Format(PyExc_TypeError,

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

funcname);

return NULL;

}

Py_RETURN_NONE;

}

static PyObject *

set_completion_display_matches_hook(PyObject *self, PyObject *args)

{

PyObject *result = set_hook("completion_display_matches_hook",

&readlinestate_global->completion_display_matches_hook, args);

#ifdef HAVE_RL_COMPLETION_DISPLAY_MATCHES_HOOK

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

rl_completion_display_matches_hook =

readlinestate_global->completion_display_matches_hook ?

#if defined(_RL_FUNCTION_TYPEDEF)

(rl_compdisp_func_t *)on_completion_display_matches_hook : 0;

(VFunction *)on_completion_display_matches_hook : 0;

return result;

}

PyDoc_STRVAR(doc_set_completion_display_matches_hook,

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

static PyObject *

set_startup_hook(PyObject *self, PyObject *args)

{

return set_hook("startup_hook", &readlinestate_global->startup_hook, args);

}

PyDoc_STRVAR(doc_set_startup_hook,

before readline prints the first prompt.");

#ifdef HAVE_RL_PRE_INPUT_HOOK

static PyObject *

set_pre_input_hook(PyObject *self, PyObject *args)

{

return set_hook("pre_input_hook", &readlinestate_global->pre_input_hook, args);

}

PyDoc_STRVAR(doc_set_pre_input_hook,

characters.");

static PyObject *

get_completion_type(PyObject *self, PyObject *noarg)

{

return PyLong_FromLong(rl_completion_type);

}

PyDoc_STRVAR(doc_get_completion_type,

Get the type of completion being attempted.");

static PyObject *

get_begidx(PyObject *self, PyObject *noarg)

{

Py_INCREF(readlinestate_global->begidx);

return readlinestate_global->begidx;

}

PyDoc_STRVAR(doc_get_begidx,

get the beginning index of the completion scope");

static PyObject *

get_endidx(PyObject *self, PyObject *noarg)

{

Py_INCREF(readlinestate_global->endidx);

return readlinestate_global->endidx;

}

PyDoc_STRVAR(doc_get_endidx,

get the ending index of the completion scope");

static PyObject *

set_completer_delims(PyObject *self, PyObject *string)

{

char *break_chars;

PyObject *encoded = encode(string);

if (encoded == NULL) {

return NULL;

}

/* Keep a reference to the allocated memory in the module state in case

break_chars = strdup(PyBytes_AS_STRING(encoded));

Py_DECREF(encoded);

if (break_chars) {

free(completer_word_break_characters);

completer_word_break_characters = break_chars;

rl_completer_word_break_characters = break_chars;

Py_RETURN_NONE;

}

else

return PyErr_NoMemory();

}

PyDoc_STRVAR(doc_set_completer_delims,

set the word delimiters for completion");

#if defined(RL_READLINE_VERSION) && RL_READLINE_VERSION >= 0x0500

static void

_py_free_history_entry(HIST_ENTRY *entry)

{

histdata_t data = free_history_entry(entry);

free(data);

}

static void

_py_free_history_entry(HIST_ENTRY *entry)

{

if (entry->line)

free((void *)entry->line);

if (entry->data)

free(entry->data);

free(entry);

}

static PyObject *

py_remove_history(PyObject *self, PyObject *args)

{

int entry_number;

HIST_ENTRY *entry;

if (!PyArg_ParseTuple(args, "i:remove_history_item", &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 */

_py_free_history_entry(entry);

Py_RETURN_NONE;

}

PyDoc_STRVAR(doc_remove_history,

remove history item given by its position");

static PyObject *

py_replace_history(PyObject *self, PyObject *args)

{

int entry_number;

PyObject *line;

PyObject *encoded;

HIST_ENTRY *old_entry;

if (!PyArg_ParseTuple(args, "iU:replace_history_item", &entry_number,

&line)) {

return NULL;

}

if (entry_number < 0) {

PyErr_SetString(PyExc_ValueError,

"History index cannot be negative");

return NULL;

}

encoded = encode(line);

if (encoded == NULL) {

return NULL;

}

old_entry = replace_history_entry(entry_number, PyBytes_AS_STRING(encoded), (void *)NULL);

Py_DECREF(encoded);

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 */

_py_free_history_entry(old_entry);

Py_RETURN_NONE;

}

PyDoc_STRVAR(doc_replace_history,

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

static PyObject *

py_add_history(PyObject *self, PyObject *string)

{

PyObject *encoded = encode(string);

if (encoded == NULL) {

return NULL;

}

add_history(PyBytes_AS_STRING(encoded));

Py_DECREF(encoded);

Py_RETURN_NONE;

}

PyDoc_STRVAR(doc_add_history,

add an item to the history buffer");

static int should_auto_add_history = 1;

static PyObject *

py_set_auto_history(PyObject *self, PyObject *args)

{

if (!PyArg_ParseTuple(args, "p:set_auto_history",

&should_auto_add_history)) {

return NULL;

}

Py_RETURN_NONE;

}

PyDoc_STRVAR(doc_set_auto_history,

Enables or disables automatic history.");

static PyObject *

get_completer_delims(PyObject *self, PyObject *noarg)

{

return decode(rl_completer_word_break_characters);

}

PyDoc_STRVAR(doc_get_completer_delims,

get the word delimiters for completion");

static PyObject *

set_completer(PyObject *self, PyObject *args)

{

return set_hook("completer", &readlinestate_global->completer, args);

}

PyDoc_STRVAR(doc_set_completer,

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

static PyObject *

get_completer(PyObject *self, PyObject *noargs)

{

if (readlinestate_global->completer == NULL) {

Py_RETURN_NONE;

}

Py_INCREF(readlinestate_global->completer);

return readlinestate_global->completer;

}

PyDoc_STRVAR(doc_get_completer,

Returns current completer function.");

static int

_py_get_history_length(void)

{

HISTORY_STATE *hist_st = history_get_history_state();

int length = hist_st->length;

/* the history docs don't say so, but the address of hist_st changes each

free(hist_st);

return length;

}

static PyObject *

get_history_item(PyObject *self, PyObject *args)

{

int idx = 0;

HIST_ENTRY *hist_ent;

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

return NULL;

#ifdef __APPLE__

if (using_libedit_emulation) {

/* Older versions of libedit's readline emulation

int length = _py_get_history_length();

idx = idx - 1 + libedit_history_start;

/*

if (idx < (0 + libedit_history_start)

|| idx >= (length + libedit_history_start)) {

Py_RETURN_NONE;

}

}

#endif /* __APPLE__ */

if ((hist_ent = history_get(idx)))

return decode(hist_ent->line);

else {

Py_RETURN_NONE;

}

}

PyDoc_STRVAR(doc_get_history_item,

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

static PyObject *

get_current_history_length(PyObject *self, PyObject *noarg)

{

return PyLong_FromLong((long)_py_get_history_length());

}

PyDoc_STRVAR(doc_get_current_history_length,

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

static PyObject *

get_line_buffer(PyObject *self, PyObject *noarg)

{

return decode(rl_line_buffer);

}

PyDoc_STRVAR(doc_get_line_buffer,

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

#ifdef HAVE_RL_COMPLETION_APPEND_CHARACTER

static PyObject *

py_clear_history(PyObject *self, PyObject *noarg)

{

clear_history();

Py_RETURN_NONE;

}

PyDoc_STRVAR(doc_clear_history,

Clear the current readline history.");

static PyObject *

insert_text(PyObject *self, PyObject *string)

{

PyObject *encoded = encode(string);

if (encoded == NULL) {

return NULL;

}

rl_insert_text(PyBytes_AS_STRING(encoded));

Py_DECREF(encoded);

Py_RETURN_NONE;

}

PyDoc_STRVAR(doc_insert_text,

Insert text into the line buffer at the cursor position.");

static PyObject *

redisplay(PyObject *self, PyObject *noarg)

{

rl_redisplay();

Py_RETURN_NONE;

}

PyDoc_STRVAR(doc_redisplay,

contents of the line buffer.");

static struct PyMethodDef readline_methods[] =

{

{"parse_and_bind", parse_and_bind, METH_O, doc_parse_and_bind},

{"get_line_buffer", get_line_buffer, METH_NOARGS, doc_get_line_buffer},

{"insert_text", insert_text, METH_O, doc_insert_text},

{"redisplay", redisplay, METH_NOARGS, doc_redisplay},

{"read_init_file", read_init_file, METH_VARARGS, doc_read_init_file},

{"read_history_file", read_history_file,

METH_VARARGS, doc_read_history_file},

{"write_history_file", write_history_file,

METH_VARARGS, doc_write_history_file},

#ifdef HAVE_RL_APPEND_HISTORY

{"append_history_file", append_history_file,

METH_VARARGS, doc_append_history_file},

{"get_history_item", get_history_item,

METH_VARARGS, doc_get_history_item},

{"get_current_history_length", (PyCFunction)get_current_history_length,

METH_NOARGS, doc_get_current_history_length},

{"set_history_length", set_history_length,

METH_VARARGS, set_history_length_doc},

{"get_history_length", get_history_length,

METH_NOARGS, get_history_length_doc},

{"set_completer", set_completer, METH_VARARGS, doc_set_completer},

{"get_completer", get_completer, METH_NOARGS, doc_get_completer},

{"get_completion_type", get_completion_type,

METH_NOARGS, doc_get_completion_type},

{"get_begidx", get_begidx, METH_NOARGS, doc_get_begidx},

{"get_endidx", get_endidx, METH_NOARGS, doc_get_endidx},

{"set_completer_delims", set_completer_delims,

METH_O, doc_set_completer_delims},

{"set_auto_history", py_set_auto_history, METH_VARARGS, doc_set_auto_history},

{"add_history", py_add_history, METH_O, doc_add_history},

{"remove_history_item", py_remove_history, METH_VARARGS, doc_remove_history},

{"replace_history_item", py_replace_history, METH_VARARGS, doc_replace_history},

{"get_completer_delims", get_completer_delims,

METH_NOARGS, doc_get_completer_delims},

{"set_completion_display_matches_hook", set_completion_display_matches_hook,

METH_VARARGS, doc_set_completion_display_matches_hook},

{"set_startup_hook", set_startup_hook,

METH_VARARGS, doc_set_startup_hook},

#ifdef HAVE_RL_PRE_INPUT_HOOK

{"set_pre_input_hook", set_pre_input_hook,

METH_VARARGS, doc_set_pre_input_hook},

#ifdef HAVE_RL_COMPLETION_APPEND_CHARACTER

{"clear_history", py_clear_history, METH_NOARGS, doc_clear_history},

{0, 0}

};

static int

on_hook(PyObject *func)

{

int result = 0;

if (func != NULL) {

PyObject *r;

r = _PyObject_CallNoArg(func);

if (r == NULL)

goto error;

if (r == Py_None)

result = 0;

else {

result = _PyLong_AsInt(r);

if (result == -1 && PyErr_Occurred())

goto error;

}

Py_DECREF(r);

goto done;

error:

PyErr_Clear();

Py_XDECREF(r);

done:

return result;

}

return result;

}

static int

#if defined(_RL_FUNCTION_TYPEDEF)

on_startup_hook(void)

on_startup_hook()

{

int r;

#ifdef WITH_THREAD

PyGILState_STATE gilstate = PyGILState_Ensure();

r = on_hook(readlinestate_global->startup_hook);

#ifdef WITH_THREAD

PyGILState_Release(gilstate);

return r;

}

#ifdef HAVE_RL_PRE_INPUT_HOOK

static int

#if defined(_RL_FUNCTION_TYPEDEF)

on_pre_input_hook(void)

on_pre_input_hook()

{

int r;

#ifdef WITH_THREAD

PyGILState_STATE gilstate = PyGILState_Ensure();

r = on_hook(readlinestate_global->pre_input_hook);

#ifdef WITH_THREAD

PyGILState_Release(gilstate);

return r;

}

#ifdef HAVE_RL_COMPLETION_DISPLAY_MATCHES_HOOK

static void

on_completion_display_matches_hook(char **matches,

int num_matches, int max_length)

{

int i;

PyObject *sub, *m=NULL, *s=NULL, *r=NULL;

#ifdef WITH_THREAD

PyGILState_STATE gilstate = PyGILState_Ensure();

m = PyList_New(num_matches);

if (m == NULL)

goto error;

for (i = 0; i < num_matches; i++) {

s = decode(matches[i+1]);

if (s == NULL)

goto error;

if (PyList_SetItem(m, i, s) == -1)

goto error;

}

sub = decode(matches[0]);

r = PyObject_CallFunction(readlinestate_global->completion_display_matches_hook,

"NNi", sub, m, max_length);

m=NULL;

if (r == NULL ||

(r != Py_None && PyLong_AsLong(r) == -1 && PyErr_Occurred())) {

goto error;

}

Py_CLEAR(r);

if (0) {

error:

PyErr_Clear();

Py_XDECREF(m);

Py_XDECREF(r);

}

#ifdef WITH_THREAD

PyGILState_Release(gilstate);

}

#ifdef HAVE_RL_RESIZE_TERMINAL

static volatile sig_atomic_t sigwinch_received;

static PyOS_sighandler_t sigwinch_ohandler;

static void

readline_sigwinch_handler(int signum)

{

sigwinch_received = 1;

if (sigwinch_ohandler &&

sigwinch_ohandler != SIG_IGN && sigwinch_ohandler != SIG_DFL)

sigwinch_ohandler(signum);

#ifndef HAVE_SIGACTION

/* If the handler was installed with signal() rather than sigaction(),

PyOS_setsig(SIGWINCH, readline_sigwinch_handler);

}

static char *