AppPkg/Applications/Python/Python-2.7.2/Modules/readline.c

   1 /* This module makes GNU readline available to Python.  It has ideas
   2  * contributed by Lee Busby, LLNL, and William Magro, Cornell Theory
   3  * Center.  The completer interface was inspired by Lele Gaifax.  More
   4  * recently, it was largely rewritten by Guido van Rossum.
   5  */
   6
   7 /* Standard definitions */
   8 #include "Python.h"
   9 #include <setjmp.h>
  10 #include <signal.h>
  11 #include <errno.h>
  12 #include <sys/time.h>
  13
  14 #if defined(HAVE_SETLOCALE)
  15 /* GNU readline() mistakenly sets the LC_CTYPE locale.
  16  * This is evil.  Only the user or the app's main() should do this!
  17  * We must save and restore the locale around the rl_initialize() call.
  18  */
  19 #define SAVE_LOCALE
  20 #include <locale.h>
  21 #endif
  22
  23 #ifdef SAVE_LOCALE
  24 #  define RESTORE_LOCALE(sl) { setlocale(LC_CTYPE, sl); free(sl); }
  25 #else
  26 #  define RESTORE_LOCALE(sl)
  27 #endif
  28
  29 /* GNU readline definitions */
  30 #undef HAVE_CONFIG_H /* Else readline/chardefs.h includes strings.h */
  31 #include <readline/readline.h>
  32 #include <readline/history.h>
  33
  34 #ifdef HAVE_RL_COMPLETION_MATCHES
  35 #define completion_matches(x, y) \
  36     rl_completion_matches((x), ((rl_compentry_func_t *)(y)))
  37 #else
  38 #if defined(_RL_FUNCTION_TYPEDEF)
  39 extern char **completion_matches(char *, rl_compentry_func_t *);
  40 #else
  41
  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 }