include libslang-1.4.9 and automatically build it and link erlang-slang against it

few (erlang) people will still have libslang-1.4.9 installed or spend time
to get it to link against the driver

1 files changed, 3430 insertions, 0 deletions

diff --git a/libslang/doc/tm/cref.tm b/libslang/doc/tm/cref.tm
new file mode 100644
index 0000000..527c145
--- /dev/null
+++ b/libslang/doc/tm/cref.tm
@@ -0,0 +1,3430 @@
+#i linuxdoc.tm
+
+#d slang \bf{S-lang}
+#d jed \bf{jed}
+#d slang-c-programmers-guide \em{S-Lang Library C Programmer's Guide}
+#d kw#1 \tt{$1}
+#d exmp#1 \tt{$1}
+#d var#1 \tt{$1}
+#d ldots ...
+#d chapter#1 <chapt>$1<p>
+#d preface <preface>
+#d tag#1 <tag>$1</tag>
+
+#d function#1 \sect{<bf>$1</bf>\label{$1}}<descrip>
+#d variable#1 \sect{<bf>$1</bf>\label{$1}}<descrip>
+#cd function#1 <p><bf>$1</bf>\label{$1}<p><descrip>
+#d synopsis#1 <tag> Synopsis </tag> $1
+#d keywords#1 <tag> Keywords </tag> $1
+#d usage#1 <tag> Usage </tag> <tt>$1</tt>
+#d description <tag> Description </tag>
+#d example <tag> Example </tag>
+#d notes <tag> Notes </tag>
+#d seealso#1 <tag> See Also </tag> <tt>$1</tt>
+#d documentstyle article
+#d r#1 \ref{$1}{$1}
+#d done </descrip><p>
+#d 0 \exmp{0}
+#d -1 \exmp{-1}
+#d 1 \exmp{1}
+
+\linuxdoc
+\begin{\documentstyle}
+
+\title {The \slang C Library Reference}
+\author John E. Davis, \tt{davis@space.mit.edu}
+\date \__today__
+
+\toc
+
+
+\function{SLsmg_fill_region}
+\synopsis{Fill a rectangular region with a character}
+\usage{void SLsmg_fill_region (r, c, nr, nc, ch)}
+#v+
+    int r
+    int c
+    unsigned int nr
+    unsigned int nc
+    unsigned char ch
+#v-
+\description
+  The \var{SLsmg_fill_region} function may be used to a 
+  rectangular region with the character \var{ch} in the current color.
+  The rectangle's upper left corner is at row \var{r} and column
+  \var{c}, and spans \var{nr} rows and \var{nc} columns.  The position
+  of the virtual cursor will be left at (\var{r}, \var{c}).
+\seealso{SLsmg_write_char, SLsmg_set_color}
+\done
+
+
+
+\function{SLsmg_set_char_set}
+\synopsis{Turn on or off line drawing characters}
+\usage{void SLsmg_set_char_set (int a);}
+\description
+  \var{SLsmg_set_char_set} may be used to select or deselect the line drawing
+  character set as the current character set.  If \var{a} is non-zero,
+  the line drawing character set will be selected.  Otherwise, the
+  standard character set will be selected.
+\notes
+  There is no guarantee that this function will actually enable the
+  use of line drawing characters.  All it does is cause subsequent
+  characters to be rendered using the terminal's alternate character
+  set.  Such character sets usually contain line drawing characters.
+\seealso{SLsmg_write_char, SLtt_get_terminfo}
+\done
+
+
+\variable{int SLsmg_Scroll_Hash_Border;}
+\synopsis{Set the size of the border for the scroll hash}
+\usage{int SLsmg_Scroll_Hash_Border = 0;}
+\description
+  This variable may be used to ignore the characters that occur at the
+  beginning and the end of a row when performing the hash calculation
+  to determine whether or not a line has scrolled.  The default value
+  is zero which means that all the characters on a line will be used.
+\seealso{SLsmg_refresh}
+\done
+
+
+\function{SLsmg_suspend_smg}
+\synopsis{Suspend screen management}
+\usage{int SLsmg_suspend_smg (void)}
+\description
+  \var{SLsmg_suspend_smg} can be used to suspend the state of the
+  screen management facility during suspension of the program.  Use of
+  this function will reset the display back to its default state.  The
+  funtion \var{SLsmg_resume_smg} should be called after suspension.  
+
+  It returns zero upon success, or \-1 upon error.
+
+  This function is similar to \var{SLsmg_reset_smg} except that the
+  state of the display prior to calling \var{SLsmg_suspend_smg} is saved.
+\seealso{SLsmg_resume_smg, SLsmg_reset_smg}
+\done
+
+
+\function{SLsmg_resume_smg}
+\synopsis{Resume screen management}
+\usage{int SLsmg_resume_smg (void)}
+\description
+  \var{SLsmg_resume_smg} should be called after
+  \var{SLsmg_suspend_smg} to redraw the display exactly like it was
+  before \var{SLsmg_suspend_smg} was called.  It returns zero upon
+  success, or \-1 upon error.
+\seealso{SLsmg_suspend_smg}
+\done
+
+
+\function{SLsmg_erase_eol}
+\synopsis{Erase to the end of the row}
+\usage{void SLsmg_erase_eol (void);}
+\description
+  \var{SLsmg_erase_eol} erases all characters from the current
+  position to the end of the line.  The newly created space is given
+  the color of the current color.  This function has no effect on the
+  position of the virtual cursor.
+\seealso{SLsmg_gotorc, SLsmg_erase_eos, SLsmg_fill_region}
+\done
+
+
+\function{SLsmg_gotorc}
+\synopsis{Move the virtual cursor}
+\usage{void SLsmg_gotorc (int r, int c)}
+\description
+  The \var{SLsmg_gotorc} function moves the virtual cursor to the row
+  \var{r} and column \var{c}.  The first row and first column is
+  specified by \exmp{r = 0} and \exmp{c = 0}.
+\seealso{SLsmg_refresh}
+\done
+
+
+\function{SLsmg_erase_eos}
+\synopsis{Erase to the end of the screen}
+\usage{void SLsmg_erase_eos (void);}
+\description
+  The \var{SLsmg_erase_eos} is like \var{SLsmg_erase_eol} except that
+  it erases all text from the current position to the end of the
+  display.  The current color will be used to set the background of
+  the erased area.
+\seealso{SLsmg_erase_eol}
+\done
+
+
+\function{SLsmg_reverse_video}
+\synopsis{Set the current color to 1}
+\usage{void SLsmg_reverse_video (void);}
+\description
+  This function is nothing more than \exmp{SLsmg_set_color(1)}.  
+\seealso{SLsmg_set_color}
+\done
+
+
+\function{SLsmg_set_color (int)}
+\synopsis{Set the current color}
+\usage{void SLsmg_set_color (int c);}
+\description
+  \var{SLsmg_set_color} is used to set the current color.  The
+  parameter \var{c} is really a color object descriptor.  Actual
+  foreground and background colors as well as other visual attributes
+  may be associated with a color descriptor via the
+  \var{SLtt_set_color} function.
+\example
+  This example defines color \exmp{7} to be green foreground on black
+  background and then displays some text in this color:
+#v+
+      SLtt_set_color (7, NULL, "green", "black");
+      SLsmg_set_color (7);
+      SLsmg_write_string ("Hello");
+      SLsmg_refresh ();
+#v-
+\notes
+  It is important to understand that the screen managment routines
+  know nothing about the actual colors associated with a color
+  descriptor.  Only the descriptor itself is used by the \var{SLsmg}
+  routines.  The lower level \var{SLtt} interface converts the color
+  descriptors to actual colors.  Thus
+#v+
+      SLtt_set_color (7, NULL, "green", "black");
+      SLsmg_set_color (7);
+      SLsmg_write_string ("Hello");
+      SLtt_set_color (7, NULL, "red", "blue");
+      SLsmg_write_string ("World");
+      SLsmg_refresh ();
+#v-
+  will result in \exmp{"hello"} displayed in red on blue and \em{not}
+  green on black.
+\seealso{SLtt_set_color, SLtt_set_color_object}
+\done
+
+
+\function{SLsmg_normal_video}
+\synopsis{Set the current color to 0}
+\usage{void SLsmg_normal_video (void);}
+\description
+  \var{SLsmg_normal_video} sets the current color descriptor to \var{0}.
+\seealso{SLsmg_set_color}
+\done
+
+
+\function{SLsmg_printf}
+\synopsis{Format a string on the virtual display}
+\usage{void SLsmg_printf (char *fmt, ...)}
+\description
+  \var{SLsmg_printf} format a \var{printf} style variable argument
+  list and writes it on the virtual display.  The virtual cursor will
+  be moved to the end of the string.
+\seealso{SLsmg_write_string, SLsmg_vprintf}
+\done
+
+
+\function{SLsmg_vprintf}
+\synopsis{Format a string on the virtual display}
+\usage{void SLsmg_vprintf (char *fmt, va_list ap)}
+\description
+  \var{SLsmg_vprintf} formats a string in the manner of \em{vprintf}
+  and writes the result to the display.  The virtual cursor is
+  advanced to the end of the string.
+\seealso{SLsmg_write_string, SLsmg_printf}
+\done
+
+
+\function{SLsmg_write_string}
+\synopsis{Write a character string on the display }
+\usage{void SLsmg_write_string (char *s)}
+\description
+  The function \var{SLsmg_write_string} displays the string \var{s} on
+  the virtual display at the current position and moves the position
+  to the end of the string.
+\seealso{SLsmg_printf, SLsmg_write_nstring}
+\done
+
+
+\function{SLsmg_write_nstring}
+\synopsis{Write the first n characters of a string on the display}
+\usage{void SLsmg_write_nstring (char *s, unsigned int n);}
+\description
+  \var{SLsmg_write_nstring} writes the first \var{n} characters of
+  \var{s} to this virtual display.  If the length of the string
+  \var{s} is less than \var{n}, the spaces will used until
+  \var{n} characters have been written.  \var{s} can be \var{NULL}, in
+  which case \var{n} spaces will be written.
+\seealso{SLsmg_write_string, SLsmg_write_nchars}
+\done
+
+
+\function{SLsmg_write_char}
+\synopsis{Write a character to the virtual display}
+\usage{void SLsmg_write_char (char ch);}
+\description
+  \var{SLsmg_write_char} writes the character \var{ch} to the virtual
+  display.
+\seealso{SLsmg_write_nchars, SLsmg_write_string}
+\done
+
+
+\function{SLsmg_write_nchars}
+\synopsis{Write n characters to the virtual display}
+\usage{void SLsmg_write_nchars (char *s, unsigned int n);}
+\description
+  \var{SLsmg_write_nchars} writes at most \var{n} characters from the
+  string \var{s} to the display.  If the length of \var{s} is less
+  than \var{n}, the whole length of the string will get written.
+  
+  This function differs from \var{SLsmg_write_nstring} in that
+  \var{SLsmg_write_nstring} will pad the string to write exactly
+  \var{n} characters.  \var{SLsmg_write_nchars} does not perform any
+  padding.
+\seealso{SLsmg_write_nchars, SLsmg_write_nstring}
+\done
+
+
+\function{SLsmg_write_wrapped_string}
+\synopsis{Write a string to the display with wrapping}
+\usage{void SLsmg_write_wrapped_string (s, r, c, nr, nc, fill)}
+#v+
+    char *s
+    int r, c
+    unsigned int nr, nc
+    int fill
+#v-
+\description
+  \var{SLsmg_write_wrapped_string} writes the string \var{s} to the
+  virtual display.  The string will be confined to the rectangular
+  region whose upper right corner is at row \var{r} and column \var{c},
+  and consists of \var{nr} rows and \var{nc} columns.  The string will
+  be wrapped at the boundaries of the box.  If \var{fill} is non-zero,
+  the last line to which characters have been written will get padded
+  with spaces.
+\notes
+  This function does not wrap on word boundaries.  However, it will
+  wrap when a newline charater is encountered.
+\seealso{SLsmg_write_string}
+\done
+
+
+\function{SLsmg_cls}
+\synopsis{Clear the virtual display}
+\usage{void SLsmg_cls (void)}
+\description
+  \var{SLsmg_cls} erases the virtual display using the current color.
+  This will cause the physical display to get cleared the next time
+  \var{SLsmg_refresh} is called.
+\notes
+  This function is not the same as
+#v+
+     SLsmg_gotorc (0,0); SLsmg_erase_eos ();
+#v-
+  since these statements do not guarantee that the physical screen
+  will get cleared.
+\seealso{SLsmg_refresh, SLsmg_erase_eos}
+\done
+
+
+\function{SLsmg_refresh}
+\synopsis{Update physical screen}
+\usage{void SLsmg_refresh (void)}
+\description
+  The \var{SLsmg_refresh} function updates the physical display to
+  look like the virtual display.
+\seealso{SLsmg_suspend_smg, SLsmg_init_smg, SLsmg_reset_smg}
+\done
+
+
+\function{SLsmg_touch_lines}
+\synopsis{Mark lines on the virtual display for redisplay}
+\usage{void SLsmg_touch_lines (int r, unsigned int nr)}
+\description
+  \var{SLsmg_touch_lines} marks the \var{nr} lines on the virtual
+  display starting at row \var{r} for redisplay upon the next call to
+  \var{SLsmg_refresh}.
+\notes
+  This function should rarely be called, if ever.  If you find that
+  you need to call this function, then your application should be
+  modified to properly use the \var{SLsmg} screen management routines.
+  This function is provided only for curses compatibility.
+\seealso{SLsmg_refresh}
+\done
+
+\function{SLsmg_init_smg}
+\synopsis{Initialize the \var{SLsmg} routines}
+\usage{int SLsmg_init_smg (void)}
+\description
+  The \var{SLsmg_init_smg} function initializes the \var{SLsmg} screen
+  management routines.   Specifically, this function allocates space
+  for the virtual display and calls \var{SLtt_init_video} to put the
+  terminal's physical display in the proper state.  It is up to the
+  caller to make sure that the \var{SLtt} routines are initialized via
+  \var{SLtt_get_terminfo} before calling \var{SLsmg_init_smg}.
+  
+  This function should also be called any time the size of the
+  physical display has changed so that it can reallocate a new virtual
+  display to match the physical display.
+  
+  It returns zero upon success, or \-1 upon failure.
+\seealso{SLsmg_reset_smg}
+\done
+
+
+\function{SLsmg_reset_smg}
+\synopsis{Reset the \var{SLsmg} routines}
+\usage{int SLsmg_reset_smg (void);}
+\description
+  \var{SLsmg_reset_smg} resets the \var{SLsmg} screen management
+  routines by freeing all memory allocated while it was active.  It
+  also calls \var{SLtt_reset_video} to put the terminal's display in
+  it default state.
+\seealso{SLsmg_init_smg}
+\done
+
+
+\function{SLsmg_char_at}
+\synopsis{Get the character at the current position on the virtual display}
+\usage{unsigned short SLsmg_char_at(void)}
+\description
+  The \var{SLsmg_char_at} function returns the character and its color
+  at the current position on the virtual display.
+\seealso{SLsmg_read_raw, SLsmg_write_char}
+\done
+
+
+\function{SLsmg_set_screen_start}
+\synopsis{Set the origin of the virtual display}
+\usage{void SLsmg_set_screen_start (int *r, int *c)}
+\description
+  \var{SLsmg_set_screen_start} sets the origin of the virtual display
+  to the row \var{*r} and the column \var{*c}.  If either \var{r} or \var{c}
+  is \var{NULL}, then the corresponding value will be set to \var{0}.
+  Otherwise, the location specified by the pointers will be updated to
+  reflect the old origin.
+  
+  See \tt{slang/demo/pager.c} for how this function may be used to
+  scroll horizontally.
+\seealso{SLsmg_init_smg}
+\done
+
+
+\function{SLsmg_draw_hline}
+\synopsis{Draw a horizontal line}
+\usage{void SLsmg_draw_hline (unsigned int len)}
+\description
+  The \var{SLsmg_draw_hline} function draws a horizontal line of
+  length \var{len} on the virtual display.  The position of the
+  virtual cursor is left at the end of the line.
+\seealso{SLsmg_draw_vline}
+\done
+
+
+\function{SLsmg_draw_vline}
+\synopsis{Draw a vertical line}
+\usage{void SLsmg_draw_vline (unsigned int len);}
+\description
+  The \var{SLsmg_draw_vline} function draws a vertical line of
+  length \var{len} on the virtual display.  The position of the
+  virtual cursor is left at the end of the line.
+\seealso{??}
+\done
+
+
+\function{SLsmg_draw_object}
+\synopsis{Draw an object from the alternate character set}
+\usage{void SLsmg_draw_object (int r, int c, unsigned char obj)}
+\description
+  The \var{SLsmg_draw_object} function may be used to place the object
+  specified by \var{obj} at row \var{r} and column \var{c}.  The
+  object is really a character from the alternate character set and
+  may be specified using one of the following constants:
+#v+
+    SLSMG_HLINE_CHAR         Horizontal line 
+    SLSMG_VLINE_CHAR         Vertical line 
+    SLSMG_ULCORN_CHAR        Upper left corner 
+    SLSMG_URCORN_CHAR        Upper right corner
+    SLSMG_LLCORN_CHAR        Lower left corner
+    SLSMG_LRCORN_CHAR        Lower right corner
+    SLSMG_CKBRD_CHAR         Checkboard character
+    SLSMG_RTEE_CHAR          Right Tee
+    SLSMG_LTEE_CHAR          Left Tee
+    SLSMG_UTEE_CHAR          Up Tee
+    SLSMG_DTEE_CHAR          Down Tee
+    SLSMG_PLUS_CHAR          Plus or Cross character
+#v-
+\seealso{SLsmg_draw_vline, SLsmg_draw_hline, SLsmg_draw_box}
+\done
+
+
+\function{SLsmg_draw_box}
+\synopsis{Draw a box on the virtual display}
+\usage{void SLsmg_draw_box (int r, int c, unsigned int dr, unsigned int dc)}
+\description
+  \var{SLsmg_draw_box} uses the \var{SLsmg_draw_hline} and
+  \var{SLsmg_draw_vline} functions to draw a rectangular box on the
+  virtual display.  The box's upper left corner is placed at row
+  \var{r} and column \var{c}.  The width and length of the box is
+  specified by \var{dc} and \var{dr}, respectively.
+\seealso{SLsmg_draw_vline, SLsmg_draw_hline, SLsmg_draw_object}
+\done
+
+\function{SLsmg_set_color_in_region}
+\synopsis{Change the color of a specifed region}
+\usage{void SLsmg_set_color_in_region (color, r, c, dr, dc)}
+#v+
+  int color;
+  int r, c;
+  unsigned int dr, dc;
+#v-
+\description
+  \var{SLsmg_set_color_in_region} may be used to change the color of a
+  rectangular region whose upper left corner is given by
+  (\var{r},\var{c}), and whose width and height is given by \var{dc}
+  and \var{dr}, respectively.  The color of the region is given by the
+  \var{color} parameter.
+\seealso{SLsmg_draw_box, SLsmg_set_color}
+\done
+
+
+\function{SLsmg_get_column}
+\synopsis{Get the column of the virtual cursor}
+\usage{int SLsmg_get_column(void);}
+\description
+  The \var{SLsmg_get_column} function returns the current column of
+  the virtual cursor on the virtual display.
+\seealso{SLsmg_get_row, SLsmg_gotorc}
+\done
+
+
+\function{SLsmg_get_row}
+\synopsis{Get the row of the virtual cursor}
+\usage{int SLsmg_get_row(void);}
+\description
+  The \var{SLsmg_get_row} function returns the current row of the
+  virtual cursor on the virtual display.
+\seealso{SLsmg_get_column, SLsmg_gotorc}
+\done
+
+
+\function{SLsmg_forward}
+\synopsis{Move the virtual cursor forward n columns}
+\usage{void SLsmg_forward (int n);}
+\description
+  The \var{SLsmg_forward} function moves the virtual cursor forward
+  \var{n} columns.
+\seealso{SLsmg_gotorc}
+\done
+
+
+\function{SLsmg_write_color_chars}
+\synopsis{Write characters with color descriptors to virtual display}
+\usage{void SLsmg_write_color_chars (unsigned short *s, unsigned int len)}
+\description
+  The \var{SLsmg_write_color_chars} function may be used to write
+  \var{len} characters, each with a different color descriptor to the
+  virtual display.  Each character and its associated color are
+  encoded as an \exmp{unsigned short} such that the lower eight bits
+  form the character and the next eight bits form the color.
+\seealso{SLsmg_char_at, SLsmg_write_raw}
+\done
+
+
+\function{SLsmg_read_raw}
+\synopsis{Read characters from the virtual display}
+\usage{unsigned int SLsmg_read_raw (unsigned short *buf, unsigned int len)}
+\description
+  \var{SLsmg_read_raw} attempts to read \var{len} characters from the
+  current position on the virtual display into the buffer specified by
+  \var{buf}.  It returns the number of characters actually read.  This
+  number will be less than \var{len} if an attempt is made to read
+  past the right margin of the display.
+\notes
+  The purpose of the pair of functions, \var{SLsmg_read_raw} and
+  \var{SLsmg_write_raw}, is to permit one to copy the contents of one
+  region of the virtual display to another region.
+\seealso{SLsmg_char_at, SLsmg_write_raw}
+\done
+
+
+\function{SLsmg_write_raw}
+\synopsis{Write characters directly to the virtual display}
+\usage{unsigned int SLsmg_write_raw (unsigned short *buf, unsigned int len)}
+\description
+  The \var{SLsmg_write_raw} function attempts to write \var{len}
+  characters specified by \var{buf} to the display at the current
+  position.  It returns the number of characters successfully written,
+  which will be less than \var{len} if an attempt is made to write
+  past the right margin.
+\notes
+  The purpose of the pair of functions, \var{SLsmg_read_raw} and
+  \var{SLsmg_write_raw}, is to permit one to copy the contents of one
+  region of the virtual display to another region.
+\seealso{SLsmg_read_raw}
+\done
+
+
+\function{SLallocate_load_type}
+\synopsis{Allocate a SLang_Load_Type object}
+\usage{SLang_Load_Type *SLallocate_load_type (char *name)}
+\description
+  The \var{SLallocate_load_type} function allocates and initializes
+  space for a \var{SLang_Load_Type} object and returns it.  Upon
+  failure, the function returns \var{NULL}.  The parameter \var{name}
+  must uniquely identify the object.  For example, if the object
+  represents a file, then \var{name} could be the absolute path name
+  of the file.
+\seealso{SLdeallocate_load_type, SLang_load_object}
+\done
+
+\function{SLdeallocate_load_type}
+\synopsis{Free a SLang_Load_Type object}
+\usage{void SLdeallocate_load_type (SLang_Load_Type *slt)}
+\description
+  This function frees the memory associated with a
+  \var{SLang_Load_Type} object that was acquired from a call to the
+  \var{SLallocate_load_type} function.
+\seealso{SLallocate_load_type, SLang_load_object}
+\done
+
+
+\function{SLang_load_object}
+\synopsis{Load an object into the interpreter}
+\usage{int SLang_load_object (SLang_Load_Type *obj)}
+\description
+  The function \var{SLang_load_object} is a generic function that may
+  be used to loaded an object of type \var{SLang_Load_Type} into the
+  interpreter.  For example, the functions \var{SLang_load_file} and
+  \var{SLang_load_string} are wrappers around this function to load a
+  file and a string, respectively.
+\seealso{SLang_load_file, SLang_load_string, SLallocate_load_type}
+\done
+
+
+\function{SLclass_allocate_class}
+\synopsis{Allocate a class for a new data type}
+\usage{SLang_Class_Type *SLclass_allocate_class (char *name)}
+\description
+  The purpose of this function is to allocate and initialize space
+  that defines a new data type or class called \var{name}.  If
+  successful, a pointer to the class is returned, or upon failure the
+  function returns \var{NULL}.
+  
+  This function does not automatically create the new data type.
+  Callback functions must first be associated with the data type via
+  functions such as \var{SLclass_set_push_function}, and the data
+  type must be registered with the interpreter via
+  \var{SLclass_register_class}.  See the \slang library programmer's
+  guide for more information.
+\seealso{SLclass_register_class, SLclass_set_push_function}
+\done
+
+
+\function{SLclass_register_class}
+\synopsis{Register a new data type with the interpreter}
+\usage{int SLclass_register_class (cl, type, sizeof_type, class_type)}
+#v+
+    SLang_Class_Type *cl
+    unsigned char type
+    unsigned int sizeof_type
+    unsigned char class_type
+#v-
+\description
+  The \var{SLclass_register_class} function is used to register a new
+  class or data type with the interpreter.  If successful, the
+  function returns \exmp{0}, or upon failure, it returns \var{-1}.
+
+  The first parameter, \var{cl}, must have been previously obtained
+  via the \var{SLclass_allocate_class} function.
+
+  The second parameter, \var{type} specifies the data type of the new
+  class.  It must be an unsigned character with value greater that
+  \exmp{127}.  The values in the range \exmp{0-127} are reserved for
+  internal use by the library.
+
+  The size that the data type represents in bytes is specified by the
+  third parameter, \var{sizeof_type}.   This value should not be
+  confused with the sizeof the structure that represents the data
+  type, unless the data type is of class \var{SLANG_CLASS_TYPE_VECTOR}
+  or \var{SLANG_CLASS_TYPE_SCALAR}.  For pointer objects, the value
+  of this parameter is just \var{sizeof(void *)}.
+
+  The final parameter specifies the class type of the data type.  It must
+  be one of the values:
+#v+
+     SLANG_CLASS_TYPE_SCALAR
+     SLANG_CLASS_TYPE_VECTOR
+     SLANG_CLASS_TYPE_PTR
+     SLANG_CLASS_TYPE_MMT
+#v-
+  The \var{SLANG_CLASS_TYPE_SCALAR} indicates that the new data type
+  is a scalar.  Examples of scalars in \var{SLANG_INT_TYPE} and
+  \var{SLANG_DOUBLE_TYPE}.
+  
+  Setting \var{class_type} to SLANG_CLASS_TYPE_VECTOR implies that the
+  new data type is a vector, or a 1-d array of scalar types.  An
+  example of a data type of this class is the
+  \var{SLANG_COMPLEX_TYPE}, which represents complex numbers.
+  
+  \var{SLANG_CLASS_TYPE_PTR} specifies the data type is of a pointer
+  type.  Examples of data types of this class include
+  \var{SLANG_STRING_TYPE} and \var{SLANG_ARRAY_TYPE}.  Such types must
+  provide for their own memory management.
+  
+  Data types of class \var{SLANG_CLASS_TYPE_MMT} are pointer types
+  except that the memory management, i.e., creation and destruction of
+  the type, is handled by the interpreter.  Such a type is called a
+  \em{memory managed type}.  An example of this data type is the
+  \var{SLANG_FILEPTR_TYPE}.
+\notes
+   See the \slang-c-programmers-guide for more information.
+\seealso{SLclass_allocate_class}
+\done
+
+
+\function{SLclass_set_string_function}
+\synopsis{Set a data type's string representation callback}
+\usage{int SLclass_set_string_function (cl, sfun)}
+#v+
+   SLang_Class_Type *cl
+   char *(*sfun) (unsigned char, VOID_STAR);
+#v-
+\description
+  The \var{SLclass_set_string_function} routine is used to define a
+  callback function, \var{sfun}, that will be used when a string
+  representation of an object of the data type represented by \var{cl}
+  is needed.  \var{cl} must have already been obtained via a call to
+  \var{SLclass_allocate_class}.  When called, \var{sfun} will be
+  passed two arguments: a unsigned char which represents the data
+  type, and the address of the object for which a string represetation
+  is required.  The callback function must return a \em{malloced}
+  string.
+  
+  Upon success, \var{SLclass_set_string_function} returns zero, or
+  upon error it returns \-1.
+\example
+  A callback function that handles both \var{SLANG_STRING_TYPE} and
+  \var{SLANG_INT_TYPE} variables looks like:
+#v+
+     char *string_and_int_callback (unsigned char type, VOID_STAR addr)
+     {
+        char buf[64];
+
+	switch (type)
+	  {
+	     case SLANG_STRING_TYPE:
+	       return SLmake_string (*(char **)addr);
+	     
+	     case SLANG_INTEGER_TYPE:
+	       sprintf (buf, "%d", *(int *)addr);
+	       return SLmake_string (buf);
+          }
+        return NULL;
+     }
+#v-
+\notes
+  The default string callback simply returns the name of the data type.
+\seealso{SLclass_allocate_class, SLclass_register_class}
+\done
+
+
+\function{SLclass_set_destroy_function}
+\synopsis{Set the destroy method callback for a data type}
+\usage{int SLclass_set_destroy_function (cl, destroy_fun)}
+#v+
+    SLang_Class_Type *cl
+    void (*destroy_fun) (unsigned char, VOID_STAR);
+#v-
+\description
+  \var{SLclass_set_destroy_function} is used to set the destroy
+  callback for a data type.  The data type's class \var{cl} must have
+  been previously obtained via a call to \var{SLclass_allocate_class}.
+  When called, \var{destroy_fun} will be passed two arguments: a
+  unsigned char which represents the data type, and the address of the
+  object to be destroyed.
+  
+  \var{SLclass_set_destroy_function} returns zero upon success, and
+  \-1 upon failure.
+\example
+  The destroy method for \var{SLANG_STRING_TYPE} looks like:
+#v+
+    static void string_destroy (unsigned char type, VOID_STAR ptr)
+    {
+       char *s = *(char **) ptr;
+       if (s != NULL) SLang_free_slstring (*(char **) s);
+    }
+#v-
+\notes
+  Data types of class SLANG_CLASS_TYPE_SCALAR do not require a destroy
+  callback.  However, other classes do.
+\seealso{SLclass_allocate_class, SLclass_register_class}
+\done
+
+
+\function{SLclass_set_push_function}
+\synopsis{Set the push callback for a new data type}
+\usage{int SLclass_set_push_function (cl, push_fun)}
+#v+
+    SLang_Class_Type *cl
+    int (*push_fun) (unsigned char, VOID_STAR);
+#v-
+\description
+   \var{SLclass_set_push_function} is used to set the push callback
+   for a new data type specified by \var{cl}, which must have been
+   previously obtained via \var{SLclass_allocate_class}.
+   
+   The parameter \var{push_fun} is a pointer to the push callback.  It
+   is required to take two arguments: an unsigned character
+   representing the data type, and the address of the object to be
+   pushed.  It must return zero upon success, or \-1 upon failure.
+   
+   \var{SLclass_set_push_function} returns zero upon success, or \-1
+   upon failure.
+\example
+   The push callback for \var{SLANG_COMPLEX_TYPE} looks like:
+#v+
+      static int complex_push (unsigned char type, VOID_STAR ptr)
+      {
+         double *z = *(double **) ptr;
+         return SLang_push_complex (z[0], z[1]);
+      }
+#v-
+\seealso{SLclass_allocate_class, SLclass_register_class}
+\done
+
+
+\function{SLclass_set_pop_function}
+\synopsis{Set the pop callback for a new data type}
+\usage{int SLclass_set_pop_function (cl, pop_fun)}
+#v+
+    SLang_Class_Type *cl
+    int (*pop_fun) (unsigned char, VOID_STAR);
+#v-
+\description
+   \var{SLclass_set_pop_function} is used to set the callback for
+   popping an object from the stack for a new data type specified by
+   \var{cl}, which must have been previously obtained via
+   \var{SLclass_allocate_class}. 
+
+   The parameter \var{pop_fun} is a pointer to the pop callback
+   function, which is required to take two arguments: an unsigned
+   character representing the data type, and the address of the object
+   to be popped.  It must return zero upon success, or \-1 upon
+   failure.
+
+   \var{SLclass_set_pop_function} returns zero upon success, or \-1
+   upon failure.
+\example
+   The pop callback for \var{SLANG_COMPLEX_TYPE} looks like:
+#v+
+      static int complex_push (unsigned char type, VOID_STAR ptr)
+      {
+         double *z = *(double **) ptr;
+         return SLang_pop_complex (&z[0], &z[1]);
+      }
+#v-
+\seealso{SLclass_allocate_class, SLclass_register_class}
+\done
+
+
+\function{SLclass_get_datatype_name}
+\synopsis{Get the name of a data type}
+\usage{char *SLclass_get_datatype_name (unsigned char type)}
+\description
+  The \var{SLclass_get_datatype_name} function returns the name of the
+  data type specified by \var{type}.  For example, if \var{type} is
+  \var{SLANG_INT_TYPE}, the string \exmp{"Integer_Type"} will be
+  returned.
+  
+  This function returns a pointer that should not be modified or freed.
+\seealso{SLclass_allocate_class, SLclass_register_class}
+\done
+
+\function{SLang_free_mmt}
+\synopsis{Free a memory managed type}
+\usage{void SLang_free_mmt (SLang_MMT_Type *mmt)}
+\description
+  The \var{SLang_MMT_Type} function is used to free a memory managed
+  data type.
+\seealso{SLang_object_from_mmt, SLang_create_mmt}
+\done
+
+
+\function{SLang_object_from_mmt}
+\synopsis{Get a pointer to the value of a memory managed type}
+\usage{VOID_STAR SLang_object_from_mmt (SLang_MMT_Type *mmt)}
+\description
+  The \var{SLang_object_from_mmt} function returns a pointer to the
+  actual object whose memory is being managed by the interpreter.
+\seealso{SLang_free_mmt, SLang_create_mmt}
+\done
+
+
+\function{SLang_create_mmt}
+\synopsis{Create a memory managed data type}
+\usage{SLang_MMT_Type *SLang_create_mmt (unsigned char t, VOID_STAR ptr)}
+\description
+  The \var{SLang_create_mmt} function returns a pointer to a new
+  memory managed object.  This object contains information necessary
+  to manage the memory associated with the pointer \var{ptr} which
+  represents the application defined data type of type \var{t}.
+\seealso{SLang_object_from_mmt, SLang_push_mmt, SLang_free_mmt}
+\done
+
+
+\function{SLang_push_mmt}
+\synopsis{Push a memory managed type}
+\usage{int SLang_push_mmt (SLang_MMT_Type *mmt)}
+\description
+   This function is used to push a memory managed type onto the
+   interpreter stack.  It returns zero upon success, or \exmp{-1} upon
+   failure.
+\seealso{SLang_create_mmt, SLang_pop_mmt}
+\done
+
+
+\function{SLang_pop_mmt}
+\synopsis{Pop a memory managed data type}
+\usage{SLang_MMT_Type *SLang_pop_mmt (unsigned char t)}
+\description
+  The \var{SLang_pop_mmt} function may be used to pop a memory managed
+  type of type \var{t} from the stack.  It returns a pointer to the
+  memory managed object upon success, or \var{NULL} upon failure.  The
+  function \var{SLang_object_from_mmt} should be used to access the
+  actual pointer to the data type.
+\seealso{SLang_object_from_mmt, SLang_push_mmt}
+\done
+
+
+\function{SLang_inc_mmt}
+\synopsis{Increment a memory managed type reference count}
+\usage{void SLang_inc_mmt (SLang_MMT_Type *mmt);}
+\description
+  The \var{SLang_inc_mmt} function may be used to increment the
+  reference count associated with the memory managed data type given
+  by \var{mmt}.
+\seealso{SLang_free_mmt, SLang_create_mmt, SLang_pop_mmt, SLang_pop_mmt}
+\done
+
+
+\function{SLang_vmessage}
+\synopsis{Display a message to the message device}
+\usage{void SLang_vmessage (char *fmt, ...)}
+\description
+  This function prints a \var{printf} style formatted variable
+  argument list to the message device.  The default message device is
+  \var{stdout}.
+\seealso{SLang_verror}
+\done
+
+
+\function{SLang_exit_error}
+\synopsis{Exit the program and display an error message}
+\usage{void SLang_exit_error (char *fmt, ...)}
+\description
+   The \var{SLang_exit_error} function terminates the program and
+   displays an error message using a \var{printf} type variable
+   argument list.  The default behavior to this function is to write
+   the message to \var{stderr} and exit with the \var{exit} system
+   call. 
+   
+   If the function pointer \var{SLang_Exit_Error_Hook} is
+   non-NULL, the function to which it points will be called.  This
+   permits an application to perform whatever cleanup is necessary.
+   This hook has the prototype:
+#v+
+     void (*SLang_Exit_Error_Hook)(char *, va_list);
+#v-
+\seealso{SLang_verror, exit}
+\done
+
+
+\function{SLang_init_slang}
+\synopsis{Initialize the interpreter}
+\usage{int SLang_init_slang (void)}
+\description
+  The \var{SLang_init_slang} function must be called by all
+  applications that use the \slang interpreter.  It initializes the
+  interpreter, defines the built-in data types, and adds a set of core
+  intrinsic functions.
+  
+  The function returns \var{0} upon success, or \var{-1} upon failure.
+\seealso{SLang_init_slfile, SLang_init_slmath, SLang_init_slunix}
+\done
+
+\function{SLang_init_slfile}
+\synopsis{Initialize the interpreter file I/O intrinsics}
+\usage{int SLang_init_slfile (void)}
+\description
+  This function initializes the interpreters file I/O intrinsic
+  functions.  This function adds intrinsic functions such as
+  \var{fopen}, \var{fclose}, and \var{fputs} to the interpreter.
+  It returns \exmp{0} if successful, or \exmp{-1} upon error.
+\notes
+  Before this function can be called, it is first necessary to call
+  \var{SLang_init_slang}.  It also adds
+  the preprocessor symbol \var{__SLFILE__} to the interpreter.
+\seealso{SLang_init_slang, SLang_init_slunix, SLang_init_slmath}
+\done
+
+
+\function{SLang_init_slmath}
+\synopsis{Initialize the interpreter math intrinsics}
+\usage{int SLang_init_slmath (void)}
+\description
+  The \var{SLang_init_slmath} function initializes the interpreter's
+  mathematical intrinsic functions and makes them available to the
+  language.  The intrinsic functions include \var{sin}, \var{cos},
+  \var{tan}, etc...  It returns \exmp{0} if successful, or \exmp{-1}
+  upon failure.
+\notes
+  This function must be called after \var{SLang_init_slang}.  It adds
+  the preprocessor symbol \var{__SLMATH__} to the interpreter.
+\seealso{SLang_init_slang, SLang_init_slfile, SLang_init_slunix}
+\done
+
+
+\function{SLang_init_slunix}
+\synopsis{Make available some unix system calls to the interpreter}
+\usage{int SLang_init_slunix (void)}
+\description
+  The \var{SLang_init_slunix} function initializes the interpreter's
+  unix system call intrinsic functions and makes them available to the
+  language.  Examples of functions made available by
+  \var{SLang_init_slunix} include \var{chmod}, \var{chown}, and
+  \var{stat_file}.  It returns \exmp{0} if successful, or \exmp{-1}
+  upon failure.
+\notes
+  This function must be called after \var{SLang_init_slang}.  It adds
+  the preprocessor symbol \var{__SLUNIX__} to the interpreter.
+\seealso{SLang_init_slang, SLang_init_slfile, SLang_init_slmath}
+\done
+
+
+\function{SLadd_intrin_fun_table}
+\synopsis{Add a table of intrinsic functions to the interpreter}
+\usage{int SLadd_intrin_fun_table(SLang_Intrin_Fun_Type *tbl, char *pp_name);}
+\description
+  The \var{SLadd_intrin_fun_table} function adds an array, or table, of
+  \var{SLang_Intrin_Fun_Type} objects to the interpreter.  The first
+  parameter, \var{tbl} specifies the table to be added.  The second
+  parameter \var{pp_name}, if non-NULL will be added to the list of
+  preprocessor symbols.
+  
+  This function returns \-1 upon failure or zero upon success.
+\notes
+  A table should only be loaded one time and it is considered to be an
+  error on the part of the application if it loads a table more than
+  once.
+\seealso{SLadd_intrin_var_table, SLadd_intrinsic_function, SLdefine_for_ifdef}
+\done
+
+\function{SLadd_intrin_var_table}
+\synopsis{Add a table of intrinsic variables to the interpreter}
+\usage{int SLadd_intrin_var_table (SLang_Intrin_Var_Type *tbl, char *pp_name);}
+\description
+  The \var{SLadd_intrin_var_table} function adds an array, or table, of
+  \var{SLang_Intrin_Var_Type} objects to the interpreter.  The first
+  parameter, \var{tbl} specifies the table to be added.  The second
+  parameter \var{pp_name}, if non-NULL will be added to the list of
+  preprocessor symbols.
+  
+  This function returns \-1 upon failure or zero upon success.
+\notes
+  A table should only be loaded one time and it is considered to be an
+  error on the part of the application if it loads a table more than
+  once.
+\seealso{SLadd_intrin_var_table, SLadd_intrinsic_function, SLdefine_for_ifdef}
+\done
+
+
+\function{SLang_load_file}
+\synopsis{Load a file into the interpreter}
+\usage{int SLang_load_file (char *fn)}
+\description
+  The \var{SLang_load_file} function opens the file whose name is
+  specified by \var{fn} and feeds it to the interpreter, line by line,
+  for execution.  If \var{fn} is \var{NULL}, the function will take
+  input from \var{stdin}.
+
+  If no error occurs, it returns \exmp{0}; otherwise,
+  it returns \exmp{-1}, and sets \var{SLang_Error} accordingly.  For
+  example, if it fails to open the file, it will return \exmp{-1} with
+  \var{SLang_Error} set to \var{SL_OBJ_NOPEN}.
+\notes
+   If the hook \var{SLang_Load_File_Hook} declared as
+#v+
+      int (*SLang_Load_File_Hook)(char *);
+#v-
+   is non-NULL, the function point to by it will be used to load the
+   file.  For example, the \jed editor uses this hook to load files
+   via its own routines.
+\seealso{SLang_load_object, SLang_load_string}
+\done
+
+
+\function{SLang_restart}
+\synopsis{Reset the interpreter after an error}
+\usage{void SLang_restart (int full)}
+\description
+   The \var{SLang_restart} function should be called by the
+   application at top level if an error occurs.  If the parameter
+   \var{full} is non-zero, any objects on the \slang run time stack
+   will be removed from the stack; otherwise, the stack will be left
+   intact.  Any time the stack is believed to be trashed, this routine
+   should be called with a non-zero argument (e.g., if
+   \var{setjmp}/\var{longjmp} is called).
+   
+   Calling \var{SLang_restart} does not reset the global variable
+   \var{SLang_Error} to zero.  It is up to the application to reset
+   that variable to zero after calling \var{SLang_restart}.
+\example
+#v+
+      while (1)
+        {
+	   if (SLang_Error) 
+	     {
+	        SLang_restart (1);
+		SLang_Error = 0;
+	     }
+	   (void) SLang_load_file (NULL);
+	}
+#v-
+\seealso{SLang_init_slang, SLang_load_file}
+\done
+
+
+\function{SLang_byte_compile_file}
+\synopsis{Byte-compile a file for faster loading}
+\usage{int SLang_byte_compile_file(char *fn, int reserved)}
+\description
+  The \var{SLang_byte_compile_file} function ``byte-compiles'' the
+  file \var{fn} for faster loading by the interpreter.  This produces
+  a new file whose filename is equivalent to the one specified by
+  \var{fn}, except that a \var{'c'} is appended to the name.  For
+  example, if \var{fn} is set to \exmp{init.sl}, then the new file
+  will have the name exmp{init.slc}.  The meaning of the second
+  parameter, \var{reserved}, is reserved for future use.  For now, set
+  it to \var{0}.
+  
+  The function returns zero upon success, or \exmp{-1} upon error and
+  sets SLang_Error accordingly.
+\seealso{SLang_load_file, SLang_init_slang}
+\done
+
+
+\function{SLang_autoload}
+\synopsis{Autoload a function from a file}
+\usage{int SLang_autoload(char *funct, char *filename)}
+\description
+  The \var{SLang_autoload} function may be used to associate a
+  \var{slang} function name \var{funct} with the file \var{filename}
+  such that if \var{funct} has not already been defined when needed,
+  it will be loaded from \var{filename}.
+  
+  \var{SLang_autoload} has no effect if \var{funct} has already been
+  defined.  Otherwise it declares \var{funct} as a user-defined \slang
+  function.  It returns \exmp{0} upon success, or \exmp{-1} upon error.
+\seealso{SLang_load_file, SLang_is_defined}
+\done
+
+
+\function{SLang_load_string}
+\synopsis{Interpret a string}
+\usage{int SLang_load_string(char *str)}
+\description
+  The \var{SLang_load_string} function feeds the string specified by
+  \var{str} to the interpreter for execution.  It returns zero upon
+  success, or \exmp{-1} upon failure.
+\seealso{SLang_load_file, SLang_load_object}
+\done
+
+
+\function{SLdo_pop}
+\synopsis{Delete an object from the stack}
+\usage{int SLdo_pop(void)}
+\description
+   This function removes an object from the top of the interpeter's
+   run-time stack and frees any memory associated with it.  It returns
+   zero upon success, or \var{-1} upon error (most likely due to a
+   stack-underflow).
+\seealso{SLdo_pop_n, SLang_pop_integer, SLang_pop_string}
+\done
+
+\function{SLdo_pop_n}
+\synopsis{Delete n objects from the stack}
+\usage{int SLdo_pop_n (unsigned int n)}
+\description
+   The \var{SLdo_pop_n} function removes the top \var{n} objects from
+   the interpreter's run-time stack and frees all memory associated
+   with the objects.  It returns zero upon success, or \var{-1} upon
+   error (most likely due to a stack-underflow).
+\seealso{SLdo_pop, SLang_pop_integer, SLang_pop_string}
+\done
+
+
+\function{SLang_pop_integer}
+\synopsis{Pop an integer off the stack}
+\usage{int SLang_pop_integer (int *i)}
+\description
+   The \var{SLang_pop_integer} function removes an integer from the
+   top of the interpreter's run-time stack and returns its value via
+   the pointer \var{i}.  If successful, it returns zero.  However, if
+   the top stack item is not of type \var{SLANG_INT_TYPE}, or the
+   stack is empty, the function will return \exmp{-1} and set
+   \var{SLang_Error} accordingly.
+\seealso{SLang_push_integer, SLang_pop_double}
+\done
+
+
+\function{SLpop_string}
+\synopsis{Pop a string from the stack}
+\usage{int SLpop_string (char **strptr);}
+\description
+   The \var{SLpop_string} function pops a string from the stack and
+   returns it as a malloced pointer.  It is up to the calling routine
+   to free this string via a call to \var{free} or \var{SLfree}.  If
+   successful, \var{SLpop_string} returns zero.  However, if the top
+   stack item is not of type \var{SLANG_STRING_TYPE}, or the stack is
+   empty, the function will return \exmp{-1} and set
+   \var{SLang_Error} accordingly.
+\example
+#v+
+      define print_string (void)
+      {
+         char *s;
+	 if (-1 == SLpop_string (&s))
+	   return;
+	 fputs (s, stdout);
+	 SLfree (s);
+      }
+#v-
+\notes
+   This function should not be confused with \var{SLang_pop_slstring},
+   which pops a \em{hashed} string from the stack.
+\seealso{SLang_pop_slstring. SLfree}
+\done
+
+
+\function{SLang_pop_string}
+\synopsis{Pop a string from the stack}
+\usage{int SLang_pop_string(char **strptr, int *do_free)}
+\description
+   The \var{SLpop_string} function pops a string from the stack and
+   returns it as a malloced pointer via \var{strptr}.  After the
+   function returns, the integer pointed to by the second parameter
+   will be set to a non-zero value if \var{*strptr} should be freed via 
+   \var{free} or \var{SLfree}.  If successful, \var{SLpop_string}
+   returns zero.  However, if the top stack item is not of type
+   \var{SLANG_STRING_TYPE}, or the stack is empty, the function will
+   return \exmp{-1} and set \var{SLang_Error} accordingly.
+\notes
+   This function is considered obsolete and should not be used by
+   applications.  If one requires a malloced string for modification,
+   \var{SLpop_string} should be used.  If one requires a constant
+   string that will not be modifed by the application,
+   \var{SLang_pop_slstring} should be used.
+\seealso{SLang_pop_slstring, SLpop_string}
+\done
+
+
+\function{SLang_pop_slstring}
+\synopsis{Pop a hashed string from the stack}
+\usage{int SLang_pop_slstring (char **s_ptr)}
+\description
+   The \var{SLang_pop_slstring} function pops a hashed string from the
+   \slang run-time stack and returns it via \var{s_ptr}.  It returns
+   zero if successful, or \-1 upon failure.  The resulting string
+   should be freed via a call to \var{SLang_free_slstring} after use.
+\example
+#v+
+   void print_string (void)
+   {
+      char *s;
+      if (-1 == SLang_pop_slstring (&s))
+        return;
+      fprintf (stdout, "%s\n", s);
+      SLang_free_slstring (s);
+   }
+#v-
+\notes
+   \var{SLang_free_slstring} is the preferred function for popping
+   strings.  This is a result of the fact that the interpreter uses
+   hashed strings as the native representation for string data.
+   
+   One must \em{never} free a hashed string using \var{free} or
+   \var{SLfree}.  In addition, one must never make any attempt to
+   modify a hashed string and doing so will result in memory
+   corruption.
+\seealso{SLang_free_slstring, SLpop_string}
+\done
+
+\function{SLang_pop_double}
+\synopsis{Pop a double from the stack}
+\usage{int SLang_pop_double (double *dptr, int *iptr, int *conv)}
+\description
+   The \var{SLang_pop_double} function pops a double precision number
+   from the stack and returns it via \var{dptr}.  If the number was
+   derived from an integer, \var{*conv} will be set to \exmp{1} upon
+   return, otherwise, \var{*conv} will be set to \exmp{0}.  This
+   function returns \0 upon success, otherwise it returns \-1 and sets
+   \var{SLang_Error} accordingly.
+\notes
+   If one does not care whether or not \exmp{*dptr} was derived from
+   an integer, \var{iptr} and \var{conv} may be passed as \var{NULL}
+   pointers.
+\seealso{SLang_pop_integer, SLang_push_double}
+\done
+
+
+\function{SLang_pop_complex}
+\synopsis{Pop a complex number from the stack}
+\usage{int SLang_pop_complex (double *re, double *im)}
+\description
+   \var{SLang_pop_complex} pops a complex number from the stack and
+   returns it via the parameters \var{re} and \var{im} as the real and
+   imaginary parts of the complex number, respectively.  This function
+   automatically converts objects of type \var{SLANG_DOUBLE_TYPE} and
+   \var{SLANG_INT_TYPE} to \var{SLANG_COMPLEX_TYPE}, if necessary.
+   It returns zero upon success, or \-1 upon error setting
+   \var{SLang_Error} accordingly.
+\seealso{SLang_pop_integer, SLang_pop_double, SLang_push_complex}
+\done
+
+
+\function{SLang_push_complex}
+\synopsis{Push a complex number onto the stack}
+\usage{int SLang_push_complex (double re, double im)}
+\description
+   \var{SLang_push_complex} may be used to push the complex number
+   whose real and imaginary parts are given by \var{re} and \var{im},
+   respectively.  It returns zero upon success, or \-1 upon error
+   setting \var{SLang_Error} accordingly.
+\seealso{SLang_pop_complex, SLang_push_double}
+\done
+
+
+\function{SLang_push_double}
+\synopsis{Push a double onto the stack}
+\usage{int SLang_push_double(double d)}
+\description
+   \var{SLang_push_double} may be used to push the double precision
+   floating point number \var{d} onto the interpreter's run-time
+   stack.  It returns zero upon success, or \-1 upon error setting
+   \var{SLang_Error} accordingly.
+\seealso{SLang_pop_double, SLang_push_integer}
+\done
+
+
+\function{SLang_push_string}
+\synopsis{Push a string onto the stack}
+\usage{int SLang_push_string (char *s)}
+\description
+   \var{SLang_push_string} pushes a copy of the string specified by
+   \var{s} onto the interpreter's run-time stack.  It returns zero
+   upon success, or \-1 upon error setting \var{SLang_Error}
+   accordingly.
+\notes
+   If \var{s} is \var{NULL}, this function pushes \var{NULL}
+   (\var{SLANG_NULL_TYPE}) onto the stack.
+\seealso{SLang_push_malloced_string}
+\done
+
+\function{SLang_push_integer}
+\synopsis{Push an integer onto the stack}
+\usage{int SLang_push_integer (int i)}
+\description
+   \var{SLang_push_integer} the integer \var{i} onto the interpreter's
+   run-time stack.  It returns zero upon success, or \-1 upon error
+   setting \var{SLang_Error} accordingly.
+\seealso{SLang_pop_integer, SLang_push_double, SLang_push_string}
+\done
+
+\function{SLang_push_malloced_string}
+\synopsis{Push a malloced string onto the stack}
+\usage{int SLang_push_malloced_string (char *s);}
+\description
+   \var{SLang_push_malloced_string} may be used to push a malloced
+   string onto the interpreter's run-time stack.  It returns zero upon
+   success, or \-1 upon error setting \var{SLang_Error} accordingly.
+\example
+   The following example illustrates that it is up to the calling
+   routine to free the string if \var{SLang_push_malloced_string} fails:
+#v+
+      int push_hello (void)
+      {
+         char *s = malloc (6);
+	 if (s == NULL) return -1;
+	 strcpy (s, "hello");
+	 if (-1 == SLang_push_malloced_string (s))
+	   {
+	      free (s);
+	      return -1;
+	   }
+	 return 0;
+      }
+#v-
+\example
+   The function \var{SLang_create_slstring} returns a hashed string.
+   Such a string may not be malloced and should not be passed to
+   \var{SLang_push_malloced_string}.
+\notes
+   If \var{s} is \var{NULL}, this function pushes \var{NULL}
+   (\var{SLANG_NULL_TYPE}) onto the stack.
+\seealso{SLang_push_string, SLmake_string}
+\done
+
+
+\function{SLang_is_defined}
+\synopsis{Check to see if the interpreter defines an object}
+\usage{int SLang_is_defined (char *nm)}
+\description
+   The \var{SLang_is_defined} function may be used to determine
+   whether or not a variable or function whose name is given by
+   \var{em} has been defined.  It returns zero if no such object has
+   been defined.  Othewise it returns a non-zero value whose meaning
+   is given by the following table:
+#v+
+      1    intrinsic function  (SLANG_INTRINSIC)
+      2    user-defined slang function (SLANG_FUNCTION)
+     -1    intrinsic variable (SLANG_IVARIABLE)
+     -2    user-defined global variable (SLANG_GVARIABLE)
+#v-
+\seealso{SLadd_intrinsic_function, SLang_run_hooks, SLang_execute_function}
+\done
+
+
+\function{SLang_run_hooks}
+\synopsis{Run a user-defined hook with arguments}
+\usage{int SLang_run_hooks (char *fname, unsigned int n, ...)}
+\description
+   The \var{SLang_run_hooks} function may be used to execute a
+   user-defined function named \var{fname}.  Before execution of the
+   function, the \var{n} string arguments specified by the variable
+   parameter list are pushed onto the stack.  If the function
+   \var{fname} does not exist, \var{SLang_run_hooks} returns zero;
+   otherwise, it returns \exmp{1} upon successful execution of the
+   function, or \-1 if an error occurred.
+\example
+   The \jed editor uses \var{SLang_run_hooks} to setup the mode of a
+   buffer based on the filename extension of the file associated with
+   the buffer:
+#v+
+      char *ext = get_filename_extension (filename);
+      if (ext == NULL) return -1;
+      if (-1 == SLang_run_hooks ("mode_hook", 1, ext))
+        return -1;
+      return 0;
+#v-
+\seealso{SLang_is_defined, SLang_execute_function}
+\done
+
+
+\function{SLang_execute_function}
+\synopsis{Execute a user or intrinsic function}
+\usage{int SLang_execute_function (char *fname)}
+\description
+   This function may be used to execute either a user-defined function
+   or an intrinisic function.  The name of the function is specified
+   by \var{fname}.  It returns zero if \var{fname} is not defined, or
+   \exmp{1} if the function was successfully executed, or \-1 upon
+   error.
+\notes
+   The function \var{SLexecute_function} may be a better alternative
+   for some uses.
+\seealso{SLang_run_hooks, SLexecute_function, SLang_is_defined}
+\done
+
+\function{SLang_verror}
+\synopsis{Signal an error with a message}
+\usage{void SLang_verror (int code, char *fmt, ...);}
+\description
+   The \var{SLang_verror} function sets \var{SLang_Error} to
+   \var{code} if \var{SLang_Error} is 0.  It also displays the error
+   message implied by the \var{printf} variable argument list using
+   \var{fmt} as the format.
+\example
+#v+
+      FILE *open_file (char *file)
+      {
+         char *file = "my_file.dat";
+	 if (NULL == (fp = fopen (file, "w")))
+	   SLang_verror (SL_INTRINSIC_ERROR, "Unable to open %s", file);
+	 return fp;
+      }
+#v-
+\seealso{SLang_vmessage, SLang_exit_error}
+\done
+
+
+\function{SLang_doerror}
+\synopsis{Signal an error}
+\usage{void SLang_doerror (char *err_str)}
+\description
+  The \var{SLang_doerror} function displays the string \var{err_str}
+  to the error device and signals a \slang error.
+\notes
+  \var{SLang_doerror} is considered to obsolete.  Applications should
+  use the \var{SLang_verror} function instead.
+\seealso{SLang_verror, SLang_exit_error}
+\done
+
+
+\function{SLang_get_function}
+\synopsis{Get a pointer to a \slang function}
+\usage{SLang_Name_Type *SLang_get_function (char *fname)}
+\description
+  This function returns a pointer to the internal \slang table entry
+  of a function whose name is given by \var{fname}.  It returns
+  \var{NULL} upon failure.  The value returned by this function can be
+  used \var{SLexecute_function} to call the function directly
+  from C.
+\seealso{SLexecute_function}
+\done
+
+
+
+\function{SLexecute_function}
+\synopsis{Execute a \slang or intrinsic function}
+\usage{int SLexecute_function (SLang_Name_Type *nt)}
+\description
+  The \var{SLexecute_function} allows an application to call the
+  \slang function specified by the \var{SLang_Name_Type} pointer
+  \var{nt}.  This parameter must be non \var{NULL} and must have been
+   previously obtained by a call to \var{SLang_get_function}.
+\example
+   Consider the \slang function:
+#v+
+     define my_fun (x)
+     {
+        return x^2 - 2;
+     }
+#v-
+   Suppose that it is desired to call this function many times with
+   different values of x.  There are at least two ways to do this.
+   The easiest way is to use \var{SLang_execute_function} by passing
+   the string \exmp{"my_fun"}.  A better way that is much faster is to
+   use \var{SLexecute_function}:
+#v+
+      int sum_a_function (char *fname, double *result)
+      {
+         double sum, x, y;
+	 SLang_Name_Type *nt;
+
+	 if (NULL == (nt = SLang_get_function (fname)))
+	   return -1;
+	 
+	 sum = 0;
+	 for (x = 0; x < 10.0; x += 0.1)
+	   {
+	      SLang_start_arg_list ();
+	      if (-1 == SLang_push_double (x))
+	        return -1;
+	      SLang_end_arg_list ();
+	      if (-1 == SLexecute_function (nt))
+	        return -1;
+	      if (-1 == SLang_pop_double (&y, NULL, NULL))
+	        return -1;
+	      
+	      sum += y;
+	   }
+	 return sum;
+      }
+#v-
+   Although not necessary in this case, \var{SLang_start_arg_list} and
+   \var{SLang_end_arg_list} were used to provide the function with
+   information about the number of parameters passed to it.
+\seealso{SLang_get_function, SLang_start_arg_list, SLang_end_arg_list}
+\done
+
+
+\function{SLang_peek_at_stack}
+\synopsis{Find the type of object on the top of the stack}
+\usage{int SLang_peek_at_stack (void)}
+\description
+  The \var{SLang_peek_at_stack} function is useful for determining the
+  data type of the object at the top of the stack.  It returns the
+  data type, or -1 upon a stack-underflow error.  It does not remove
+  anything from the stack.
+\seealso{SLang_pop_string, SLang_pop_integer}
+\done
+
+
+\function{SLmake_string}
+\synopsis{Duplicate a string}
+\usage{char *SLmake_string (char *s)}
+\description
+  The \var{SLmake_string} function creates a new copy of the string
+  \var{s}, via \var{malloc}, and returns it.  Upon failure it returns
+  \var{NULL}.  Since the resulting string is malloced, it should be
+  freed when nolonger needed via a call to either \var{free} or
+  \var{SLfree}.
+\notes
+  \var{SLmake_string} should not be confused with the function
+  \var{SLang_create_slstring}, which performs a similar function.
+\seealso{SLmake_nstring, SLfree, SLmalloc, SLang_create_slstring}
+\done
+
+
+\function{SLmake_nstring}
+\synopsis{Duplicate a substring}
+\usage{char *SLmake_nstring (char *s, unsigned int n)}
+\description
+  This function is like \var{SLmake_nstring} except that it creates a
+  null terminated string formed from the first \var{n} characters of
+  \var{s}.  Upon failure, it returns \var{NULL}, otherwise it returns
+  the new string.  When nolonger needed, the returned string should be
+  freed with either \var{free} or \var{SLfree}.
+\seealso{SLmake_nstring, SLfree, SLang_create_nslstring}
+\done
+
+
+\function{SLang_create_nslstring}
+\synopsis{Created a hashed substring}
+\usage{char *SLang_create_nslstring (char *s, unsigned int n)}
+\description
+  \var{SLang_create_nslstring} is like \var{SLang_create_slstring}
+  except that only the first \var{n} characters of \var{s} are used to
+  perform the string.  Upon error, it returns \var{NULL}, otherwise it
+  returns the hashed substring.  Such a string must be freed by the
+  function \var{SLang_free_slstring}.
+\notes
+  Do not use \var{free} or \var{SLfree} to free the string returned by
+  \var{SLang_create_slstring} or \var{SLang_create_nslstring}.  Also
+  it is important that no attempt is made to modify the hashed string
+  returned by either of these functions.  If one needs to modify a
+  string, the functions \var{SLmake_string} or \var{SLmake_nstring}
+  should be used instead.
+\seealso{SLang_free_slstring, SLang_create_slstring, SLmake_nstring}
+\done
+
+\function{SLang_create_slstring}
+\synopsis{Create a hashed string}
+\usage{char *SLang_create_slstring (char *s)}
+\description
+  The \var{SLang_create_slstring} creates a copy of \var{s} and
+  returns it as a hashed string.  Upon error, the function returns
+  \var{NULL}, otherwise it returns the hashed string.  Such a string
+  must only be freed via the \var{SLang_free_slstring} function.
+\notes
+  Do not use \var{free} or \var{SLfree} to free the string returned by
+  \var{SLang_create_slstring} or \var{SLang_create_nslstring}.  Also
+  it is important that no attempt is made to modify the hashed string
+  returned by either of these functions.  If one needs to modify a
+  string, the functions \var{SLmake_string} or \var{SLmake_nstring}
+  should be used instead.
+\seealso{SLang_free_slstring, SLang_create_nslstring, SLmake_string}
+\done
+
+
+\function{SLang_free_slstring}
+\synopsis{Free a hashed string}
+\usage{void SLang_free_slstring (char *s)}
+\description
+  The \var{SLang_free_slstring} function is used to free a hashed
+  string such as one returned by \var{SLang_create_slstring},
+  \var{SLang_create_nslstring}, or \var{SLang_create_static_slstring}.
+  If \var{s} is \var{NULL}, the routine does nothing.
+\seealso{SLang_create_slstring, SLang_create_nslstring, SLang_create_static_slstring}
+\done
+
+
+\function{SLang_concat_slstrings}
+\synopsis{Concatenate two strings to produce a hashed string}
+\usage{char *SLang_concat_slstrings (char *a, char *b)}
+\description
+  The \var{SLang_concat_slstrings} function concatenates two strings,
+  \var{a} and \var{b}, and returns the result as a hashed string.
+  Upon failure, \var{NULL} is returned.
+\notes
+  A hashed string can only be freed using \var{SLang_free_slstring}.
+  Never use either \var{free} or \var{SLfree} to free a hashed string,
+  otherwise memory corruption will result.
+\seealso{SLang_free_slstring, SLang_create_slstring}
+\done
+
+\function{SLang_create_static_slstring}
+\synopsis{Create a hashed string}
+\usage{char *SLang_create_static_slstring (char *s_literal)}
+\description
+  The \var{SLang_create_static_slstring} creates a hashed string from
+  the string literal \var{s_literal} and returns the result.  Upon
+  failure it returns \var{NULL}.
+\example
+#v+
+     char *create_hello (void)
+     {
+        return SLang_create_static_slstring ("hello");
+     }
+#v-
+\notes
+  This function should only be used with string literals.
+\seealso{SLang_create_slstring, SLang_create_nslstring}
+\done
+
+
+\function{SLmalloc}
+\synopsis{Allocate some memory}
+\usage{char *SLmalloc (unsigned int nbytes)}
+\description
+  This function uses \var{malloc} to allocate \var{nbytes} of memory.
+  Upon error it returns \var{NULL}; otherwise it returns a pointer to
+  the allocated memory.  One should use \var{SLfree} to free the
+  memory after used.
+\seealso{SLfree, SLrealloc, SLcalloc}
+\done
+
+
+\function{SLcalloc}
+\synopsis{Allocate some memory}
+\usage{char *SLcalloc (unsigned int num_elem, unsigned int elem_size)}
+\description
+  This function uses \var{calloc} to allocate memory for
+  \var{num_elem} objects with each of size \var{elem_size} and returns
+  the result.  In addition, the newly allocated memory is zeroed. 
+  Upon error it returns \var{NULL}; otherwise it returns a pointer to
+  the allocated memory.  One should use \var{SLfree} to free the
+  memory after used.
+\seealso{SLmalloc, SLrealloc, SLfree}
+\done
+
+
+\function{SLfree}
+\synopsis{Free some allocated memory}
+\usage{void SLfree (char *ptr)}
+\description
+  The \var{SLfree} function uses \var{free} to deallocate the memory
+  specified by \var{ptr}, which may be \var{NULL} in which case the
+  function does nothing.
+\notes
+  Never use this function to free a hashed string returned by one of
+  the family of \var{slstring} functions, e.g.,
+  \var{SLang_pop_slstring}.
+\seealso{SLmalloc, SLcalloc, SLrealloc, SLmake_string}
+\done
+
+
+\function{SLrealloc}
+\synopsis{Resize a dynamic memory block}
+\usage{char *SLrealloc (char *ptr, unsigned int new_size)}
+\description
+  The \var{SLrealloc} uses the \var{realloc} function to resize the
+  memory block specified by \var{ptr} to the new size \var{new_size}.
+  If \var{ptr} is \var{NULL}, the function call is equivalent to
+  \exmp{SLmalloc(new_size)}.  Similarly, if \var{new_size} is zero,
+  the function call is equivalent to \var{SLfree(ptr)}.  
+
+  If the function fails, or if \var{new_size} is zero, \var{NULL} is
+  returned.  Otherwise a pointer is returned to the (possibly moved)
+  new block of memory.
+\seealso{SLfree, SLmalloc, SLcalloc}
+\done
+
+
+\function{SLcurrent_time_string}
+\synopsis{Get the current time as a string}
+\usage{char *SLcurrent_time_string (void)}
+\description
+  The \var{SLcurrent_time_string} function uses the C library function
+  \var{ctime} to obtain a string representation of the
+  current date and time in the form
+#v+
+     "Wed Dec 10 12:50:28 1997"
+#v-
+  However, unlike the \var{ctime} function, a newline character is not
+  present in the string.  
+  
+  The returned value points to a statically allocated memory block
+  which may get overwritten on subsequent function calls.
+\seealso{SLmake_string}
+\done
+
+
+
+\function{SLatoi}
+\synopsis{Convert a text string to an integer}
+\usage{int SLatoi(unsigned char *str}
+\description
+  \var{SLatoi} parses the string \var{str} to interpret it as an
+  integer value.  Unlike \var{atoi}, \var{SLatoi} can also parse
+  strings containing integers expressed in
+  hexidecimal (e.g., \exmp{"0x7F"}) and octal (e.g., \exmp{"012"}.)
+  notation.
+\seealso{SLang_guess_type}
+\done
+
+
+\function{SLang_pop_fileptr}
+\synopsis{Pop a file pointer}
+\usage{int SLang_pop_fileptr (SLang_MMT_Type **mmt, FILE **fp)}
+\description
+  \var{SLang_pop_fileptr} pops a file pointer from the \slang
+  run-time stack.  It returns zero upon success, or \-1 upon failure.
+  
+  A \slang file pointer (SLANG_FILEPTR_TYPE) is actually a memory
+  managed object.  For this reason, \var{SLang_pop_fileptr} also
+  returns the memory managed object via the argument list.  It is up
+  to the calling routine to call \var{SLang_free_mmt} to free the
+  object.
+\example
+  The following example illustrates an application defined intrinsic
+  function that writes a user defined double precision number to a
+  file.  Note the use of \var{SLang_free_mmt}:
+#v+
+     int write_double (void)
+     {
+        double t;
+	SLang_MMT_Type *mmt;
+	FILE *fp;
+	int status;
+
+	if (-1 == SLang_pop_double (&d, NULL, NULL))
+	  return -1;
+	if (-1 == SLang_pop_fileptr (&mmt, &fp))
+	  return -1;
+	
+	status = fwrite (&d, sizeof (double), 1, fp);
+	SLang_free_mmt (mmt);
+        return status;
+     }
+#v-
+  This function can be used by a \slang function as follows:
+#v+
+     define write_some_values ()
+     {
+        variable fp, d;
+
+	fp = fopen ("myfile.dat", "wb");
+	if (fp == NULL)
+	  error ("file failed to open");
+	for (d = 0; d < 10.0; d += 0.1)
+	  {
+	     if (-1 == write_double (fp, d))
+	       error ("write failed");
+	  }
+	if (-1 == fclose (fp))
+	  error ("fclose failed");
+     }
+#v-
+\seealso{SLang_free_mmt, SLang_pop_double}
+\done
+
+
+\function{SLadd_intrinsic_function}
+\synopsis{Add a new intrinsic function to the interpreter}
+\usage{int SLadd_intrinsic_function (name, f, type, nargs, ...)}
+#v+
+    char *name
+    FVOID_STAR f
+    unsigned char type
+    unsigned int nargs
+#v-
+\description
+  The \var{SLadd_intrinsic_function} function may be used to add a new
+  intrinsic function.  The \slang name of the function is specified by
+  \var{name} and the actual function pointer is given by \var{f}, cast
+  to \var{FVOID_STAR}.  The third parameter, \var{type} specifies the
+  return type of the function and must be one of the following values:
+#v+
+    SLANG_VOID_TYPE   (returns nothing)
+    SLANG_INT_TYPE    (returns int)
+    SLANG_DOUBLE_TYPE (returns double)
+    SLANG_STRING_TYPE (returns char *)
+#v-
+  The \var{nargs} parameter specifies the number of parameters to pass
+  to the function.  The variable argument list following \var{nargs}
+  must consists of \var{nargs} integers which specify the data type of
+  each argument.
+
+  The function returns zero upon success or \-1 upon failure.
+\example
+  The \jed editor uses this function to change the \var{system}
+  intrinsic function to the following:
+#v+
+     static int jed_system (char *cmd)
+     {
+        if (Jed_Secure_Mode)
+	  {
+	    msg_error ("Access denied.");
+	    return -1;
+	  }	  
+	return SLsystem (cmd);
+     }
+#v-
+  After initializing the interpreter with \var{SLang_init_slang},
+  \jed calls \var{SLadd_intrinsic_function} to substitute the above
+  definition for the default \slang definition:
+#v+
+     if (-1 == SLadd_intrinsic_function ("system", (FVOID_STAR)jed_system,
+                                          SLANG_INT_TYPE, 1,
+					  SLANG_STRING_TYPE))
+       return -1;
+#v-
+\seealso{SLadd_intrinsic_variable, SLadd_intrinsic_array}
+\done
+
+\function{SLadd_intrinsic_variable}
+\synopsis{Add an intrinsic variable to the interpreter}
+\usage{int SLadd_intrinsic_variable (name, addr, type, rdonly)}
+#v+
+    char *name
+    VOID_STAR type
+    unsigned char type
+    int rdonly
+#v-
+\description
+  The \var{SLadd_intrinsic_variable} function adds an intrinsic
+  variable called \var{name} to the interpeter.  The second parameter
+  \var{addr} specifies the address of the variable (cast to
+  \var{VOID_STAR}).  The third parameter, \var{type}, specifies the
+  data type of the variable.  If the fourth parameter, \var{rdonly},
+  is non-zero, the variable will interpreted by the interpreter as
+  read-only.
+  
+  If successful, \var{SLadd_intrinsic_variable} returns zero,
+  otherwise it returns \-1.
+\example
+  Suppose that \var{My_Global_Int} is a global variable (at least not
+  a local one):
+#v+
+    int My_Global_Int;
+#v-
+  It can be added to the interpreter via the function call
+#v+
+    if (-1 == SLadd_intrinsic_variable ("MyGlobalInt",
+                                        (VOID_STAR)&My_Global_Int,
+					SLANG_INT_TYPE, 0))
+      exit (1);
+#v-
+\notes
+  The current implementation requires all pointer type intrinsic
+  variables to be read-only.  For example,
+#v+
+    char *My_Global_String;
+#v-
+  is of type \var{SLANG_STRING_TYPE}, and must be declared as
+  read-only.  Finally, not that
+#v+
+   char My_Global_Char_Buf[256];
+#v-
+  is \em{not} a \var{SLANG_STRING_TYPE} object.  This difference is
+  very important because internally the interpreter dereferences the
+  address passed to it to get to the value of the variable.
+\seealso{SLadd_intrinsic_function, SLadd_intrinsic_array}
+\done
+}
+
+
+\function{SLclass_add_unary_op}
+\synopsis{??}
+\usage{int SLclass_add_unary_op (unsigned char,int (*) (int, unsigned char, VOID_STAR, unsigned int, VOID_STAR), int (*) (int, unsigned char, unsigned char *));}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{SLclass_add_app_unary_op}
+\synopsis{??}
+\usage{int SLclass_add_app_unary_op (unsigned char, int (*) (int,unsigned char, VOID_STAR, unsigned int,VOID_STAR),int (*) (int, unsigned char, unsigned char *));}
+\description
+??
+\seealso{??}
+\done
+
+\function{SLclass_add_binary_op}
+\synopsis{??}
+\usage{int SLclass_add_binary_op (unsigned char, unsigned char,int (*)(int, unsigned char, VOID_STAR, unsigned int,unsigned char, VOID_STAR, unsigned int,VOID_STAR),int (*) (int, unsigned char, unsigned char, unsigned char *));}
+\description
+??
+\seealso{??}
+\done
+
+\function{SLclass_add_math_op}
+\synopsis{??}
+\usage{int SLclass_add_math_op (unsigned char,int (*)(int,unsigned char, VOID_STAR, unsigned int,VOID_STAR),int (*)(int, unsigned char, unsigned char *));}
+\description
+??
+\seealso{??}
+\done
+
+\function{SLclass_add_typecast}
+\synopsis{??}
+\usage{int SLclass_add_typecast (unsigned char, unsigned char int (*)_PROTO((unsigned char, VOID_STAR, unsigned int,unsigned char, VOID_STAR)),int);}
+\description
+??
+\seealso{??}
+\done
+
+\function{SLang_init_tty}
+\synopsis{Initialize the terminal keyboard interface}
+\usage{int SLang_init_tty (int intr_ch, int no_flow_ctrl, int opost)}
+\description
+  \var{SLang_init_tty} initializes the terminal for single character
+  input.  If the first parameter \var{intr_ch} is in the range 0-255,
+  it will be used as the interrupt character, e.g., under Unix this
+  character will generate a \var{SIGINT} signal.  Otherwise, if it is
+  \exmp{-1}, the interrupt character will be left unchanged.  
+
+  If the second parameter \var{no_flow_ctrl} is non-zero, flow control
+  (\var{XON}/\var{XOFF}) processing will be
+  enabled.  
+  
+  If the last parmeter \var{opost} is non-zero, output processing by the
+  terminal will be enabled.  If one intends to use this function in
+  conjunction with the \slang screen management routines
+  (\var{SLsmg}), this paramete shold be set to zero.
+  
+  \var{SLang_init_tty} returns zero upon success, or \-1 upon error.
+\notes
+  Terminal I/O is a complex subject.  The \slang interface presents a
+  simplification that the author has found useful in practice.  For
+  example, the only special character processing that
+  \var{SLang_init_tty} enables is that of the \var{SIGINT} character,
+  and the generation of other signals via the keyboard is disabled.
+  However, generation of the job control signal \var{SIGTSTP} is possible
+  via the \var{SLtty_set_suspend_state} function.
+  
+  Under Unix, the integer variable \var{SLang_TT_Read_FD} is used to
+  specify the input descriptor for the terminal.  If
+  \var{SLang_TT_Read_FD} represents a terminal device as determined
+  via the \var{isatty} system call, then it will be used as the
+  terminal file descriptor.  Otherwise, the terminal device
+  \exmp{/dev/tty} will used as the input device.  The default value of
+  \var{SLang_TT_Read_FD} is \-1 which causes \exmp{/dev/tty} to be
+  used.  So, if you prefer to use \var{stdin} for input, then set
+  \var{SLang_TT_Read_FD} to \exmp{fileno(stdin)} \em{before} calling
+  \var{SLang_init_tty}.
+  
+  If the variable \var{SLang_TT_Baud_Rate} is zero when this function
+  is called, the function will attempt to determine the baud rate by
+  querying the terminal driver and set \var{SLang_TT_Baud_Rate} to
+  that value.  
+\seealso{SLang_reset_tty, SLang_getkey, SLtty_set_suspend_state}
+\done
+
+
+\function{SLang_reset_tty}
+\synopsis{Reset the terminal}
+\usage{void SLang_reset_tty (void)}
+\description
+  \var{SLang_reset_tty} resets the terminal interface back to the
+  state it was in before \var{SLang_init_tty} was called.
+\seealso{SLang_init_tty}
+\done
+
+
+\function{SLtty_set_suspend_state}
+\synopsis{Enable or disable keyboard suspension}
+\usage{void SLtty_set_suspend_state (int s)}
+\description
+  The \var{SLtty_set_suspend_state} function may be used to enable or
+  disable keyboard generation of the \var{SIGTSTP} job control signal.
+  If \var{s} is non-zero, generation of this signal via the terminal
+  interface will be enabled, otherwise it will be disabled.
+  
+  This function should only be called after the terminal driver has be
+  initialized via \var{SLang_init_tty}.  The \var{SLang_init_tty}
+  always disables the generation of \var{SIGTSTP} via the keyboard.
+\seealso{SLang_init_tty}
+\done
+
+\function{SLang_getkey}
+\synopsis{Read a character from the keyboard}
+\usage{unsigned int SLang_getkey (void);}
+\description
+  The \var{SLang_getkey} reads a single character from the terminal
+  and returns it.  The terminal must first be initialized via a call
+  to \var{SLang_init_tty} before this function can be called.  Upon
+  success, \var{SLang_getkey} returns the character read from the
+  terminal, otherwise it returns \var{SLANG_GETKEY_ERROR}.
+\seealso{SLang_init_tty, SLang_input_pending, SLang_ungetkey}
+\done
+
+\function{SLang_ungetkey_string}
+\synopsis{Unget a key string}
+\usage{int SLang_ungetkey_string (unsigned char *buf, unsigned int n)}
+\description
+  The \var{SLang_ungetkey_string} function may be used to push the
+  \var{n} characters pointed to by \var{buf} onto the buffered input
+  stream that \var{SLgetkey} uses.  If there is not enough room for
+  the characters, \-1 is returned and none are buffered.  Otherwise,
+  it returns zero.
+\notes
+  The difference between \var{SLang_buffer_keystring} and
+  \var{SLang_ungetkey_string} is that the \var{SLang_buffer_keystring}
+  appends the characters to the end of the getkey buffer, whereas
+  \var{SLang_ungetkey_string} inserts the characters at the beginning
+  of the input buffer.
+\seealso{SLang_ungetkey, SLang_getkey}
+\done
+
+
+\function{SLang_buffer_keystring}
+\synopsis{Append a keystring to the input buffer}
+\usage{int SLang_buffer_keystring (unsigned char *b, unsigned int len)}
+\description
+  \var{SLang_buffer_keystring} places the \var{len} characters
+  specified by \var{b} at the \em{end} of the buffer that
+  \var{SLang_getkey} uses.  Upon success it returns 0; otherwise, no
+  characters are buffered and it returns \-1.
+\notes
+  The difference between \var{SLang_buffer_keystring} and
+  \var{SLang_ungetkey_string} is that the \var{SLang_buffer_keystring}
+  appends the characters to the end of the getkey buffer, whereas
+  \var{SLang_ungetkey_string} inserts the characters at the beginning
+  of the input buffer.
+\seealso{SLang_getkey, SLang_ungetkey, SLang_ungetkey_string}
+\done
+
+
+\function{SLang_ungetkey}
+\synopsis{Push a character back onto the input buffer}
+\usage{int SLang_ungetkey (unsigned char ch)}
+\description
+  \var{SLang_ungetkey} pushes the character \var{ch} back onto the
+  \var{SLgetkey} input stream.  Upon success, it returns zero,
+  otherwise it returns \1.
+\example
+  This function is implemented as:
+#v+
+    int SLang_ungetkey (unsigned char ch)
+    {
+       return SLang_ungetkey_string(&ch, 1);
+    }
+#v-
+\seealso{SLang_getkey, SLang_ungetkey_string}
+\done
+
+
+\function{SLang_flush_input}
+\synopsis{Discard all keyboard input waiting to be read}
+\usage{void SLang_flush_input (void)}
+\description
+  \var{SLang_flush_input} discards all input characters waiting to be
+  read by the \var{SLang_getkey} function.
+\seealso{SLang_getkey}
+\done
+
+
+\function{SLang_input_pending}
+\synopsis{Check to see if input is pending}
+\usage{int SLang_input_pending (int tsecs)}
+\description
+  \var{SLang_input_pending} may be used to see if an input character
+  is available to be read without causing \var{SLang_getkey} to block.
+  It will wait up to \var{tsecs} tenths of a second if no characters
+  are immediately available for reading.  If \var{tsecs} is less than
+  zero, then \var{SLang_input_pending} will wait \exmp{-tsecs}
+  milliseconds for input, otherwise \var{tsecs} represents \var{1/10}
+  of a second intervals.
+\notes
+  Not all systems support millisecond resolution.
+\seealso{SLang_getkey}
+\done
+
+
+\function{SLang_set_abort_signal}
+\synopsis{Set the signal to trap SIGINT}
+\usage{void SLang_set_abort_signal (void (*f)(int));}
+\description
+  \var{SLang_set_abort_signal} sets the function that gets
+  triggered when the user presses the interrupt key (\var{SIGINT}) to
+  the function \var{f}.  If \var{f} is \var{NULL} the default handler
+  will get installed.
+\example
+  The default interrupt handler on a Unix system is:
+#v+
+     static void default_sigint (int sig)
+     {
+        SLKeyBoard_Quit = 1;
+	if (SLang_Ignore_User_Abort == 0) SLang_Error = SL_USER_BREAK;
+	SLsignal_intr (SIGINT, default_sigint);
+   }
+#v-
+\notes
+  For Unix programmers, the name of this function may appear
+  misleading since it is associated with \var{SIGINT} and not
+  \var{SIGABRT}.  The origin of the name stems from the original intent
+  of the function: to allow the user to abort the running of a \slang
+  interpreter function.
+\seealso{SLang_init_tty, SLsignal_intr}
+\done
+
+
+\function{SLkm_define_key}
+\synopsis{Define a key in a keymap}
+\usage{int SLkm_define_key (char *seq, FVOID_STAR f, SLKeyMap_List_Type *km)}
+\description
+  \var{SLkm_define_key} associates the key sequence \var{seq} with the
+  function pointer \var{f} in the keymap specified by \var{km}.  Upon
+  success, it returns zero, otherwise it returns a negative integer
+  upon error.
+\seealso{SLkm_define_keysym, SLang_define_key}
+\done
+
+
+
+\function{SLang_define_key}
+\synopsis{Define a key in a keymap}
+\usage{int SLang_define_key(char *seq, char *fun, SLKeyMap_List_Type *km)}
+\description
+  \var{SLang_define_key} associates the key sequence \var{seq} with
+  the function whose name is \var{fun} in the keymap specified by
+  \var{km}.
+\seealso{SLkm_define_keysym, SLkm_define_key}
+\done
+
+
+\function{SLkm_define_keysym}
+\synopsis{Define a keysym in a keymap}
+\usage{int SLkm_define_keysym (seq, ks, km)}
+#v+
+      char *seq;
+      unsigned int ks;
+      SLKeyMap_List_Type *km;
+#v-
+\description
+  \var{SLkm_define_keysym} associates the key sequence \var{seq} with
+  the keysym \var{ks} in the keymap \var{km}.  Keysyms whose value is
+  less than or equal to \exmp{0x1000} is reserved by the library and
+  should not be used.
+\seealso{SLkm_define_key, SLang_define_key}
+\done
+
+\function{SLang_undefine_key}
+\synopsis{Undefined a key from a keymap}
+\usage{void SLang_undefine_key(char *seq, SLKeyMap_List_Type *km);}
+\description
+  \var{SLang_undefine_key} removes the key sequence \var{seq} from the
+  keymap \var{km}.
+\seealso{SLang_define_key}
+\done
+
+\function{SLang_create_keymap}
+\synopsis{Create a new keymap}
+\usage{SLKeyMap_List_Type *SLang_create_keymap (name, km)}
+#v+
+     char *name;
+     SLKeyMap_List_Type *km;
+#v-
+\description
+  \var{SLang_create_keymap} creates a new keymap called \var{name} by
+  copying the key definitions from the keymap \var{km}.  If \var{km}
+  is \var{NULL}, the newly created keymap will be empty and it is up
+  to the calling routine to initialize it via the
+  \var{SLang_define_key} and \var{SLkm_define_keysym} functions.
+  \var{SLang_create_keymap} returns a pointer to the new keymap, or
+  \var{NULL} upon failure.
+\seealso{SLang_define_key, SLkm_define_keysym}
+\done
+
+
+\function{SLang_do_key}
+\synopsis{Read a keysequence and return its keymap entry}
+\usage{SLang_Key_Type *SLang_do_key (kml, getkey)}
+#v+
+     SLKeyMap_List_Type *kml;
+     int (*getkey)(void);
+#v-
+\description
+  The \var{SLang_do_key} function reads characters using the function
+  specified by the \var{getkey} function pointer and uses the
+  key sequence to return the appropriate entry in the keymap specified
+  by \var{kml}.
+  
+  \var{SLang_do_key} returns \var{NULL} if the key sequence is not
+  defined by the keymap, otherwise it returns a pointer to an object
+  of type \var{SLang_Key_Type}, which is defined in \exmp{slang.h} as
+#v+
+     #define SLANG_MAX_KEYMAP_KEY_SEQ 14
+     typedef struct SLang_Key_Type
+     {
+       struct SLang_Key_Type *next;
+       union
+       {
+          char *s;
+	  FVOID_STAR f;
+	  unsigned int keysym;
+       }
+       f;
+       unsigned char type;	       /* type of function */
+     #define SLKEY_F_INTERPRET  0x01
+     #define SLKEY_F_INTRINSIC  0x02
+     #define SLKEY_F_KEYSYM     0x03
+       unsigned char str[SLANG_MAX_KEYMAP_KEY_SEQ + 1];/* key sequence */
+     }
+SLang_Key_Type;
+
+#v-
+  The \var{type} field specifies which field of the union \var{f}
+  should be used.  If \var{type} is \var{SLKEY_F_INTERPRET}, then
+  \var{f.s} is a string that should be passed to the interpreter for
+  evaluation.  If \var{type} is \var{SLKEY_F_INTRINSIC}, then
+  \var{f.f} refers to function that should be called.  Otherwise,
+  \var{type} is \var{SLKEY_F_KEYSYM} and \var{f.keysym} represents the
+  value of the keysym that is associated with the key sequence.
+\seealso{SLkm_define_keysym, SLkm_define_key}
+\done
+
+
+\function{SLang_find_key_function}
+\synopsis{Obtain a function pointer associated with a keymap}
+\usage{FVOID_STAR SLang_find_key_function (fname, km);}
+#v+
+    char *fname;
+    SLKeyMap_List_Type *km;
+#v-
+\description
+  The \var{SLang_find_key_function} routine searches through the
+  \var{SLKeymap_Function_Type} list of functions associated with the
+  keymap \var{km} for the function with name \var{fname}.
+  If a matching function is found, a pointer to the function will
+  be returned, otherwise \var{SLang_find_key_function} will return
+  \var{NULL}.
+\seealso{SLang_create_keymap, SLang_find_keymap}
+\done
+
+
+\function{SLang_find_keymap}
+\synopsis{Find a keymap}
+\usage{SLKeyMap_List_Type *SLang_find_keymap (char *keymap_name);}
+\description
+  The \var{SLang_find_keymap} function searches through the list of
+  keymaps looking for one whose name is \var{keymap_name}.  If a
+  matching keymap is found, the function returns a pointer to the
+  keymap.  It returns \var{NULL} if no such keymap exists.
+\seealso{SLang_create_keymap, SLang_find_key_function}
+\done
+
+\function{SLang_process_keystring}
+\synopsis{Un-escape a key-sequence}
+\usage{char *SLang_process_keystring (char *kseq);}
+\description
+  The \var{SLang_process_keystring} function converts an escaped key
+  sequence to its raw form by converting two-character combinations
+  such as \var{^A} to the \em{single} character \exmp{Ctrl-A} (ASCII
+  1).  In addition, if the key sequence contains constructs such as
+  \exmp{^(XX)}, where \exmp{XX} represents a two-character termcap
+  specifier, the termcap escape sequence will be looked up and
+  substituted.   
+  
+  Upon success, \var{SLang_process_keystring} returns a raw
+  key-sequence whose first character represents the total length of
+  the key-sequence, including the length specifier itself.  It returns
+  \var{NULL} upon failure.
+\example
+  Consider the following examples:
+#v+
+     SLang_process_keystring ("^X^C");
+     SLang_process_keystring ("^[[A");
+#v-
+  The first example will return a pointer to a buffer of three characters
+  whose ASCII values are given by \exmp{\{3,24,3\}}.  Similarly, the
+  second example will return a pointer to the four characters
+  \exmp{\{4,27,91,65\}}.  Finally, the result of
+#v+
+     SLang_process_keystring ("^[^(ku)");
+#v-
+  will depend upon the termcap/terminfo capability \exmp{"ku"}, which
+  represents the escape sequence associated with the terminal's UP
+  arrow key.  For an ANSI terminal whose UP arrow produces
+  \exmp{"ESC [ A"}, the result will be \exmp{5,27,27,91,65}.
+\notes
+  \var{SLang_process_keystring} returns a pointer to a static area
+  that will be overwritten on subsequent calls.
+\seealso{SLang_define_key, SLang_make_keystring}
+\done
+
+\function{SLang_make_keystring}
+\synopsis{Make a printable key sequence}
+\usage{char *SLang_make_keystring (unsigned char *ks);}
+\description
+  The \var{SLang_make_keystring} function takes a raw key sequence
+  \var{ks} and converts it to a printable form by converting
+  characters such as ASCII 1 (ctrl-A) to \exmp{^A}.  That is, it
+  performs the opposite function of \var{SLang_process_keystring}.
+\notes
+  This function returns a pointer to a static area that will be
+  overwritten on the next call to \var{SLang_make_keystring}.
+\seealso{SLang_process_keystring}
+\done
+
+
+\function{SLextract_list_element}
+\synopsis{Extract a substring of a delimited string}
+\usage{int SLextract_list_element (dlist, nth, delim, buf, buflen)}
+#v+
+    char *dlist;
+    unsigned int nth;
+    char delim;
+    char *buf;
+    unsigned int buflen;
+#v-
+\description
+  \var{SLextract_list_element} may be used to obtain the \var{nth}
+  element of a list of strings, \var{dlist}, that are delimited by the
+  character \var{delim}.  The routine copies the \var{nth} element of
+  \var{dlist} to the buffer \var{buf} whose size is \var{buflen}
+  characters.  It returns zero upon success, or \-1 if \var{dlist}
+  does not contain an \var{nth} element.
+\example
+  A delimited list of strings may be turned into an array of strings
+  as follows.  For conciseness, all malloc error checking has been
+  omitted.
+#v+
+    int list_to_array (char *list, char delim, char ***ap)
+    {
+       unsigned int nth;
+       char **a;
+       char buf[1024];
+
+       /* Determine the size of the array */
+       nth = 0;
+       while (0 == SLextract_list_element (list, nth, delim, buf, sizeof(buf)))
+         nth++;
+       
+       ap = (char **) SLmalloc ((nth + 1) * sizeof (char **));
+       nth = 0;
+       while (0 == SLextract_list_element (list, nth, delim, buf, sizeof(buf)))
+         {
+	     a[nth] = SLmake_string (buf);
+	     nth++;
+	 }
+       a[nth] = NULL;
+       *ap = a;
+       return 0;
+    }
+#v-
+\seealso{SLmalloc, SLmake_string}
+\done
+
+
+#%+
+\function{SLprep_open_prep}
+\synopsis{??}
+\usage{int SLprep_open_prep (SLPreprocess_Type *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{SLprep_close_prep}
+\synopsis{??}
+\usage{void SLprep_close_prep (SLPreprocess_Type *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{SLprep_line_ok}
+\synopsis{??}
+\usage{int SLprep_line_ok (char *, SLPreprocess_Type *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{SLdefine_for_ifdef}
+\synopsis{??}
+\usage{int SLdefine_for_ifdef (char *);}
+\description
+??
+\seealso{??}
+\done
+
+\function{SLang_Read_Line_Type * SLang_rline_save_line (SLang_RLine_Info_Type *);}
+\synopsis{??}
+\usage{SLang_Read_Line_Type * SLang_rline_save_line (SLang_RLine_Info_Type *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{int SLang_init_readline (SLang_RLine_Info_Type *);}
+\synopsis{??}
+\usage{int SLang_init_readline (SLang_RLine_Info_Type *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{int SLang_read_line (SLang_RLine_Info_Type *);}
+\synopsis{??}
+\usage{int SLang_read_line (SLang_RLine_Info_Type *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{int SLang_rline_insert (char *);}
+\synopsis{??}
+\usage{int SLang_rline_insert (char *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{void SLrline_redraw (SLang_RLine_Info_Type *);}
+\synopsis{??}
+\usage{void SLrline_redraw (SLang_RLine_Info_Type *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{int SLtt_flush_output (void);}
+\synopsis{??}
+\usage{int SLtt_flush_output (void);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{void SLtt_set_scroll_region(int, int);}
+\synopsis{??}
+\usage{void SLtt_set_scroll_region(int, int);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{void SLtt_reset_scroll_region(void);}
+\synopsis{??}
+\usage{void SLtt_reset_scroll_region(void);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{void SLtt_reverse_video (int);}
+\synopsis{??}
+\usage{void SLtt_reverse_video (int);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{void SLtt_bold_video (void);}
+\synopsis{??}
+\usage{void SLtt_bold_video (void);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{void SLtt_begin_insert(void);}
+\synopsis{??}
+\usage{void SLtt_begin_insert(void);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{void SLtt_end_insert(void);}
+\synopsis{??}
+\usage{void SLtt_end_insert(void);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{void SLtt_del_eol(void);}
+\synopsis{??}
+\usage{void SLtt_del_eol(void);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{void SLtt_goto_rc (int, int);}
+\synopsis{??}
+\usage{void SLtt_goto_rc (int, int);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{void SLtt_delete_nlines(int);}
+\synopsis{??}
+\usage{void SLtt_delete_nlines(int);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{void SLtt_delete_char(void);}
+\synopsis{??}
+\usage{void SLtt_delete_char(void);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{void SLtt_erase_line(void);}
+\synopsis{??}
+\usage{void SLtt_erase_line(void);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{void SLtt_normal_video(void);}
+\synopsis{??}
+\usage{void SLtt_normal_video(void);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{void SLtt_cls(void);}
+\synopsis{??}
+\usage{void SLtt_cls(void);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{void SLtt_beep(void);}
+\synopsis{??}
+\usage{void SLtt_beep(void);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{void SLtt_reverse_index(int);}
+\synopsis{??}
+\usage{void SLtt_reverse_index(int);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{void SLtt_smart_puts(unsigned short *, unsigned short *, int, int);}
+\synopsis{??}
+\usage{void SLtt_smart_puts(unsigned short *, unsigned short *, int, int);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{void SLtt_write_string (char *);}
+\synopsis{??}
+\usage{void SLtt_write_string (char *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{void SLtt_putchar(char);}
+\synopsis{??}
+\usage{void SLtt_putchar(char);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{int SLtt_init_video (void);}
+\synopsis{??}
+\usage{int SLtt_init_video (void);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{int SLtt_reset_video (void);}
+\synopsis{??}
+\usage{int SLtt_reset_video (void);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{void SLtt_get_terminfo(void);}
+\synopsis{??}
+\usage{void SLtt_get_terminfo(void);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{void SLtt_get_screen_size (void);}
+\synopsis{??}
+\usage{void SLtt_get_screen_size (void);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{int SLtt_set_cursor_visibility (int);}
+\synopsis{??}
+\usage{int SLtt_set_cursor_visibility (int);}
+\description
+??
+\seealso{??}
+\done
+
+
+
+\function{int SLtt_initialize (char *);}
+\synopsis{??}
+\usage{int SLtt_initialize (char *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{void SLtt_enable_cursor_keys(void);}
+\synopsis{??}
+\usage{void SLtt_enable_cursor_keys(void);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{void SLtt_set_term_vtxxx(int *);}
+\synopsis{??}
+\usage{void SLtt_set_term_vtxxx(int *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{void SLtt_set_color_esc (int, char *);}
+\synopsis{??}
+\usage{void SLtt_set_color_esc (int, char *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{void SLtt_wide_width(void);}
+\synopsis{??}
+\usage{void SLtt_wide_width(void);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{void SLtt_narrow_width(void);}
+\synopsis{??}
+\usage{void SLtt_narrow_width(void);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{int SLtt_set_mouse_mode (int, int);}
+\synopsis{??}
+\usage{int SLtt_set_mouse_mode (int, int);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{void SLtt_set_alt_char_set (int);}
+\synopsis{??}
+\usage{void SLtt_set_alt_char_set (int);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{int SLtt_write_to_status_line (char *, int);}
+\synopsis{??}
+\usage{int SLtt_write_to_status_line (char *, int);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{void SLtt_disable_status_line (void);}
+\synopsis{??}
+\usage{void SLtt_disable_status_line (void);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{char *SLtt_tgetstr (char *);}
+\synopsis{??}
+\usage{char *SLtt_tgetstr (char *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{int SLtt_tgetnum (char *);}
+\synopsis{??}
+\usage{int SLtt_tgetnum (char *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{int SLtt_tgetflag (char *);}
+\synopsis{??}
+\usage{int SLtt_tgetflag (char *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{char *SLtt_tigetent (char *);}
+\synopsis{??}
+\usage{char *SLtt_tigetent (char *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{char *SLtt_tigetstr (char *, char **);}
+\synopsis{??}
+\usage{char *SLtt_tigetstr (char *, char **);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{int SLtt_tigetnum (char *, char **);}
+\synopsis{??}
+\usage{int SLtt_tigetnum (char *, char **);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{SLtt_Char_Type SLtt_get_color_object (int);}
+\synopsis{??}
+\usage{SLtt_Char_Type SLtt_get_color_object (int);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{void SLtt_set_color_object (int, SLtt_Char_Type);}
+\synopsis{??}
+\usage{void SLtt_set_color_object (int, SLtt_Char_Type);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{void SLtt_set_color (int, char *, char *, char *);}
+\synopsis{??}
+\usage{void SLtt_set_color (int, char *, char *, char *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{void SLtt_set_mono (int, char *, SLtt_Char_Type);}
+\synopsis{??}
+\usage{void SLtt_set_mono (int, char *, SLtt_Char_Type);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{void SLtt_add_color_attribute (int, SLtt_Char_Type);}
+\synopsis{??}
+\usage{void SLtt_add_color_attribute (int, SLtt_Char_Type);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{void SLtt_set_color_fgbg (int, SLtt_Char_Type, SLtt_Char_Type);}
+\synopsis{??}
+\usage{void SLtt_set_color_fgbg (int, SLtt_Char_Type, SLtt_Char_Type);}
+\description
+??
+\seealso{??}
+\done
+
+
+
+\function{int SLkp_define_keysym (char *, unsigned int);}
+\synopsis{??}
+\usage{int SLkp_define_keysym (char *, unsigned int);}
+\description
+??
+\seealso{??}
+\done
+
+
+
+\function{int SLkp_init (void);}
+\synopsis{??}
+\usage{int SLkp_init (void);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{int SLkp_getkey (void);}
+\synopsis{??}
+\usage{int SLkp_getkey (void);}
+\description
+??
+\seealso{??}
+\done
+
+
+
+\function{int SLscroll_find_top (SLscroll_Window_Type *);}
+\synopsis{??}
+\usage{int SLscroll_find_top (SLscroll_Window_Type *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{int SLscroll_find_line_num (SLscroll_Window_Type *);}
+\synopsis{??}
+\usage{int SLscroll_find_line_num (SLscroll_Window_Type *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{unsigned int SLscroll_next_n (SLscroll_Window_Type *, unsigned int);}
+\synopsis{??}
+\usage{unsigned int SLscroll_next_n (SLscroll_Window_Type *, unsigned int);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{unsigned int SLscroll_prev_n (SLscroll_Window_Type *, unsigned int);}
+\synopsis{??}
+\usage{unsigned int SLscroll_prev_n (SLscroll_Window_Type *, unsigned int);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{int SLscroll_pageup (SLscroll_Window_Type *);}
+\synopsis{??}
+\usage{int SLscroll_pageup (SLscroll_Window_Type *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{int SLscroll_pagedown (SLscroll_Window_Type *);}
+\synopsis{??}
+\usage{int SLscroll_pagedown (SLscroll_Window_Type *);}
+\description
+??
+\seealso{??}
+\done
+
+
+
+\function{SLSig_Fun_Type *SLsignal (int, SLSig_Fun_Type *);}
+\synopsis{??}
+\usage{SLSig_Fun_Type *SLsignal (int, SLSig_Fun_Type *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{SLSig_Fun_Type *SLsignal_intr (int, SLSig_Fun_Type *);}
+\synopsis{??}
+\usage{SLSig_Fun_Type *SLsignal_intr (int, SLSig_Fun_Type *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{int SLsig_block_signals (void);}
+\synopsis{??}
+\usage{int SLsig_block_signals (void);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{int SLsig_unblock_signals (void);}
+\synopsis{??}
+\usage{int SLsig_unblock_signals (void);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{int SLsystem (char *);}
+\synopsis{??}
+\usage{int SLsystem (char *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{void SLadd_at_handler (long *, char *);}
+\synopsis{??}
+\usage{void SLadd_at_handler (long *, char *);}
+\description
+??
+\seealso{??}
+\done
+
+
+
+\function{void SLang_define_case(int *, int *);}
+\synopsis{??}
+\usage{void SLang_define_case(int *, int *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{void SLang_init_case_tables (void);}
+\synopsis{??}
+\usage{void SLang_init_case_tables (void);}
+\description
+??
+\seealso{??}
+\done
+
+
+
+\function{unsigned char *SLang_regexp_match(unsigned char *, unsigned int, SLRegexp_Type *);}
+\synopsis{??}
+\usage{unsigned char *SLang_regexp_match(unsigned char *, unsigned int, SLRegexp_Type *);}
+\description
+??
+\seealso{??}
+\done
+
+
+
+\function{int SLang_regexp_compile (SLRegexp_Type *);}
+\synopsis{??}
+\usage{int SLang_regexp_compile (SLRegexp_Type *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{char *SLregexp_quote_string (char *, char *, unsigned int);}
+\synopsis{??}
+\usage{char *SLregexp_quote_string (char *, char *, unsigned int);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{int SLcmd_execute_string (char *, SLcmd_Cmd_Table_Type *);}
+\synopsis{??}
+\usage{int SLcmd_execute_string (char *, SLcmd_Cmd_Table_Type *);}
+\description
+??
+\seealso{??}
+\done
+
+
+
+\function{int SLsearch_init (char *, int, int, SLsearch_Type *);}
+\synopsis{??}
+\usage{int SLsearch_init (char *, int, int, SLsearch_Type *);}
+\description
+??
+/* 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.
+ */
+\seealso{??}
+\done
+
+
+\function{unsigned char *SLsearch (unsigned char *, unsigned char *, SLsearch_Type *);}
+\synopsis{??}
+\usage{unsigned char *SLsearch (unsigned char *, unsigned char *, SLsearch_Type *);}
+\description
+??
+/* 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.
+ */
+\seealso{??}
+\done
+
+
+\function{SLcomplex_abs}
+\synopsis{Returns the norm of a complex number}
+\usage{double SLcomplex_abs (double *z)}}
+\description
+  The \var{SLcomplex_abs} function returns the absolute value or the
+  norm of the complex number given by \var{z}.
+\seealso{SLcomplex_times}
+\done
+
+
+\function{double *SLcomplex_times (double *, double *, double *);}
+\synopsis{??}
+\usage{double *SLcomplex_times (double *, double *, double *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{double *SLcomplex_divide (double *, double *, double *);}
+\synopsis{??}
+\usage{double *SLcomplex_divide (double *, double *, double *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{double *SLcomplex_sin (double *, double *);}
+\synopsis{??}
+\usage{double *SLcomplex_sin (double *, double *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{double *SLcomplex_cos (double *, double *);}
+\synopsis{??}
+\usage{double *SLcomplex_cos (double *, double *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{double *SLcomplex_tan (double *, double *);}
+\synopsis{??}
+\usage{double *SLcomplex_tan (double *, double *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{double *SLcomplex_asin (double *, double *);}
+\synopsis{??}
+\usage{double *SLcomplex_asin (double *, double *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{double *SLcomplex_acos (double *, double *);}
+\synopsis{??}
+\usage{double *SLcomplex_acos (double *, double *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{double *SLcomplex_atan (double *, double *);}
+\synopsis{??}
+\usage{double *SLcomplex_atan (double *, double *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{double *SLcomplex_exp (double *, double *);}
+\synopsis{??}
+\usage{double *SLcomplex_exp (double *, double *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{double *SLcomplex_log (double *, double *);}
+\synopsis{??}
+\usage{double *SLcomplex_log (double *, double *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{double *SLcomplex_log10 (double *, double *);}
+\synopsis{??}
+\usage{double *SLcomplex_log10 (double *, double *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{double *SLcomplex_sqrt (double *, double *);}
+\synopsis{??}
+\usage{double *SLcomplex_sqrt (double *, double *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{double *SLcomplex_sinh (double *, double *);}
+\synopsis{??}
+\usage{double *SLcomplex_sinh (double *, double *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{double *SLcomplex_cosh (double *, double *);}
+\synopsis{??}
+\usage{double *SLcomplex_cosh (double *, double *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{double *SLcomplex_tanh (double *, double *);}
+\synopsis{??}
+\usage{double *SLcomplex_tanh (double *, double *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{double *SLcomplex_pow (double *, double *, double *);}
+\synopsis{??}
+\usage{double *SLcomplex_pow (double *, double *, double *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{double SLmath_hypot (double x, double y);}
+\synopsis{??}
+\usage{double SLmath_hypot (double x, double y);}
+\description
+??
+\seealso{??}
+\done
+
+
+
+extern double *SLcomplex_asinh (double *, double *);
+\function{double *SLcomplex_acosh (double *, double *);}
+\synopsis{??}
+\usage{double *SLcomplex_acosh (double *, double *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{double *SLcomplex_atanh (double *, double *);}
+\synopsis{??}
+\usage{double *SLcomplex_atanh (double *, double *);}
+\description
+??
+\seealso{??}
+\done
+
+
+
+
+\function{char *SLdebug_malloc (unsigned long);}
+\synopsis{??}
+\usage{char *SLdebug_malloc (unsigned long);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{char *SLdebug_calloc (unsigned long, unsigned long);}
+\synopsis{??}
+\usage{char *SLdebug_calloc (unsigned long, unsigned long);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{char *SLdebug_realloc (char *, unsigned long);}
+\synopsis{??}
+\usage{char *SLdebug_realloc (char *, unsigned long);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{void SLdebug_free (char *);}
+\synopsis{??}
+\usage{void SLdebug_free (char *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{void SLmalloc_dump_statistics (void);}
+\synopsis{??}
+\usage{void SLmalloc_dump_statistics (void);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{char *SLstrcpy(register char *, register char *);}
+\synopsis{??}
+\usage{char *SLstrcpy(register char *, register char *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{int SLstrcmp(register char *, register char *);}
+\synopsis{??}
+\usage{int SLstrcmp(register char *, register char *);}
+\description
+??
+\seealso{??}
+\done
+
+
+\function{char *SLstrncpy(char *, register char *, register  int);}
+\synopsis{??}
+\usage{char *SLstrncpy(char *, register char *, register  int);}
+\description
+??
+\seealso{??}
+\done
+
+
+
+\function{void SLmemset (char *, char, int);}
+\synopsis{??}
+\usage{void SLmemset (char *, char, int);}
+\description
+??
+\seealso{??}
+\done
+
+
+extern int SLang_add_intrinsic_array (char *,   /* name */
+				      unsigned char,   /* type */
+				      int,   /* readonly */
+				      VOID_STAR,   /* data */
+				      unsigned int, ...);   /* num dims */
+
+
+
+\function{void SLexpand_escaped_string (register char *, register char *, register char *);}
+\synopsis{??}
+\usage{void SLexpand_escaped_string (register char *, register char *, register char *);}
+\description
+??
+\seealso{??}
+\done
+
+
+
+\function{void SLmake_lut (unsigned char *, unsigned char *, unsigned char);}
+\synopsis{??}
+\usage{void SLmake_lut (unsigned char *, unsigned char *, unsigned char);}
+\description
+??
+\seealso{??}
+\done
+
+
+
+\function{int SLang_guess_type (char *);}
+\synopsis{??}
+\usage{int SLang_guess_type (char *);}
+\description
+??
+\seealso{??}
+\done
+
+#%-
+
+\end{\documentstyle}