Modules/readline.c

   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 PyLong_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 PyLong_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 PyUnicode_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 PyUnicode_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 PyLong_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 PyUnicode_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 = PyLong_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 = PyUnicode_FromString(matches[i+1]);
 688         if (s == NULL)
 689             goto error;
 690         if (PyList_SetItem(m, i, s) == -1)
 691             goto error;
 692     }
 693     r = PyObject_CallFunction(completion_display_matches_hook,
 694                               "sOi", matches[0], m, max_length);
 695
 696     Py_DECREF(m); m=NULL;
 697
 698     if (r == NULL ||
 699         (r != Py_None && PyLong_AsLong(r) == -1 && PyErr_Occurred())) {
 700         goto error;
 701     }
 702     Py_XDECREF(r); r=NULL;
 703
 704     if (0) {
 705     error:
 706         PyErr_Clear();
 707         Py_XDECREF(m);
 708         Py_XDECREF(r);
 709     }
 710 #ifdef WITH_THREAD
 711     PyGILState_Release(gilstate);
 712 #endif
 713 }
 714
 715
 716 /* C function to call the Python completer. */
 717
 718 static char *
 719 on_completion(const char *text, int state)
 720 {
 721     char *result = NULL;
 722     if (completer != NULL) {
 723         PyObject *r;
 724 #ifdef WITH_THREAD
 725         PyGILState_STATE gilstate = PyGILState_Ensure();
 726 #endif
 727         rl_attempted_completion_over = 1;
 728         r = PyObject_CallFunction(completer, "si", text, state);
 729         if (r == NULL)
 730             goto error;
 731         if (r == Py_None) {
 732             result = NULL;
 733         }
 734         else {
 735             char *s = _PyUnicode_AsString(r);
 736             if (s == NULL)
 737                 goto error;
 738             result = strdup(s);
 739         }
 740         Py_DECREF(r);
 741         goto done;
 742       error:
 743         PyErr_Clear();
 744         Py_XDECREF(r);
 745       done:
 746 #ifdef WITH_THREAD
 747         PyGILState_Release(gilstate);
 748 #endif
 749         return result;
 750     }
 751     return result;
 752 }
 753
 754
 755 /* A more flexible constructor that saves the "begidx" and "endidx"
 756  * before calling the normal completer */
 757
 758 static char **
 759 flex_complete(char *text, int start, int end)
 760 {
 761 #ifdef HAVE_RL_COMPLETION_APPEND_CHARACTER
 762     rl_completion_append_character ='\0';
 763 #endif
 764 #ifdef HAVE_RL_COMPLETION_SUPPRESS_APPEND
 765     rl_completion_suppress_append = 0;
 766 #endif
 767     Py_XDECREF(begidx);
 768     Py_XDECREF(endidx);
 769     begidx = PyLong_FromLong((long) start);
 770     endidx = PyLong_FromLong((long) end);
 771     return completion_matches(text, *on_completion);
 772 }
 773
 774
 775 /* Helper to initialize GNU readline properly. */
 776
 777 static void
 778 setup_readline(void)
 779 {
 780 #ifdef SAVE_LOCALE
 781     char *saved_locale = strdup(setlocale(LC_CTYPE, NULL));
 782     if (!saved_locale)
 783         Py_FatalError("not enough memory to save locale");
 784 #endif
 785
 786     using_history();
 787
 788     rl_readline_name = "python";
 789 #if defined(PYOS_OS2) && defined(PYCC_GCC)
 790     /* Allow $if term= in .inputrc to work */
 791     rl_terminal_name = getenv("TERM");
 792 #endif
 793     /* Force rebind of TAB to insert-tab */
 794     rl_bind_key('\t', rl_insert);
 795     /* Bind both ESC-TAB and ESC-ESC to the completion function */
 796     rl_bind_key_in_map ('\t', rl_complete, emacs_meta_keymap);
 797     rl_bind_key_in_map ('\033', rl_complete, emacs_meta_keymap);
 798     /* Set our hook functions */
 799     rl_startup_hook = (Function *)on_startup_hook;
 800 #ifdef HAVE_RL_PRE_INPUT_HOOK
 801     rl_pre_input_hook = (Function *)on_pre_input_hook;
 802 #endif
 803     /* Set our completion function */
 804     rl_attempted_completion_function = (CPPFunction *)flex_complete;
 805     /* Set Python word break characters */
 806     rl_completer_word_break_characters =
 807         strdup(" \t\n`~!@#$%^&*()-=+[{]}\\|;:'\",<>/?");
 808         /* All nonalphanums except '.' */
 809
 810     begidx = PyLong_FromLong(0L);
 811     endidx = PyLong_FromLong(0L);
 812     /* Initialize (allows .inputrc to override)
 813      *
 814      * XXX: A bug in the readline-2.2 library causes a memory leak
 815      * inside this function.  Nothing we can do about it.
 816      */
 817     rl_initialize();
 818
 819     RESTORE_LOCALE(saved_locale)
 820 }
 821
 822 /* Wrapper around GNU readline that handles signals differently. */
 823
 824
 825 #if defined(HAVE_RL_CALLBACK) && defined(HAVE_SELECT)
 826
 827 static  char *completed_input_string;
 828 static void
 829 rlhandler(char *text)
 830 {
 831     completed_input_string = text;
 832     rl_callback_handler_remove();
 833 }
 834
 835 extern PyThreadState* _PyOS_ReadlineTState;
 836
 837 static char *
 838 readline_until_enter_or_signal(char *prompt, int *signal)
 839 {
 840     char * not_done_reading = "";
 841     fd_set selectset;
 842
 843     *signal = 0;
 844 #ifdef HAVE_RL_CATCH_SIGNAL
 845     rl_catch_signals = 0;
 846 #endif
 847
 848     rl_callback_handler_install (prompt, rlhandler);
 849     FD_ZERO(&selectset);
 850
 851     completed_input_string = not_done_reading;
 852
 853     while (completed_input_string == not_done_reading) {
 854         int has_input = 0;
 855
 856         while (!has_input)
 857         {               struct timeval timeout = {0, 100000}; /* 0.1 seconds */
 858
 859             /* [Bug #1552726] Only limit the pause if an input hook has been
 860                defined.  */
 861             struct timeval *timeoutp = NULL;
 862             if (PyOS_InputHook)
 863                 timeoutp = &timeout;
 864             FD_SET(fileno(rl_instream), &selectset);
 865             /* select resets selectset if no input was available */
 866             has_input = select(fileno(rl_instream) + 1, &selectset,
 867                                NULL, NULL, timeoutp);
 868             if(PyOS_InputHook) PyOS_InputHook();
 869         }
 870
 871         if(has_input > 0) {
 872             rl_callback_read_char();
 873         }
 874         else if (errno == EINTR) {
 875             int s;
 876 #ifdef WITH_THREAD
 877             PyEval_RestoreThread(_PyOS_ReadlineTState);
 878 #endif
 879             s = PyErr_CheckSignals();
 880 #ifdef WITH_THREAD
 881             PyEval_SaveThread();
 882 #endif
 883             if (s < 0) {
 884                 rl_free_line_state();
 885                 rl_cleanup_after_signal();
 886                 rl_callback_handler_remove();
 887                 *signal = 1;
 888                 completed_input_string = NULL;
 889             }
 890         }
 891     }
 892
 893     return completed_input_string;
 894 }
 895
 896
 897 #else
 898
 899 /* Interrupt handler */
 900
 901 static jmp_buf jbuf;
 902
 903 /* ARGSUSED */
 904 static void
 905 onintr(int sig)
 906 {
 907     longjmp(jbuf, 1);
 908 }
 909
 910
 911 static char *
 912 readline_until_enter_or_signal(char *prompt, int *signal)
 913 {
 914     PyOS_sighandler_t old_inthandler;
 915     char *p;
 916
 917     *signal = 0;
 918
 919     old_inthandler = PyOS_setsig(SIGINT, onintr);
 920     if (setjmp(jbuf)) {
 921 #ifdef HAVE_SIGRELSE
 922         /* This seems necessary on SunOS 4.1 (Rasmus Hahn) */
 923         sigrelse(SIGINT);
 924 #endif
 925         PyOS_setsig(SIGINT, old_inthandler);
 926         *signal = 1;
 927         return NULL;
 928     }
 929     rl_event_hook = PyOS_InputHook;
 930     p = readline(prompt);
 931     PyOS_setsig(SIGINT, old_inthandler);
 932
 933     return p;
 934 }
 935 #endif /*defined(HAVE_RL_CALLBACK) && defined(HAVE_SELECT) */
 936
 937
 938 static char *
 939 call_readline(FILE *sys_stdin, FILE *sys_stdout, char *prompt)
 940 {
 941     size_t n;
 942     char *p, *q;
 943     int signal;
 944
 945 #ifdef SAVE_LOCALE
 946     char *saved_locale = strdup(setlocale(LC_CTYPE, NULL));
 947     if (!saved_locale)
 948         Py_FatalError("not enough memory to save locale");
 949     setlocale(LC_CTYPE, "");
 950 #endif
 951
 952     if (sys_stdin != rl_instream || sys_stdout != rl_outstream) {
 953         rl_instream = sys_stdin;
 954         rl_outstream = sys_stdout;
 955 #ifdef HAVE_RL_COMPLETION_APPEND_CHARACTER
 956         rl_prep_terminal (1);
 957 #endif
 958     }
 959
 960     p = readline_until_enter_or_signal(prompt, &signal);
 961
 962     /* we got an interrupt signal */
 963     if (signal) {
 964         RESTORE_LOCALE(saved_locale)
 965         return NULL;
 966     }
 967
 968     /* We got an EOF, return a empty string. */
 969     if (p == NULL) {
 970         p = PyMem_Malloc(1);
 971         if (p != NULL)
 972             *p = '\0';
 973         RESTORE_LOCALE(saved_locale)
 974         return p;
 975     }
 976
 977     /* we have a valid line */
 978     n = strlen(p);
 979     if (n > 0) {
 980         char *line;
 981         HISTORY_STATE *state = history_get_history_state();
 982         if (state->length > 0)
 983             line = history_get(state->length)->line;
 984         else
 985             line = "";
 986         if (strcmp(p, line))
 987             add_history(p);
 988         /* the history docs don't say so, but the address of state
 989            changes each time history_get_history_state is called
 990            which makes me think it's freshly malloc'd memory...
 991            on the other hand, the address of the last line stays the
 992            same as long as history isn't extended, so it appears to
 993            be malloc'd but managed by the history package... */
 994         free(state);
 995     }
 996     /* Copy the malloc'ed buffer into a PyMem_Malloc'ed one and
 997        release the original. */
 998     q = p;
 999     p = PyMem_Malloc(n+2);
1000     if (p != NULL) {
1001         strncpy(p, q, n);
1002         p[n] = '\n';
1003         p[n+1] = '\0';
1004     }
1005     free(q);
1006     RESTORE_LOCALE(saved_locale)
1007     return p;
1008 }
1009
1010
1011 /* Initialize the module */
1012
1013 PyDoc_STRVAR(doc_module,
1014 "Importing this module enables command line editing using GNU readline.");
1015
1016
1017 static struct PyModuleDef readlinemodule = {
1018     PyModuleDef_HEAD_INIT,
1019     "readline",
1020     doc_module,
1021     -1,
1022     readline_methods,
1023     NULL,
1024     NULL,
1025     NULL,
1026     NULL
1027 };
1028
1029 PyMODINIT_FUNC
1030 PyInit_readline(void)
1031 {
1032     PyObject *m;
1033
1034     m = PyModule_Create(&readlinemodule);
1035     if (m == NULL)
1036         return NULL;
1037
1038     PyOS_ReadlineFunctionPointer = call_readline;
1039     setup_readline();
1040     return m;
1041 }