No issues found
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 }