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 #endif
 807 #ifdef HAVE_RL_COMPLETION_SUPPRESS_APPEND
 808         rl_completion_suppress_append = 0;
 809 #endif
 810         Py_XDECREF(begidx);
 811         Py_XDECREF(endidx);
 812         begidx = PyInt_FromLong((long) start);
 813         endidx = PyInt_FromLong((long) end);
 814         return completion_matches(text, *on_completion);
 815 }
 816
 817
 818 /* Helper to initialize GNU readline properly. */
 819
 820 static void
 821 setup_readline(void)
 822 {
 823 #ifdef SAVE_LOCALE
 824         char *saved_locale = strdup(setlocale(LC_CTYPE, NULL));
 825         if (!saved_locale)
 826                 Py_FatalError("not enough memory to save locale");
 827 #endif
 828
 829         using_history();
 830
 831         rl_readline_name = "python";
 832 #if defined(PYOS_OS2) && defined(PYCC_GCC)
 833         /* Allow $if term= in .inputrc to work */
 834         rl_terminal_name = getenv("TERM");
 835 #endif
 836         /* Force rebind of TAB to insert-tab */
 837         rl_bind_key('\t', rl_insert);
 838         /* Bind both ESC-TAB and ESC-ESC to the completion function */
 839         rl_bind_key_in_map ('\t', rl_complete, emacs_meta_keymap);
 840         rl_bind_key_in_map ('\033', rl_complete, emacs_meta_keymap);
 841         /* Set our hook functions */
 842         rl_startup_hook = (Function *)on_startup_hook;
 843 #ifdef HAVE_RL_PRE_INPUT_HOOK
 844         rl_pre_input_hook = (Function *)on_pre_input_hook;
 845 #endif
 846         /* Set our completion function */
 847         rl_attempted_completion_function = (CPPFunction *)flex_complete;
 848         /* Set Python word break characters */
 849         rl_completer_word_break_characters =
 850                 strdup(" \t\n`~!@#$%^&*()-=+[{]}\\|;:'\",<>/?");
 851                 /* All nonalphanums except '.' */
 852
 853         begidx = PyInt_FromLong(0L);
 854         endidx = PyInt_FromLong(0L);
 855         /* Initialize (allows .inputrc to override)
 856          *
 857          * XXX: A bug in the readline-2.2 library causes a memory leak
 858          * inside this function.  Nothing we can do about it.
 859          */
 860         rl_initialize();
 861
 862         RESTORE_LOCALE(saved_locale)
 863 }
 864
 865 /* Wrapper around GNU readline that handles signals differently. */
 866
 867
 868 #if defined(HAVE_RL_CALLBACK) && defined(HAVE_SELECT)
 869
 870 static  char *completed_input_string;
 871 static void
 872 rlhandler(char *text)
 873 {
 874         completed_input_string = text;
 875         rl_callback_handler_remove();
 876 }
 877
 878 extern PyThreadState* _PyOS_ReadlineTState;
 879
 880 static char *
 881 readline_until_enter_or_signal(char *prompt, int *signal)
 882 {
 883         char * not_done_reading = "";
 884         fd_set selectset;
 885
 886         *signal = 0;
 887 #ifdef HAVE_RL_CATCH_SIGNAL
 888         rl_catch_signals = 0;
 889 #endif
 890
 891         rl_callback_handler_install (prompt, rlhandler);
 892         FD_ZERO(&selectset);
 893
 894         completed_input_string = not_done_reading;
 895
 896         while (completed_input_string == not_done_reading) {
 897                 int has_input = 0;
 898
 899                 while (!has_input)
 900                 {       struct timeval timeout = {0, 100000}; /* 0.1 seconds */
 901
 902                         /* [Bug #1552726] Only limit the pause if an input hook has been
 903                            defined.  */
 904                         struct timeval *timeoutp = NULL;
 905                         if (PyOS_InputHook)
 906                                 timeoutp = &timeout;
 907                         FD_SET(fileno(rl_instream), &selectset);
 908                         /* select resets selectset if no input was available */
 909                         has_input = select(fileno(rl_instream) + 1, &selectset,
 910                                            NULL, NULL, timeoutp);
 911                         if(PyOS_InputHook) PyOS_InputHook();
 912                 }
 913
 914                 if(has_input > 0) {
 915                         rl_callback_read_char();
 916                 }
 917                 else if (errno == EINTR) {
 918                         int s;
 919 #ifdef WITH_THREAD
 920                         PyEval_RestoreThread(_PyOS_ReadlineTState);
 921 #endif
 922                         s = PyErr_CheckSignals();
 923 #ifdef WITH_THREAD
 924                         PyEval_SaveThread();
 925 #endif
 926                         if (s < 0) {
 927                                 rl_free_line_state();
 928                                 rl_cleanup_after_signal();
 929                                 rl_callback_handler_remove();
 930                                 *signal = 1;
 931                                 completed_input_string = NULL;
 932                         }
 933                 }
 934         }
 935
 936         return completed_input_string;
 937 }
 938
 939
 940 #else
 941
 942 /* Interrupt handler */
 943
 944 static jmp_buf jbuf;
 945
 946 /* ARGSUSED */
 947 static void
 948 onintr(int sig)
 949 {
 950         longjmp(jbuf, 1);
 951 }
 952
 953
 954 static char *
 955 readline_until_enter_or_signal(char *prompt, int *signal)
 956 {
 957         PyOS_sighandler_t old_inthandler;
 958         char *p;
 959
 960         *signal = 0;
 961
 962         old_inthandler = PyOS_setsig(SIGINT, onintr);
 963         if (setjmp(jbuf)) {
 964 #ifdef HAVE_SIGRELSE
 965                 /* This seems necessary on SunOS 4.1 (Rasmus Hahn) */
 966                 sigrelse(SIGINT);
 967 #endif
 968                 PyOS_setsig(SIGINT, old_inthandler);
 969                 *signal = 1;
 970                 return NULL;
 971         }
 972         rl_event_hook = PyOS_InputHook;
 973         p = readline(prompt);
 974         PyOS_setsig(SIGINT, old_inthandler);
 975
 976     return p;
 977 }
 978 #endif /*defined(HAVE_RL_CALLBACK) && defined(HAVE_SELECT) */
 979
 980
 981 static char *
 982 call_readline(FILE *sys_stdin, FILE *sys_stdout, char *prompt)
 983 {
 984         size_t n;
 985         char *p, *q;
 986         int signal;
 987
 988 #ifdef SAVE_LOCALE
 989         char *saved_locale = strdup(setlocale(LC_CTYPE, NULL));
 990         if (!saved_locale)
 991                 Py_FatalError("not enough memory to save locale");
 992         setlocale(LC_CTYPE, "");
 993 #endif
 994
 995         if (sys_stdin != rl_instream || sys_stdout != rl_outstream) {
 996                 rl_instream = sys_stdin;
 997                 rl_outstream = sys_stdout;
 998 #ifdef HAVE_RL_COMPLETION_APPEND_CHARACTER
 999                 rl_prep_terminal (1);
1000 #endif
1001         }
1002
1003         p = readline_until_enter_or_signal(prompt, &signal);
1004
1005         /* we got an interrupt signal */
1006         if (signal) {
1007                 RESTORE_LOCALE(saved_locale)
1008                 return NULL;
1009         }
1010
1011         /* We got an EOF, return a empty string. */
1012         if (p == NULL) {
1013                 p = PyMem_Malloc(1);
1014                 if (p != NULL)
1015                         *p = '\0';
1016                 RESTORE_LOCALE(saved_locale)
1017                 return p;
1018         }
1019
1020         /* we have a valid line */
1021         n = strlen(p);
1022         if (n > 0) {
1023                 char *line;
1024                 HISTORY_STATE *state = history_get_history_state();
1025                 if (state->length > 0)
1026 #ifdef __APPLE__
1027                         if (using_libedit_emulation) {
1028                                 /*
1029                                  * Libedit's emulation uses 0-based indexes,
1030                                  * the real readline uses 1-based indexes.
1031                                  */
1032                                 line = history_get(state->length - 1)->line;
1033                         } else
1034 #endif /* __APPLE__ */
1035                         line = history_get(state->length)->line;
1036                 else
1037                         line = "";
1038                 if (strcmp(p, line))
1039                         add_history(p);
1040                 /* the history docs don't say so, but the address of state
1041                    changes each time history_get_history_state is called
1042                    which makes me think it's freshly malloc'd memory...
1043                    on the other hand, the address of the last line stays the
1044                    same as long as history isn't extended, so it appears to
1045                    be malloc'd but managed by the history package... */
1046                 free(state);
1047         }
1048         /* Copy the malloc'ed buffer into a PyMem_Malloc'ed one and
1049            release the original. */
1050         q = p;
1051         p = PyMem_Malloc(n+2);
1052         if (p != NULL) {
1053                 strncpy(p, q, n);
1054                 p[n] = '\n';
1055                 p[n+1] = '\0';
1056         }
1057         free(q);
1058         RESTORE_LOCALE(saved_locale)
1059         return p;
1060 }
1061
1062
1063 /* Initialize the module */
1064
1065 PyDoc_STRVAR(doc_module,
1066 "Importing this module enables command line editing using GNU readline.");
1067
1068 #ifdef __APPLE__
1069 PyDoc_STRVAR(doc_module_le,
1070 "Importing this module enables command line editing using libedit readline.");
1071 #endif /* __APPLE__ */
1072
1073 PyMODINIT_FUNC
1074 initreadline(void)
1075 {
1076         PyObject *m;
1077
1078 #ifdef __APPLE__
1079         if (strncmp(rl_library_version, libedit_version_tag, strlen(libedit_version_tag)) == 0) {
1080                 using_libedit_emulation = 1;
1081         }
1082
1083         if (using_libedit_emulation)
1084                 m = Py_InitModule4("readline", readline_methods, doc_module_le,
1085                            (PyObject *)NULL, PYTHON_API_VERSION);
1086         else
1087
1088 #endif /* __APPLE__ */
1089
1090         m = Py_InitModule4("readline", readline_methods, doc_module,
1091                            (PyObject *)NULL, PYTHON_API_VERSION);
1092         if (m == NULL)
1093                 return;
1094
1095
1096
1097         PyOS_ReadlineFunctionPointer = call_readline;
1098         setup_readline();
1099 }