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 #ifdef __APPLE__
  46 /*
  47  * It is possible to link the readline module to the readline
  48  * emulation library of editline/libedit.
  49  *
  50  * On OSX this emulation library is not 100% API compatible
  51  * with the "real" readline and cannot be detected at compile-time,
  52  * hence we use a runtime check to detect if we're using libedit
  53  *
  54  * Currently there is one know API incompatibility:
  55  * - 'get_history' has a 1-based index with GNU readline, and a 0-based
  56  *   index with libedit's emulation.
  57  * - Note that replace_history and remove_history use a 0-based index
  58  *   with both implementation.
  59  */
  60 static int using_libedit_emulation = 0;
  61 static const char libedit_version_tag[] = "EditLine wrapper";
  62 #endif /* __APPLE__ */
  63
  64 static void
  65 on_completion_display_matches_hook(char **matches,
  66                                    int num_matches, int max_length);
  67
  68
  69 /* Exported function to send one line to readline's init file parser */
  70
  71 static PyObject *
  72 parse_and_bind(PyObject *self, PyObject *args)
  73 {
  74         char *s, *copy;
  75         if (!PyArg_ParseTuple(args, "s:parse_and_bind", &s))
  76                 return NULL;
  77         /* Make a copy -- rl_parse_and_bind() modifies its argument */
  78         /* Bernard Herzog */
  79         copy = malloc(1 + strlen(s));
  80         if (copy == NULL)
  81                 return PyErr_NoMemory();
  82         strcpy(copy, s);
  83         rl_parse_and_bind(copy);
  84         free(copy); /* Free the copy */
  85         Py_RETURN_NONE;
  86 }
  87
  88 PyDoc_STRVAR(doc_parse_and_bind,
  89 "parse_and_bind(string) -> None\n\
  90 Parse and execute single line of a readline init file.");
  91
  92
  93 /* Exported function to parse a readline init file */
  94
  95 static PyObject *
  96 read_init_file(PyObject *self, PyObject *args)
  97 {
  98         char *s = NULL;
  99         if (!PyArg_ParseTuple(args, "|z:read_init_file", &s))
 100                 return NULL;
 101         errno = rl_read_init_file(s);
 102         if (errno)
 103                 return PyErr_SetFromErrno(PyExc_IOError);
 104         Py_RETURN_NONE;
 105 }
 106
 107 PyDoc_STRVAR(doc_read_init_file,
 108 "read_init_file([filename]) -> None\n\
 109 Parse a readline initialization file.\n\
 110 The default filename is the last filename used.");
 111
 112
 113 /* Exported function to load a readline history file */
 114
 115 static PyObject *
 116 read_history_file(PyObject *self, PyObject *args)
 117 {
 118         char *s = NULL;
 119         if (!PyArg_ParseTuple(args, "|z:read_history_file", &s))
 120                 return NULL;
 121         errno = read_history(s);
 122         if (errno)
 123                 return PyErr_SetFromErrno(PyExc_IOError);
 124         Py_RETURN_NONE;
 125 }
 126
 127 static int _history_length = -1; /* do not truncate history by default */
 128 PyDoc_STRVAR(doc_read_history_file,
 129 "read_history_file([filename]) -> None\n\
 130 Load a readline history file.\n\
 131 The default filename is ~/.history.");
 132
 133
 134 /* Exported function to save a readline history file */
 135
 136 static PyObject *
 137 write_history_file(PyObject *self, PyObject *args)
 138 {
 139         char *s = NULL;
 140         if (!PyArg_ParseTuple(args, "|z:write_history_file", &s))
 141                 return NULL;
 142         errno = write_history(s);
 143         if (!errno && _history_length >= 0)
 144                 history_truncate_file(s, _history_length);
 145         if (errno)
 146                 return PyErr_SetFromErrno(PyExc_IOError);
 147         Py_RETURN_NONE;
 148 }
 149
 150 PyDoc_STRVAR(doc_write_history_file,
 151 "write_history_file([filename]) -> None\n\
 152 Save a readline history file.\n\
 153 The default filename is ~/.history.");
 154
 155
 156 /* Set history length */
 157
 158 static PyObject*
 159 set_history_length(PyObject *self, PyObject *args)
 160 {
 161         int length = _history_length;
 162         if (!PyArg_ParseTuple(args, "i:set_history_length", &length))
 163                 return NULL;
 164         _history_length = length;
 165         Py_RETURN_NONE;
 166 }
 167
 168 PyDoc_STRVAR(set_history_length_doc,
 169 "set_history_length(length) -> None\n\
 170 set the maximal number of items which will be written to\n\
 171 the history file. A negative length is used to inhibit\n\
 172 history truncation.");
 173
 174
 175 /* Get history length */
 176
 177 static PyObject*
 178 get_history_length(PyObject *self, PyObject *noarg)
 179 {
 180         return PyInt_FromLong(_history_length);
 181 }
 182
 183 PyDoc_STRVAR(get_history_length_doc,
 184 "get_history_length() -> int\n\
 185 return the maximum number of items that will be written to\n\
 186 the history file.");
 187
 188
 189 /* Generic hook function setter */
 190
 191 static PyObject *
 192 set_hook(const char *funcname, PyObject **hook_var, PyObject *args)
 193 {
 194         PyObject *function = Py_None;
 195         char buf[80];
 196         PyOS_snprintf(buf, sizeof(buf), "|O:set_%.50s", funcname);
 197         if (!PyArg_ParseTuple(args, buf, &function))
 198                 return NULL;
 199         if (function == Py_None) {
 200                 Py_XDECREF(*hook_var);
 201                 *hook_var = NULL;
 202         }
 203         else if (PyCallable_Check(function)) {
 204                 PyObject *tmp = *hook_var;
 205                 Py_INCREF(function);
 206                 *hook_var = function;
 207                 Py_XDECREF(tmp);
 208         }
 209         else {
 210                 PyOS_snprintf(buf, sizeof(buf),
 211                               "set_%.50s(func): argument not callable",
 212                               funcname);
 213                 PyErr_SetString(PyExc_TypeError, buf);
 214                 return NULL;
 215         }
 216         Py_RETURN_NONE;
 217 }
 218
 219
 220 /* Exported functions to specify hook functions in Python */
 221
 222 static PyObject *completion_display_matches_hook = NULL;
 223 static PyObject *startup_hook = NULL;
 224
 225 #ifdef HAVE_RL_PRE_INPUT_HOOK
 226 static PyObject *pre_input_hook = NULL;
 227 #endif
 228
 229 static PyObject *
 230 set_completion_display_matches_hook(PyObject *self, PyObject *args)
 231 {
 232         PyObject *result = set_hook("completion_display_matches_hook",
 233                         &completion_display_matches_hook, args);
 234 #ifdef HAVE_RL_COMPLETION_DISPLAY_MATCHES_HOOK
 235         /* We cannot set this hook globally, since it replaces the
 236            default completion display. */
 237         rl_completion_display_matches_hook =
 238                 completion_display_matches_hook ?
 239 #if defined(_RL_FUNCTION_TYPEDEF)
 240                 (rl_compdisp_func_t *)on_completion_display_matches_hook : 0;
 241 #else
 242                 (VFunction *)on_completion_display_matches_hook : 0;
 243 #endif
 244 #endif
 245         return result;
 246
 247 }
 248
 249 PyDoc_STRVAR(doc_set_completion_display_matches_hook,
 250 "set_completion_display_matches_hook([function]) -> None\n\
 251 Set or remove the completion display function.\n\
 252 The function is called as\n\
 253   function(substitution, [matches], longest_match_length)\n\
 254 once each time matches need to be displayed.");
 255
 256 static PyObject *
 257 set_startup_hook(PyObject *self, PyObject *args)
 258 {
 259         return set_hook("startup_hook", &startup_hook, args);
 260 }
 261
 262 PyDoc_STRVAR(doc_set_startup_hook,
 263 "set_startup_hook([function]) -> None\n\
 264 Set or remove the startup_hook function.\n\
 265 The function is called with no arguments just\n\
 266 before readline prints the first prompt.");
 267
 268
 269 #ifdef HAVE_RL_PRE_INPUT_HOOK
 270
 271 /* Set pre-input hook */
 272
 273 static PyObject *
 274 set_pre_input_hook(PyObject *self, PyObject *args)
 275 {
 276         return set_hook("pre_input_hook", &pre_input_hook, args);
 277 }
 278
 279 PyDoc_STRVAR(doc_set_pre_input_hook,
 280 "set_pre_input_hook([function]) -> None\n\
 281 Set or remove the pre_input_hook function.\n\
 282 The function is called with no arguments after the first prompt\n\
 283 has been printed and just before readline starts reading input\n\
 284 characters.");
 285
 286 #endif
 287
 288
 289 /* Exported function to specify a word completer in Python */
 290
 291 static PyObject *completer = NULL;
 292
 293 static PyObject *begidx = NULL;
 294 static PyObject *endidx = NULL;
 295
 296
 297 /* Get the completion type for the scope of the tab-completion */
 298 static PyObject *
 299 get_completion_type(PyObject *self, PyObject *noarg)
 300 {
 301   return PyInt_FromLong(rl_completion_type);
 302 }
 303
 304 PyDoc_STRVAR(doc_get_completion_type,
 305 "get_completion_type() -> int\n\
 306 Get the type of completion being attempted.");
 307
 308
 309 /* Get the beginning index for the scope of the tab-completion */
 310
 311 static PyObject *
 312 get_begidx(PyObject *self, PyObject *noarg)
 313 {
 314         Py_INCREF(begidx);
 315         return begidx;
 316 }
 317
 318 PyDoc_STRVAR(doc_get_begidx,
 319 "get_begidx() -> int\n\
 320 get the beginning index of the readline tab-completion scope");
 321
 322
 323 /* Get the ending index for the scope of the tab-completion */
 324
 325 static PyObject *
 326 get_endidx(PyObject *self, PyObject *noarg)
 327 {
 328         Py_INCREF(endidx);
 329         return endidx;
 330 }
 331
 332 PyDoc_STRVAR(doc_get_endidx,
 333 "get_endidx() -> int\n\
 334 get the ending index of the readline tab-completion scope");
 335
 336
 337 /* Set the tab-completion word-delimiters that readline uses */
 338
 339 static PyObject *
 340 set_completer_delims(PyObject *self, PyObject *args)
 341 {
 342         char *break_chars;
 343
 344         if(!PyArg_ParseTuple(args, "s:set_completer_delims", &break_chars)) {
 345                 return NULL;
 346         }
 347         free((void*)rl_completer_word_break_characters);
 348         rl_completer_word_break_characters = strdup(break_chars);
 349         Py_RETURN_NONE;
 350 }
 351
 352 PyDoc_STRVAR(doc_set_completer_delims,
 353 "set_completer_delims(string) -> None\n\
 354 set the readline word delimiters for tab-completion");
 355
 356 static PyObject *
 357 py_remove_history(PyObject *self, PyObject *args)
 358 {
 359         int entry_number;
 360         HIST_ENTRY *entry;
 361
 362         if (!PyArg_ParseTuple(args, "i:remove_history", &entry_number))
 363                 return NULL;
 364         if (entry_number < 0) {
 365                 PyErr_SetString(PyExc_ValueError,
 366                                 "History index cannot be negative");
 367                 return NULL;
 368         }
 369         entry = remove_history(entry_number);
 370         if (!entry) {
 371                 PyErr_Format(PyExc_ValueError,
 372                              "No history item at position %d",
 373                               entry_number);
 374                 return NULL;
 375         }
 376         /* free memory allocated for the history entry */
 377         if (entry->line)
 378                 free(entry->line);
 379         if (entry->data)
 380                 free(entry->data);
 381         free(entry);
 382
 383         Py_RETURN_NONE;
 384 }
 385
 386 PyDoc_STRVAR(doc_remove_history,
 387 "remove_history_item(pos) -> None\n\
 388 remove history item given by its position");
 389
 390 static PyObject *
 391 py_replace_history(PyObject *self, PyObject *args)
 392 {
 393         int entry_number;
 394         char *line;
 395         HIST_ENTRY *old_entry;
 396
 397         if (!PyArg_ParseTuple(args, "is:replace_history", &entry_number,
 398                               &line)) {
 399                 return NULL;
 400         }
 401         if (entry_number < 0) {
 402                 PyErr_SetString(PyExc_ValueError,
 403                                 "History index cannot be negative");
 404                 return NULL;
 405         }
 406         old_entry = replace_history_entry(entry_number, line, (void *)NULL);
 407         if (!old_entry) {
 408                 PyErr_Format(PyExc_ValueError,
 409                              "No history item at position %d",
 410                              entry_number);
 411                 return NULL;
 412         }
 413         /* free memory allocated for the old history entry */
 414         if (old_entry->line)
 415             free(old_entry->line);
 416         if (old_entry->data)
 417             free(old_entry->data);
 418         free(old_entry);
 419
 420         Py_RETURN_NONE;
 421 }
 422
 423 PyDoc_STRVAR(doc_replace_history,
 424 "replace_history_item(pos, line) -> None\n\
 425 replaces history item given by its position with contents of line");
 426
 427 /* Add a line to the history buffer */
 428
 429 static PyObject *
 430 py_add_history(PyObject *self, PyObject *args)
 431 {
 432         char *line;
 433
 434         if(!PyArg_ParseTuple(args, "s:add_history", &line)) {
 435                 return NULL;
 436         }
 437         add_history(line);
 438         Py_RETURN_NONE;
 439 }
 440
 441 PyDoc_STRVAR(doc_add_history,
 442 "add_history(string) -> None\n\
 443 add a line to the history buffer");
 444
 445
 446 /* Get the tab-completion word-delimiters that readline uses */
 447
 448 static PyObject *
 449 get_completer_delims(PyObject *self, PyObject *noarg)
 450 {
 451         return PyString_FromString(rl_completer_word_break_characters);
 452 }
 453
 454 PyDoc_STRVAR(doc_get_completer_delims,
 455 "get_completer_delims() -> string\n\
 456 get the readline word delimiters for tab-completion");
 457
 458
 459 /* Set the completer function */
 460
 461 static PyObject *
 462 set_completer(PyObject *self, PyObject *args)
 463 {
 464         return set_hook("completer", &completer, args);
 465 }
 466
 467 PyDoc_STRVAR(doc_set_completer,
 468 "set_completer([function]) -> None\n\
 469 Set or remove the completer function.\n\
 470 The function is called as function(text, state),\n\
 471 for state in 0, 1, 2, ..., until it returns a non-string.\n\
 472 It should return the next possible completion starting with 'text'.");
 473
 474
 475 static PyObject *
 476 get_completer(PyObject *self, PyObject *noargs)
 477 {
 478         if (completer == NULL) {
 479                 Py_RETURN_NONE;
 480         }
 481         Py_INCREF(completer);
 482         return completer;
 483 }
 484
 485 PyDoc_STRVAR(doc_get_completer,
 486 "get_completer() -> function\n\
 487 \n\
 488 Returns current completer function.");
 489
 490 /* Exported function to get any element of history */
 491
 492 static PyObject *
 493 get_history_item(PyObject *self, PyObject *args)
 494 {
 495         int idx = 0;
 496         HIST_ENTRY *hist_ent;
 497
 498         if (!PyArg_ParseTuple(args, "i:index", &idx))
 499                 return NULL;
 500 #ifdef  __APPLE__
 501         if (using_libedit_emulation) {
 502                 /* Libedit emulation uses 0-based indexes,
 503                  * the real one uses 1-based indexes,
 504                  * adjust the index to ensure that Python
 505                  * code doesn't have to worry about the
 506                  * difference.
 507                  */
 508                 HISTORY_STATE *hist_st;
 509                 hist_st = history_get_history_state();
 510
 511                 idx --;
 512
 513                 /*
 514                  * Apple's readline emulation crashes when
 515                  * the index is out of range, therefore
 516                  * test for that and fail gracefully.
 517                  */
 518                 if (idx < 0 || idx >= hist_st->length) {
 519                         Py_RETURN_NONE;
 520                 }
 521         }
 522 #endif /* __APPLE__ */
 523         if ((hist_ent = history_get(idx)))
 524                 return PyString_FromString(hist_ent->line);
 525         else {
 526                 Py_RETURN_NONE;
 527         }
 528 }
 529
 530 PyDoc_STRVAR(doc_get_history_item,
 531 "get_history_item() -> string\n\
 532 return the current contents of history item at index.");
 533
 534
 535 /* Exported function to get current length of history */
 536
 537 static PyObject *
 538 get_current_history_length(PyObject *self, PyObject *noarg)
 539 {
 540         HISTORY_STATE *hist_st;
 541
 542         hist_st = history_get_history_state();
 543         return PyInt_FromLong(hist_st ? (long) hist_st->length : (long) 0);
 544 }
 545
 546 PyDoc_STRVAR(doc_get_current_history_length,
 547 "get_current_history_length() -> integer\n\
 548 return the current (not the maximum) length of history.");
 549
 550
 551 /* Exported function to read the current line buffer */
 552
 553 static PyObject *
 554 get_line_buffer(PyObject *self, PyObject *noarg)
 555 {
 556         return PyString_FromString(rl_line_buffer);
 557 }
 558
 559 PyDoc_STRVAR(doc_get_line_buffer,
 560 "get_line_buffer() -> string\n\
 561 return the current contents of the line buffer.");
 562
 563
 564 #ifdef HAVE_RL_COMPLETION_APPEND_CHARACTER
 565
 566 /* Exported function to clear the current history */
 567
 568 static PyObject *
 569 py_clear_history(PyObject *self, PyObject *noarg)
 570 {
 571         clear_history();
 572         Py_RETURN_NONE;
 573 }
 574
 575 PyDoc_STRVAR(doc_clear_history,
 576 "clear_history() -> None\n\
 577 Clear the current readline history.");
 578 #endif
 579
 580
 581 /* Exported function to insert text into the line buffer */
 582
 583 static PyObject *
 584 insert_text(PyObject *self, PyObject *args)
 585 {
 586         char *s;
 587         if (!PyArg_ParseTuple(args, "s:insert_text", &s))
 588                 return NULL;
 589         rl_insert_text(s);
 590         Py_RETURN_NONE;
 591 }
 592
 593 PyDoc_STRVAR(doc_insert_text,
 594 "insert_text(string) -> None\n\
 595 Insert text into the command line.");
 596
 597
 598 /* Redisplay the line buffer */
 599
 600 static PyObject *
 601 redisplay(PyObject *self, PyObject *noarg)
 602 {
 603         rl_redisplay();
 604         Py_RETURN_NONE;
 605 }
 606
 607 PyDoc_STRVAR(doc_redisplay,
 608 "redisplay() -> None\n\
 609 Change what's displayed on the screen to reflect the current\n\
 610 contents of the line buffer.");
 611
 612
 613 /* Table of functions exported by the module */
 614
 615 static struct PyMethodDef readline_methods[] =
 616 {
 617         {"parse_and_bind", parse_and_bind, METH_VARARGS, doc_parse_and_bind},
 618         {"get_line_buffer", get_line_buffer, METH_NOARGS, doc_get_line_buffer},
 619         {"insert_text", insert_text, METH_VARARGS, doc_insert_text},
 620         {"redisplay", redisplay, METH_NOARGS, doc_redisplay},
 621         {"read_init_file", read_init_file, METH_VARARGS, doc_read_init_file},
 622         {"read_history_file", read_history_file,
 623          METH_VARARGS, doc_read_history_file},
 624         {"write_history_file", write_history_file,
 625          METH_VARARGS, doc_write_history_file},
 626         {"get_history_item", get_history_item,
 627          METH_VARARGS, doc_get_history_item},
 628         {"get_current_history_length", (PyCFunction)get_current_history_length,
 629          METH_NOARGS, doc_get_current_history_length},
 630         {"set_history_length", set_history_length,
 631          METH_VARARGS, set_history_length_doc},
 632         {"get_history_length", get_history_length,
 633          METH_NOARGS, get_history_length_doc},
 634         {"set_completer", set_completer, METH_VARARGS, doc_set_completer},
 635         {"get_completer", get_completer, METH_NOARGS, doc_get_completer},
 636         {"get_completion_type", get_completion_type,
 637          METH_NOARGS, doc_get_completion_type},
 638         {"get_begidx", get_begidx, METH_NOARGS, doc_get_begidx},
 639         {"get_endidx", get_endidx, METH_NOARGS, doc_get_endidx},
 640
 641         {"set_completer_delims", set_completer_delims,
 642          METH_VARARGS, doc_set_completer_delims},
 643         {"add_history", py_add_history, METH_VARARGS, doc_add_history},
 644         {"remove_history_item", py_remove_history, METH_VARARGS, doc_remove_history},
 645         {"replace_history_item", py_replace_history, METH_VARARGS, doc_replace_history},
 646         {"get_completer_delims", get_completer_delims,
 647          METH_NOARGS, doc_get_completer_delims},
 648
 649         {"set_completion_display_matches_hook", set_completion_display_matches_hook,
 650          METH_VARARGS, doc_set_completion_display_matches_hook},
 651         {"set_startup_hook", set_startup_hook,
 652          METH_VARARGS, doc_set_startup_hook},
 653 #ifdef HAVE_RL_PRE_INPUT_HOOK
 654         {"set_pre_input_hook", set_pre_input_hook,
 655          METH_VARARGS, doc_set_pre_input_hook},
 656 #endif
 657 #ifdef HAVE_RL_COMPLETION_APPEND_CHARACTER
 658         {"clear_history", py_clear_history, METH_NOARGS, doc_clear_history},
 659 #endif
 660         {0, 0}
 661 };
 662
 663
 664 /* C function to call the Python hooks. */
 665
 666 static int
 667 on_hook(PyObject *func)
 668 {
 669         int result = 0;
 670         if (func != NULL) {
 671                 PyObject *r;
 672 #ifdef WITH_THREAD
 673                 PyGILState_STATE gilstate = PyGILState_Ensure();
 674 #endif
 675                 r = PyObject_CallFunction(func, NULL);
 676                 if (r == NULL)
 677                         goto error;
 678                 if (r == Py_None)
 679                         result = 0;
 680                 else {
 681                         result = PyInt_AsLong(r);
 682                         if (result == -1 && PyErr_Occurred())
 683                                 goto error;
 684                 }
 685                 Py_DECREF(r);
 686                 goto done;
 687           error:
 688                 PyErr_Clear();
 689                 Py_XDECREF(r);
 690           done:
 691 #ifdef WITH_THREAD
 692                 PyGILState_Release(gilstate);
 693 #endif
 694                 return result;
 695         }
 696         return result;
 697 }
 698
 699 static int
 700 on_startup_hook(void)
 701 {
 702         return on_hook(startup_hook);
 703 }
 704
 705 #ifdef HAVE_RL_PRE_INPUT_HOOK
 706 static int
 707 on_pre_input_hook(void)
 708 {
 709         return on_hook(pre_input_hook);
 710 }
 711 #endif
 712
 713
 714 /* C function to call the Python completion_display_matches */
 715
 716 static void
 717 on_completion_display_matches_hook(char **matches,
 718                                    int num_matches, int max_length)
 719 {
 720         int i;
 721         PyObject *m=NULL, *s=NULL, *r=NULL;
 722 #ifdef WITH_THREAD
 723         PyGILState_STATE gilstate = PyGILState_Ensure();
 724 #endif
 725         m = PyList_New(num_matches);
 726         if (m == NULL)
 727                 goto error;
 728         for (i = 0; i < num_matches; i++) {
 729                 s = PyString_FromString(matches[i+1]);
 730                 if (s == NULL)
 731                         goto error;
 732                 if (PyList_SetItem(m, i, s) == -1)
 733                         goto error;
 734         }
 735
 736         r = PyObject_CallFunction(completion_display_matches_hook,
 737                                   "sOi", matches[0], m, max_length);
 738
 739         Py_DECREF(m); m=NULL;
 740
 741         if (r == NULL ||
 742             (r != Py_None && PyInt_AsLong(r) == -1 && PyErr_Occurred())) {
 743                 goto error;
 744         }
 745         Py_XDECREF(r); r=NULL;
 746
 747         if (0) {
 748         error:
 749                 PyErr_Clear();
 750                 Py_XDECREF(m);
 751                 Py_XDECREF(r);
 752         }
 753 #ifdef WITH_THREAD
 754         PyGILState_Release(gilstate);
 755 #endif
 756 }
 757
 758
 759 /* C function to call the Python completer. */
 760
 761 static char *
 762 on_completion(const char *text, int state)
 763 {
 764         char *result = NULL;
 765         if (completer != NULL) {
 766                 PyObject *r;
 767 #ifdef WITH_THREAD
 768                 PyGILState_STATE gilstate = PyGILState_Ensure();
 769 #endif
 770                 rl_attempted_completion_over = 1;
 771                 r = PyObject_CallFunction(completer, "si", text, state);
 772                 if (r == NULL)
 773                         goto error;
 774                 if (r == Py_None) {
 775                         result = NULL;
 776                 }
 777                 else {
 778                         char *s = PyString_AsString(r);
 779                         if (s == NULL)
 780                                 goto error;
 781                         result = strdup(s);
 782                 }
 783                 Py_DECREF(r);
 784                 goto done;
 785           error:
 786                 PyErr_Clear();
 787                 Py_XDECREF(r);
 788           done:
 789 #ifdef WITH_THREAD
 790                 PyGILState_Release(gilstate);
 791 #endif
 792                 return result;
 793         }
 794         return result;
 795 }
 796
 797
 798 /* A more flexible constructor that saves the "begidx" and "endidx"
 799  * before calling the normal completer */
 800
 801 static char **
 802 flex_complete(char *text, int start, int end)
 803 {
 804 #ifdef HAVE_RL_COMPLETION_APPEND_CHARACTER
 805         rl_completion_append_character ='\0';
 806         rl_completion_suppress_append = 0;
 807 #endif
 808         Py_XDECREF(begidx);
 809         Py_XDECREF(endidx);
 810         begidx = PyInt_FromLong((long) start);
 811         endidx = PyInt_FromLong((long) end);
 812         return completion_matches(text, *on_completion);
 813 }
 814
 815
 816 /* Helper to initialize GNU readline properly. */
 817
 818 static void
 819 setup_readline(void)
 820 {
 821 #ifdef SAVE_LOCALE
 822         char *saved_locale = strdup(setlocale(LC_CTYPE, NULL));
 823         if (!saved_locale)
 824                 Py_FatalError("not enough memory to save locale");
 825 #endif
 826
 827         using_history();
 828
 829         rl_readline_name = "python";
 830 #if defined(PYOS_OS2) && defined(PYCC_GCC)
 831         /* Allow $if term= in .inputrc to work */
 832         rl_terminal_name = getenv("TERM");
 833 #endif
 834         /* Force rebind of TAB to insert-tab */
 835         rl_bind_key('\t', rl_insert);
 836         /* Bind both ESC-TAB and ESC-ESC to the completion function */
 837         rl_bind_key_in_map ('\t', rl_complete, emacs_meta_keymap);
 838         rl_bind_key_in_map ('\033', rl_complete, emacs_meta_keymap);
 839         /* Set our hook functions */
 840         rl_startup_hook = (Function *)on_startup_hook;
 841 #ifdef HAVE_RL_PRE_INPUT_HOOK
 842         rl_pre_input_hook = (Function *)on_pre_input_hook;
 843 #endif
 844         /* Set our completion function */
 845         rl_attempted_completion_function = (CPPFunction *)flex_complete;
 846         /* Set Python word break characters */
 847         rl_completer_word_break_characters =
 848                 strdup(" \t\n`~!@#$%^&*()-=+[{]}\\|;:'\",<>/?");
 849                 /* All nonalphanums except '.' */
 850
 851         begidx = PyInt_FromLong(0L);
 852         endidx = PyInt_FromLong(0L);
 853         /* Initialize (allows .inputrc to override)
 854          *
 855          * XXX: A bug in the readline-2.2 library causes a memory leak
 856          * inside this function.  Nothing we can do about it.
 857          */
 858         rl_initialize();
 859
 860         RESTORE_LOCALE(saved_locale)
 861 }
 862
 863 /* Wrapper around GNU readline that handles signals differently. */
 864
 865
 866 #if defined(HAVE_RL_CALLBACK) && defined(HAVE_SELECT)
 867
 868 static  char *completed_input_string;
 869 static void
 870 rlhandler(char *text)
 871 {
 872         completed_input_string = text;
 873         rl_callback_handler_remove();
 874 }
 875
 876 extern PyThreadState* _PyOS_ReadlineTState;
 877
 878 static char *
 879 readline_until_enter_or_signal(char *prompt, int *signal)
 880 {
 881         char * not_done_reading = "";
 882         fd_set selectset;
 883
 884         *signal = 0;
 885 #ifdef HAVE_RL_CATCH_SIGNAL
 886         rl_catch_signals = 0;
 887 #endif
 888
 889         rl_callback_handler_install (prompt, rlhandler);
 890         FD_ZERO(&selectset);
 891
 892         completed_input_string = not_done_reading;
 893
 894         while (completed_input_string == not_done_reading) {
 895                 int has_input = 0;
 896
 897                 while (!has_input)
 898                 {       struct timeval timeout = {0, 100000}; /* 0.1 seconds */
 899
 900                         /* [Bug #1552726] Only limit the pause if an input hook has been
 901                            defined.  */
 902                         struct timeval *timeoutp = NULL;
 903                         if (PyOS_InputHook)
 904                                 timeoutp = &timeout;
 905                         FD_SET(fileno(rl_instream), &selectset);
 906                         /* select resets selectset if no input was available */
 907                         has_input = select(fileno(rl_instream) + 1, &selectset,
 908                                            NULL, NULL, timeoutp);
 909                         if(PyOS_InputHook) PyOS_InputHook();
 910                 }
 911
 912                 if(has_input > 0) {
 913                         rl_callback_read_char();
 914                 }
 915                 else if (errno == EINTR) {
 916                         int s;
 917 #ifdef WITH_THREAD
 918                         PyEval_RestoreThread(_PyOS_ReadlineTState);
 919 #endif
 920                         s = PyErr_CheckSignals();
 921 #ifdef WITH_THREAD
 922                         PyEval_SaveThread();
 923 #endif
 924                         if (s < 0) {
 925                                 rl_free_line_state();
 926                                 rl_cleanup_after_signal();
 927                                 rl_callback_handler_remove();
 928                                 *signal = 1;
 929                                 completed_input_string = NULL;
 930                         }
 931                 }
 932         }
 933
 934         return completed_input_string;
 935 }
 936
 937
 938 #else
 939
 940 /* Interrupt handler */
 941
 942 static jmp_buf jbuf;
 943
 944 /* ARGSUSED */
 945 static void
 946 onintr(int sig)
 947 {
 948         longjmp(jbuf, 1);
 949 }
 950
 951
 952 static char *
 953 readline_until_enter_or_signal(char *prompt, int *signal)
 954 {
 955         PyOS_sighandler_t old_inthandler;
 956         char *p;
 957
 958         *signal = 0;
 959
 960         old_inthandler = PyOS_setsig(SIGINT, onintr);
 961         if (setjmp(jbuf)) {
 962 #ifdef HAVE_SIGRELSE
 963                 /* This seems necessary on SunOS 4.1 (Rasmus Hahn) */
 964                 sigrelse(SIGINT);
 965 #endif
 966                 PyOS_setsig(SIGINT, old_inthandler);
 967                 *signal = 1;
 968                 return NULL;
 969         }
 970         rl_event_hook = PyOS_InputHook;
 971         p = readline(prompt);
 972         PyOS_setsig(SIGINT, old_inthandler);
 973
 974     return p;
 975 }
 976 #endif /*defined(HAVE_RL_CALLBACK) && defined(HAVE_SELECT) */
 977
 978
 979 static char *
 980 call_readline(FILE *sys_stdin, FILE *sys_stdout, char *prompt)
 981 {
 982         size_t n;
 983         char *p, *q;
 984         int signal;
 985
 986 #ifdef SAVE_LOCALE
 987         char *saved_locale = strdup(setlocale(LC_CTYPE, NULL));
 988         if (!saved_locale)
 989                 Py_FatalError("not enough memory to save locale");
 990         setlocale(LC_CTYPE, "");
 991 #endif
 992
 993         if (sys_stdin != rl_instream || sys_stdout != rl_outstream) {
 994                 rl_instream = sys_stdin;
 995                 rl_outstream = sys_stdout;
 996 #ifdef HAVE_RL_COMPLETION_APPEND_CHARACTER
 997                 rl_prep_terminal (1);
 998 #endif
 999         }
1000
1001         p = readline_until_enter_or_signal(prompt, &signal);
1002
1003         /* we got an interrupt signal */
1004         if (signal) {
1005                 RESTORE_LOCALE(saved_locale)
1006                 return NULL;
1007         }
1008
1009         /* We got an EOF, return a empty string. */
1010         if (p == NULL) {
1011                 p = PyMem_Malloc(1);
1012                 if (p != NULL)
1013                         *p = '\0';
1014                 RESTORE_LOCALE(saved_locale)
1015                 return p;
1016         }
1017
1018         /* we have a valid line */
1019         n = strlen(p);
1020         if (n > 0) {
1021                 char *line;
1022                 HISTORY_STATE *state = history_get_history_state();
1023                 if (state->length > 0)
1024 #ifdef __APPLE__
1025                         if (using_libedit_emulation) {
1026                                 /*
1027                                  * Libedit's emulation uses 0-based indexes,
1028                                  * the real readline uses 1-based indexes.
1029                                  */
1030                                 line = history_get(state->length - 1)->line;
1031                         } else
1032 #endif /* __APPLE__ */
1033                         line = history_get(state->length)->line;
1034                 else
1035                         line = "";
1036                 if (strcmp(p, line))
1037                         add_history(p);
1038                 /* the history docs don't say so, but the address of state
1039                    changes each time history_get_history_state is called
1040                    which makes me think it's freshly malloc'd memory...
1041                    on the other hand, the address of the last line stays the
1042                    same as long as history isn't extended, so it appears to
1043                    be malloc'd but managed by the history package... */
1044                 free(state);
1045         }
1046         /* Copy the malloc'ed buffer into a PyMem_Malloc'ed one and
1047            release the original. */
1048         q = p;
1049         p = PyMem_Malloc(n+2);
1050         if (p != NULL) {
1051                 strncpy(p, q, n);
1052                 p[n] = '\n';
1053                 p[n+1] = '\0';
1054         }
1055         free(q);
1056         RESTORE_LOCALE(saved_locale)
1057         return p;
1058 }
1059
1060
1061 /* Initialize the module */
1062
1063 PyDoc_STRVAR(doc_module,
1064 "Importing this module enables command line editing using GNU readline.");
1065
1066 #ifdef __APPLE__
1067 PyDoc_STRVAR(doc_module_le,
1068 "Importing this module enables command line editing using libedit readline.");
1069 #endif /* __APPLE__ */
1070
1071 PyMODINIT_FUNC
1072 initreadline(void)
1073 {
1074         PyObject *m;
1075
1076 #ifdef __APPLE__
1077         if (strncmp(rl_library_version, libedit_version_tag, strlen(libedit_version_tag)) == 0) {
1078                 using_libedit_emulation = 1;
1079         }
1080
1081         if (using_libedit_emulation)
1082                 m = Py_InitModule4("readline", readline_methods, doc_module_le,
1083                            (PyObject *)NULL, PYTHON_API_VERSION);
1084         else
1085
1086 #endif /* __APPLE__ */
1087
1088         m = Py_InitModule4("readline", readline_methods, doc_module,
1089                            (PyObject *)NULL, PYTHON_API_VERSION);
1090         if (m == NULL)
1091                 return;
1092
1093
1094
1095         PyOS_ReadlineFunctionPointer = call_readline;
1096         setup_readline();
1097 }