#ifndef DAVIS_SLANG_H_
#define DAVIS_SLANG_H_
/* -*- mode: C; mode: fold; -*- */
/* Copyright (c) 1992, 1995 John E. Davis
 * All rights reserved.
 * 
 * You may distribute under the terms of either the GNU General Public
 * License or the Perl Artistic License.
 */
#define SLANG_VERSION 9938
/*{{{ System Dependent Macros and Typedefs */

#if defined(__WATCOMC__) && !defined(__QNX__)
#  ifndef msdos
#    define msdos
#  endif
#  ifndef  DOS386
#    define  DOS386
#  endif
#  ifndef FLOAT_TYPE
#    define FLOAT_TYPE
#  endif
#  ifndef pc_system
#    define pc_system
#  endif
#endif /* __watcomc__ */

#ifdef unix
# ifndef __unix__
#  define __unix__ 1
# endif
#endif

#ifndef __GO32__
# ifdef __unix__
#  define REAL_UNIX_SYSTEM
# endif
#endif

/* Set of the various defines for pc systems.  This includes OS/2 */
#ifdef __MSDOS__
# ifndef msdos
#   define msdos
# endif
# ifndef pc_system
#   define pc_system
# endif
#endif

#ifdef __GO32__
# ifndef pc_system
#   define pc_system
# endif
# ifdef REAL_UNIX_SYSTEM
#   undef REAL_UNIX_SYSTEM
# endif
#endif

#if defined(__EMX__) && defined(OS2)
# ifndef pc_system
#   define pc_system
# endif
# ifndef __os2__
#   define __os2__
# endif
#endif

#ifdef __cplusplus
extern "C" {
#endif
#if 0
}
#endif
/* ---------------------------- Generic Macros ----------------------------- */

/*  __SC__ is defined for Symantec C++
   DOS386 is defined for -mx memory model, 32 bit DOS extender. */

#ifdef VOID
# undef VOID
#endif

#if defined(msdos) && !defined(DOS386) & !defined(__WIN32__) && !defined(__GO32__)
# ifdef __SC__
#  include <dos.h>
# endif
   typedef void *VOID_STAR;
# define VOID void
# include <alloc.h>
#else
# if defined (__cplusplus) || defined(__STDC__)
   typedef void *VOID_STAR;
#  define VOID void
# else
   typedef unsigned char *VOID_STAR;
#  define VOID unsigned char
# endif
#endif
   
#if 1
   typedef int (*FVOID_STAR)(void);
#else
# define FVOID_STAR VOID_STAR
#endif
   
#if defined(msdos) && !defined(DOS386) && !defined(__GO32__) && !defined(__WIN32__)
# define SLFREE(buf)  farfree((void far *)(buf))
# define SLMALLOC(x) farmalloc((unsigned long) (x))
# define SLREALLOC(buf, n) farrealloc((void far *) (buf), (unsigned long) (n))
# define SLCALLOC(n, m) farcalloc((unsigned long) (n), (unsigned long) (m))
#else
# if defined(VMS) && !defined(__DECC)
#  define SLFREE VAXC$FREE_OPT
#  define SLMALLOC VAXC$MALLOC_OPT
#  define SLREALLOC VAXC$REALLOC_OPT
#  define SLCALLOC VAXC$CALLOC_OPT
# else
#  define SLFREE(x) free((char *)(x))
#  define SLMALLOC malloc
#  if defined(__cplusplus) && !defined(__BEOS__)
#   define SLREALLOC(p,n) realloc((malloc_t) (p), (n))
#  else
#   define SLREALLOC realloc
#  endif
#  define SLCALLOC calloc
# endif
#endif

#ifdef SL_MALLOC_DEBUG
# undef SLMALLOC
# undef SLCALLOC
# undef SLREALLOC
# undef SLFREE
# define SLMALLOC(x) SLdebug_malloc((unsigned long) (x))
# define SLFREE(x) SLdebug_free((unsigned char *)(x))
# define SLCALLOC(n, m) SLdebug_calloc((unsigned long) (n), (unsigned long)(m))
# define SLREALLOC(p, x) SLdebug_realloc((unsigned char *)(p), (unsigned long)(x))
#endif /* SL_MALLOC_DEBUG */
   
   extern unsigned char *SLdebug_malloc (unsigned long);
   extern unsigned char *SLdebug_calloc (unsigned long, unsigned long);
   extern unsigned char *SLdebug_realloc (unsigned char *, unsigned long);
   extern void SLdebug_free (unsigned char *);
   extern void SLmalloc_dump_statistics (void);
   extern char *SLstrcpy(register char *, register char *);
   extern int SLstrcmp(register char *, register char *);
   extern char *SLstrncpy(char *, register char *, register  int);
   
   extern void SLmemset (char *, char, int);
   extern char *SLmemchr (register char *, register char, register int);
   extern char *SLmemcpy (char *, char *, int);
   extern int SLmemcmp (char *, char *, int);

#ifdef float64
# undef float64
#endif
   
#ifndef FLOAT64_TYPEDEFED
# define FLOAT64_TYPEDEFED
  typedef double float64;
#endif


/*}}}*/

/*{{{ Interpreter Typedefs */

#define SLANG_MAX_NAME_LEN 30
/* maximum length of an identifier */
/* first char in identifiers is the hash */

   /* Note that long is used for addresses instead of void *.  The reason for
    * this is that I have a gut feeling that sizeof (long) > sizeof(void *)
    * on some machines.  This is certainly the case for MSDOS where addresses
    * can be 16 bit.
    */
typedef struct SLang_Name_Type
  {
#ifdef SLANG_STATS
     int n;			       /* number of times referenced */
#endif
     char name[SLANG_MAX_NAME_LEN + 2]; /* [0] is hash */

     unsigned char sub_type;
     
/* Values for main_type may be as follows.  The particlular values are
 * for compatability.
 */
#define SLANG_LVARIABLE		0x01
#define SLANG_INTRINSIC 	0x06
#define SLANG_FUNCTION  	0x07
#define SLANG_GVARIABLE 	0x0D
#define SLANG_IVARIABLE 	0x0E           /* intrinsic variables */
/* Note!!! For Macro MAKE_VARIABLE below to work, SLANG_IVARIABLE Must
   be 1 less than SLANG_RVARIABLE!!! */
#define SLANG_RVARIABLE		0x0F	       /* read only variable */
     unsigned char main_type;
     void * addr;
  }
SLang_Name_Type;


typedef struct SLang_Load_Type
{
   long name;			       /* file name, string address, ... */
   long handle;			       /* FILE *, string address, etc... */
   
   char *ptr;			       /* input pointer to next line in object
					* to be read. 
					*/
   /* Things below here are used by S-Lang. */
   int type;			       /* 'F' = file, 'S' = String, etc.. */
   char *buf;			       /* buffer for file, etc... */
   char *(*read)(struct SLang_Load_Type *);   /* function to call to read obj */
   int n;			       /* line number, etc... */
   char token[256];		       /* token to be parsed */
   int ofs;			       /* offset from buf where last read
					* took place 
					*/
   int top_level;		       /* 1 if at top level of parsing */
} SLang_Load_Type;

#if defined(ultrix) && !defined(__GNUC__)
# ifndef NO_PROTOTYPES
#  define NO_PROTOTYPES
# endif
#endif
   
#ifndef NO_PROTOTYPES 
# define _PROTO(x) x
#else
# define _PROTO(x) ()
#endif

typedef struct SL_OOBinary_Type
{
   unsigned char sub_type;	       /* partner type for binary op */
   
   /* The function take the binary op as first argument, the operand types
    * form the second and third parameters and the last two parameters are 
    * pointers to the objects themselves.  It is up to the function to push
    * the result on the stack.  It must return 1 if it handled the operation 
    * return zero if the operation is not defined.
    */
   int (*binary_function)_PROTO((int, unsigned char, unsigned char, 
				  VOID_STAR, VOID_STAR));

   struct SL_OOBinary_Type *next;
}
SL_OOBinary_Type;

typedef struct
{
   /* Methods */
   void (*destroy)_PROTO((VOID_STAR));
   /* called to delete/free the object */
   char *(*string)_PROTO((VOID_STAR));
   /* returns a string representation of the object */
   int (*unary_function)_PROTO((int, unsigned char, VOID_STAR));
   /* unary operation function */
   SL_OOBinary_Type *binary_ops;
   
   int (*copy_function)_PROTO((unsigned char, VOID_STAR));
   /* This function is called do make a copy of the object */
} SLang_Class_Type;

extern SLang_Class_Type *SLang_Registered_Types[256];
   
typedef struct
{
   unsigned char main_type;	       /* SLANG_RVARIABLE, etc.. */
   unsigned char sub_type;	       /* int, string, etc... */
   long *obj;			       /* address of user structure */

   /* Everything below is considered private */
   unsigned int count;		       /* number of references */
}
SLuser_Object_Type;

   
/*}}}*/
/*{{{ Interpreter Function Prototypes */

  extern volatile int SLang_Error;
  /* Non zero if error occurs.  Must be reset to zero to continue. */

  extern int SLang_Traceback;
  /* If non-zero, dump an S-Lang traceback upon error.  Available as 
     _traceback in S-Lang. */

  extern char *SLang_User_Prompt;
  /* Prompt to use when reading from stdin */
  extern int SLang_Version;

  extern void (*SLang_Error_Routine)(char *);
  /* Pointer to application dependent error messaging routine.  By default,
     messages are displayed on stderr. */

  extern void (*SLang_Exit_Error_Hook)(char *);
  extern void SLang_exit_error (char *);
  extern void (*SLang_Dump_Routine)(char *);
  /* Called if S-Lang traceback is enabled as well as other debugging 
     routines (e.g., trace).  By default, these messages go to stderr. */
  
  extern void (*SLang_Interrupt)(void);
  /* function to call whenever inner interpreter is entered.  This is 
     a good place to set SLang_Error to USER_BREAK. */

  extern void (*SLang_User_Clear_Error)(void);
  /* function that gets called when '_clear_error' is called. */
  extern int (*SLang_User_Open_Slang_Object)(SLang_Load_Type *); 
  extern int (*SLang_User_Close_Slang_Object)(SLang_Load_Type *);
  /* user defined loading routines. */


  /* If non null, these call C functions before and after a slang function. */
  extern void (*SLang_Enter_Function)(char *);
  extern void (*SLang_Exit_Function)(char *);


/* Functions: */

   extern int init_SLang(void);   
   /* This function is mandatory and must be called by all applications */
   extern int init_SLfiles(void);
   /* called if fputs, fgets, etc are need in S-Lang */
   extern int init_SLmath(void);
   /* called if math functions sin, cos, etc... are needed. */

   extern int init_SLunix(void);
   /* unix system functions chmod, stat, etc... */

   extern int init_SLmatrix(void);
   
   extern int SLang_add_table(SLang_Name_Type *, char *);
   /* add application dependent function table p1 to S-Lang.  A name p2 less 
    *  than 32 characters must also be supplied.      
    * Returns 0 upon failure or 1 upon success. */

   extern int SLang_add_global_variable (char *);
   extern int SLang_load_object(SLang_Load_Type *);
   extern int SLang_load_file(char *);
   /* Load a file of S-Lang code for interpreting.  If the parameter is
   NULL, input comes from stdin. */

   extern void SLang_restart(int);
   /* should be called if an error occurs.  If the passed integer is
    * non-zero, items are popped off the stack; otherwise, the stack is 
    * left intact.  Any time the stack is believed to be trashed, this routine
    * should be called with a non-zero argument (e.g., if setjmp/longjmp is
    * called). */ 

   extern void SLang_byte_compile_file(char *, int *);
   /* takes a file of S-Lang code and ``byte-compiles'' it for faster
    * loading.  The new filename is equivalent to the old except that a `c' is
    * appended to the name.  (e.g., init.sl --> init.slc).  If the second 
    * parameter is non-zero, preprocess the file only.
    */

   extern void SLang_autoload(char *, char *);
   /* Automatically load S-Lang function p1 from file p2.  This function
      is also available via S-Lang */
   
   extern char *SLang_load_string(char *);
   /* Like SLang_load_file except input is from a null terminated string. */
   
   extern void SLang_do_pop(void);
   /* pops item off stack and frees any memory associated with it */
   
   extern int SLang_pop_integer(int *);
   /* pops integer *p0 from the stack.  Returns 0 upon success and non-zero
    * if the stack is empty or a type mismatch occurs, setting SLang_Error.
    */

   extern int SLpop_string (char **);
   extern int SLang_pop_string(char **, int *);
   /* pops string *p0 from stack.  If *p1 is non-zero, the string must be
    * freed after its use.  DO NOT FREE p0 if *p1 IS ZERO! Returns 0 upon
    * success */
      
   extern int SLang_pop_float(float64 *, int *, int *);
   /* Pops float *p1 from stack.  If *p3 is non-zero, *p1 was derived
      from the integer *p2. Returns zero upon success. */
      
   extern SLuser_Object_Type *SLang_pop_user_object (unsigned char);
   extern void SLang_free_user_object (SLuser_Object_Type *);
   extern void SLang_free_intrinsic_user_object (SLuser_Object_Type *);
   /* This is like SLang_free_user_object but is meant to free those
    * that have been declared as intrinsic variables by the application.
    * Normally an application would never need to call this.
    */

   extern void SLang_push_user_object (SLuser_Object_Type *);
   extern SLuser_Object_Type *SLang_create_user_object (unsigned char);
   
   extern int SLang_add_unary_op (unsigned char, FVOID_STAR);
   extern int SLang_add_binary_op (unsigned char, unsigned char, FVOID_STAR);
   extern int SLang_register_class (unsigned char, FVOID_STAR, FVOID_STAR);
   extern int SLang_add_copy_operation (unsigned char, FVOID_STAR);

   extern long *SLang_pop_pointer(unsigned char *, unsigned char *, int *);
   /* Returns a pointer to object of type *p1,*p2 on top of stack. 
      If *p3 is non-zero, the Object must be freed after use. */


   extern void SLang_push_float(float64);
   /* Push Float onto stack */

   extern void SLang_push_string(char *);
   /* Push string p1 onto stack */
   
   extern void SLang_push_integer(int);
   /* push integer p1 on stack */

   extern void SLang_push_malloced_string(char *);
   /* The normal SLang_push_string mallocs space for the string.  This one
      does not.  DO NOT FREE IT IF YOU USE THIS ROUTINE */

   extern int SLang_is_defined(char *);
   /* Return non-zero is p1 is defined otherwise returns 0. */
   
   extern int SLang_run_hooks(char *, char *, char *);
   /* calls S-Lang function p1 pushing strings p2 and p3 onto the stack
    * first.  If either string is NULL, it is not pushed. If p1 is not
    * defined, 0 is returned. */

   extern int SLang_execute_function(char *);
   /* Call S-Lang function p1.  Returns 0 if the function is not defined 
    * and 1 if it is.
    */

   extern char *SLang_find_name(char *);
   /* Return a pointer to p1 in table if it is defined.  Returns NULL
    * otherwise.  This is useful when one wants to avoid redundant strings. 
    */

   extern char *SLang_rpn_interpret(char *);
   /* Interpret string as reverse polish notation */

   extern void SLang_doerror(char *);
   /* set SLang_Error and display p1 as error message */
   
   extern SLuser_Object_Type *SLang_add_array(char *, long *, 
					      int, int, int, int, 
					      unsigned char, unsigned char);
   /* This function has not been tested thoroughly yet.  Its purpose is to 
    * allow a S-Lang procedure to access a C array. For example, suppose that 
    * you have an array of 100 ints defined as:
    *  
    *  int c_array[100];
    *
    * By calling something like:
    *
    *   SLang_add_array ("array_name", (long *) c_array, 1, 100, 0, 0,
    *   		 'i', SLANG_IVARIABLE);
    *
    * the array can be accessed by the name 'array_name'.  This function 
    * returns -1 upon failure.  The 3rd argument specifies the dimension 
    * of the array, the 4th, and 5th arguments specify how many elements
    * there are in the x,y, and z directions.  The last argument must 
    * be one of: 
    * 
    *        SLANG_IVARIABLE:  indicates array is writable
    *        SLANG_RVARIABLE:  indicates array is read only
    * 
    * Returns NULL upon failure.
    */


extern int SLang_free_array_handle (int);
/* This routine may be called by application to free array handle created by 
 * the application.  Returns 0 upon success, -1 if the handle is invalid and
 * -2 if the handle is not associated with a C array.
 */

   extern char *SLang_extract_list_element(char *, int *, int*);
   extern void SLexpand_escaped_string (register char *, register char *, 
					register char *);

extern SLang_Name_Type *SLang_get_function (char *);
/* The parameter is the name of a user defined S-Lang function.  This 
 * routine returns NULL if the function does not exist or it returns the
 * a pointer to it in an internal S-Lang table.  This pointer can be used
 * by 'SLexecute_function' to call the function directly from C.
 */
  
extern void SLexecute_function(SLang_Name_Type *);
/* This function allows an application to call a S-Lang function from within
 * the C program.  The parameter must be non-NULL and must have been 
 * previously obtained by a call to 'SLang_get_function'.
 */
extern void SLroll_stack (int *);
/* If argument *p is positive, the top |*p| objects on the stack are rolled
 * up.  If negative, the stack is rolled down.
 */

extern void SLmake_lut (unsigned char *, unsigned char *, unsigned char);

   extern int SLang_guess_type (char *);


/*}}}*/

/*{{{ Misc Functions */

extern char *SLmake_string (char *);
extern char *SLmake_nstring (char *, unsigned int);
/* Returns a null terminated string made from the first n characters of the
 * string.
 */

extern char *SLcurrent_time_string (void);

extern int SLatoi(unsigned char *);

extern int SLang_extract_token(char **, char *, int);
/* returns 0 upon failure and non-zero upon success.  The first parameter 
 * is a pointer to the input stream which this function will bump along.  
 * The second parameter is the buffer where the token is placed.  The third 
 * parameter is used internally by the S-Lang library and should be 0 for
 * user applications.
 */

/*}}}*/

/*{{{ SLang getkey interface Functions */
   
#ifdef REAL_UNIX_SYSTEM
extern int SLang_TT_Baud_Rate;
extern int SLang_TT_Read_FD;
#endif
   
extern int SLang_init_tty (int, int, int);
/* Initializes the tty for single character input.  If the first parameter *p1
 * is in the range 0-255, it will be used for the abort character;
 * otherwise, (unix only) if it is -1, the abort character will be the one
 * used by the terminal.  If the second parameter p2 is non-zero, flow
 * control is enabled.  If the last parmeter p3 is zero, output processing
 * is NOT turned on.  A value of zero is required for the screen management
 * routines. Returns 0 upon success. In addition, if SLang_TT_Baud_Rate ==
 * 0 when this function is called, SLang will attempt to determine the
 * terminals baud rate.  As far as the SLang library is concerned, if
 * SLang_TT_Baud_Rate is less than or equal to zero, the baud rate is
 * effectively infinite.
 */

extern void SLang_reset_tty (void);
/* Resets tty to what it was prior to a call to SLang_init_tty */
#ifdef REAL_UNIX_SYSTEM
extern void SLtty_set_suspend_state (int);
   /* If non-zero argument, terminal driver will be told to react to the
    * suspend character.  If 0, it will not.
    */
extern int (*SLang_getkey_intr_hook) (void);
#endif

#define SLANG_GETKEY_ERROR 0xFFFF
extern unsigned int SLang_getkey (void);
/* reads a single key from the tty.  If the read fails,  0xFFFF is returned. */

extern void SLang_ungetkey_string (unsigned char *, unsigned int);
extern void SLang_buffer_keystring (unsigned char *, unsigned int);
extern void SLang_ungetkey (unsigned char);
extern void SLang_flush_input (void);
extern int SLang_input_pending (int);
extern int SLang_Abort_Char;
/* The value of the character (0-255) used to trigger SIGINT */
extern int SLang_Ignore_User_Abort;
/* If non-zero, pressing the abort character will not result in USER_BREAK
 * SLang_Error. */

extern void SLang_set_abort_signal (void (*)(int));
/* If SIGINT is generated, the function p1 will be called.  If p1 is NULL
 * the SLang_default signal handler is called.  This sets SLang_Error to 
 * USER_BREAK.  I suspect most users will simply want to pass NULL.
 */

extern volatile int SLKeyBoard_Quit;

#ifdef VMS
/* If this function returns -1, ^Y will be added to input buffer. */
extern int (*SLtty_VMS_Ctrl_Y_Hook) (void);
#endif
/*}}}*/

/*{{{ SLang Keymap routines */

typedef struct SLKeymap_Function_Type
  {
      char *name;
      int (*f)(void);
  }
SLKeymap_Function_Type;

typedef struct SLang_Key_Type
  {
     unsigned char str[13];	       /* key sequence */
#define SLKEY_F_INTERPRET	0x01
#define SLKEY_F_INTRINSIC	0x02
#define SLKEY_F_KEYSYM		0x03
     unsigned char type;	       /* type of function */
#ifdef SLKEYMAP_OBSOLETE
     VOID_STAR f;			       /* function to invoke */
#else
     union
       {
	  char *s;
	  FVOID_STAR f;
	  unsigned int keysym;
       }
     f;
#endif
     struct SLang_Key_Type *next;      /* */
  }
SLang_Key_Type;

#define MAX_KEYMAP_NAME_LEN 8
typedef struct SLKeyMap_List_Type
{
   char name[MAX_KEYMAP_NAME_LEN + 1];
   SLang_Key_Type *keymap;
   SLKeymap_Function_Type *functions;  /* intrinsic functions */
}
SLKeyMap_List_Type;

/* This is arbitrary but I have got to start somewhere */
#ifdef msdos
#define SLANG_MAX_KEYMAPS 10
#else
#define SLANG_MAX_KEYMAPS 30
#endif

extern SLKeyMap_List_Type SLKeyMap_List[SLANG_MAX_KEYMAPS];   /* these better be inited to 0! */


extern char *SLang_process_keystring(char *);

#ifdef SLKEYMAP_OBSOLETE   
extern int SLang_define_key1(char *, VOID_STAR, unsigned int, SLKeyMap_List_Type *);
/* define key p1 in keymap p4 to invoke function p2.  If type p3 is given by
 * SLKEY_F_INTRINSIC, p2 is an intrinsic function, else it is a string to be
 * passed to the interpreter for evaluation.  The return value is important.
 * It returns 0 upon success, -1 upon malloc error, and -2 if the key is 
 * inconsistent.  SLang_Error is set upon error. */
#else
extern int SLkm_define_key (char *, FVOID_STAR, SLKeyMap_List_Type *);
#endif
   
extern int SLang_define_key(char *, char *, SLKeyMap_List_Type *);
/* Like define_key1 except that p2 is a string that is to be associated with 
 * a function in the functions field of p3.  This routine calls define_key1.
 */

extern int SLkm_define_keysym (char *, unsigned int, SLKeyMap_List_Type *);

extern void SLang_undefine_key(char *, SLKeyMap_List_Type *);

extern SLKeyMap_List_Type *SLang_create_keymap(char *, SLKeyMap_List_Type *);
/* create and returns a pointer to a new keymap named p1 created by copying
 * keymap p2.  If p2 is NULL, it is up to the calling routine to initialize
 * the keymap.
 */

extern char *SLang_make_keystring(unsigned char *);

extern SLang_Key_Type *SLang_do_key(SLKeyMap_List_Type *, int (*)(void));
/* read a key using keymap p1 with getkey function p2 */

extern
#ifdef SLKEYMAP_OBSOLETE
     VOID_STAR
#else
     FVOID_STAR
#endif
     SLang_find_key_function(char *, SLKeyMap_List_Type *);

extern SLKeyMap_List_Type *SLang_find_keymap(char *);

extern int SLang_Last_Key_Char;
extern int SLang_Key_TimeOut_Flag;


/*}}}*/

/*{{{ SLang Readline Interface */

typedef struct SLang_Read_Line_Type
{
   struct SLang_Read_Line_Type *prev, *next;
   unsigned char *buf;
   int buf_len;			       /* number of chars in the buffer */
   int num;			       /* num and misc are application specific*/
   int misc;
} SLang_Read_Line_Type;

/* Maximum size of display */
#define SLRL_DISPLAY_BUFFER_SIZE 256

typedef struct 
{
   SLang_Read_Line_Type *root, *tail, *last;
   unsigned char *buf;		       /* edit buffer */
   int buf_len;			       /* sizeof buffer */
   int point;			       /* current editing point */
   int tab;			       /* tab width */
   int len;			       /* current line size */
   
   /* display variables */
   int edit_width;		       /* length of display field */
   int curs_pos;			       /* current column */
   int start_column;		       /* column offset of display */
   int dhscroll;		       /* amount to use for horiz scroll */
   char *prompt;
   
   FVOID_STAR last_fun;		       /* last function executed by rl */

   /* These two contain an image of what is on the display */
   unsigned char upd_buf1[SLRL_DISPLAY_BUFFER_SIZE];
   unsigned char upd_buf2[SLRL_DISPLAY_BUFFER_SIZE];
   unsigned char *old_upd, *new_upd;   /* pointers to previous two buffers */
   int new_upd_len, old_upd_len;       /* length of output buffers */
   
   SLKeyMap_List_Type *keymap;

   /* tty variables */
   unsigned int flags;		       /*  */
#define SL_RLINE_NO_ECHO	1
#define SL_RLINE_USE_ANSI	2
   unsigned int (*getkey)(void);       /* getkey function -- required */
   void (*tt_goto_column)(int);
   void (*tt_insert)(char);
   void (*update_hook)(unsigned char *, int, int);
   /* The update hook is called with a pointer to a buffer p1 that contains
    * an image of what the update hook is suppoed to produce.  The length 
    * of the buffer is p2 and after the update, the cursor is to be placed
    * in column p3.
    */
} SLang_RLine_Info_Type;

extern int SLang_RL_EOF_Char;

extern SLang_Read_Line_Type * SLang_rline_save_line (SLang_RLine_Info_Type *);
extern int SLang_init_readline (SLang_RLine_Info_Type *);
extern int SLang_read_line (SLang_RLine_Info_Type *);
extern int SLang_rline_insert (char *);
extern void SLrline_redraw (SLang_RLine_Info_Type *);   
extern int SLang_Rline_Quit;

/*}}}*/

/*{{{ Low Level Screen Output Interface */

extern unsigned long SLtt_Num_Chars_Output;
extern int SLtt_Baud_Rate;

typedef unsigned long SLtt_Char_Type;

#define SLTT_BOLD_MASK	0x01000000
#define SLTT_BLINK_MASK	0x02000000
#define SLTT_ULINE_MASK	0x04000000
#define SLTT_REV_MASK	0x08000000
#define SLTT_ALTC_MASK  0x10000000

extern int SLtt_Screen_Rows;
extern int SLtt_Screen_Cols;
extern int SLtt_Term_Cannot_Insert;
extern int SLtt_Term_Cannot_Scroll;
extern int SLtt_Use_Ansi_Colors;
extern int SLtt_Ignore_Beep;
#if defined(REAL_UNIX_SYSTEM)
extern int SLtt_Force_Keypad_Init;
#endif
   
#ifndef __GO32__
#if defined(VMS) || defined(REAL_UNIX_SYSTEM)
extern int SLtt_Blink_Mode;
extern int SLtt_Use_Blink_For_ACS;
extern int SLtt_Newline_Ok;
extern int SLtt_Has_Alt_Charset;
extern int SLtt_Has_Status_Line;       /* if 0, NO.  If > 0, YES, IF -1, ?? */
# ifndef VMS
extern int SLtt_Try_Termcap;
# endif
#endif
#endif

#ifdef msdos
extern int SLtt_Msdos_Cheap_Video;
#endif
   
   
extern int SLtt_flush_output (void);
extern void SLtt_set_scroll_region(int, int);
extern void SLtt_reset_scroll_region(void);
extern void SLtt_reverse_video (int);
extern void SLtt_bold_video (void);
extern void SLtt_begin_insert(void);
extern void SLtt_end_insert(void);
extern void SLtt_del_eol(void);
extern void SLtt_goto_rc (int, int);
extern void SLtt_delete_nlines(int);
extern void SLtt_delete_char(void);
extern void SLtt_erase_line(void);
extern void SLtt_normal_video(void);
extern void SLtt_cls(void);
extern void SLtt_beep(void);
extern void SLtt_reverse_index(int);
extern void SLtt_smart_puts(unsigned short *, unsigned short *, int, int);
extern void SLtt_write_string (char *);
extern void SLtt_putchar(char);
extern void SLtt_init_video (void);
extern void SLtt_reset_video (void);
extern void SLtt_get_terminfo(void);
extern void SLtt_get_screen_size (void);
extern int SLtt_set_cursor_visibility (int);
   
#if defined(VMS) || defined(REAL_UNIX_SYSTEM)
extern void SLtt_enable_cursor_keys(void);
extern void SLtt_set_term_vtxxx(int *);
extern void SLtt_set_color_esc (int, char *);
extern void SLtt_wide_width(void);
extern void SLtt_narrow_width(void);
extern int SLtt_set_mouse_mode (int, int);
extern void SLtt_set_alt_char_set (int);
extern int SLtt_write_to_status_line (char *, int);
extern void SLtt_disable_status_line (void);
# ifdef REAL_UNIX_SYSTEM
   extern char *SLtt_tgetstr (char *);
   extern int SLtt_tgetnum (char *);
   extern int SLtt_tgetflag (char *);
   extern char *SLtt_tigetent (char *);
   extern char *SLtt_tigetstr (char *, char **);
   extern int SLtt_tigetnum (char *, char **);
# endif
#endif
   
extern SLtt_Char_Type SLtt_get_color_object (int);
extern void SLtt_set_color_object (int, SLtt_Char_Type);
extern void SLtt_set_color (int, char *, char *, char *);
extern void SLtt_set_mono (int, char *, SLtt_Char_Type);
extern void SLtt_add_color_attribute (int, SLtt_Char_Type);
extern void SLtt_set_color_fgbg (int, SLtt_Char_Type, SLtt_Char_Type);
     
/*}}}*/

/*{{{ SLang Preprocessor Interface */

typedef struct 
{
   int this_level;
   int exec_level;
   int prev_exec_level;
   char preprocess_char;
   char comment_char;
   unsigned char flags;
#define SLPREP_BLANK_LINES_OK	1
#define SLPREP_COMMENT_LINES_OK	2
}
SLPreprocess_Type;

extern int SLprep_open_prep (SLPreprocess_Type *);
extern void SLprep_close_prep (SLPreprocess_Type *);
extern int SLprep_line_ok (char *, SLPreprocess_Type *);
   extern int SLdefine_for_ifdef (char *);
   /* Adds a string to the SLang #ifdef preparsing defines. SLang already
      defines MSDOS, UNIX, and VMS on the appropriate system. */
extern int (*SLprep_exists_hook) (char *, char);
      
   
/*}}}*/

/*{{{ SLsmg Screen Management Functions */

#include <stdarg.h>
extern void SLsmg_fill_region (int, int, int, int, unsigned char);
#ifndef pc_system
extern void SLsmg_set_char_set (int);
extern int SLsmg_Scroll_Hash_Border;
#endif
extern void SLsmg_suspend_smg (void);
extern void SLsmg_resume_smg (void);
extern void SLsmg_erase_eol (void);
extern void SLsmg_gotorc (int, int);
extern void SLsmg_erase_eos (void);
extern void SLsmg_reverse_video (void);
extern void SLsmg_set_color (int);
extern void SLsmg_normal_video (void);
extern void SLsmg_printf (char *, ...);
extern void SLsmg_vprintf (char *, va_list);
extern void SLsmg_write_string (char *);
extern void SLsmg_write_nstring (char *, int);
extern void SLsmg_write_char (char);
extern void SLsmg_write_nchars (char *, int);
extern void SLsmg_write_wrapped_string (char *, int, int, int, int, int);
extern void SLsmg_cls (void);
extern void SLsmg_refresh (void);
extern void SLsmg_touch_lines (int, int);
extern int SLsmg_init_smg (void);
extern void SLsmg_reset_smg (void);
extern unsigned short SLsmg_char_at(void);
extern void SLsmg_set_screen_start (int *, int *);
extern void SLsmg_draw_hline (int);
extern void SLsmg_draw_vline (int);
extern void SLsmg_draw_object (int, int, unsigned char);
extern void SLsmg_draw_box (int, int, int, int);
extern int SLsmg_get_column(void);
extern int SLsmg_get_row(void);
extern void SLsmg_forward (int);
extern void SLsmg_write_color_chars (unsigned short *, unsigned int);
extern unsigned int SLsmg_read_raw (unsigned short *, unsigned int);
extern unsigned int SLsmg_write_raw (unsigned short *, unsigned int);
   
extern int SLsmg_Display_Eight_Bit;
extern int SLsmg_Tab_Width;
extern int SLsmg_Newline_Moves;
extern int SLsmg_Backspace_Moves;

#ifdef pc_system
# define SLSMG_HLINE_CHAR	0xC4
# define SLSMG_VLINE_CHAR	0xB3
# define SLSMG_ULCORN_CHAR	0xDA
# define SLSMG_URCORN_CHAR	0xBF
# define SLSMG_LLCORN_CHAR	0xC0
# define SLSMG_LRCORN_CHAR	0xD9
# define SLSMG_RTEE_CHAR	0xB4
# define SLSMG_LTEE_CHAR	0xC3
# define SLSMG_UTEE_CHAR	0xC2
# define SLSMG_DTEE_CHAR	0xC1
# define SLSMG_PLUS_CHAR	0xC5
/* There are several to choose from: 0xB0, 0xB1, and 0xB2 */
# define SLSMG_CKBRD_CHAR	0xB0
#else
# define SLSMG_HLINE_CHAR	'q'
# define SLSMG_VLINE_CHAR	'x'
# define SLSMG_ULCORN_CHAR	'l'
# define SLSMG_URCORN_CHAR	'k'
# define SLSMG_LLCORN_CHAR	'm'
# define SLSMG_LRCORN_CHAR	'j'
# define SLSMG_CKBRD_CHAR	'a'
# define SLSMG_RTEE_CHAR	'u'
# define SLSMG_LTEE_CHAR	't'
# define SLSMG_UTEE_CHAR	'w'
# define SLSMG_DTEE_CHAR	'v'
# define SLSMG_PLUS_CHAR	'n'
#endif

#ifndef pc_system
# define SLSMG_COLOR_BLACK		0x000000
# define SLSMG_COLOR_RED		0x000001
# define SLSMG_COLOR_GREEN		0x000002
# define SLSMG_COLOR_BROWN		0x000003
# define SLSMG_COLOR_BLUE		0x000004
# define SLSMG_COLOR_MAGENTA		0x000005
# define SLSMG_COLOR_CYAN		0x000006
# define SLSMG_COLOR_LGRAY		0x000007
# define SLSMG_COLOR_GRAY		0x000008
# define SLSMG_COLOR_BRIGHT_RED		0x000009
# define SLSMG_COLOR_BRIGHT_GREEN	0x00000A
# define SLSMG_COLOR_BRIGHT_BROWN	0x00000B
# define SLSMG_COLOR_BRIGHT_BLUE	0x00000C
# define SLSMG_COLOR_BRIGHT_CYAN	0x00000D
# define SLSMG_COLOR_BRIGHT_MAGENTA	0x00000E
# define SLSMG_COLOR_BRIGHT_WHITE	0x00000F
#endif

/*}}}*/

/*{{{ SLang Keypad Interface */

#define SL_KEY_ERR		0xFFFF

#define SL_KEY_UP		0x101
#define SL_KEY_DOWN		0x102
#define SL_KEY_LEFT		0x103
#define SL_KEY_RIGHT		0x104
#define SL_KEY_PPAGE		0x105
#define SL_KEY_NPAGE		0x106
#define SL_KEY_HOME		0x107
#define SL_KEY_END		0x108
#define SL_KEY_A1		0x109
#define SL_KEY_A3		0x10A
#define SL_KEY_B2		0x10B
#define SL_KEY_C1		0x10C
#define SL_KEY_C3		0x10D
#define SL_KEY_REDO		0x10E
#define SL_KEY_UNDO		0x10F
#define SL_KEY_BACKSPACE	0x110
#define SL_KEY_ENTER		0x111
#define SL_KEY_IC		0x112
#define SL_KEY_DELETE		0x113

#define SL_KEY_F0		0x200
#define SL_KEY_F(X)		(SL_KEY_F0 + X)

/* I do not intend to use keysymps > 0x1000.  Applications can use those. */
/* Returns 0 upon success or -1 upon error. */
int SLkp_define_keysym (char *, unsigned int);

/* This function must be called AFTER SLtt_get_terminfo and not before. */
extern int SLkp_init (void);

/* This function uses SLang_getkey and assumes that what ever initialization 
 * is required for SLang_getkey has been performed.
 */
extern int SLkp_getkey (void);

/*}}}*/

/*{{{ SLang Scroll Interface */

typedef struct _SLscroll_Type
{
   struct _SLscroll_Type *next;
   struct _SLscroll_Type *prev;
   unsigned int flags;
}
SLscroll_Type;

typedef struct 
{
   unsigned int flags;
   SLscroll_Type *top_window_line;   /* list element at top of window */
   SLscroll_Type *bot_window_line;   /* list element at bottom of window */
   SLscroll_Type *current_line;    /* current list element */
   SLscroll_Type *lines;	       /* first list element */
   unsigned int nrows;		       /* number of rows in window */
   unsigned int hidden_mask;	       /* applied to flags in SLscroll_Type */
   unsigned int line_num;	       /* current line number (visible) */
   unsigned int num_lines;	       /* total number of lines (visible) */
   unsigned int window_row;	       /* row of current_line in window */
   unsigned int border;		       /* number of rows that form scroll border */
   int cannot_scroll;		       /* should window scroll or recenter */
}
SLscroll_Window_Type;

extern int SLscroll_find_top (SLscroll_Window_Type *);
extern int SLscroll_find_line_num (SLscroll_Window_Type *);
extern unsigned int SLscroll_next_n (SLscroll_Window_Type *, unsigned int);
extern unsigned int SLscroll_prev_n (SLscroll_Window_Type *, unsigned int);
extern int SLscroll_pageup (SLscroll_Window_Type *);
extern int SLscroll_pagedown (SLscroll_Window_Type *);

/*}}}*/

/*{{{ Signal Routines */

typedef void SLSig_Fun_Type (int);
extern SLSig_Fun_Type *SLsignal (int, SLSig_Fun_Type *);
extern SLSig_Fun_Type *SLsignal_intr (int, SLSig_Fun_Type *);
#ifndef pc_system
extern int SLsig_block_signals (void);
extern int SLsig_unblock_signals (void);
#endif
/*}}}*/

/*{{{ Interpreter Macro Definitions */

/* This value is a main_type just like the other main_types defined
 * near the definition of SLang_Name_Type.  Applications should avoid using
 * this so if you do not understands its role, do not use it.
 */
#define SLANG_DATA		0x30           /* real objects which may be destroyed */

/* Subtypes */

/* The definitions here are for objects that may be on the run-time stack.
 * They are actually sub_types of literal and data main_types.
 */
#define VOID_TYPE	1
#define INT_TYPE 	2
#ifdef FLOAT_TYPE
# undef FLOAT_TYPE
# define FLOAT_TYPE	3
#endif
#define CHAR_TYPE	4
#define INTP_TYPE	5
/* An object of INTP_TYPE should never really occur on the stack.  Rather,
 * the integer to which it refers will be there instead.  It is defined here
 * because it is a valid type for MAKE_VARIABLE.
 */

#define SLANG_OBJ_TYPE	6
/* SLANG_OBJ_TYPE refers to an object on the stack that is a pointer to
 * some other object.
 */

#if 0
/* This is not ready yet.  */
# define SLANG_NOOP	9
#endif
   
/* Everything above string should correspond to a pointer in the object 
 * structure.  See do_binary (slang.c) for exploitation of this fact.
 */
#define STRING_TYPE 	10
/* Array type MUST be the smallest number for SLuser_Object_Type structs */
#define ARRAY_TYPE	20
/* I am reserving values greater than or equal to user applications.  The
 * first 99 are used for S-Lang.
 */


/* Binary and Unary Subtypes */
/* Since the application can define new types and can overload the binary
 * and unary operators, these definitions must be present in this file.
 */
#define SLANG_PLUS	1
#define SLANG_MINUS	2
#define SLANG_TIMES	3
#define SLANG_DIVIDE	4
#define SLANG_EQ		5
#define SLANG_NE		6
#define SLANG_GT		7
#define SLANG_GE		8
#define SLANG_LT		9
#define SLANG_LE		10

/* UNARY subtypes  (may be overloaded) */
#define SLANG_ABS	11
#define SLANG_SIGN	12
#define SLANG_SQR	13
#define SLANG_MUL2	14
#define SLANG_CHS	15

/* error codes, severe errors are less than 0 */
#define SL_INVALID_PARM		-6
#define SL_MALLOC_ERROR		-5
#define INTERNAL_ERROR		-4
#define UNKNOWN_ERROR		-3
#define STACK_OVERFLOW		-1
#define STACK_UNDERFLOW		-2
#define INTRINSIC_ERROR		1
/* Intrinsic error is an error generated by intrinsic functions */
#define USER_BREAK		2
#define UNDEFINED_NAME		3
#define SYNTAX_ERROR		4
#define DUPLICATE_DEFINITION	5
#define TYPE_MISMATCH		6
#define READONLY_ERROR		7
#define DIVIDE_ERROR		8
/* object could not be opened */
#define SL_OBJ_NOPEN		9
/* unknown object */
#define SL_OBJ_UNKNOWN		10

extern char *SLang_Error_Message;

extern void SLadd_name(char *, long, unsigned char, unsigned char);
extern void SLadd_at_handler (long *, char *);

#define SLANG_MAKE_ARGS(out, in) ((unsigned char)(out) | ((unsigned short) (in) << 4))

#ifdef SLANG_STATS

#define MAKE_INTRINSIC(n, f, out, in)        \
    {0, n, (out | (in << 4)), SLANG_INTRINSIC, (void *) f}
       
#define MAKE_VARIABLE(n, v, t, r)     \
    {0, n, t, (SLANG_IVARIABLE + r), (void *) v}

#else
#define MAKE_INTRINSIC(n, f, out, in)        \
    {n, (out | (in << 4)), SLANG_INTRINSIC, (void *) f}
       
#define MAKE_VARIABLE(n, v, t, r)     \
    {n, t, (SLANG_IVARIABLE + r), (void *) v}
#endif

#define SLANG_END_TABLE  MAKE_INTRINSIC("", 0, 0, 0)


/*}}}*/

/*{{{ Upper/Lowercase Functions */

extern void SLang_define_case(int *, int *);
extern void SLang_init_case_tables (void);

extern unsigned char Chg_UCase_Lut[256];
extern unsigned char Chg_LCase_Lut[256];
#define UPPER_CASE(x) (Chg_UCase_Lut[(unsigned char) (x)])
#define LOWER_CASE(x) (Chg_LCase_Lut[(unsigned char) (x)])
#define CHANGE_CASE(x) (((x) == Chg_LCase_Lut[(unsigned char) (x)]) ?\
			Chg_UCase_Lut[(unsigned char) (x)] : Chg_LCase_Lut[(unsigned char) (x)])


/*}}}*/

/*{{{ Regular Expression Interface */

typedef struct
{
   unsigned char *pat;		       /* regular expression pattern */
   unsigned char *buf;		       /* buffer for compiled regexp */
   unsigned int buf_len;	       /* length of buffer */
   int case_sensitive;		       /* 1 if match is case sensitive  */
   int must_match;		       /* 1 if line must contain substring */
   int must_match_bol;		       /* true if it must match beginning of line */
   unsigned char must_match_str[16];   /* 15 char null term substring */
   int osearch;			       /* 1 if ordinary search suffices */
   unsigned int min_length;	       /* minimum length the match must be */
   int beg_matches[10];		       /* offset of start of \( */
   unsigned int end_matches[10];       /* length of nth submatch
					* Note that the entire match corresponds
					* to \0 
					*/
   int offset;			       /* offset to be added to beg_matches */
} SLRegexp_Type;

extern unsigned char *SLang_regexp_match(unsigned char *, 
					 unsigned int, 
					 SLRegexp_Type *);
extern int SLang_regexp_compile (SLRegexp_Type *);
extern char *SLregexp_quote_string (char *, char *, unsigned int);


/*}}}*/

/*{{{ SLang Command Interface */

#define SLCMD_MAX_ARGS 10
struct _SLcmd_Cmd_Type; /* Pre-declaration is needed below */
typedef struct
{
   struct _SLcmd_Cmd_Type *table;
   int argc;
   char *string_args[SLCMD_MAX_ARGS];
   int int_args[SLCMD_MAX_ARGS];
   float64 float_args[SLCMD_MAX_ARGS];
   unsigned char arg_type[SLCMD_MAX_ARGS];
} SLcmd_Cmd_Table_Type;


typedef struct _SLcmd_Cmd_Type
{
   int (*cmdfun)(int, SLcmd_Cmd_Table_Type *);
   char cmd[32];
   char arg_type[SLCMD_MAX_ARGS];
} SLcmd_Cmd_Type;

extern int SLcmd_execute_string (char *, SLcmd_Cmd_Table_Type *);

/*}}}*/

/*{{{ SLang Search Interface */

typedef struct
{
   int cs;			       /* case sensitive */
   unsigned char key[256];
   int ind[256];
   int key_len;
   int dir;
} SLsearch_Type;

extern int SLsearch_init (char *, int, int, SLsearch_Type *);
/* This routine must first be called before any search can take place. 
 * The second parameter specifies the direction of the search: greater than 
 * zero for a forwrd search and less than zero for a backward search.  The 
 * third parameter specifies whether the search is case sensitive or not.
 * The last parameter is a pointer to a structure that is filled by this 
 * function and it is this structure that must be passed to SLsearch.
 */

unsigned char *SLsearch (unsigned char *, unsigned char *, SLsearch_Type *);
/* To use this routine, you must first call 'SLsearch_init'.  Then the first 
 * two parameters p1 and p2 serve to define the region over which the search
 * is to take place.  The third parameter is the structure that was previously
 * initialized by SLsearch_init.
 * 
 * The routine returns a pointer to the match if found otherwise it returns 
 * NULL.
 */

/*}}}*/

#if 0
{
#endif
#ifdef __cplusplus
}
#endif

#endif  /* _DAVIS_SLANG_H_ */
