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