Modules/readline.c

   1 /* This module makes GNU readline available to Python.  It has ideas
   2  * contributed by Lee Busby, LLNL, and William Magro, Cornell Theory
   3  * Center.  The completer interface was inspired by Lele Gaifax.
   4  *
   5  * More recently, it was largely rewritten by Guido van Rossum who is
   6  * now maintaining it.
   7  */
   8
   9 /* Standard definitions */
  10 #include "Python.h"
  11 #include <setjmp.h>
  12 #include <signal.h>
  13 #include <errno.h>
  14
  15 #ifdef HAVE_UNISTD_H
  16 #include <unistd.h> /* For isatty() */
  17 #endif
  18
  19 /* GNU readline definitions */
  20 /* If you have string.h, you might need to add yourself to this #if... [cjh] */
  21 #if defined(__BEOS__)
  22 #undef HAVE_CONFIG_H
  23 /* At max warnings, we need protos for everything. [cjh] */
  24 #include <readline/readline.h>
  25 #include <readline/history.h>
  26 #include <unistd.h>
  27 #else
  28 #include <readline/readline.h> /* You may need to add an -I option to Setup */
  29
  30 extern int rl_parse_and_bind();
  31 extern int rl_read_init_file();
  32 extern int rl_insert_text();
  33 extern int rl_bind_key();
  34 extern int rl_bind_key_in_map();
  35 extern int rl_initialize();
  36 extern int add_history();
  37 extern Function *rl_event_hook;
  38 #endif
  39
  40 /* Pointers needed from outside (but not declared in a header file). */
  41 extern int (*PyOS_InputHook)();
  42 extern char *(*PyOS_ReadlineFunctionPointer) Py_PROTO((char *));
  43
  44
  45 /* Exported function to send one line to readline's init file parser */
  46
  47 static PyObject *
  48 parse_and_bind(self, args)
  49         PyObject *self;
  50         PyObject *args;
  51 {
  52         char *s, *copy;
  53         if (!PyArg_ParseTuple(args, "s", &s))
  54                 return NULL;
  55         /* Make a copy -- rl_parse_and_bind() modifies its argument */
  56         /* Bernard Herzog */
  57         copy = malloc(1 + strlen(s));
  58         if (copy == NULL)
  59                 return PyErr_NoMemory();
  60         strcpy(copy, s);
  61         rl_parse_and_bind(copy);
  62         free(copy); /* Free the copy */
  63         Py_INCREF(Py_None);
  64         return Py_None;
  65 }
  66
  67 static char doc_parse_and_bind[] = "\
  68 parse_and_bind(string) -> None\n\
  69 Parse and execute single line of a readline init file.\
  70 ";
  71
  72
  73 /* Exported function to parse a readline init file */
  74
  75 static PyObject *
  76 read_init_file(self, args)
  77         PyObject *self;
  78         PyObject *args;
  79 {
  80         char *s = NULL;
  81         if (!PyArg_ParseTuple(args, "|z", &s))
  82                 return NULL;
  83         errno = rl_read_init_file(s);
  84         if (errno)
  85                 return PyErr_SetFromErrno(PyExc_IOError);
  86         Py_INCREF(Py_None);
  87         return Py_None;
  88 }
  89
  90 static char doc_read_init_file[] = "\
  91 read_init_file([filename]) -> None\n\
  92 Parse a readline initialization file.\n\
  93 The default filename is the last filename used.\
  94 ";
  95
  96
  97 /* Exported function to specify a word completer in Python */
  98
  99 static PyObject *completer = NULL;
 100 static PyThreadState *tstate = NULL;
 101
 102 static PyObject *
 103 set_completer(self, args)
 104         PyObject *self;
 105         PyObject *args;
 106 {
 107         PyObject *function = Py_None;
 108         if (!PyArg_ParseTuple(args, "|O", &function))
 109                 return NULL;
 110         if (function == Py_None) {
 111                 Py_XDECREF(completer);
 112                 completer = NULL;
 113                 tstate = NULL;
 114         }
 115         else if (PyCallable_Check(function)) {
 116                 PyObject *tmp = completer;
 117                 Py_INCREF(function);
 118                 completer = function;
 119                 Py_XDECREF(tmp);
 120                 tstate = PyThreadState_Get();
 121         }
 122         else {
 123                 PyErr_SetString(PyExc_TypeError,
 124                                 "set_completer(func): argument not callable");
 125                 return NULL;
 126         }
 127         Py_INCREF(Py_None);
 128         return Py_None;
 129 }
 130
 131 static char doc_set_completer[] = "\
 132 set_completer([function]) -> None\n\
 133 Set or remove the completer function.\n\
 134 The function is called as function(text, state),\n\
 135 for i in [0, 1, 2, ...] until it returns a non-string.\n\
 136 It should return the next possible completion starting with 'text'.\
 137 ";
 138
 139 /* Exported function to read the current line buffer */
 140
 141 static PyObject *
 142 get_line_buffer(self, args)
 143         PyObject *self;
 144         PyObject *args;
 145 {
 146         if (PyArg_NoArgs(args))
 147                 return NULL;
 148         return PyString_FromString(rl_line_buffer);
 149 }
 150
 151 static char doc_get_line_buffer[] = "\
 152 get_line_buffer() -> string\n\
 153 return the current contents of the line buffer.\
 154 ";
 155
 156 /* Exported function to insert text into the line buffer */
 157
 158 static PyObject *
 159 insert_text(self, args)
 160         PyObject *self;
 161         PyObject *args;
 162 {
 163         char *s;
 164         if (!PyArg_ParseTuple(args, "s", &s))
 165                 return NULL;
 166         rl_insert_text(s);
 167         Py_INCREF(Py_None);
 168         return Py_None;
 169 }
 170
 171
 172 static char doc_insert_text[] = "\
 173 insert_text(string) -> None\n\
 174 Insert text into the command line.\
 175 ";
 176
 177
 178 /* Table of functions exported by the module */
 179
 180 static struct PyMethodDef readline_methods[] =
 181 {
 182         {"parse_and_bind", parse_and_bind, 1, doc_parse_and_bind},
 183         {"get_line_buffer", get_line_buffer, 1, doc_get_line_buffer},
 184         {"insert_text", insert_text, 1, doc_insert_text},
 185         {"read_init_file", read_init_file, 1, doc_read_init_file},
 186         {"set_completer", set_completer, 1, doc_set_completer},
 187         {0, 0}
 188 };
 189
 190 /* C function to call the Python completer. */
 191
 192 static char *
 193 on_completion(text, state)
 194         char *text;
 195         int state;
 196 {
 197         char *result = NULL;
 198         if (completer != NULL) {
 199                 PyObject *r;
 200                 PyThreadState *save_tstate;
 201                 /* Note that readline is called with the interpreter
 202                    lock released! */
 203                 save_tstate = PyThreadState_Swap(NULL);
 204                 PyEval_RestoreThread(tstate);
 205                 r = PyObject_CallFunction(completer, "si", text, state);
 206                 if (r == NULL)
 207                         goto error;
 208                 if (r == Py_None) {
 209                         result = NULL;
 210                 }
 211                 else {
 212                         char *s = PyString_AsString(r);
 213                         if (s == NULL)
 214                                 goto error;
 215                         result = strdup(s);
 216                 }
 217                 Py_DECREF(r);
 218                 goto done;
 219           error:
 220                 PyErr_Clear();
 221                 Py_XDECREF(r);
 222           done:
 223                 PyEval_SaveThread();
 224                 PyThreadState_Swap(save_tstate);
 225         }
 226         return result;
 227 }
 228
 229
 230 /* Helper to initialize GNU readline properly. */
 231
 232 static void
 233 setup_readline()
 234 {
 235         rl_readline_name = "python";
 236         /* Force rebind of TAB to insert-tab */
 237         rl_bind_key('\t', rl_insert);
 238         /* Bind both ESC-TAB and ESC-ESC to the completion function */
 239         rl_bind_key_in_map ('\t', rl_complete, emacs_meta_keymap);
 240         rl_bind_key_in_map ('\033', rl_complete, emacs_meta_keymap);
 241         /* Set our completion function */
 242         rl_completion_entry_function = (Function *) on_completion;
 243         /* Set Python word break characters */
 244         rl_completer_word_break_characters =
 245                 " \t\n`~!@#$%^&*()-=+[{]}\\|;:'\",<>/?";
 246                 /* All nonalphanums except '.' */
 247         /* Initialize (allows .inputrc to override)
 248          *
 249          * XXX: A bug in the readline-2.2 library causes a memory leak
 250          * inside this function.  Nothing we can do about it.
 251          */
 252         rl_initialize();
 253 }
 254
 255
 256 /* Interrupt handler */
 257
 258 static jmp_buf jbuf;
 259
 260 /* ARGSUSED */
 261 static RETSIGTYPE
 262 onintr(sig)
 263         int sig;
 264 {
 265         longjmp(jbuf, 1);
 266 }
 267
 268
 269 /* Wrapper around GNU readline that handles signals differently. */
 270
 271 static char *
 272 call_readline(prompt)
 273         char *prompt;
 274 {
 275         int n;
 276         char *p;
 277         RETSIGTYPE (*old_inthandler)();
 278         old_inthandler = signal(SIGINT, onintr);
 279         if (setjmp(jbuf)) {
 280 #ifdef HAVE_SIGRELSE
 281                 /* This seems necessary on SunOS 4.1 (Rasmus Hahn) */
 282                 sigrelse(SIGINT);
 283 #endif
 284                 signal(SIGINT, old_inthandler);
 285                 return NULL;
 286         }
 287         rl_event_hook = PyOS_InputHook;
 288         p = readline(prompt);
 289         signal(SIGINT, old_inthandler);
 290         if (p == NULL) {
 291                 p = malloc(1);
 292                 if (p != NULL)
 293                         *p = '\0';
 294                 return p;
 295         }
 296         n = strlen(p);
 297         if (n > 0)
 298                 add_history(p);
 299         if ((p = realloc(p, n+2)) != NULL) {
 300                 p[n] = '\n';
 301                 p[n+1] = '\0';
 302         }
 303         return p;
 304 }
 305
 306
 307 /* Initialize the module */
 308
 309 static char doc_module[] =
 310 "Importing this module enables command line editing using GNU readline.";
 311
 312 DL_EXPORT(void)
 313 initreadline()
 314 {
 315         PyObject *m;
 316
 317         m = Py_InitModule4("readline", readline_methods, doc_module,
 318                            (PyObject *)NULL, PYTHON_API_VERSION);
 319         if (isatty(fileno(stdin))) {
 320                 PyOS_ReadlineFunctionPointer = call_readline;
 321                 setup_readline();
 322         }
 323 }