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