This is pyrl.m in view mode; [Download] [Up]
/* Copyright (c) 1996 by Lele Gaifax. All Rights Reserved
*
* This file is part of Nothing (yet).
*
* $RCSfile: pyrl.m,v $
* $Revision: 1.1 $
* $Date: 1997/03/23 08:02:13 $
*
* Created Tue Oct 1 12:04:57 1996.
*/
/* This module encapsulate the GNU readline library facilities: by
leaving them into an external module, you gain some Kbytes and
flexibility, since the interpreter may load it only when it is
needed, ie only in interactive sessions.
To enable the use of this module, you must explicitly add the
option `--with-readline' to the `configure' script: it will
automatically select the needed libraries (readline.a for sure,
adding whatever terminal library your OS is using), putting
their names into the Modules/Makefile' variable `PYRL_LIBS'.
Then a line in the Setup file like
pyrl pyrl.c $(PYRL_LIBS)
will include it the build process. */
/* OpenSTEP version:
This is the very same module, but it is implemented as a bundle
instead as of a shared module. This is very easy, given the
PyNSBundledModule class included in the core framework: just
implement a subclass of it, with its +initModule method "wrapping"
the usual initxxx function. See the end of this file for an
example. */
#include <Python/Python.h>
#include "PyNSBundledModule.h"
#ifdef WITH_READLINE
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include "myproto.h"
#include "mymalloc.h"
#include "intrcheck.h"
#include <readline/readline.h>
#include <readline/history.h>
#include <setjmp.h>
#include <signal.h>
/* AIX requires this to be the first thing in the file. */
#ifdef __GNUC__
#ifndef alloca /* predefined by NeXT's header */
# define alloca __builtin_alloca
#endif
#else
# if HAVE_ALLOCA_H
# include <alloca.h>
# else
# ifdef _AIX
#pragma alloca
# else
# ifndef alloca /* predefined by HP cc +Olibcalls */
char *alloca ();
# endif
# endif
# endif
#endif
static inline char *
strdup (const char *s)
{
char *dup = malloc (strlen (s) + 1);
return strcpy (dup, s);
}
static jmp_buf jbuf;
/* ARGSUSED */
static RETSIGTYPE
onintr(sig)
int sig;
{
longjmp(jbuf, sig);
}
/* Appends to LIST the ``papabile'' symbols in DICT, that may actually
be a dictionary, a list, or an object responding to .keys().
Returns the number of added symbols, or 0 on errors. */
static int
append_papabile_symbols (PyObject *list,
PyObject *dict,
const char *text,
int len)
{
PyObject *keys;
int count;
if (PyDict_Check (dict))
{
keys = PyDict_Keys (dict);
if (!keys)
return 0;
if (PyList_Sort (keys) != 0)
{
Py_DECREF (keys);
return 0;
}
}
else if (PyList_Check (dict))
{
keys = dict;
Py_INCREF (keys);
}
else
keys = PyObject_CallMethod (dict, "keys", NULL);
count = 0;
if (keys)
{
unsigned int idx = PyList_Size (keys);
while (idx--)
{
PyObject *localsym = PyList_GetItem (keys, idx);
if (strncmp (text, PyString_AsString (localsym), len) == 0)
{
PyList_Append (list, localsym);
count++;
}
}
Py_DECREF (keys);
}
else
PyErr_Clear();
return count;
}
/* If STATUS==0, collects the symbols from __main__.__dict__ and from
__builtins__.__dict__, then build a list of those beginning with
TEXT.
Returns the next symbol's name if there is one, NULL otherwise.
This is called from the readline's completer function. */
static char *
try_complete_local_symbol (char *text, int state)
{
static PyObject *symbols_list = NULL;
static int symbols_list_idx;
if (!state)
{
PyObject *symbols;
int len;
Py_XDECREF (symbols_list);
symbols_list = NULL;
symbols_list_idx = 0;
symbols_list = PyList_New(0);
if (!symbols_list)
return NULL;
len = strlen (text);
symbols = PyObject_GetAttrString (PyImport_AddModule ("__main__"), "__dict__");
if (symbols)
{
symbols_list_idx += append_papabile_symbols (symbols_list,
symbols,
text,
len);
Py_DECREF (symbols);
}
else
PyErr_Clear();
symbols = PyObject_GetAttrString (PyEval_GetBuiltins(), "__dict__");
if (symbols)
{
symbols_list_idx += append_papabile_symbols (symbols_list,
symbols,
text,
len);
Py_DECREF (symbols);
}
else
PyErr_Clear();
}
if (symbols_list_idx > 0)
{
PyObject *localsym = PyList_GetItem (symbols_list, --symbols_list_idx);
return strdup (PyString_AsString (localsym));
}
return NULL;
}
/* If STATUS==0, tries to understand from the entered TEXT the object
we are writing the name, and then collects in a list the name of the
symbols in both ``__dict__'' and ``__members__'' slots of it.
Returns the next symbol's name if there is one, NULL otherwise.
This is called from the readline's completer function. */
static char *
try_complete_member_symbol (char *text, int state)
{
static PyObject *symbols_list = NULL;
static int symbols_list_idx;
static int prefix_len;
if (!state)
{
int len;
PyObject *symbols = PyImport_AddModule ("__main__");
PyObject *list;
const char *point, *start;
Py_XDECREF (symbols_list);
symbols_list = NULL;
symbols_list_idx = 0;
symbols_list = PyList_New(0);
if (!symbols_list)
return NULL;
/* PyImport_AddModule() does not return a new reference! */
Py_INCREF (symbols);
start = text;
while ((point = strchr (start, '.')))
{
int symlen = point-start;
char *symname;
if (!symlen)
return NULL;
symname = alloca (symlen+1);
strncpy (symname, start, symlen);
symname[symlen] = '\0';
/* This is safe: if this is the first time, we INCREFed the
module before the loop; if not, the previous GetAttrString()
returned a new reference to a surely-existing-somewhere object. */
Py_DECREF (symbols);
symbols = PyObject_GetAttrString (symbols, symname);
if (!symbols)
{
PyErr_Clear();
return NULL;
}
start = point+1;
}
prefix_len = start-text;
len = strlen (start);
list = PyObject_GetAttrString (symbols, "__dict__");
if (list)
{
symbols_list_idx += append_papabile_symbols (symbols_list,
list,
start,
len);
Py_DECREF (list);
}
else
PyErr_Clear();
list = PyObject_GetAttrString (symbols, "__members__");
if (list)
{
symbols_list_idx += append_papabile_symbols (symbols_list,
list,
start,
len);
Py_DECREF (list);
}
else
PyErr_Clear();
list = PyObject_GetAttrString (symbols, "__methods__");
if (list)
{
symbols_list_idx += append_papabile_symbols (symbols_list,
list,
start,
len);
Py_DECREF (list);
}
else
PyErr_Clear();
}
if (symbols_list_idx > 0)
{
PyObject *localsym = PyList_GetItem (symbols_list, --symbols_list_idx);
extern char *strdup (const char *);
const char *ls = PyString_AsString (localsym);
char *complete;
complete = alloca (prefix_len + PyString_Size (localsym) + 1);
strncpy (complete, text, prefix_len);
strcpy (complete+prefix_len, ls);
return strdup (complete);
}
return NULL;
}
static inline char **
builtin_completion (char *text, int start, int end)
{
if (end > start && strchr (text, '.'))
return completion_matches (text, try_complete_member_symbol);
else
return completion_matches (text, try_complete_local_symbol);
}
static PyObject *python_completion_in_python;
/* If the current TEXT contains a point '.', assume we are accessing a
member of an object and attempt to complete that; otherwise try to
complete a local symbol. */
static char **
python_completion (char *text, int start, int end)
{
/* Do not perform standard filename completion, even if we can't complete
the symbol. */
rl_attempted_completion_over = 1;
if (python_completion_in_python)
{
PyTupleObject *args;
PyObject *result;
args = (PyTupleObject *) PyTuple_New (3);
if (!args)
return NULL;
PyTuple_SET_ITEM (args, 0, PyString_FromString (text));
PyTuple_SET_ITEM (args, 1, PyInt_FromLong (start));
PyTuple_SET_ITEM (args, 2, PyInt_FromLong (end));
result = PyEval_CallObject (python_completion_in_python, (PyObject *) args);
Py_DECREF (args);
if (result && PyList_Check (result))
{
int midx = PyList_Size (result);
char **matches = malloc ((midx+1) * sizeof (char *));
if (!matches)
{
PyErr_NoMemory();
return NULL;
}
matches[midx] = NULL;
while (midx--)
matches[midx] = strdup (PyString_AsString (PyList_GetItem (result, midx)));
Py_DECREF (result);
return matches;
}
else
{
if (! result)
{
PyErr_Print();
Py_DECREF (python_completion_in_python);
python_completion_in_python = NULL;
}
else
Py_DECREF (result);
return NULL;
}
}
else
return builtin_completion (text, start, end);
}
static char *
py_readline (prompt)
char *prompt;
{
int n;
char *p;
RETSIGTYPE (*old_inthandler)();
int sig;
#ifdef NeXT
RETSIGTYPE (*old_conthandler)();
sigcont_received:
old_conthandler = signal (SIGCONT, onintr);
#endif
old_inthandler = signal (SIGINT, onintr);
if ((sig = setjmp (jbuf)))
{
#ifdef HAVE_SIGRELSE
/* This seems necessary on SunOS 4.1 (Rasmus Hahn) */
sigrelse(SIGINT);
#endif
signal(SIGINT, old_inthandler);
#ifdef NeXT
signal (SIGCONT, old_conthandler);
if (sig == SIGCONT)
goto sigcont_received;
#endif
return NULL;
}
p = readline (prompt);
signal (SIGINT, old_inthandler);
#ifdef NeXT
signal (SIGCONT, old_conthandler);
#endif
if (p == NULL)
{
p = malloc(1);
if (p != NULL)
*p = '\0';
return p;
}
n = strlen (p);
if (n > 0)
add_history (p);
if ((p = realloc (p, n+2)) != NULL)
{
p[n] = '\n';
p[n+1] = '\0';
}
return p;
}
static char pyrl_set_completer_doc[] =
"Set a new completer function. The COMPLETER argument must be a callable\n\
object, and will be called with three arguments: the TEXT entered so far,\n\
START and END show the region of TEXT that contains the word to complete.\n\
Returns the previous completer object, or None if it was the builtin one.";
static PyObject *
pyrl_set_completer (PyObject *self, PyObject *args)
{
PyObject *new;
if (PyArg_ParseTuple (args, "O;completer", &new))
{
if (new == Py_None || PyCallable_Check (new))
{
PyObject *old = python_completion_in_python;
if (new != Py_None)
{
python_completion_in_python = new;
Py_INCREF (python_completion_in_python);
}
else
python_completion_in_python = NULL;
if (!old)
{
old = Py_None;
Py_INCREF (old);
}
return old;
}
else
PyErr_BadArgument();
}
return NULL;
}
static char pyrl_readline_doc[] =
"Read a line of input from the user with the GNU readline facility. If the\n\
optional PROMPT is not given, sys.ps1 is used instead.";
static PyObject *
pyrl_readline (PyObject *self, PyObject *args)
{
char *prompt = NULL;
if (PyArg_ParseTuple (args, "|s;prompt", &prompt))
{
char *line;
if (prompt == NULL)
{
PyObject *ps1 = PySys_GetObject ("ps1");
prompt = PyString_AsString (ps1);
}
line = py_readline (prompt);
if (line)
{
PyObject *ret = PyString_FromString (line);
free (line);
return ret;
}
else
{
PyErr_NoMemory();
return NULL;
}
}
return NULL;
}
static char pyrl_builtin_completer_doc[] = "The builtin completer function";
static PyObject *
pyrl_builtin_completer (PyObject *self, PyObject *args)
{
char *text;
int start, end;
if (PyArg_ParseTuple (args, "sii", &text, &start, &end))
{
char **result = builtin_completion (text, start, end);
if (result)
{
PyObject *list;
int ncompl;
for (ncompl=0; result[ncompl]; ncompl++)
/* do nothing */;
list = PyList_New (ncompl);
if (!list)
return NULL;
while (ncompl--)
{
PyObject *str = PyString_FromString (result[ncompl]);
PyList_SetItem (list, ncompl, str);
free (result[ncompl]);
}
free (result);
return list;
}
else
{
Py_INCREF (Py_None);
return Py_None;
}
}
return NULL;
}
extern char * (*PyOS_Readline)();
#endif /* WITH_READLINE */
static PyMethodDef pyrl_methods[] =
{
#ifdef WITH_READLINE
{ "set_completer", (PyCFunction) pyrl_set_completer, METH_VARARGS, pyrl_set_completer_doc },
{ "builtin_completer",(PyCFunction) pyrl_builtin_completer, METH_VARARGS, pyrl_builtin_completer_doc },
{ "readline", (PyCFunction) pyrl_readline, METH_VARARGS, pyrl_readline_doc },
#endif
{ 0, 0, 0, 0 }
};
static char pyrl_doc[] =
#ifdef WITH_READLINE
"A replacement for the builtin readline implementation that uses GNU readline.";
#else
"A placehold empty module";
#endif
@interface PyNSPyrlModule : PyNSBundledModule
{
}
+ (void) initModule;
@end
@implementation PyNSPyrlModule
+ (void) initModule
{
Py_InitModule4 ("pyrl", pyrl_methods, pyrl_doc, NULL, PYTHON_API_VERSION);
#ifdef WITH_READLINE
/* Force rebind of TAB to insert-tab */
rl_bind_key ('\t', rl_insert);
rl_bind_key_in_map ('\t', rl_complete, emacs_meta_keymap);
rl_readline_name = "Python";
rl_attempted_completion_function = (CPPFunction *) python_completion;
rl_basic_word_break_characters = " \t\"'`<>=()[]{}";
PyOS_Readline = py_readline;
#endif
}
@end
These are the contents of the former NiCE NeXT User Group NeXTSTEP/OpenStep software archive, currently hosted by Netfuture.ch.