372 lines
8.1 KiB
C
372 lines
8.1 KiB
C
/*************************************************************************
|
|
* *
|
|
* YAP Prolog *
|
|
* *
|
|
* Yap Prolog was developed at NCCUP - Universidade do Porto *
|
|
* *
|
|
* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 *
|
|
* *
|
|
**************************************************************************
|
|
* *
|
|
* File: readline.c *
|
|
* Last rev: 5/2/88 *
|
|
* mods: *
|
|
* comments: Input/Output C implemented predicates *
|
|
* *
|
|
*************************************************************************/
|
|
#ifdef SCCS
|
|
static char SccsId[] = "%W% %G%";
|
|
#endif
|
|
|
|
/*
|
|
* This file includes the interface to the readline library, if installed in the system.
|
|
*
|
|
*/
|
|
|
|
#include "Yap.h"
|
|
#include "Yatom.h"
|
|
#include "YapHeap.h"
|
|
#include "yapio.h"
|
|
#include <stdlib.h>
|
|
#if HAVE_UNISTD_H
|
|
#include <unistd.h>
|
|
#endif
|
|
#if HAVE_STDARG_H
|
|
#include <stdarg.h>
|
|
#endif
|
|
#ifdef _WIN32
|
|
#if HAVE_IO_H
|
|
/* Windows */
|
|
#include <io.h>
|
|
#endif
|
|
#if HAVE_SOCKET
|
|
#include <winsock2.h>
|
|
#endif
|
|
#include <windows.h>
|
|
#ifndef S_ISDIR
|
|
#define S_ISDIR(x) (((x)&_S_IFDIR)==_S_IFDIR)
|
|
#endif
|
|
#endif
|
|
|
|
#include "iopreds.h"
|
|
|
|
#if defined(HAVE_LIBREADLINE)
|
|
|
|
#include <readline/readline.h>
|
|
#include <readline/history.h>
|
|
|
|
static int ReadlineGetc( int);
|
|
static int ReadlinePutc( int,int);
|
|
|
|
#define READLINE_OUT_BUF_MAX 256
|
|
|
|
typedef struct scan_atoms {
|
|
Int pos;
|
|
Atom atom;
|
|
} scan_atoms_t;
|
|
|
|
static char *
|
|
atom_enumerate(const char *prefix, int state)
|
|
{
|
|
CACHE_REGS
|
|
struct scan_atoms *index;
|
|
Atom catom;
|
|
Int i;
|
|
|
|
if ( !state )
|
|
{ index = (struct scan_atoms *)malloc(sizeof(struct scan_atoms));
|
|
i = 0;
|
|
catom = NIL;
|
|
} else
|
|
{
|
|
CACHE_REGS
|
|
index = LOCAL_search_atoms;
|
|
catom = index->atom;
|
|
i = index->pos;
|
|
}
|
|
|
|
while (catom != NIL || i < AtomHashTableSize) {
|
|
// if ( is_signalled() ) /* Notably allow windows version */
|
|
// PL_handle_signals(); /* to break out on ^C */
|
|
AtomEntry *ap;
|
|
|
|
if (catom == NIL) {
|
|
/* move away from current hash table line */
|
|
READ_LOCK(HashChain[i].AERWLock);
|
|
catom = HashChain[i].Entry;
|
|
READ_UNLOCK(HashChain[i].AERWLock);
|
|
i++;
|
|
} else {
|
|
ap = RepAtom(catom);
|
|
READ_LOCK(ap->ARWLock);
|
|
if ( strstr( ap->StrOfAE, prefix) == ap->StrOfAE) {
|
|
index->pos = i;
|
|
index->atom = ap->NextOfAE;
|
|
LOCAL_search_atoms = index;
|
|
READ_UNLOCK(ap->ARWLock);
|
|
return ap->StrOfAE;
|
|
}
|
|
catom = ap->NextOfAE;
|
|
READ_UNLOCK(ap->ARWLock);
|
|
}
|
|
}
|
|
LOCAL_search_atoms = NULL;
|
|
free(index);
|
|
return NULL;
|
|
}
|
|
|
|
|
|
static char *
|
|
atom_generator(const char *prefix, int state)
|
|
{ char *s = atom_enumerate(prefix, state);
|
|
|
|
if ( s )
|
|
{ char *copy = malloc(1 + strlen(s));
|
|
|
|
if ( copy ) /* else pretend no completion */
|
|
strcpy(copy, s);
|
|
s = copy;
|
|
}
|
|
|
|
return s;
|
|
}
|
|
|
|
|
|
static char **
|
|
prolog_completion(const char *text, int start, int end)
|
|
{ char **matches = NULL;
|
|
|
|
if ( (start == 1 && rl_line_buffer[0] == '[') || /* [file */
|
|
(start == 2 && strncmp(rl_line_buffer, "['", 2)) )
|
|
matches = rl_completion_matches((char *)text, /* for pre-4.2 */
|
|
rl_filename_completion_function);
|
|
else
|
|
matches = rl_completion_matches((char *)text,
|
|
atom_generator);
|
|
|
|
return matches;
|
|
}
|
|
|
|
|
|
void
|
|
Yap_ReadlineFlush( int sno )
|
|
{
|
|
if (GLOBAL_Stream[sno].status & Tty_Stream_f &&
|
|
GLOBAL_Stream[sno].status & Output_Stream_f) {
|
|
rl_redisplay();
|
|
|
|
}
|
|
}
|
|
|
|
bool Yap_ReadlinePrompt( StreamDesc * s )
|
|
{
|
|
if (s->status & Tty_Stream_f) {
|
|
s->stream_getc = ReadlineGetc;
|
|
if (GLOBAL_Stream[0].status & Tty_Stream_f &&
|
|
s->name == GLOBAL_Stream[0].name)
|
|
s->stream_putc = ReadlinePutc;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
Yap_ReadlineOps( StreamDesc *s )
|
|
{
|
|
if (s->status & Tty_Stream_f) {
|
|
if (GLOBAL_Stream[0].status & Tty_Stream_f &&
|
|
is_same_tty(s->file,GLOBAL_Stream[0].file))
|
|
s->stream_putc = ReadlinePutc;
|
|
s->stream_getc = ReadlineGetc;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
static int
|
|
prolog_complete(int ignore, int key)
|
|
{ if ( rl_point > 0 && rl_line_buffer[rl_point-1] != ' ' )
|
|
{
|
|
#if HAVE_DECL_RL_CATCH_SIGNALS_ /* actually version >= 1.2, or true readline */
|
|
rl_begin_undo_group();
|
|
rl_complete(ignore, key);
|
|
if ( rl_point > 0 && rl_line_buffer[rl_point-1] == ' ' )
|
|
{
|
|
rl_delete_text(rl_point-1, rl_point);
|
|
rl_point -= 1;
|
|
rl_delete(-1, key);
|
|
}
|
|
rl_end_undo_group();
|
|
#endif
|
|
} else
|
|
rl_complete(ignore, key);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
InitReadline(void) {
|
|
// don't call readline within emacs
|
|
if (getenv("ËMACS"))
|
|
return;
|
|
GLOBAL_Stream[StdInStream].u.irl.buf = NULL;
|
|
GLOBAL_Stream[StdInStream].u.irl.ptr = NULL;
|
|
#if _MSC_VER || defined(__MINGW32__)
|
|
rl_instream = stdin;
|
|
#endif
|
|
rl_outstream = stderr;
|
|
using_history();
|
|
char *s = Yap_AbsoluteFile("~/.YAP.history",NULL);
|
|
if (!read_history (s))
|
|
{ FILE *f = fopen(s, "w");
|
|
if (f) {
|
|
fclose(f);
|
|
read_history (s);
|
|
}
|
|
}
|
|
rl_readline_name = "Prolog";
|
|
rl_attempted_completion_function = prolog_completion;
|
|
#ifdef HAVE_RL_COMPLETION_FUNC_T
|
|
rl_add_defun("prolog-complete", prolog_complete, '\t');
|
|
#else
|
|
rl_add_defun("prolog-complete", (void *)prolog_complete, '\t');
|
|
#endif
|
|
|
|
}
|
|
|
|
static bool
|
|
getLine( int inp, int out )
|
|
{
|
|
CACHE_REGS
|
|
rl_instream = GLOBAL_Stream[inp].file;
|
|
rl_outstream = GLOBAL_Stream[out].file;
|
|
const char *myrl_line;
|
|
StreamDesc *s = GLOBAL_Stream+inp;
|
|
|
|
if (!(s->status & Tty_Stream_f))
|
|
return false;
|
|
|
|
/* window of vulnerability opened */
|
|
LOCAL_PrologMode |= ConsoleGetcMode;
|
|
|
|
if (GLOBAL_Stream[out].linepos == 0) { // no output so far
|
|
myrl_line = readline (LOCAL_Prompt);
|
|
} else {
|
|
LOCAL_PrologMode |= ConsoleGetcMode;
|
|
myrl_line = readline (NULL);
|
|
}
|
|
/* Do it the gnu way */
|
|
if (LOCAL_PrologMode & InterruptMode) {
|
|
Yap_external_signal( 0, YAP_INT_SIGNAL );
|
|
LOCAL_PrologMode &= ~ConsoleGetcMode;
|
|
if (LOCAL_PrologMode & AbortMode) {
|
|
Yap_Error(PURE_ABORT, TermNil, "");
|
|
LOCAL_ErrorMessage = "Abort";
|
|
return console_post_process_eof(s);
|
|
}
|
|
} else {
|
|
LOCAL_PrologMode &= ~ConsoleGetcMode;
|
|
}
|
|
strncpy (LOCAL_Prompt, RepAtom (LOCAL_AtPrompt)->StrOfAE, MAX_PROMPT);
|
|
/* window of vulnerability closed */
|
|
if (myrl_line == NULL)
|
|
return false;
|
|
if (myrl_line[0] != '\0' && myrl_line[1] != '\0') {
|
|
add_history (myrl_line);
|
|
write_history ( Yap_AbsoluteFile("~/.YAP.history", NULL));
|
|
}
|
|
s->u.irl.ptr = s->u.irl.buf = myrl_line;
|
|
return true;
|
|
}
|
|
|
|
static int
|
|
ReadlinePutc (int sno, int ch)
|
|
{
|
|
StreamDesc *s = &GLOBAL_Stream[sno];
|
|
#if MAC || _MSC_VER || defined(__MINGW32__)
|
|
if (ch == 10)
|
|
{
|
|
putc ('\n', s->file);
|
|
}
|
|
else
|
|
#endif
|
|
putc (ch, s->file);
|
|
console_count_output_char(ch,s);
|
|
if (ch == 10) {
|
|
Yap_ReadlineFlush( sno );
|
|
}
|
|
return ((int) ch);
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
reading from the console is complicated because we need to
|
|
know whether to prompt and so on...
|
|
*/
|
|
static int
|
|
ReadlineGetc(int sno)
|
|
{
|
|
StreamDesc *s = &GLOBAL_Stream[sno];
|
|
int ch;
|
|
bool fetch = (s->u.irl.buf == NULL);
|
|
|
|
if (!fetch || getLine( sno, StdErrStream ) ) {
|
|
const char *ttyptr = s->u.irl.ptr++, *myrl_line = s->u.irl.buf;
|
|
ch = *ttyptr;
|
|
if (ch == '\0') {
|
|
ch = '\n';
|
|
free ((void *)myrl_line);
|
|
s->u.irl.ptr = s->u.irl.buf = NULL;
|
|
}
|
|
} else {
|
|
return EOF;
|
|
}
|
|
return console_post_process_read_char(ch, s);
|
|
}
|
|
|
|
int
|
|
Yap_ReadlineForSIGINT(void)
|
|
{
|
|
CACHE_REGS
|
|
int ch;
|
|
StreamDesc *s = &GLOBAL_Stream[StdInStream];
|
|
const char *myrl_line = s->u.irl.buf;
|
|
|
|
if ((LOCAL_PrologMode & ConsoleGetcMode) && myrl_line != (char *) NULL) {
|
|
ch = myrl_line[0];
|
|
free((void *)myrl_line);
|
|
myrl_line = NULL;
|
|
return ch;
|
|
} else {
|
|
myrl_line = readline ("Action (h for help): ");
|
|
if (!myrl_line) {
|
|
ch = EOF;
|
|
return ch;
|
|
} else {
|
|
ch = myrl_line[0];
|
|
free((void *)myrl_line);
|
|
myrl_line = NULL;
|
|
return ch;
|
|
}
|
|
}
|
|
}
|
|
|
|
static Int has_readline(USES_REGS1)
|
|
{
|
|
#if HAVE_LIBREADLINE && HAVE_READLINE_READLINE_H
|
|
return true;
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
|
|
void Yap_InitReadline(void) {
|
|
Yap_InitCPred ("$has_readline", 0, has_readline, SafePredFlag|HiddenPredFlag);
|
|
InitReadline();
|
|
}
|
|
|
|
#endif
|