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

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

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

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

     5  */

     6 

     7 /* Standard definitions */

     8 #include "Python.h"

     9 #include <setjmp.h>

    10 #include <signal.h>

    11 #include <errno.h>

    12 #include <sys/time.h>

    13 

    14 #if defined(HAVE_SETLOCALE)

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

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

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

    18  */

    19 #define SAVE_LOCALE

    20 #include <locale.h>

    21 #endif

    22 

    23 #ifdef SAVE_LOCALE

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

    25 #else

    26 #  define RESTORE_LOCALE(sl) 

    27 #endif

    28 

    29 /* GNU readline definitions */

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

    31 #include <readline/readline.h>

    32 #include <readline/history.h>

    33 

    34 #ifdef HAVE_RL_COMPLETION_MATCHES

    35 #define completion_matches(x, y) \

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

    37 #else

    38 #if defined(_RL_FUNCTION_TYPEDEF)

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

    40 #else

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

    42 #endif

    43 #endif

    44 

    45 static void

    46 on_completion_display_matches_hook(char **matches,

    47 				   int num_matches, int max_length);

    48 

    49 

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

    51 

    52 static PyObject *

    53 parse_and_bind(PyObject *self, PyObject *args)

    54 {

    55 	char *s, *copy;

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

    57 		return NULL;

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

    59 	/* Bernard Herzog */

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

    61 	if (copy == NULL)

    62 		return PyErr_NoMemory();

    63 	strcpy(copy, s);

    64 	rl_parse_and_bind(copy);

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

    66 	Py_RETURN_NONE;

    67 }

    68 

    69 PyDoc_STRVAR(doc_parse_and_bind,

    70 "parse_and_bind(string) -> None\n\

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

    72 

    73 

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

    75 

    76 static PyObject *

    77 read_init_file(PyObject *self, PyObject *args)

    78 {

    79 	char *s = NULL;

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

    81 		return NULL;

    82 	errno = rl_read_init_file(s);

    83 	if (errno)

    84 		return PyErr_SetFromErrno(PyExc_IOError);

    85 	Py_RETURN_NONE;

    86 }

    87 

    88 PyDoc_STRVAR(doc_read_init_file,

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

    90 Parse a readline initialization file.\n\

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

    92 

    93 

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

    95 

    96 static PyObject *

    97 read_history_file(PyObject *self, PyObject *args)

    98 {

    99 	char *s = NULL;

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

   101 		return NULL;

   102 	errno = read_history(s);

   103 	if (errno)

   104 		return PyErr_SetFromErrno(PyExc_IOError);

   105 	Py_RETURN_NONE;

   106 }

   107 

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

   109 PyDoc_STRVAR(doc_read_history_file,

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

   111 Load a readline history file.\n\

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

   113 

   114 

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

   116 

   117 static PyObject *

   118 write_history_file(PyObject *self, PyObject *args)

   119 {

   120 	char *s = NULL;

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

   122 		return NULL;

   123 	errno = write_history(s);

   124 	if (!errno && _history_length >= 0)

   125 		history_truncate_file(s, _history_length);

   126 	if (errno)

   127 		return PyErr_SetFromErrno(PyExc_IOError);

   128 	Py_RETURN_NONE;

   129 }

   130 

   131 PyDoc_STRVAR(doc_write_history_file,

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

   133 Save a readline history file.\n\

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

   135 

   136 

   137 /* Set history length */

   138 

   139 static PyObject*

   140 set_history_length(PyObject *self, PyObject *args)

   141 {

   142 	int length = _history_length;

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

   144 		return NULL;

   145 	_history_length = length;

   146 	Py_RETURN_NONE;

   147 }

   148 

   149 PyDoc_STRVAR(set_history_length_doc,

   150 "set_history_length(length) -> None\n\

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

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

   153 history truncation.");

   154 

   155 

   156 /* Get history length */

   157 

   158 static PyObject*

   159 get_history_length(PyObject *self, PyObject *noarg)

   160 {

   161 	return PyInt_FromLong(_history_length);

   162 }

   163 

   164 PyDoc_STRVAR(get_history_length_doc,

   165 "get_history_length() -> int\n\

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

   167 the history file.");

   168 

   169 

   170 /* Generic hook function setter */

   171 

   172 static PyObject *

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

   174 {

   175 	PyObject *function = Py_None;

   176 	char buf[80];

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

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

   179 		return NULL;

   180 	if (function == Py_None) {

   181 		Py_XDECREF(*hook_var);

   182 		*hook_var = NULL;

   183 	}

   184 	else if (PyCallable_Check(function)) {

   185 		PyObject *tmp = *hook_var;

   186 		Py_INCREF(function);

   187 		*hook_var = function;

   188 		Py_XDECREF(tmp);

   189 	}

   190 	else {

   191 		PyOS_snprintf(buf, sizeof(buf),

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

   193 			      funcname);

   194 		PyErr_SetString(PyExc_TypeError, buf);

   195 		return NULL;

   196 	}

   197 	Py_RETURN_NONE;

   198 }

   199 

   200 

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

   202 

   203 static PyObject *completion_display_matches_hook = NULL;

   204 static PyObject *startup_hook = NULL;

   205 

   206 #ifdef HAVE_RL_PRE_INPUT_HOOK

   207 static PyObject *pre_input_hook = NULL;

   208 #endif

   209 

   210 static PyObject *

   211 set_completion_display_matches_hook(PyObject *self, PyObject *args)

   212 {

   213 	PyObject *result = set_hook("completion_display_matches_hook",

   214 			&completion_display_matches_hook, args);

   215 #ifdef HAVE_RL_COMPLETION_DISPLAY_MATCHES_HOOK

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

   217 	   default completion display. */

   218 	rl_completion_display_matches_hook =

   219 		completion_display_matches_hook ?

   220 #if defined(_RL_FUNCTION_TYPEDEF)

   221 		(rl_compdisp_func_t *)on_completion_display_matches_hook : 0;

   222 #else

   223 		(VFunction *)on_completion_display_matches_hook : 0;

   224 #endif

   225 #endif

   226 	return result;

   227 

   228 }

   229 

   230 PyDoc_STRVAR(doc_set_completion_display_matches_hook,

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

   232 Set or remove the completion display function.\n\

   233 The function is called as\n\

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

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

   236 

   237 static PyObject *

   238 set_startup_hook(PyObject *self, PyObject *args)

   239 {

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

   241 }

   242 

   243 PyDoc_STRVAR(doc_set_startup_hook,

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

   245 Set or remove the startup_hook function.\n\

   246 The function is called with no arguments just\n\

   247 before readline prints the first prompt.");

   248 

   249 

   250 #ifdef HAVE_RL_PRE_INPUT_HOOK

   251 

   252 /* Set pre-input hook */

   253 

   254 static PyObject *

   255 set_pre_input_hook(PyObject *self, PyObject *args)

   256 {

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

   258 }

   259 

   260 PyDoc_STRVAR(doc_set_pre_input_hook,

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

   262 Set or remove the pre_input_hook function.\n\

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

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

   265 characters.");

   266 

   267 #endif

   268 

   269 

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

   271 

   272 static PyObject *completer = NULL;

   273 

   274 static PyObject *begidx = NULL;

   275 static PyObject *endidx = NULL;

   276 

   277 

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

   279 static PyObject *

   280 get_completion_type(PyObject *self, PyObject *noarg)

   281 {

   282   return PyInt_FromLong(rl_completion_type);

   283 }

   284 

   285 PyDoc_STRVAR(doc_get_completion_type,

   286 "get_completion_type() -> int\n\

   287 Get the type of completion being attempted.");

   288 

   289 

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

   291 

   292 static PyObject *

   293 get_begidx(PyObject *self, PyObject *noarg)

   294 {

   295 	Py_INCREF(begidx);

   296 	return begidx;

   297 }

   298 

   299 PyDoc_STRVAR(doc_get_begidx,

   300 "get_begidx() -> int\n\

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

   302 

   303 

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

   305 

   306 static PyObject *

   307 get_endidx(PyObject *self, PyObject *noarg)

   308 {

   309 	Py_INCREF(endidx);

   310 	return endidx;

   311 }

   312 

   313 PyDoc_STRVAR(doc_get_endidx,

   314 "get_endidx() -> int\n\

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

   316 

   317 

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

   319 

   320 static PyObject *

   321 set_completer_delims(PyObject *self, PyObject *args)

   322 {

   323 	char *break_chars;

   324 

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

   326 		return NULL;

   327 	}

   328 	free((void*)rl_completer_word_break_characters);

   329 	rl_completer_word_break_characters = strdup(break_chars);

   330 	Py_RETURN_NONE;

   331 }

   332 

   333 PyDoc_STRVAR(doc_set_completer_delims,

   334 "set_completer_delims(string) -> None\n\

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

   336 

   337 static PyObject *

   338 py_remove_history(PyObject *self, PyObject *args)

   339 {

   340 	int entry_number;

   341 	HIST_ENTRY *entry;

   342 

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

   344 		return NULL;

   345 	if (entry_number < 0) {

   346 		PyErr_SetString(PyExc_ValueError,

   347 				"History index cannot be negative");

   348 		return NULL;

   349 	}

   350 	entry = remove_history(entry_number);

   351 	if (!entry) {

   352 		PyErr_Format(PyExc_ValueError,

   353 			     "No history item at position %d",

   354 			      entry_number);

   355 		return NULL;

   356 	}

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

   358 	if (entry->line)

   359 		free(entry->line);

   360 	if (entry->data)

   361 		free(entry->data);

   362 	free(entry);

   363 

   364 	Py_RETURN_NONE;

   365 }

   366 

   367 PyDoc_STRVAR(doc_remove_history,

   368 "remove_history_item(pos) -> None\n\

   369 remove history item given by its position");

   370 

   371 static PyObject *

   372 py_replace_history(PyObject *self, PyObject *args)

   373 {

   374 	int entry_number;

   375 	char *line;

   376 	HIST_ENTRY *old_entry;

   377 

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

   379 	      		      &line)) {

   380 		return NULL;

   381 	}

   382 	if (entry_number < 0) {

   383 		PyErr_SetString(PyExc_ValueError,

   384 				"History index cannot be negative");

   385 		return NULL;

   386 	}

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

   388 	if (!old_entry) {

   389 		PyErr_Format(PyExc_ValueError,

   390 			     "No history item at position %d",

   391 			     entry_number);

   392 		return NULL;

   393 	}

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

   395 	if (old_entry->line)

   396 	    free(old_entry->line);

   397 	if (old_entry->data)

   398 	    free(old_entry->data);

   399 	free(old_entry);

   400 

   401 	Py_RETURN_NONE;

   402 }

   403 

   404 PyDoc_STRVAR(doc_replace_history,

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

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

   407 

   408 /* Add a line to the history buffer */

   409 

   410 static PyObject *

   411 py_add_history(PyObject *self, PyObject *args)

   412 {

   413 	char *line;

   414 

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

   416 		return NULL;

   417 	}

   418 	add_history(line);

   419 	Py_RETURN_NONE;

   420 }

   421 

   422 PyDoc_STRVAR(doc_add_history,

   423 "add_history(string) -> None\n\

   424 add a line to the history buffer");

   425 

   426 

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

   428 

   429 static PyObject *

   430 get_completer_delims(PyObject *self, PyObject *noarg)

   431 {

   432 	return PyString_FromString(rl_completer_word_break_characters);

   433 }

   434 

   435 PyDoc_STRVAR(doc_get_completer_delims,

   436 "get_completer_delims() -> string\n\

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

   438 

   439 

   440 /* Set the completer function */

   441 

   442 static PyObject *

   443 set_completer(PyObject *self, PyObject *args)

   444 {

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

   446 }

   447 

   448 PyDoc_STRVAR(doc_set_completer,

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

   450 Set or remove the completer function.\n\

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

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

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

   454 

   455 

   456 static PyObject *

   457 get_completer(PyObject *self, PyObject *noargs)

   458 {

   459 	if (completer == NULL) {

   460 		Py_RETURN_NONE;

   461 	}

   462 	Py_INCREF(completer);

   463 	return completer;

   464 }

   465 

   466 PyDoc_STRVAR(doc_get_completer,

   467 "get_completer() -> function\n\

   468 \n\

   469 Returns current completer function.");

   470 

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

   472 

   473 static PyObject *

   474 get_history_item(PyObject *self, PyObject *args)

   475 {

   476 	int idx = 0;

   477 	HIST_ENTRY *hist_ent;

   478 

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

   480 		return NULL;

   481 	if ((hist_ent = history_get(idx)))

   482 		return PyString_FromString(hist_ent->line);

   483 	else {

   484 		Py_RETURN_NONE;

   485 	}

   486 }

   487 

   488 PyDoc_STRVAR(doc_get_history_item,

   489 "get_history_item() -> string\n\

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

   491 

   492 

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

   494 

   495 static PyObject *

   496 get_current_history_length(PyObject *self, PyObject *noarg)

   497 {

   498 	HISTORY_STATE *hist_st;

   499 

   500 	hist_st = history_get_history_state();

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

   502 }

   503 

   504 PyDoc_STRVAR(doc_get_current_history_length,

   505 "get_current_history_length() -> integer\n\

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

   507 

   508 

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

   510 

   511 static PyObject *

   512 get_line_buffer(PyObject *self, PyObject *noarg)

   513 {

   514 	return PyString_FromString(rl_line_buffer);

   515 }

   516 

   517 PyDoc_STRVAR(doc_get_line_buffer,

   518 "get_line_buffer() -> string\n\

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

   520 

   521 

   522 #ifdef HAVE_RL_COMPLETION_APPEND_CHARACTER

   523 

   524 /* Exported function to clear the current history */

   525 

   526 static PyObject *

   527 py_clear_history(PyObject *self, PyObject *noarg)

   528 {

   529 	clear_history();

   530 	Py_RETURN_NONE;

   531 }

   532 

   533 PyDoc_STRVAR(doc_clear_history,

   534 "clear_history() -> None\n\

   535 Clear the current readline history.");

   536 #endif

   537 

   538 

   539 /* Exported function to insert text into the line buffer */

   540 

   541 static PyObject *

   542 insert_text(PyObject *self, PyObject *args)

   543 {

   544 	char *s;

   545 	if (!PyArg_ParseTuple(args, "s:insert_text", &s))

   546 		return NULL;

   547 	rl_insert_text(s);

   548 	Py_RETURN_NONE;

   549 }

   550 

   551 PyDoc_STRVAR(doc_insert_text,

   552 "insert_text(string) -> None\n\

   553 Insert text into the command line.");

   554 

   555 

   556 /* Redisplay the line buffer */

   557 

   558 static PyObject *

   559 redisplay(PyObject *self, PyObject *noarg)

   560 {

   561 	rl_redisplay();

   562 	Py_RETURN_NONE;

   563 }

   564 

   565 PyDoc_STRVAR(doc_redisplay,

   566 "redisplay() -> None\n\

   567 Change what's displayed on the screen to reflect the current\n\

   568 contents of the line buffer.");

   569 

   570 

   571 /* Table of functions exported by the module */

   572 

   573 static struct PyMethodDef readline_methods[] =

   574 {

   575 	{"parse_and_bind", parse_and_bind, METH_VARARGS, doc_parse_and_bind},

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

   577 	{"insert_text", insert_text, METH_VARARGS, doc_insert_text},

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

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

   580 	{"read_history_file", read_history_file,

   581 	 METH_VARARGS, doc_read_history_file},

   582 	{"write_history_file", write_history_file,

   583 	 METH_VARARGS, doc_write_history_file},

   584 	{"get_history_item", get_history_item,

   585 	 METH_VARARGS, doc_get_history_item},

   586 	{"get_current_history_length", (PyCFunction)get_current_history_length,

   587 	 METH_NOARGS, doc_get_current_history_length},

   588 	{"set_history_length", set_history_length,

   589 	 METH_VARARGS, set_history_length_doc},

   590 	{"get_history_length", get_history_length,

   591 	 METH_NOARGS, get_history_length_doc},

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

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

   594 	{"get_completion_type", get_completion_type,

   595 	 METH_NOARGS, doc_get_completion_type},

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

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

   598 

   599 	{"set_completer_delims", set_completer_delims,

   600 	 METH_VARARGS, doc_set_completer_delims},

   601 	{"add_history", py_add_history, METH_VARARGS, doc_add_history},

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

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

   604 	{"get_completer_delims", get_completer_delims,

   605 	 METH_NOARGS, doc_get_completer_delims},

   606 

   607 	{"set_completion_display_matches_hook", set_completion_display_matches_hook,

   608 	 METH_VARARGS, doc_set_completion_display_matches_hook},

   609 	{"set_startup_hook", set_startup_hook,

   610 	 METH_VARARGS, doc_set_startup_hook},

   611 #ifdef HAVE_RL_PRE_INPUT_HOOK

   612 	{"set_pre_input_hook", set_pre_input_hook,

   613 	 METH_VARARGS, doc_set_pre_input_hook},

   614 #endif

   615 #ifdef HAVE_RL_COMPLETION_APPEND_CHARACTER

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

   617 #endif

   618 	{0, 0}

   619 };

   620 

   621 

   622 /* C function to call the Python hooks. */

   623 

   624 static int

   625 on_hook(PyObject *func)

   626 {

   627 	int result = 0;

   628 	if (func != NULL) {

   629 		PyObject *r;

   630 #ifdef WITH_THREAD

   631 		PyGILState_STATE gilstate = PyGILState_Ensure();

   632 #endif

   633 		r = PyObject_CallFunction(func, NULL);

   634 		if (r == NULL)

   635 			goto error;

   636 		if (r == Py_None)

   637 			result = 0;

   638 		else {

   639 			result = PyInt_AsLong(r);

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

   641 				goto error;

   642 		}

   643 		Py_DECREF(r);

   644 		goto done;

   645 	  error:

   646 		PyErr_Clear();

   647 		Py_XDECREF(r);

   648 	  done:

   649 #ifdef WITH_THREAD

   650 		PyGILState_Release(gilstate);

   651 #endif

   652 		return result;

   653 	}

   654 	return result;

   655 }

   656 

   657 static int

   658 on_startup_hook(void)

   659 {

   660 	return on_hook(startup_hook);

   661 }

   662 

   663 #ifdef HAVE_RL_PRE_INPUT_HOOK

   664 static int

   665 on_pre_input_hook(void)

   666 {

   667 	return on_hook(pre_input_hook);

   668 }

   669 #endif

   670 

   671 

   672 /* C function to call the Python completion_display_matches */

   673 

   674 static void

   675 on_completion_display_matches_hook(char **matches,

   676 				   int num_matches, int max_length)

   677 {

   678 	int i;

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

   680 #ifdef WITH_THREAD

   681 	PyGILState_STATE gilstate = PyGILState_Ensure();

   682 #endif

   683 	m = PyList_New(num_matches);

   684 	if (m == NULL)

   685 		goto error;

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

   687 		s = PyString_FromString(matches[i+1]);

   688 		if (s == NULL)

   689 			goto error;

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

   691 			goto error;

   692 	}

   693 

   694 	r = PyObject_CallFunction(completion_display_matches_hook,

   695 				  "sOi", matches[0], m, max_length);

   696 

   697 	Py_DECREF(m), m=NULL;

   698 	

   699 	if (r == NULL ||

   700 	    (r != Py_None && PyInt_AsLong(r) == -1 && PyErr_Occurred())) {

   701 		goto error;

   702 	}

   703 	Py_XDECREF(r), r=NULL;

   704 

   705 	if (0) {

   706 	error:

   707 		PyErr_Clear();

   708 		Py_XDECREF(m);

   709 		Py_XDECREF(r);

   710 	}

   711 #ifdef WITH_THREAD

   712 	PyGILState_Release(gilstate);

   713 #endif

   714 }

   715 

   716 

   717 /* C function to call the Python completer. */

   718 

   719 static char *

   720 on_completion(const char *text, int state)

   721 {

   722 	char *result = NULL;

   723 	if (completer != NULL) {

   724 		PyObject *r;

   725 #ifdef WITH_THREAD	      

   726 		PyGILState_STATE gilstate = PyGILState_Ensure();

   727 #endif

   728 		rl_attempted_completion_over = 1;

   729 		r = PyObject_CallFunction(completer, "si", text, state);

   730 		if (r == NULL)

   731 			goto error;

   732 		if (r == Py_None) {

   733 			result = NULL;

   734 		}

   735 		else {

   736 			char *s = PyString_AsString(r);

   737 			if (s == NULL)

   738 				goto error;

   739 			result = strdup(s);

   740 		}

   741 		Py_DECREF(r);

   742 		goto done;

   743 	  error:

   744 		PyErr_Clear();

   745 		Py_XDECREF(r);

   746 	  done:

   747 #ifdef WITH_THREAD	      

   748 		PyGILState_Release(gilstate);

   749 #endif

   750 		return result;

   751 	}

   752 	return result;

   753 }

   754 

   755 

   756 /* A more flexible constructor that saves the "begidx" and "endidx"

   757  * before calling the normal completer */

   758 

   759 static char **

   760 flex_complete(char *text, int start, int end)

   761 {

   762 	Py_XDECREF(begidx);

   763 	Py_XDECREF(endidx);

   764 	begidx = PyInt_FromLong((long) start);

   765 	endidx = PyInt_FromLong((long) end);

   766 	return completion_matches(text, *on_completion);

   767 }

   768 

   769 

   770 /* Helper to initialize GNU readline properly. */

   771 

   772 static void

   773 setup_readline(void)

   774 {

   775 #ifdef SAVE_LOCALE

   776 	char *saved_locale = strdup(setlocale(LC_CTYPE, NULL));

   777 	if (!saved_locale)

   778 		Py_FatalError("not enough memory to save locale");

   779 #endif

   780 

   781 	using_history();

   782 

   783 	rl_readline_name = "python";

   784 #if defined(PYOS_OS2) && defined(PYCC_GCC)

   785 	/* Allow $if term= in .inputrc to work */

   786 	rl_terminal_name = getenv("TERM");

   787 #endif

   788 	/* Force rebind of TAB to insert-tab */

   789 	rl_bind_key('\t', rl_insert);

   790 	/* Bind both ESC-TAB and ESC-ESC to the completion function */

   791 	rl_bind_key_in_map ('\t', rl_complete, emacs_meta_keymap);

   792 	rl_bind_key_in_map ('\033', rl_complete, emacs_meta_keymap);

   793 	/* Set our hook functions */

   794 	rl_startup_hook = (Function *)on_startup_hook;

   795 #ifdef HAVE_RL_PRE_INPUT_HOOK

   796 	rl_pre_input_hook = (Function *)on_pre_input_hook;

   797 #endif

   798 	/* Set our completion function */

   799 	rl_attempted_completion_function = (CPPFunction *)flex_complete;

   800 	/* Set Python word break characters */

   801 	rl_completer_word_break_characters =

   802 		strdup(" \t\n`~!@#$%^&*()-=+[{]}\\|;:'\",<>/?");

   803 		/* All nonalphanums except '.' */

   804 #ifdef HAVE_RL_COMPLETION_APPEND_CHARACTER

   805 	rl_completion_append_character ='\0';

   806 #endif

   807 

   808 	begidx = PyInt_FromLong(0L);

   809 	endidx = PyInt_FromLong(0L);

   810 	/* Initialize (allows .inputrc to override)

   811 	 *

   812 	 * XXX: A bug in the readline-2.2 library causes a memory leak

   813 	 * inside this function.  Nothing we can do about it.

   814 	 */

   815 	rl_initialize();

   816 

   817 	RESTORE_LOCALE(saved_locale)

   818 }

   819 

   820 /* Wrapper around GNU readline that handles signals differently. */

   821 

   822 

   823 #if defined(HAVE_RL_CALLBACK) && defined(HAVE_SELECT)

   824 

   825 static	char *completed_input_string;

   826 static void

   827 rlhandler(char *text)

   828 {

   829 	completed_input_string = text;

   830 	rl_callback_handler_remove();

   831 }

   832 

   833 extern PyThreadState* _PyOS_ReadlineTState;

   834 

   835 static char *

   836 readline_until_enter_or_signal(char *prompt, int *signal)

   837 {

   838 	char * not_done_reading = "";

   839 	fd_set selectset;

   840 

   841 	*signal = 0;

   842 #ifdef HAVE_RL_CATCH_SIGNAL

   843 	rl_catch_signals = 0;

   844 #endif

   845 

   846 	rl_callback_handler_install (prompt, rlhandler);

   847 	FD_ZERO(&selectset);

   848 	

   849 	completed_input_string = not_done_reading;

   850 

   851 	while (completed_input_string == not_done_reading) {

   852 		int has_input = 0;

   853 

   854 		while (!has_input)

   855 		{	struct timeval timeout = {0, 100000}; /* 0.1 seconds */

   856 

   857 			/* [Bug #1552726] Only limit the pause if an input hook has been 

   858 			   defined.  */

   859 		 	struct timeval *timeoutp = NULL;

   860 			if (PyOS_InputHook) 

   861 				timeoutp = &timeout;

   862 			FD_SET(fileno(rl_instream), &selectset);

   863 			/* select resets selectset if no input was available */

   864 			has_input = select(fileno(rl_instream) + 1, &selectset,

   865 					   NULL, NULL, timeoutp);

   866 			if(PyOS_InputHook) PyOS_InputHook();

   867 		}

   868 

   869 		if(has_input > 0) {

   870 			rl_callback_read_char();

   871 		}

   872 		else if (errno == EINTR) {

   873 			int s;

   874 #ifdef WITH_THREAD

   875 			PyEval_RestoreThread(_PyOS_ReadlineTState);

   876 #endif

   877 			s = PyErr_CheckSignals();

   878 #ifdef WITH_THREAD

   879 			PyEval_SaveThread();	

   880 #endif

   881 			if (s < 0) {

   882 				rl_free_line_state();

   883 				rl_cleanup_after_signal();

   884 				rl_callback_handler_remove();

   885 				*signal = 1;

   886 				completed_input_string = NULL;

   887 			}

   888 		}

   889 	}

   890 

   891 	return completed_input_string;

   892 }

   893 

   894 

   895 #else

   896 

   897 /* Interrupt handler */

   898 

   899 static jmp_buf jbuf;

   900 

   901 /* ARGSUSED */

   902 static void

   903 onintr(int sig)

   904 {

   905 	longjmp(jbuf, 1);

   906 }

   907 

   908 

   909 static char *

   910 readline_until_enter_or_signal(char *prompt, int *signal)

   911 {

   912 	PyOS_sighandler_t old_inthandler;

   913 	char *p;

   914     

   915 	*signal = 0;

   916 

   917 	old_inthandler = PyOS_setsig(SIGINT, onintr);

   918 	if (setjmp(jbuf)) {

   919 #ifdef HAVE_SIGRELSE

   920 		/* This seems necessary on SunOS 4.1 (Rasmus Hahn) */

   921 		sigrelse(SIGINT);

   922 #endif

   923 		PyOS_setsig(SIGINT, old_inthandler);

   924 		*signal = 1;

   925 		return NULL;

   926 	}

   927 	rl_event_hook = PyOS_InputHook;

   928 	p = readline(prompt);

   929 	PyOS_setsig(SIGINT, old_inthandler);

   930 

   931     return p;

   932 }

   933 #endif /*defined(HAVE_RL_CALLBACK) && defined(HAVE_SELECT) */

   934 

   935 

   936 static char *

   937 call_readline(FILE *sys_stdin, FILE *sys_stdout, char *prompt)

   938 {

   939 	size_t n;

   940 	char *p, *q;

   941 	int signal;

   942 

   943 #ifdef SAVE_LOCALE

   944 	char *saved_locale = strdup(setlocale(LC_CTYPE, NULL));

   945 	if (!saved_locale)

   946 		Py_FatalError("not enough memory to save locale");

   947 	setlocale(LC_CTYPE, "");

   948 #endif

   949 

   950 	if (sys_stdin != rl_instream || sys_stdout != rl_outstream) {

   951 		rl_instream = sys_stdin;

   952 		rl_outstream = sys_stdout;

   953 #ifdef HAVE_RL_COMPLETION_APPEND_CHARACTER

   954 		rl_prep_terminal (1);

   955 #endif

   956 	}

   957 

   958 	p = readline_until_enter_or_signal(prompt, &signal);

   959 	

   960 	/* we got an interrupt signal */

   961 	if (signal) {

   962 		RESTORE_LOCALE(saved_locale)

   963 		return NULL;

   964 	}

   965 

   966 	/* We got an EOF, return a empty string. */

   967 	if (p == NULL) {

   968 		p = PyMem_Malloc(1);

   969 		if (p != NULL)

   970 			*p = '\0';

   971 		RESTORE_LOCALE(saved_locale)

   972 		return p;

   973 	}

   974 

   975 	/* we have a valid line */

   976 	n = strlen(p);

   977 	if (n > 0) {

   978 		char *line;

   979 		HISTORY_STATE *state = history_get_history_state();

   980 		if (state->length > 0)

   981 			line = history_get(state->length)->line;

   982 		else

   983 			line = "";

   984 		if (strcmp(p, line))

   985 			add_history(p);

   986 		/* the history docs don't say so, but the address of state

   987 		   changes each time history_get_history_state is called

   988 		   which makes me think it's freshly malloc'd memory...

   989 		   on the other hand, the address of the last line stays the

   990 		   same as long as history isn't extended, so it appears to

   991 		   be malloc'd but managed by the history package... */

   992 		free(state);

   993 	}

   994 	/* Copy the malloc'ed buffer into a PyMem_Malloc'ed one and

   995 	   release the original. */

   996 	q = p;

   997 	p = PyMem_Malloc(n+2);

   998 	if (p != NULL) {

   999 		strncpy(p, q, n);

  1000 		p[n] = '\n';

  1001 		p[n+1] = '\0';

  1002 	}

  1003 	free(q);

  1004 	RESTORE_LOCALE(saved_locale)

  1005 	return p;

  1006 }

  1007 

  1008 

  1009 /* Initialize the module */

  1010 

  1011 PyDoc_STRVAR(doc_module,

  1012 "Importing this module enables command line editing using GNU readline.");

  1013 

  1014 PyMODINIT_FUNC

  1015 initreadline(void)

  1016 {

  1017 	PyObject *m;

  1018 

  1019 	m = Py_InitModule4("readline", readline_methods, doc_module,

  1020 			   (PyObject *)NULL, PYTHON_API_VERSION);

  1021 	if (m == NULL)

  1022 		return;

  1023 

  1024 	PyOS_ReadlineFunctionPointer = call_readline;

  1025 	setup_readline();

  1026 }