[bpt/guile.git] / guile-readline / readline.c

/* readline.c --- line editing support for Guile */

/* Copyright (C) 1997,1999,2000,2001 Free Software Foundation, Inc.
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2, or (at your option)
 * any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this software; see the file COPYING.  If not, write to
 * the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, MA 02111-1307 USA
 *
 */


\f

#include "libguile/_scm.h"
#ifdef HAVE_RL_GETC_FUNCTION
#include "libguile.h"
#include "libguile/gh.h"
#include "libguile/iselect.h"

#include <stdio.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#include <readline/readline.h>
#include <readline/history.h>
#ifndef __MINGW32__
#include <sys/time.h>
#else
#include <io.h>
#endif
#include <signal.h>

#include "libguile/validate.h"
#include "guile-readline/readline.h"

scm_t_option scm_readline_opts[] = {
  { SCM_OPTION_BOOLEAN, "history-file", 1,
    "Use history file." },
  { SCM_OPTION_INTEGER, "history-length", 200,
    "History length." },
  { SCM_OPTION_INTEGER, "bounce-parens", 500,
    "Time (ms) to show matching opening parenthesis (0 = off)."}
};

extern void stifle_history (int max);

SCM_DEFINE (scm_readline_options, "readline-options-interface", 0, 1, 0, 
            (SCM setting),
"")
#define FUNC_NAME s_scm_readline_options
{
  SCM ans = scm_options (setting,
			 scm_readline_opts,
			 SCM_N_READLINE_OPTIONS,
			 FUNC_NAME);
  stifle_history (SCM_HISTORY_LENGTH);
  return ans;
}
#undef FUNC_NAME

#ifndef HAVE_STRDUP
static char *
strdup (char *s)
{
  size_t len = strlen (s);
  char *new = malloc (len + 1);
  strcpy (new, s);
  return new;
}
#endif /* HAVE_STRDUP */

#ifndef HAVE_RL_CLEANUP_AFTER_SIGNAL

/* These are readline functions added in release 2.3.  They will work
 * together with readline-2.1 and 2.2.  (The readline interface is
 * disabled for earlier releases.)
 * They are declared static; if we want to use them elsewhere, then
 * we need external declarations for them, but at the moment, I don't
 * think anything else in Guile ought to use these.
 */

extern void _rl_clean_up_for_exit ();
extern void _rl_kill_kbd_macro ();
extern int _rl_init_argument ();

void
rl_cleanup_after_signal ()
{
#ifdef HAVE_RL_CLEAR_SIGNALS
  _rl_clean_up_for_exit ();
#endif
  (*rl_deprep_term_function) ();
#ifdef HAVE_RL_CLEAR_SIGNALS
  rl_clear_signals ();
#endif
  rl_pending_input = 0;
}

void
rl_free_line_state ()
{
  register HIST_ENTRY *entry;
   
  free_undo_list ();

  entry = current_history ();
  if (entry)
    entry->data = (char *)NULL; 
  
  _rl_kill_kbd_macro ();
  rl_clear_message ();
  _rl_init_argument ();
}

#endif /* !HAVE_RL_CLEANUP_AFTER_SIGNAL */

static int promptp;
static SCM input_port;
static SCM before_read;

static int
current_input_getc (FILE *in SCM_UNUSED)
{
  if (promptp && !SCM_FALSEP (before_read))
    {
      scm_apply (before_read, SCM_EOL, SCM_EOL);
      promptp = 0;
    }
  return scm_getc (input_port);
}

static void
redisplay ()
{
  rl_redisplay ();
  /* promptp = 1; */
}

static int in_readline = 0;
#ifdef USE_THREADS
static scm_t_mutex reentry_barrier_mutex;
#endif

static SCM internal_readline (SCM text);
static SCM handle_error (void *data, SCM tag, SCM args);
static void reentry_barrier (void);


SCM_DEFINE (scm_readline, "%readline", 0, 4, 0, 
            (SCM text, SCM inp, SCM outp, SCM read_hook),
"")
#define FUNC_NAME s_scm_readline
{
  SCM ans;
  
  reentry_barrier ();
  
  before_read = SCM_BOOL_F;

  if (!SCM_UNBNDP (text))
    {
      if (!SCM_STRINGP (text))
	{
	  --in_readline;
	  scm_wrong_type_arg (s_scm_readline, SCM_ARG1, text);
	}
    }
  
  if (!((SCM_UNBNDP (inp) && SCM_OPINFPORTP (scm_cur_inp))
	|| SCM_OPINFPORTP (inp)))
    {
      --in_readline;
      scm_misc_error (s_scm_readline,
		      "Input port is not open or not a file port",
		      SCM_EOL);
    }
  
  if (!((SCM_UNBNDP (outp) && SCM_OPINFPORTP (scm_cur_outp))
	|| SCM_OPOUTFPORTP (outp)))
    {
      --in_readline;
      scm_misc_error (s_scm_readline,
		      "Output port is not open or not a file port",
		      SCM_EOL);
    }

  if (!(SCM_UNBNDP (read_hook) || SCM_FALSEP (read_hook)))
    {
      if (!(SCM_NFALSEP (scm_thunk_p (read_hook))))
	{
	  --in_readline;
	  scm_wrong_type_arg (s_scm_readline, SCM_ARG4, read_hook);
	}
      before_read = read_hook;
    }

  scm_readline_init_ports (inp, outp);

  ans = scm_internal_catch (SCM_BOOL_T,
			    (scm_t_catch_body) internal_readline,
			    (void *) SCM_UNPACK (text),
			    handle_error, 0);

  fclose (rl_instream);
  fclose (rl_outstream);

  --in_readline;
  return ans;
}
#undef FUNC_NAME


static void
reentry_barrier ()
{
  int reentryp = 0;
#ifdef USE_THREADS
  /* We should rather use scm_t_mutexry_lock when it becomes available */
  scm_mutex_lock (&reentry_barrier_mutex);
#endif
  if (in_readline)
    reentryp = 1;
  else
    ++in_readline;
#ifdef USE_THREADS
  scm_mutex_unlock (&reentry_barrier_mutex);
#endif
  if (reentryp)
    scm_misc_error (s_scm_readline, "readline is not reentrant", SCM_EOL);
}

static SCM
handle_error (void *data, SCM tag, SCM args)
{
  rl_free_line_state ();
  rl_cleanup_after_signal ();
  fputc ('\n', rl_outstream); /* We don't want next output on this line */
  fclose (rl_instream);
  fclose (rl_outstream);
  --in_readline;
  scm_handle_by_throw (data, tag, args);
  return SCM_UNSPECIFIED; /* never reached */
}

static SCM
internal_readline (SCM text)
{
  SCM ret;
  char *s;
  char *prompt = SCM_UNBNDP (text) ? "" : SCM_STRING_CHARS (text);

  promptp = 1;
  s = readline (prompt);
  if (s)
    ret = scm_makfrom0str (s);
  else 
    ret = SCM_EOF_VAL;

  free (s);

  return ret;
}

static FILE *
stream_from_fport (SCM port, char *mode, const char *subr)
{
  int fd;
  FILE *f;

  fd = dup (((struct scm_t_fport *) SCM_STREAM (port))->fdes);
  if (fd == -1)
    {
      --in_readline;
      scm_syserror (subr);
    }

  f = fdopen (fd, mode);
  if (f == NULL)
    {
      --in_readline;
      scm_syserror (subr);
    }

  return f;
}

void
scm_readline_init_ports (SCM inp, SCM outp)
{
  if (SCM_UNBNDP (inp))
    inp = scm_cur_inp;
  
  if (SCM_UNBNDP (outp))
    outp = scm_cur_outp;
  
  if (!SCM_OPINFPORTP (inp)) {
    scm_misc_error (0,
                    "Input port is not open or not a file port",
                    SCM_EOL);
  }

  if (!SCM_OPOUTFPORTP (outp)) {
    scm_misc_error (0,
                    "Output port is not open or not a file port",
                    SCM_EOL);
  }

  input_port = inp;
  rl_instream = stream_from_fport (inp, "r", s_scm_readline);
  rl_outstream = stream_from_fport (outp, "w", s_scm_readline);
}


SCM_DEFINE (scm_add_history, "add-history", 1, 0, 0, 
            (SCM text),
"")
#define FUNC_NAME s_scm_add_history
{
  char* s;
  SCM_VALIDATE_STRING (1,text);

  s = SCM_STRING_CHARS (text);
  add_history (strdup (s));

  return SCM_UNSPECIFIED;
}
#undef FUNC_NAME


SCM_DEFINE (scm_read_history, "read-history", 1, 0, 0, 
            (SCM file),
"")
#define FUNC_NAME s_scm_read_history
{
  SCM_VALIDATE_STRING (1,file);
  return SCM_NEGATE_BOOL (read_history (SCM_STRING_CHARS (file)));
}
#undef FUNC_NAME


SCM_DEFINE (scm_write_history, "write-history", 1, 0, 0, 
            (SCM file),
"")
#define FUNC_NAME s_scm_write_history
{
  SCM_VALIDATE_STRING (1,file);
  return SCM_NEGATE_BOOL (write_history (SCM_STRING_CHARS (file)));
}
#undef FUNC_NAME

SCM_DEFINE (scm_clear_history, "clear-history", 0, 0, 0, 
            (),
	    "Clear the history buffer of the readline machinery.")
#define FUNC_NAME s_scm_clear_history
{
  clear_history();
  return SCM_UNSPECIFIED;
}
#undef FUNC_NAME


SCM_DEFINE (scm_filename_completion_function, "filename-completion-function", 2, 0, 0, 
            (SCM text, SCM continuep),
"")
#define FUNC_NAME s_scm_filename_completion_function
{
  char *s;
  SCM ans;
  SCM_VALIDATE_STRING (1,text);
#ifdef HAVE_RL_FILENAME_COMPLETION_FUNCTION
  s = rl_filename_completion_function (SCM_STRING_CHARS (text), SCM_NFALSEP (continuep));
#else
  s = filename_completion_function (SCM_STRING_CHARS (text), SCM_NFALSEP (continuep));
#endif
  ans = scm_makfrom0str (s);
  free (s);
  return ans;
}
#undef FUNC_NAME

/*
 * The following has been modified from code contributed by
 * Andrew Archibald <aarchiba@undergrad.math.uwaterloo.ca>
 */

SCM scm_readline_completion_function_var;

static char *
completion_function (char *text, int continuep)
{
  SCM compfunc = SCM_VARIABLE_REF (scm_readline_completion_function_var);
  SCM res;

  if (SCM_FALSEP (compfunc))
    return NULL; /* #f => completion disabled */
  else
    {
      SCM t = scm_makfrom0str (text);
      SCM c = continuep ? SCM_BOOL_T : SCM_BOOL_F;
      res = scm_apply (compfunc, scm_list_2 (t, c), SCM_EOL);
  
      if (SCM_FALSEP (res))
	return NULL;
  
      if (!SCM_STRINGP (res))
	scm_misc_error (s_scm_readline,
			"Completion function returned bogus value: %S",
			scm_list_1 (res));
      return strdup (SCM_STRING_CHARS (res));
    }
}

/*Bouncing parenthesis (reimplemented by GH, 11/23/98, since readline is strict gpl)*/

static int match_paren (int x, int k);
static int find_matching_paren (int k);
static void init_bouncing_parens ();

static void
init_bouncing_parens ()
{
  if (strncmp (rl_get_keymap_name (rl_get_keymap ()), "vi", 2))
    {
      rl_bind_key (')', match_paren);
      rl_bind_key (']', match_paren);
      rl_bind_key ('}', match_paren);
    }
}

static int
find_matching_paren(int k)
{
  register int i;
  register char c = 0;
  int end_parens_found = 0;

  /* Choose the corresponding opening bracket.  */
  if (k == ')') c = '(';
  else if (k == ']') c = '[';
  else if (k == '}') c = '{';

  for (i=rl_point-2; i>=0; i--)
    {
      /* Is the current character part of a character literal?  */
      if (i - 2 >= 0
	  && rl_line_buffer[i - 1] == '\\'
	  && rl_line_buffer[i - 2] == '#')
	;
      else if (rl_line_buffer[i] == k)
	end_parens_found++;
      else if (rl_line_buffer[i] == '"')
	{
	  /* Skip over a string literal.  */
	  for (i--; i >= 0; i--)
	    if (rl_line_buffer[i] == '"'
		&& ! (i - 1 >= 0
		      && rl_line_buffer[i - 1] == '\\'))
	      break;
	}
      else if (rl_line_buffer[i] == c)
	{
	  if (end_parens_found==0)
	    return i;
	  else --end_parens_found;
	}
    }
  return -1;
}

static int
match_paren (int x, int k)
{
  int tmp, fno;
  SELECT_TYPE readset;
  struct timeval timeout;
  
  rl_insert (x, k);
  if (!SCM_READLINE_BOUNCE_PARENS)
    return 0;

  /* Did we just insert a quoted paren?  If so, then don't bounce.  */
  if (rl_point - 1 >= 1
      && rl_line_buffer[rl_point - 2] == '\\')
    return 0;

  tmp = 1000 * SCM_READLINE_BOUNCE_PARENS;
  timeout.tv_sec = tmp / 1000000;
  timeout.tv_usec = tmp % 1000000;
  FD_ZERO (&readset);
  fno = fileno (rl_instream);
  FD_SET (fno, &readset);
  
  if (rl_point > 1)
    {
      tmp = rl_point;
      rl_point = find_matching_paren (k);
      if (rl_point > -1)
	{
	  rl_redisplay ();
	  scm_internal_select (fno + 1, &readset, NULL, NULL, &timeout);
	}
      rl_point = tmp;
    }
  return 0;
}

#if defined (HAVE_RL_PRE_INPUT_HOOK) && defined (GUILE_SIGWINCH_SA_RESTART_CLEARED)
/* Readline disables SA_RESTART on SIGWINCH.
 * This code turns it back on.
 */
static int
sigwinch_enable_restart (void)
{
#ifdef HAVE_SIGINTERRUPT
  siginterrupt (SIGWINCH, 0);
#else
  struct sigaction action;
  
  sigaction (SIGWINCH, NULL, &action);
  action.sa_flags |= SA_RESTART;
  sigaction (SIGWINCH, &action, NULL);
#endif
  return 0;
}
#endif

#endif /* HAVE_RL_GETC_FUNCTION */

void
scm_init_readline ()
{
#ifdef HAVE_RL_GETC_FUNCTION
#include "guile-readline/readline.x"
  scm_readline_completion_function_var
    = scm_c_define ("*readline-completion-function*", SCM_BOOL_F);
  rl_getc_function = current_input_getc;
  rl_redisplay_function = redisplay;
#if defined (_RL_FUNCTION_TYPEDEF)
  rl_completion_entry_function = (rl_compentry_func_t*) completion_function;
#else  
  rl_completion_entry_function = (Function*) completion_function;
#endif
  rl_basic_word_break_characters = "\t\n\"'`;()";
  rl_readline_name = "Guile";
#if defined (HAVE_RL_PRE_INPUT_HOOK) && defined (GUILE_SIGWINCH_SA_RESTART_CLEARED)
  rl_pre_input_hook = sigwinch_enable_restart;
#endif

#ifdef USE_THREADS
  scm_mutex_init (&reentry_barrier_mutex);
#endif
  scm_init_opts (scm_readline_options,
		 scm_readline_opts,
		 SCM_N_READLINE_OPTIONS);
  init_bouncing_parens();
  scm_add_feature ("readline");
#endif /* HAVE_RL_GETC_FUNCTION */
}

/*
  Local Variables:
  c-file-style: "gnu"
  End:
*/
Commit	Line	Data
c374ab69 MV	1	/* readline.c --- line editing support for Guile */
c374ab69 MV	2
e81d98ec	3	/* Copyright (C) 1997,1999,2000,2001 Free Software Foundation, Inc.
c374ab69 MV	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License as published by
	7	* the Free Software Foundation; either version 2, or (at your option)
	8	* any later version.
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU General Public License
	16	* along with this software; see the file COPYING. If not, write to
c6e23ea2 JB	17	* the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
c6e23ea2 JB	18	* Boston, MA 02111-1307 USA
c374ab69 MV	19	*
c374ab69 MV	20	*/
f48e47b9	21
f48e47b9	22
c374ab69 MV	23	\f
c374ab69 MV	24
739b3bf1	25	#include "libguile/_scm.h"
62947883	26	#ifdef HAVE_RL_GETC_FUNCTION
fbf68f8b	27	#include "libguile.h"
739b3bf1 MD	28	#include "libguile/gh.h"
	29	#include "libguile/iselect.h"
	30
ffdeebc3	31	#include <stdio.h>
48552b1d MD	32	#ifdef HAVE_UNISTD_H
	33	#include <unistd.h>
	34	#endif
c374ab69 MV	35	#include <readline/readline.h>
c374ab69 MV	36	#include <readline/history.h>
5e90b6ac	37	#ifndef __MINGW32__
c374ab69	38	#include <sys/time.h>
5e90b6ac MV	39	#else
	40	#include <io.h>
	41	#endif
b71099ba	42	#include <signal.h>
c374ab69	43
1c537018	44	#include "libguile/validate.h"
a0599745	45	#include "guile-readline/readline.h"
c374ab69	46
593be5d2	47	scm_t_option scm_readline_opts[] = {
c374ab69 MV	48	{ SCM_OPTION_BOOLEAN, "history-file", 1,
	49	"Use history file." },
	50	{ SCM_OPTION_INTEGER, "history-length", 200,
	51	"History length." },
	52	{ SCM_OPTION_INTEGER, "bounce-parens", 500,
	53	"Time (ms) to show matching opening parenthesis (0 = off)."}
	54	};
	55
	56	extern void stifle_history (int max);
	57
b916d813	58	SCM_DEFINE (scm_readline_options, "readline-options-interface", 0, 1, 0,
f48e47b9 GB	59	(SCM setting),
	60	"")
	61	#define FUNC_NAME s_scm_readline_options
c374ab69 MV	62	{
	63	SCM ans = scm_options (setting,
	64	scm_readline_opts,
	65	SCM_N_READLINE_OPTIONS,
f48e47b9	66	FUNC_NAME);
c374ab69 MV	67	stifle_history (SCM_HISTORY_LENGTH);
	68	return ans;
	69	}
f48e47b9	70	#undef FUNC_NAME
c374ab69 MV	71
	72	#ifndef HAVE_STRDUP
	73	static char *
	74	strdup (char *s)
	75	{
1be6b49c	76	size_t len = strlen (s);
c374ab69 MV	77	char *new = malloc (len + 1);
	78	strcpy (new, s);
	79	return new;
	80	}
	81	#endif /* HAVE_STRDUP */
	82
	83	#ifndef HAVE_RL_CLEANUP_AFTER_SIGNAL
	84
	85	/* These are readline functions added in release 2.3. They will work
	86	* together with readline-2.1 and 2.2. (The readline interface is
	87	* disabled for earlier releases.)
	88	* They are declared static; if we want to use them elsewhere, then
	89	* we need external declarations for them, but at the moment, I don't
	90	* think anything else in Guile ought to use these.
	91	*/
	92
	93	extern void _rl_clean_up_for_exit ();
	94	extern void _rl_kill_kbd_macro ();
	95	extern int _rl_init_argument ();
	96
2e3d5987	97	void
c374ab69 MV	98	rl_cleanup_after_signal ()
	99	{
	100	#ifdef HAVE_RL_CLEAR_SIGNALS
	101	_rl_clean_up_for_exit ();
	102	#endif
	103	(*rl_deprep_term_function) ();
	104	#ifdef HAVE_RL_CLEAR_SIGNALS
	105	rl_clear_signals ();
	106	#endif
	107	rl_pending_input = 0;
	108	}
	109
2e3d5987	110	void
c374ab69 MV	111	rl_free_line_state ()
	112	{
	113	register HIST_ENTRY *entry;
	114
	115	free_undo_list ();
	116
	117	entry = current_history ();
	118	if (entry)
	119	entry->data = (char *)NULL;
	120
	121	_rl_kill_kbd_macro ();
	122	rl_clear_message ();
	123	_rl_init_argument ();
	124	}
	125
	126	#endif /* !HAVE_RL_CLEANUP_AFTER_SIGNAL */
	127
	128	static int promptp;
	129	static SCM input_port;
	130	static SCM before_read;
	131
	132	static int
e81d98ec	133	current_input_getc (FILE *in SCM_UNUSED)
c374ab69	134	{
379b35da	135	if (promptp && !SCM_FALSEP (before_read))
c374ab69 MV	136	{
	137	scm_apply (before_read, SCM_EOL, SCM_EOL);
	138	promptp = 0;
	139	}
bc858b80	140	return scm_getc (input_port);
c374ab69 MV	141	}
	142
	143	static void
	144	redisplay ()
	145	{
	146	rl_redisplay ();
	147	/* promptp = 1; */
	148	}
	149
c374ab69 MV	150	static int in_readline = 0;
c374ab69 MV	151	#ifdef USE_THREADS
593be5d2	152	static scm_t_mutex reentry_barrier_mutex;
c374ab69 MV	153	#endif
c374ab69 MV	154
f48e47b9 GB	155	static SCM internal_readline (SCM text);
f48e47b9 GB	156	static SCM handle_error (void *data, SCM tag, SCM args);
48552b1d	157	static void reentry_barrier (void);
f48e47b9 GB	158
f48e47b9 GB	159
b916d813	160	SCM_DEFINE (scm_readline, "%readline", 0, 4, 0,
f48e47b9 GB	161	(SCM text, SCM inp, SCM outp, SCM read_hook),
	162	"")
	163	#define FUNC_NAME s_scm_readline
	164	{
	165	SCM ans;
	166
	167	reentry_barrier ();
	168
	169	before_read = SCM_BOOL_F;
	170
	171	if (!SCM_UNBNDP (text))
	172	{
379b35da	173	if (!SCM_STRINGP (text))
f48e47b9 GB	174	{
	175	--in_readline;
	176	scm_wrong_type_arg (s_scm_readline, SCM_ARG1, text);
	177	}
f48e47b9 GB	178	}
f48e47b9 GB	179
379b35da DH	180	if (!((SCM_UNBNDP (inp) && SCM_OPINFPORTP (scm_cur_inp))
379b35da DH	181	\|\| SCM_OPINFPORTP (inp)))
f48e47b9 GB	182	{
	183	--in_readline;
	184	scm_misc_error (s_scm_readline,
	185	"Input port is not open or not a file port",
	186	SCM_EOL);
	187	}
	188
379b35da DH	189	if (!((SCM_UNBNDP (outp) && SCM_OPINFPORTP (scm_cur_outp))
379b35da DH	190	\|\| SCM_OPOUTFPORTP (outp)))
f48e47b9 GB	191	{
	192	--in_readline;
	193	scm_misc_error (s_scm_readline,
	194	"Output port is not open or not a file port",
	195	SCM_EOL);
	196	}
	197
	198	if (!(SCM_UNBNDP (read_hook) \|\| SCM_FALSEP (read_hook)))
	199	{
	200	if (!(SCM_NFALSEP (scm_thunk_p (read_hook))))
	201	{
	202	--in_readline;
	203	scm_wrong_type_arg (s_scm_readline, SCM_ARG4, read_hook);
	204	}
	205	before_read = read_hook;
	206	}
	207
	208	scm_readline_init_ports (inp, outp);
	209
	210	ans = scm_internal_catch (SCM_BOOL_T,
593be5d2	211	(scm_t_catch_body) internal_readline,
f60d011a	212	(void *) SCM_UNPACK (text),
f48e47b9 GB	213	handle_error, 0);
	214
	215	fclose (rl_instream);
	216	fclose (rl_outstream);
	217
	218	--in_readline;
	219	return ans;
	220	}
	221	#undef FUNC_NAME
	222
	223
c374ab69 MV	224	static void
	225	reentry_barrier ()
	226	{
	227	int reentryp = 0;
	228	#ifdef USE_THREADS
593be5d2	229	/* We should rather use scm_t_mutexry_lock when it becomes available */
c374ab69 MV	230	scm_mutex_lock (&reentry_barrier_mutex);
	231	#endif
	232	if (in_readline)
	233	reentryp = 1;
	234	else
	235	++in_readline;
	236	#ifdef USE_THREADS
	237	scm_mutex_unlock (&reentry_barrier_mutex);
	238	#endif
	239	if (reentryp)
f48e47b9	240	scm_misc_error (s_scm_readline, "readline is not reentrant", SCM_EOL);
c374ab69 MV	241	}
	242
	243	static SCM
	244	handle_error (void *data, SCM tag, SCM args)
	245	{
	246	rl_free_line_state ();
	247	rl_cleanup_after_signal ();
739b3bf1	248	fputc ('\n', rl_outstream); /* We don't want next output on this line */
c374ab69 MV	249	fclose (rl_instream);
	250	fclose (rl_outstream);
	251	--in_readline;
	252	scm_handle_by_throw (data, tag, args);
	253	return SCM_UNSPECIFIED; /* never reached */
	254	}
	255
	256	static SCM
	257	internal_readline (SCM text)
	258	{
	259	SCM ret;
	260	char *s;
08b5e6c3	261	char *prompt = SCM_UNBNDP (text) ? "" : SCM_STRING_CHARS (text);
c374ab69 MV	262
	263	promptp = 1;
	264	s = readline (prompt);
	265	if (s)
	266	ret = scm_makfrom0str (s);
	267	else
	268	ret = SCM_EOF_VAL;
	269
	270	free (s);
	271
	272	return ret;
	273	}
	274
	275	static FILE *
	276	stream_from_fport (SCM port, char mode, const char subr)
	277	{
	278	int fd;
	279	FILE *f;
	280
593be5d2	281	fd = dup (((struct scm_t_fport *) SCM_STREAM (port))->fdes);
c374ab69 MV	282	if (fd == -1)
	283	{
	284	--in_readline;
	285	scm_syserror (subr);
	286	}
	287
	288	f = fdopen (fd, mode);
	289	if (f == NULL)
	290	{
	291	--in_readline;
	292	scm_syserror (subr);
	293	}
	294
	295	return f;
	296	}
	297
2e3d5987 MD	298	void
	299	scm_readline_init_ports (SCM inp, SCM outp)
	300	{
	301	if (SCM_UNBNDP (inp))
	302	inp = scm_cur_inp;
	303
	304	if (SCM_UNBNDP (outp))
	305	outp = scm_cur_outp;
	306
379b35da	307	if (!SCM_OPINFPORTP (inp)) {
2e3d5987 MD	308	scm_misc_error (0,
	309	"Input port is not open or not a file port",
	310	SCM_EOL);
	311	}
	312
379b35da	313	if (!SCM_OPOUTFPORTP (outp)) {
2e3d5987 MD	314	scm_misc_error (0,
	315	"Output port is not open or not a file port",
	316	SCM_EOL);
	317	}
	318
	319	input_port = inp;
f48e47b9 GB	320	rl_instream = stream_from_fport (inp, "r", s_scm_readline);
f48e47b9 GB	321	rl_outstream = stream_from_fport (outp, "w", s_scm_readline);
2e3d5987 MD	322	}
2e3d5987 MD	323
c374ab69	324
c374ab69	325
b916d813	326	SCM_DEFINE (scm_add_history, "add-history", 1, 0, 0,
f48e47b9 GB	327	(SCM text),
	328	"")
	329	#define FUNC_NAME s_scm_add_history
c374ab69 MV	330	{
c374ab69 MV	331	char* s;
cbaee92a	332	SCM_VALIDATE_STRING (1,text);
c374ab69	333
08b5e6c3	334	s = SCM_STRING_CHARS (text);
c374ab69 MV	335	add_history (strdup (s));
	336
	337	return SCM_UNSPECIFIED;
	338	}
f48e47b9	339	#undef FUNC_NAME
c374ab69 MV	340
c374ab69 MV	341
b916d813	342	SCM_DEFINE (scm_read_history, "read-history", 1, 0, 0,
f48e47b9 GB	343	(SCM file),
	344	"")
	345	#define FUNC_NAME s_scm_read_history
c374ab69	346	{
cbaee92a	347	SCM_VALIDATE_STRING (1,file);
08b5e6c3	348	return SCM_NEGATE_BOOL (read_history (SCM_STRING_CHARS (file)));
c374ab69	349	}
f48e47b9	350	#undef FUNC_NAME
c374ab69 MV	351
c374ab69 MV	352
b916d813	353	SCM_DEFINE (scm_write_history, "write-history", 1, 0, 0,
f48e47b9 GB	354	(SCM file),
	355	"")
	356	#define FUNC_NAME s_scm_write_history
c374ab69	357	{
cbaee92a	358	SCM_VALIDATE_STRING (1,file);
08b5e6c3	359	return SCM_NEGATE_BOOL (write_history (SCM_STRING_CHARS (file)));
c374ab69	360	}
f48e47b9	361	#undef FUNC_NAME
c374ab69	362
8ed35a15 MV	363	SCM_DEFINE (scm_clear_history, "clear-history", 0, 0, 0,
	364	(),
	365	"Clear the history buffer of the readline machinery.")
	366	#define FUNC_NAME s_scm_clear_history
	367	{
	368	clear_history();
	369	return SCM_UNSPECIFIED;
	370	}
	371	#undef FUNC_NAME
	372
c374ab69	373
b916d813	374	SCM_DEFINE (scm_filename_completion_function, "filename-completion-function", 2, 0, 0,
f48e47b9 GB	375	(SCM text, SCM continuep),
	376	"")
	377	#define FUNC_NAME s_scm_filename_completion_function
c374ab69 MV	378	{
	379	char *s;
	380	SCM ans;
cbaee92a	381	SCM_VALIDATE_STRING (1,text);
dcb17187 MV	382	#ifdef HAVE_RL_FILENAME_COMPLETION_FUNCTION
	383	s = rl_filename_completion_function (SCM_STRING_CHARS (text), SCM_NFALSEP (continuep));
	384	#else
08b5e6c3	385	s = filename_completion_function (SCM_STRING_CHARS (text), SCM_NFALSEP (continuep));
dcb17187	386	#endif
c374ab69 MV	387	ans = scm_makfrom0str (s);
	388	free (s);
	389	return ans;
	390	}
f48e47b9	391	#undef FUNC_NAME
c374ab69 MV	392
	393	/*
	394	* The following has been modified from code contributed by
	395	* Andrew Archibald <aarchiba@undergrad.math.uwaterloo.ca>
	396	*/
	397
	398	SCM scm_readline_completion_function_var;
	399
	400	static char *
	401	completion_function (char *text, int continuep)
	402	{
296ff5e7	403	SCM compfunc = SCM_VARIABLE_REF (scm_readline_completion_function_var);
c374ab69 MV	404	SCM res;
	405
	406	if (SCM_FALSEP (compfunc))
	407	return NULL; /* #f => completion disabled */
	408	else
	409	{
	410	SCM t = scm_makfrom0str (text);
	411	SCM c = continuep ? SCM_BOOL_T : SCM_BOOL_F;
5b2a7b59	412	res = scm_apply (compfunc, scm_list_2 (t, c), SCM_EOL);
c374ab69 MV	413
	414	if (SCM_FALSEP (res))
	415	return NULL;
	416
379b35da	417	if (!SCM_STRINGP (res))
f48e47b9	418	scm_misc_error (s_scm_readline,
c374ab69	419	"Completion function returned bogus value: %S",
5b2a7b59	420	scm_list_1 (res));
08b5e6c3	421	return strdup (SCM_STRING_CHARS (res));
c374ab69 MV	422	}
	423	}
	424
	425	/Bouncing parenthesis (reimplemented by GH, 11/23/98, since readline is strict gpl)/
	426
576cdec4 MD	427	static int match_paren (int x, int k);
	428	static int find_matching_paren (int k);
	429	static void init_bouncing_parens ();
c374ab69 MV	430
c374ab69 MV	431	static void
576cdec4	432	init_bouncing_parens ()
c374ab69	433	{
576cdec4 MD	434	if (strncmp (rl_get_keymap_name (rl_get_keymap ()), "vi", 2))
	435	{
	436	rl_bind_key (')', match_paren);
	437	rl_bind_key (']', match_paren);
	438	rl_bind_key ('}', match_paren);
	439	}
c374ab69 MV	440	}
	441
	442	static int
	443	find_matching_paren(int k)
	444	{
	445	register int i;
	446	register char c = 0;
	447	int end_parens_found = 0;
	448
	449	/* Choose the corresponding opening bracket. */
	450	if (k == ')') c = '(';
	451	else if (k == ']') c = '[';
	452	else if (k == '}') c = '{';
	453
	454	for (i=rl_point-2; i>=0; i--)
	455	{
	456	/* Is the current character part of a character literal? */
	457	if (i - 2 >= 0
	458	&& rl_line_buffer[i - 1] == '\\'
	459	&& rl_line_buffer[i - 2] == '#')
	460	;
	461	else if (rl_line_buffer[i] == k)
	462	end_parens_found++;
	463	else if (rl_line_buffer[i] == '"')
	464	{
	465	/* Skip over a string literal. */
	466	for (i--; i >= 0; i--)
	467	if (rl_line_buffer[i] == '"'
	468	&& ! (i - 1 >= 0
	469	&& rl_line_buffer[i - 1] == '\\'))
	470	break;
	471	}
	472	else if (rl_line_buffer[i] == c)
	473	{
576cdec4 MD	474	if (end_parens_found==0)
576cdec4 MD	475	return i;
c374ab69 MV	476	else --end_parens_found;
	477	}
	478	}
	479	return -1;
	480	}
	481
576cdec4 MD	482	static int
576cdec4 MD	483	match_paren (int x, int k)
c374ab69	484	{
bc858b80	485	int tmp, fno;
aba2031a	486	SELECT_TYPE readset;
c374ab69 MV	487	struct timeval timeout;
c374ab69 MV	488
576cdec4	489	rl_insert (x, k);
c374ab69	490	if (!SCM_READLINE_BOUNCE_PARENS)
576cdec4	491	return 0;
c374ab69 MV	492
	493	/* Did we just insert a quoted paren? If so, then don't bounce. */
	494	if (rl_point - 1 >= 1
	495	&& rl_line_buffer[rl_point - 2] == '\\')
576cdec4	496	return 0;
c374ab69 MV	497
	498	tmp = 1000 * SCM_READLINE_BOUNCE_PARENS;
	499	timeout.tv_sec = tmp / 1000000;
	500	timeout.tv_usec = tmp % 1000000;
576cdec4	501	FD_ZERO (&readset);
bc858b80 MD	502	fno = fileno (rl_instream);
bc858b80 MD	503	FD_SET (fno, &readset);
c374ab69	504
576cdec4 MD	505	if (rl_point > 1)
	506	{
	507	tmp = rl_point;
	508	rl_point = find_matching_paren (k);
	509	if (rl_point > -1)
	510	{
	511	rl_redisplay ();
bc858b80	512	scm_internal_select (fno + 1, &readset, NULL, NULL, &timeout);
576cdec4 MD	513	}
576cdec4 MD	514	rl_point = tmp;
c374ab69	515	}
576cdec4	516	return 0;
c374ab69 MV	517	}
c374ab69 MV	518
b71099ba MD	519	#if defined (HAVE_RL_PRE_INPUT_HOOK) && defined (GUILE_SIGWINCH_SA_RESTART_CLEARED)
	520	/* Readline disables SA_RESTART on SIGWINCH.
	521	* This code turns it back on.
	522	*/
	523	static int
	524	sigwinch_enable_restart (void)
	525	{
	526	#ifdef HAVE_SIGINTERRUPT
	527	siginterrupt (SIGWINCH, 0);
	528	#else
	529	struct sigaction action;
	530
	531	sigaction (SIGWINCH, NULL, &action);
	532	action.sa_flags \|= SA_RESTART;
	533	sigaction (SIGWINCH, &action, NULL);
	534	#endif
	535	return 0;
	536	}
	537	#endif
	538
26047451 MD	539	#endif /* HAVE_RL_GETC_FUNCTION */
26047451 MD	540
c374ab69 MV	541	void
	542	scm_init_readline ()
	543	{
62947883	544	#ifdef HAVE_RL_GETC_FUNCTION
a0599745	545	#include "guile-readline/readline.x"
c374ab69	546	scm_readline_completion_function_var
296ff5e7	547	= scm_c_define ("readline-completion-function", SCM_BOOL_F);
c374ab69 MV	548	rl_getc_function = current_input_getc;
c374ab69 MV	549	rl_redisplay_function = redisplay;
dcb17187 MV	550	#if defined (_RL_FUNCTION_TYPEDEF)
	551	rl_completion_entry_function = (rl_compentry_func_t*) completion_function;
	552	#else
c374ab69	553	rl_completion_entry_function = (Function*) completion_function;
dcb17187	554	#endif
c374ab69	555	rl_basic_word_break_characters = "\t\n\"'`;()";
5c11cc9d	556	rl_readline_name = "Guile";
b71099ba MD	557	#if defined (HAVE_RL_PRE_INPUT_HOOK) && defined (GUILE_SIGWINCH_SA_RESTART_CLEARED)
	558	rl_pre_input_hook = sigwinch_enable_restart;
	559	#endif
5c11cc9d	560
c374ab69	561	#ifdef USE_THREADS
b74b1a63	562	scm_mutex_init (&reentry_barrier_mutex);
c374ab69 MV	563	#endif
	564	scm_init_opts (scm_readline_options,
	565	scm_readline_opts,
	566	SCM_N_READLINE_OPTIONS);
	567	init_bouncing_parens();
	568	scm_add_feature ("readline");
62947883	569	#endif /* HAVE_RL_GETC_FUNCTION */
c374ab69 MV	570	}
c374ab69 MV	571
89e00824 ML	572	/*
	573	Local Variables:
	574	c-file-style: "gnu"
	575	End:
	576	*/