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) 39extern char **completion_matches(char *, rl_compentry_func_t *); 40#else 41 42#if !defined(__APPLE__) 43extern 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 */ 63static int using_libedit_emulation = 0; 64static const char libedit_version_tag[] = "EditLine wrapper"; 65#endif /* __APPLE__ */ 66 67static void 68on_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 74static PyObject * 75parse_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 91PyDoc_STRVAR(doc_parse_and_bind, 92"parse_and_bind(string) -> None\n\ 93Parse and execute single line of a readline init file."); 94 95 96/* Exported function to parse a readline init file */ 97 98static PyObject * 99read_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 110PyDoc_STRVAR(doc_read_init_file, 111"read_init_file([filename]) -> None\n\ 112Parse a readline initialization file.\n\ 113The default filename is the last filename used."); 114 115 116/* Exported function to load a readline history file */ 117 118static PyObject * 119read_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 130static int _history_length = -1; /* do not truncate history by default */ 131PyDoc_STRVAR(doc_read_history_file, 132"read_history_file([filename]) -> None\n\ 133Load a readline history file.\n\ 134The default filename is ~/.history."); 135 136 137/* Exported function to save a readline history file */ 138 139static PyObject * 140write_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 153PyDoc_STRVAR(doc_write_history_file, 154"write_history_file([filename]) -> None\n\ 155Save a readline history file.\n\ 156The default filename is ~/.history."); 157 158 159/* Set history length */ 160 161static PyObject* 162set_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 171PyDoc_STRVAR(set_history_length_doc, 172"set_history_length(length) -> None\n\ 173set the maximal number of items which will be written to\n\ 174the history file. A negative length is used to inhibit\n\ 175history truncation."); 176 177 178/* Get history length */ 179 180static PyObject* 181get_history_length(PyObject *self, PyObject *noarg) 182{ 183 return PyInt_FromLong(_history_length); 184} 185 186PyDoc_STRVAR(get_history_length_doc, 187"get_history_length() -> int\n\ 188return the maximum number of items that will be written to\n\ 189the history file."); 190 191 192/* Generic hook function setter */ 193 194static PyObject * 195set_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 225static PyObject *completion_display_matches_hook = NULL; 226static PyObject *startup_hook = NULL; 227 228#ifdef HAVE_RL_PRE_INPUT_HOOK 229static PyObject *pre_input_hook = NULL; 230#endif 231 232static PyObject * 233set_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 252PyDoc_STRVAR(doc_set_completion_display_matches_hook, 253"set_completion_display_matches_hook([function]) -> None\n\ 254Set or remove the completion display function.\n\ 255The function is called as\n\ 256 function(substitution, [matches], longest_match_length)\n\ 257once each time matches need to be displayed."); 258 259static PyObject * 260set_startup_hook(PyObject *self, PyObject *args) 261{ 262 return set_hook("startup_hook", &startup_hook, args); 263} 264 265PyDoc_STRVAR(doc_set_startup_hook, 266"set_startup_hook([function]) -> None\n\ 267Set or remove the startup_hook function.\n\ 268The function is called with no arguments just\n\ 269before readline prints the first prompt."); 270 271 272#ifdef HAVE_RL_PRE_INPUT_HOOK 273 274/* Set pre-input hook */ 275 276static PyObject * 277set_pre_input_hook(PyObject *self, PyObject *args) 278{ 279 return set_hook("pre_input_hook", &pre_input_hook, args); 280} 281 282PyDoc_STRVAR(doc_set_pre_input_hook, 283"set_pre_input_hook([function]) -> None\n\ 284Set or remove the pre_input_hook function.\n\ 285The function is called with no arguments after the first prompt\n\ 286has been printed and just before readline starts reading input\n\ 287characters."); 288 289#endif 290 291 292/* Exported function to specify a word completer in Python */ 293 294static PyObject *completer = NULL; 295 296static PyObject *begidx = NULL; 297static PyObject *endidx = NULL; 298 299 300/* Get the completion type for the scope of the tab-completion */ 301static PyObject * 302get_completion_type(PyObject *self, PyObject *noarg) 303{ 304 return PyInt_FromLong(rl_completion_type); 305} 306 307PyDoc_STRVAR(doc_get_completion_type, 308"get_completion_type() -> int\n\ 309Get the type of completion being attempted."); 310 311 312/* Get the beginning index for the scope of the tab-completion */ 313 314static PyObject * 315get_begidx(PyObject *self, PyObject *noarg) 316{ 317 Py_INCREF(begidx); 318 return begidx; 319} 320 321PyDoc_STRVAR(doc_get_begidx, 322"get_begidx() -> int\n\ 323get the beginning index of the readline tab-completion scope"); 324 325 326/* Get the ending index for the scope of the tab-completion */ 327 328static PyObject * 329get_endidx(PyObject *self, PyObject *noarg) 330{ 331 Py_INCREF(endidx); 332 return endidx; 333} 334 335PyDoc_STRVAR(doc_get_endidx, 336"get_endidx() -> int\n\ 337get the ending index of the readline tab-completion scope"); 338 339 340/* Set the tab-completion word-delimiters that readline uses */ 341 342static PyObject * 343set_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 355PyDoc_STRVAR(doc_set_completer_delims, 356"set_completer_delims(string) -> None\n\ 357set 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 368static 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 379static 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 391static PyObject * 392py_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 416PyDoc_STRVAR(doc_remove_history, 417"remove_history_item(pos) -> None\n\ 418remove history item given by its position"); 419 420static PyObject * 421py_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 448PyDoc_STRVAR(doc_replace_history, 449"replace_history_item(pos, line) -> None\n\ 450replaces history item given by its position with contents of line"); 451 452/* Add a line to the history buffer */ 453 454static PyObject * 455py_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 466PyDoc_STRVAR(doc_add_history, 467"add_history(string) -> None\n\ 468add a line to the history buffer"); 469 470 471/* Get the tab-completion word-delimiters that readline uses */ 472 473static PyObject * 474get_completer_delims(PyObject *self, PyObject *noarg) 475{ 476 return PyString_FromString(rl_completer_word_break_characters); 477} 478 479PyDoc_STRVAR(doc_get_completer_delims, 480"get_completer_delims() -> string\n\ 481get the readline word delimiters for tab-completion"); 482 483 484/* Set the completer function */ 485 486static PyObject * 487set_completer(PyObject *self, PyObject *args) 488{ 489 return set_hook("completer", &completer, args); 490} 491 492PyDoc_STRVAR(doc_set_completer, 493"set_completer([function]) -> None\n\ 494Set or remove the completer function.\n\ 495The function is called as function(text, state),\n\ 496for state in 0, 1, 2, ..., until it returns a non-string.\n\ 497It should return the next possible completion starting with 'text'."); 498 499 500static PyObject * 501get_completer(PyObject *self, PyObject *noargs) 502{ 503 if (completer == NULL) { 504 Py_RETURN_NONE; 505 } 506 Py_INCREF(completer); 507 return completer; 508} 509 510PyDoc_STRVAR(doc_get_completer, 511"get_completer() -> function\n\ 512\n\ 513Returns 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 520static 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 536static PyObject * 537get_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 572PyDoc_STRVAR(doc_get_history_item, 573"get_history_item() -> string\n\ 574return the current contents of history item at index."); 575 576 577/* Exported function to get current length of history */ 578 579static PyObject * 580get_current_history_length(PyObject *self, PyObject *noarg) 581{ 582 return PyInt_FromLong((long)_py_get_history_length()); 583} 584 585PyDoc_STRVAR(doc_get_current_history_length, 586"get_current_history_length() -> integer\n\ 587return the current (not the maximum) length of history."); 588 589 590/* Exported function to read the current line buffer */ 591 592static PyObject * 593get_line_buffer(PyObject *self, PyObject *noarg) 594{ 595 return PyString_FromString(rl_line_buffer); 596} 597 598PyDoc_STRVAR(doc_get_line_buffer, 599"get_line_buffer() -> string\n\ 600return 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 607static PyObject * 608py_clear_history(PyObject *self, PyObject *noarg) 609{ 610 clear_history(); 611 Py_RETURN_NONE; 612} 613 614PyDoc_STRVAR(doc_clear_history, 615"clear_history() -> None\n\ 616Clear the current readline history."); 617#endif 618 619 620/* Exported function to insert text into the line buffer */ 621 622static PyObject * 623insert_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 632PyDoc_STRVAR(doc_insert_text, 633"insert_text(string) -> None\n\ 634Insert text into the command line."); 635 636 637/* Redisplay the line buffer */ 638 639static PyObject * 640redisplay(PyObject *self, PyObject *noarg) 641{ 642 rl_redisplay(); 643 Py_RETURN_NONE; 644} 645 646PyDoc_STRVAR(doc_redisplay, 647"redisplay() -> None\n\ 648Change what's displayed on the screen to reflect the current\n\ 649contents of the line buffer."); 650 651 652/* Table of functions exported by the module */ 653 654static 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 705static int 706on_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 738static int 739on_startup_hook(void) 740{ 741 return on_hook(startup_hook); 742} 743 744#ifdef HAVE_RL_PRE_INPUT_HOOK 745static int 746on_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 755static void 756on_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 800static char * 801on_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 840static char ** 841flex_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 859static void 860setup_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 922static char *completed_input_string; 923static void 924rlhandler(char *text) 925{ 926 completed_input_string = text; 927 rl_callback_handler_remove(); 928} 929 930extern PyThreadState* _PyOS_ReadlineTState; 931 932static char * 933readline_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 996static jmp_buf jbuf; 997 998/* ARGSUSED */ 999static void 1000onintr(int sig) 1001{ 1002 longjmp(jbuf, 1); 1003} 1004 1005 1006static char * 1007readline_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 1033static char * 1034call_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 1110PyDoc_STRVAR(doc_module, 1111"Importing this module enables command line editing using GNU readline."); 1112 1113#ifdef __APPLE__ 1114PyDoc_STRVAR(doc_module_le, 1115"Importing this module enables command line editing using libedit readline."); 1116#endif /* __APPLE__ */ 1117 1118PyMODINIT_FUNC 1119initreadline(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