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 #undef HAVE_CONFIG_H /* Else readline/chardefs.h includes strings.h */
  21 #include <readline/readline.h>
  22 #include <readline/history.h>
  23
  24 #ifdef HAVE_RL_COMPLETION_MATCHES
  25 #define completion_matches(x, y) rl_completion_matches((x), ((rl_compentry_func_t *)(y)))
  26 #endif
  27
  28 /* Pointers needed from outside (but not declared in a header file). */
  29 extern DL_IMPORT(int) (*PyOS_InputHook)(void);
  30 extern DL_IMPORT(char) *(*PyOS_ReadlineFunctionPointer)(char *);
  31
  32
  33 /* Exported function to send one line to readline's init file parser */
  34
  35 static PyObject *
  36 parse_and_bind(PyObject *self, PyObject *args)
  37 {
  38         char *s, *copy;
  39         if (!PyArg_ParseTuple(args, "s:parse_and_bind", &s))
  40                 return NULL;
  41         /* Make a copy -- rl_parse_and_bind() modifies its argument */
  42         /* Bernard Herzog */
  43         copy = malloc(1 + strlen(s));
  44         if (copy == NULL)
  45                 return PyErr_NoMemory();
  46         strcpy(copy, s);
  47         rl_parse_and_bind(copy);
  48         free(copy); /* Free the copy */
  49         Py_INCREF(Py_None);
  50         return Py_None;
  51 }
  52
  53 static char doc_parse_and_bind[] = "\
  54 parse_and_bind(string) -> None\n\
  55 Parse and execute single line of a readline init file.\
  56 ";
  57
  58
  59 /* Exported function to parse a readline init file */
  60
  61 static PyObject *
  62 read_init_file(PyObject *self, PyObject *args)
  63 {
  64         char *s = NULL;
  65         if (!PyArg_ParseTuple(args, "|z:read_init_file", &s))
  66                 return NULL;
  67         errno = rl_read_init_file(s);
  68         if (errno)
  69                 return PyErr_SetFromErrno(PyExc_IOError);
  70         Py_INCREF(Py_None);
  71         return Py_None;
  72 }
  73
  74 static char doc_read_init_file[] = "\
  75 read_init_file([filename]) -> None\n\
  76 Parse a readline initialization file.\n\
  77 The default filename is the last filename used.\
  78 ";
  79
  80
  81 /* Exported function to load a readline history file */
  82
  83 static PyObject *
  84 read_history_file(PyObject *self, PyObject *args)
  85 {
  86         char *s = NULL;
  87         if (!PyArg_ParseTuple(args, "|z:read_history_file", &s))
  88                 return NULL;
  89         errno = read_history(s);
  90         if (errno)
  91                 return PyErr_SetFromErrno(PyExc_IOError);
  92         Py_INCREF(Py_None);
  93         return Py_None;
  94 }
  95
  96 static int history_length = -1; /* do not truncate history by default */
  97 static char doc_read_history_file[] = "\
  98 read_history_file([filename]) -> None\n\
  99 Load a readline history file.\n\
 100 The default filename is ~/.history.\
 101 ";
 102
 103
 104 /* Exported function to save a readline history file */
 105
 106 static PyObject *
 107 write_history_file(PyObject *self, PyObject *args)
 108 {
 109         char *s = NULL;
 110         if (!PyArg_ParseTuple(args, "|z:write_history_file", &s))
 111                 return NULL;
 112         errno = write_history(s);
 113         if (!errno && history_length >= 0)
 114                 history_truncate_file(s, history_length);
 115         if (errno)
 116                 return PyErr_SetFromErrno(PyExc_IOError);
 117         Py_INCREF(Py_None);
 118         return Py_None;
 119 }
 120
 121 static char doc_write_history_file[] = "\
 122 write_history_file([filename]) -> None\n\
 123 Save a readline history file.\n\
 124 The default filename is ~/.history.\
 125 ";
 126
 127
 128 static char set_history_length_doc[] = "\
 129 set_history_length(length) -> None\n\
 130 set the maximal number of items which will be written to\n\
 131 the history file. A negative length is used to inhibit\n\
 132 history truncation.\n\
 133 ";
 134
 135 static PyObject*
 136 set_history_length(PyObject *self, PyObject *args)
 137 {
 138     int length = history_length;
 139     if (!PyArg_ParseTuple(args, "i:set_history_length", &length))
 140         return NULL;
 141     history_length = length;
 142     Py_INCREF(Py_None);
 143     return Py_None;
 144 }
 145
 146
 147
 148 static char get_history_length_doc[] = "\
 149 get_history_length() -> int\n\
 150 return the current history length value.\n\
 151 ";
 152
 153 static PyObject*
 154 get_history_length(PyObject *self, PyObject *args)
 155 {
 156         if (!PyArg_ParseTuple(args, ":get_history_length"))
 157                 return NULL;
 158         return Py_BuildValue("i", history_length);
 159 }
 160
 161
 162
 163 /* Exported function to specify a word completer in Python */
 164
 165 static PyObject *completer = NULL;
 166 static PyThreadState *tstate = NULL;
 167
 168 static PyObject *begidx = NULL;
 169 static PyObject *endidx = NULL;
 170
 171 /* get the beginning index for the scope of the tab-completion */
 172 static PyObject *
 173 get_begidx(PyObject *self, PyObject *args)
 174 {
 175         if(!PyArg_NoArgs(args)) {
 176                 return NULL;
 177         }
 178         Py_INCREF(begidx);
 179         return begidx;
 180 }
 181
 182 static char doc_get_begidx[] = "\
 183 get_begidx() -> int\n\
 184 get the beginning index of the readline tab-completion scope";
 185
 186 /* get the ending index for the scope of the tab-completion */
 187 static PyObject *
 188 get_endidx(PyObject *self, PyObject *args)
 189 {
 190         if(!PyArg_NoArgs(args)) {
 191                 return NULL;
 192         }
 193         Py_INCREF(endidx);
 194         return endidx;
 195 }
 196
 197 static char doc_get_endidx[] = "\
 198 get_endidx() -> int\n\
 199 get the ending index of the readline tab-completion scope";
 200
 201
 202 /* set the tab-completion word-delimiters that readline uses */
 203
 204 static PyObject *
 205 set_completer_delims(PyObject *self, PyObject *args)
 206 {
 207         char *break_chars;
 208
 209         if(!PyArg_ParseTuple(args, "s:set_completer_delims", &break_chars)) {
 210                 return NULL;
 211         }
 212         free(rl_completer_word_break_characters);
 213         rl_completer_word_break_characters = strdup(break_chars);
 214         Py_INCREF(Py_None);
 215         return Py_None;
 216 }
 217
 218 static char doc_set_completer_delims[] = "\
 219 set_completer_delims(string) -> None\n\
 220 set the readline word delimiters for tab-completion";
 221
 222
 223 /* get the tab-completion word-delimiters that readline uses */
 224
 225 static PyObject *
 226 get_completer_delims(PyObject *self, PyObject *args)
 227 {
 228         if(!PyArg_NoArgs(args)) {
 229                 return NULL;
 230         }
 231         return PyString_FromString(rl_completer_word_break_characters);
 232 }
 233
 234 static char doc_get_completer_delims[] = "\
 235 get_completer_delims() -> string\n\
 236 get the readline word delimiters for tab-completion";
 237
 238 static PyObject *
 239 set_completer(PyObject *self, PyObject *args)
 240 {
 241         PyObject *function = Py_None;
 242         if (!PyArg_ParseTuple(args, "|O:set_completer", &function))
 243                 return NULL;
 244         if (function == Py_None) {
 245                 Py_XDECREF(completer);
 246                 completer = NULL;
 247                 tstate = NULL;
 248         }
 249         else if (PyCallable_Check(function)) {
 250                 PyObject *tmp = completer;
 251                 Py_INCREF(function);
 252                 completer = function;
 253                 Py_XDECREF(tmp);
 254                 tstate = PyThreadState_Get();
 255         }
 256         else {
 257                 PyErr_SetString(PyExc_TypeError,
 258                                 "set_completer(func): argument not callable");
 259                 return NULL;
 260         }
 261         Py_INCREF(Py_None);
 262         return Py_None;
 263 }
 264
 265 static char doc_set_completer[] = "\
 266 set_completer([function]) -> None\n\
 267 Set or remove the completer function.\n\
 268 The function is called as function(text, state),\n\
 269 for i in [0, 1, 2, ...] until it returns a non-string.\n\
 270 It should return the next possible completion starting with 'text'.\
 271 ";
 272
 273 /* Exported function to read the current line buffer */
 274
 275 static PyObject *
 276 get_line_buffer(PyObject *self, PyObject *args)
 277 {
 278         if (!PyArg_NoArgs(args))
 279                 return NULL;
 280         return PyString_FromString(rl_line_buffer);
 281 }
 282
 283 static char doc_get_line_buffer[] = "\
 284 get_line_buffer() -> string\n\
 285 return the current contents of the line buffer.\
 286 ";
 287
 288 /* Exported function to insert text into the line buffer */
 289
 290 static PyObject *
 291 insert_text(PyObject *self, PyObject *args)
 292 {
 293         char *s;
 294         if (!PyArg_ParseTuple(args, "s:insert_text", &s))
 295                 return NULL;
 296         rl_insert_text(s);
 297         Py_INCREF(Py_None);
 298         return Py_None;
 299 }
 300
 301
 302 static char doc_insert_text[] = "\
 303 insert_text(string) -> None\n\
 304 Insert text into the command line.\
 305 ";
 306
 307
 308 /* Table of functions exported by the module */
 309
 310 static struct PyMethodDef readline_methods[] =
 311 {
 312         {"parse_and_bind", parse_and_bind, METH_VARARGS, doc_parse_and_bind},
 313         {"get_line_buffer", get_line_buffer,
 314          METH_OLDARGS, doc_get_line_buffer},
 315         {"insert_text", insert_text, METH_VARARGS, doc_insert_text},
 316         {"read_init_file", read_init_file, METH_VARARGS, doc_read_init_file},
 317         {"read_history_file", read_history_file,
 318          METH_VARARGS, doc_read_history_file},
 319         {"write_history_file", write_history_file,
 320          METH_VARARGS, doc_write_history_file},
 321         {"set_history_length", set_history_length,
 322          METH_VARARGS, set_history_length_doc},
 323         {"get_history_length", get_history_length,
 324          METH_VARARGS, get_history_length_doc},
 325         {"set_completer", set_completer, METH_VARARGS, doc_set_completer},
 326         {"get_begidx", get_begidx, METH_OLDARGS, doc_get_begidx},
 327         {"get_endidx", get_endidx, METH_OLDARGS, doc_get_endidx},
 328
 329         {"set_completer_delims", set_completer_delims,
 330          METH_VARARGS, doc_set_completer_delims},
 331         {"get_completer_delims", get_completer_delims,
 332          METH_OLDARGS, doc_get_completer_delims},
 333         {0, 0}
 334 };
 335
 336 /* C function to call the Python completer. */
 337
 338 static char *
 339 on_completion(char *text, int state)
 340 {
 341         char *result = NULL;
 342         if (completer != NULL) {
 343                 PyObject *r;
 344                 PyThreadState *save_tstate;
 345                 /* Note that readline is called with the interpreter
 346                    lock released! */
 347                 save_tstate = PyThreadState_Swap(NULL);
 348                 PyEval_RestoreThread(tstate);
 349                 r = PyObject_CallFunction(completer, "si", text, state);
 350                 if (r == NULL)
 351                         goto error;
 352                 if (r == Py_None) {
 353                         result = NULL;
 354                 }
 355                 else {
 356                         char *s = PyString_AsString(r);
 357                         if (s == NULL)
 358                                 goto error;
 359                         result = strdup(s);
 360                 }
 361                 Py_DECREF(r);
 362                 goto done;
 363           error:
 364                 PyErr_Clear();
 365                 Py_XDECREF(r);
 366           done:
 367                 PyEval_SaveThread();
 368                 PyThreadState_Swap(save_tstate);
 369         }
 370         return result;
 371 }
 372
 373
 374 /* a more flexible constructor that saves the "begidx" and "endidx"
 375  * before calling the normal completer */
 376
 377 char **
 378 flex_complete(char *text, int start, int end)
 379 {
 380         Py_XDECREF(begidx);
 381         Py_XDECREF(endidx);
 382         begidx = PyInt_FromLong((long) start);
 383         endidx = PyInt_FromLong((long) end);
 384         return completion_matches(text, *on_completion);
 385 }
 386
 387 /* Helper to initialize GNU readline properly. */
 388
 389 static void
 390 setup_readline(void)
 391 {
 392         rl_readline_name = "python";
 393         /* Force rebind of TAB to insert-tab */
 394         rl_bind_key('\t', rl_insert);
 395         /* Bind both ESC-TAB and ESC-ESC to the completion function */
 396         rl_bind_key_in_map ('\t', rl_complete, emacs_meta_keymap);
 397         rl_bind_key_in_map ('\033', rl_complete, emacs_meta_keymap);
 398         /* Set our completion function */
 399         rl_attempted_completion_function = (CPPFunction *)flex_complete;
 400         /* Set Python word break characters */
 401         rl_completer_word_break_characters =
 402                 strdup(" \t\n`~!@#$%^&*()-=+[{]}\\|;:'\",<>/?");
 403                 /* All nonalphanums except '.' */
 404
 405         begidx = PyInt_FromLong(0L);
 406         endidx = PyInt_FromLong(0L);
 407         /* Initialize (allows .inputrc to override)
 408          *
 409          * XXX: A bug in the readline-2.2 library causes a memory leak
 410          * inside this function.  Nothing we can do about it.
 411          */
 412         rl_initialize();
 413 }
 414
 415
 416 /* Interrupt handler */
 417
 418 static jmp_buf jbuf;
 419
 420 /* ARGSUSED */
 421 static void
 422 onintr(int sig)
 423 {
 424         longjmp(jbuf, 1);
 425 }
 426
 427
 428 /* Wrapper around GNU readline that handles signals differently. */
 429
 430 static char *
 431 call_readline(char *prompt)
 432 {
 433         size_t n;
 434         char *p, *q;
 435         PyOS_sighandler_t old_inthandler;
 436
 437         old_inthandler = PyOS_setsig(SIGINT, onintr);
 438         if (setjmp(jbuf)) {
 439 #ifdef HAVE_SIGRELSE
 440                 /* This seems necessary on SunOS 4.1 (Rasmus Hahn) */
 441                 sigrelse(SIGINT);
 442 #endif
 443                 PyOS_setsig(SIGINT, old_inthandler);
 444                 return NULL;
 445         }
 446         rl_event_hook = PyOS_InputHook;
 447         p = readline(prompt);
 448         PyOS_setsig(SIGINT, old_inthandler);
 449
 450         /* We must return a buffer allocated with PyMem_Malloc. */
 451         if (p == NULL) {
 452                 p = PyMem_Malloc(1);
 453                 if (p != NULL)
 454                         *p = '\0';
 455                 return p;
 456         }
 457         n = strlen(p);
 458         if (n > 0)
 459                 add_history(p);
 460         /* Copy the malloc'ed buffer into a PyMem_Malloc'ed one and
 461            release the original. */
 462         q = p;
 463         p = PyMem_Malloc(n+2);
 464         if (p != NULL) {
 465                 strncpy(p, q, n);
 466                 p[n] = '\n';
 467                 p[n+1] = '\0';
 468         }
 469         free(q);
 470         return p;
 471 }
 472
 473
 474 /* Initialize the module */
 475
 476 static char doc_module[] =
 477 "Importing this module enables command line editing using GNU readline.";
 478
 479 DL_EXPORT(void)
 480 initreadline(void)
 481 {
 482         PyObject *m;
 483
 484         m = Py_InitModule4("readline", readline_methods, doc_module,
 485                            (PyObject *)NULL, PYTHON_API_VERSION);
 486         if (isatty(fileno(stdin))) {
 487                 PyOS_ReadlineFunctionPointer = call_readline;
 488                 setup_readline();
 489         }
 490 }