LCOV - code coverage report
Current view: top level - Modules - readline.c (source / functions) Hit Total Coverage
Test: CPython lcov report Lines: 29 333 8.7 %
Date: 2017-04-19 Functions: 2 40 5.0 %

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

Generated by: LCOV version 1.10