  The SS--LLaanngg C Library Reference
  John E. Davis, jed@jedsoft.org
  May 28, 2009
  ____________________________________________________________


  11..  FFuunnccttiioonnss ddeeaalliinngg wwiitthh UUTTFF--88 eennccooddeedd ssttrriinnggss

  11..11..  SSLLuuttff88__sskkiipp__cchhaarr

      SSyynnooppssiiss
        Skip past a UTF-8 encoded character

      UUssaaggee
        SLuchar_Type *SLutf8_skip_char (SLuchar_Type *u, SLuchar_Type
        *umax)

      DDeessccrriippttiioonn
        The SLutf8_skip_char function returns a pointer to the character
        immediately following the UTF-8 encoded character at u. It will
        make no attempt to examine the bytes at the position umax and
        beyond. If the bytes at u do not represent a valid or legal
        UTF-8 encoded sequence, a pointer to the byte following u will
        be returned.

      NNootteess
        Unicode combining characters are treated as distinct characters
        by this function.

      SSeeee AAllssoo
        SLutf8_skip_chars, SLutf8_bskip_char, SLutf8_strlen

  11..22..  SSLLuuttff88__sskkiipp__cchhaarrss

      SSyynnooppssiiss
        Skip past a specified number of characters in a UTF-8 encoded
        string

      UUssaaggee
        SLuchar_Type *SLutf8_skip_chars (u, umax, num, dnum,
        ignore_combining)

              SLuchar_Type *u, *umax;
              unsigned int num;
              unsigned int *dnum;
              int ignore_combining;

      DDeessccrriippttiioonn
        This functions attempts to skip forward past num UTF-8 encoded
        characters at u returning the actual number skipped via the
        parameter dnum. It will make no attempt to examine bytes at umax
        and beyond. Unicode combining characters will not be counted if
        ignore_combining is non-zero, otherwise they will be treated as
        distinct characters. If the input contains an invalid or illegal
        UTF-8 sequence, then each byte in the sequence will be treated
        as a single character.

      SSeeee AAllssoo
        SLutf8_skip_char, SLutf8_bskip_chars

  11..33..  SSLLuuttff88__bbsskkiipp__cchhaarr

      SSyynnooppssiiss
        Skip backward past a UTF-8 encoded character

      UUssaaggee
        SLuchar_Type *SLutf8_bskip_char (SLuchar_Type *umin,
        SLuchar_Type *u)

      DDeessccrriippttiioonn
        The SLutf8_bskip_char skips backward to the start of the UTF-8
        encoded character immediately before the position u.  The
        function will make no attempt to examine characters before the
        position umin. UTF-8 combining characters are treated as
        distinct characters.

      SSeeee AAllssoo
        SLutf8_bskip_chars, SLutf8_skip_char

  11..44..  SSLLuuttff88__bbsskkiipp__cchhaarrss

      SSyynnooppssiiss
        Skip backward past a specified number of UTF-8 encoded
        characters

      UUssaaggee
        SLuchar_Type *SLutf8_bskip_chars (umin, u, num, dnum,
        ignore_combining)

             SLuchar_Type *umin, *u;
             unsigned int num;
             unsigned int *dnum;
             int ignore_combining;

      DDeessccrriippttiioonn
        This functions attempts to skip backward past num UTF-8 encoded
        characters occuring immediately before u. It returns the the
        actual number skipped via the parameter dnum. No attempt will be
        made to examine the bytes occuring before umin.  Unicode
        combining characters will not be counted if ignore_combining is
        non-zero, otherwise they will be treated as distinct characters.
        If the input contains an invalid or illegal UTF-8 sequence, then
        each byte in the sequence will be treated as a single character.

      SSeeee AAllssoo
        SLutf8_skip_char, SLutf8_bskip_chars

  11..55..  SSLLuuttff88__ddeeccooddee

      SSyynnooppssiiss
        Decode a UTF-8 encoded character sequence

      UUssaaggee
        SLuchar_Type *SLutf8_decode (u, umax, w, nconsumedp

             SLuchar_Type *u, *umax;
             SLwchar_Type *w;
             unsigned int *nconsumedp;

      DDeessccrriippttiioonn
        The SLutf8_decode function decodes the UTF-8 encoded character
        occuring at u and returns the decoded character via the
        parameter w. No attempt will be made to examine the bytes at
        umax and beyond. If the parameter nconsumedp is non-NULL, then
        the number of bytes consumed by the function will be returned to
        it. If the sequence at u is invalid or illegal, the function
        will return NULL and with the number of bytes consumed by the
        function equal to the size of the invalid sequence. Otherwise
        the function will return a pointer to byte following encoded
        sequence.

      SSeeee AAllssoo
        SLutf8_decode, SLutf8_strlen, SLutf8_skip_char

  11..66..  SSLLuuttff88__eennccooddee

      SSyynnooppssiiss
        UTF-8 encode a character

      UUssaaggee
        SLuchar_Type *SLutf8_encode (w, u, ulen)

             SLwchar_Type w;
             SLuchar_Type *u;
             unsigned int ulen;

      DDeessccrriippttiioonn
        This function UTF-8 encodes the Unicode character represented by
        w and stored the encoded representation in the buffer of size
        ulen bytes at u. The function will return NULL if the size of
        the buffer is too small to represent the UTF-8 encoded
        character, otherwise it will return a pointer to the byte
        following encoded representation.

      NNootteess
        This function does not null terminate the resulting byte
        sequence.  The function SLutf8_encode_null_terminate may be used
        for that purpose.

        To guarantee that the buffer is large enough to hold the encoded
        bytes, its size should be at least SLUTF8_MAX_BLEN bytes.

        The function will encode illegal Unicode characters, i.e.,
        characters in the range 0xD800-0xFFFF (the UTF-16 surrogates)
        and 0xFFFE-0xFFFF.

      SSeeee AAllssoo
        SLutf8_decode, SLutf8_encode_bytes, SLutf8_encode_null_terminate

  11..77..  SSLLuuttff88__ssttrrlleenn

      SSyynnooppssiiss
        Determine the number of characters in a UTF-8 sequence

      UUssaaggee
        unsigned int SLutf8_strlen (SLuchar_Type *s, int
        ignore_combining)

      DDeessccrriippttiioonn
        This function may be used to determine the number of characters
        represented by the null-terminated UTF-8 byte sequence. If the
        ignore_combining parameter is non-zero, then Unicode combining
        characters will not be counted.

      SSeeee AAllssoo
        SLutf8_skip_chars, SLutf8_decode

  11..88..  SSLLuuttff88__eexxttrraacctt__uuttff88__cchhaarr

      SSyynnooppssiiss
        Extract a UTF-8 encoded character

      UUssaaggee
        SLuchar_Type *SLutf8_extract_utf8_char (u, umax, buf)

             SLuchar_Type *u, *umax, *buf;

      DDeessccrriippttiioonn
        This function extracts the bytes representing UTF-8 encoded
        character at u and places them in the buffer buf, and then null
        terminates the result. The buffer is assumed to consist of at
        least SLUTF8_MAX_BLEN+1 bytes, where the extra byte may be
        necessary for null termination. No attempt will be made to
        examine the characters at umax and beyond. If the byte-sequence
        at u is an illegal or invalid UTF-8 sequence, then the byte at u
        will be copied to the buffer. The function returns a pointer to
        the byte following copied bytes.

      NNootteess
        One may think of this function as the single byte analogue of

               if (u < umax)
                 {
                    buf[0] = *u++;
                    buf[1] = 0;
                 }

      SSeeee AAllssoo
        SLutf8_decode, SLutf8_skip_char

  11..99..  SSLLuuttff88__eennccooddee__nnuullll__tteerrmmiinnaattee

      SSyynnooppssiiss
        UTF-8 encode a character and null terminate the result

      UUssaaggee
        SLuchar_Type *SLutf8_encode_null_terminate (w, buf)

             SLwchar_Type w;
             SLuchar_Type *buf;

      DDeessccrriippttiioonn
        This function has the same functionality as SLutf8_encode,
        except that it also null terminates the encoded sequences. The
        buffer buf, where the encoded sequence is placed, is assumed to
        consist of at least SLUTF8_MAX_BLEN+1 bytes.

      SSeeee AAllssoo
        SLutf8_encode

  11..1100..  SSLLuuttff88__ssttrruupp

      SSyynnooppssiiss
        Uppercase a UTF-8 encoded string

      UUssaaggee
        SLuchar_Type *SLutf8_strup (SLuchar_Type *u, SLuchar_Type *umax)

      DDeessccrriippttiioonn
        The SLutf8_strup function returns the uppercase equivalent of
        UTF-8 encoded sequence of umax-u bytes at u. The result will be
        returned as a null-terminated SLstring and should be freed with
        SLang_free_slstring when it is nolonger needed. If the function
        encounters an invalid of illegal byte sequence, then the byte-
        sequence will be copied as as-is.

      SSeeee AAllssoo
        SLutf8_strlow, SLwchar_toupper

  11..1111..  SSLLuuttff88__ssttrrlloo

      SSyynnooppssiiss
        Lowercase a UTF-8 encoded string

      UUssaaggee
        SLuchar_Type *SLutf8_strlo (SLuchar_Type *u, SLuchar_Type *umax)

      DDeessccrriippttiioonn
        The SLutf8_strlo function returns the lowercase equivalent of
        UTF-8 encoded sequence of umax-u bytes at u. The result will be
        returned as a null-terminated SLstring and should be freed with
        SLang_free_slstring when it is nolonger needed. If the function
        encounters an invalid of illegal byte sequence, then the byte-
        sequence will be copied as as-is.

      SSeeee AAllssoo
        SLutf8_strlow, SLwchar_toupper

  11..1122..  SSLLuuttff88__ssuubbsstt__wwcchhaarr

      SSyynnooppssiiss
        Replace a character in a UTF-8 encoded string

      UUssaaggee
        SLstr_Type *SLutf8_subst_wchar (u, umax, wch,
        nth,ignore_combining)

             SLuchar_Type *u, *umax;
             SLwchar_Type wch;
             unsigned int nth;
             int ignore_combining;

      DDeessccrriippttiioonn
        The SLutf8_subst_wchar function replaces the UTF-8 sequence
        representing the nth character of u by the UTF-8 representation
        of the character wch. If the value of the ignore_combining
        parameter is non-zero, then combining characters will not be
        counted when computing the position of the nth character. In
        addition, if the nth character contains any combining
        characters, then the byte-sequence associated with those
        characters will also be replaced.

        Since the byte sequence representing wch could be longer than
        the sequence of the nth character, the function returns a new
        copy of the resulting string as an SLSTRING. Hence, the calling
        function should call SLang_free_slstring when the result is
        nolonger needed.

      SSeeee AAllssoo
        SLutf8_strup, SLutf8_strlow, SLutf8_skip_chars, SLutf8_strlen

  11..1133..  SSLLuuttff88__ccoommppaarree

      SSyynnooppssiiss
        Compare two UTF-8 encoded sequences

      UUssaaggee
        int SLutf8_compare (a, amax, b, bmax, nchars, case_sensitive)

             SLuchar_Type *a, *amax;
             SLuchar_Type *b, *bmax;
             unsigned int nchars;
             int case_sensitive;

      DDeessccrriippttiioonn
        This function compares nchars of one UTF-8 encoded character
        sequence to another by performing a character by character
        comparison.  The function returns 0, +1, or -1 according to
        whether the string a is is equal to, greater than, or less than
        the string at b. At most nchars characters will be tested. The
        parameters amax and bmax serve as upper boundaries of the
        strings a and b, resp.

        If the value of the case_sensitive parameter is non-zero, then a
        case-sensitive comparison will be performed, otherwise
        characters will be compared in a case-insensitive manner.

      NNootteess
        For case-sensitive comparisons, this function is analogous to
        the standard C library's strncmp function. However,
        SLutf8_compare can also cope with invalid or illegal UTF-8
        sequences.

      SSeeee AAllssoo
        SLutf8_strup, SLutf8_strlen, SLutf8_strlen

  22..  CChhaarraacctteerr ccllaassssiiffiiccaattiioonn ffuunnccttiioonnss

  22..11..  SSLLwwcchhaarr__ttoouuppppeerr

      SSyynnooppssiiss
        Uppercase a Unicode character

      UUssaaggee
        SLwchar_Type SLwchar_toupper (SLwchar_Type wc)

      DDeessccrriippttiioonn
        SLwchar_toupper returns the uppercase equivalent of the
        specified character.

      NNootteess
        If the library is not in UTF-8 mode, then the current locale
        will be used.

      SSeeee AAllssoo
        SLwchar_tolower, SLwchar_isupper, SLutf8_strup

  22..22..  SSLLwwcchhaarr__ttoolloowweerr

      SSyynnooppssiiss
        Lowercase a Unicode character

      UUssaaggee
        SLwchar_Type SLwchar_tolower (SLwchar_Type wc)

      DDeessccrriippttiioonn
        SLwchar_tolower returns the lowercase equivalent of the
        specified character.

      NNootteess
        If the library is not in UTF-8 mode, then the current locale
        will be used.

      SSeeee AAllssoo
        SLwchar_toupper, SLwchar_islower, SLutf8_strlow

  22..33..  SSLLwwcchhaarr__wwccwwiiddtthh

      SSyynnooppssiiss
        Determine the displayable width of a wide character

      UUssaaggee
        int SLwchar_wcwidth (SLwchar_Type wc)

      DDeessccrriippttiioonn
        This function returns the number of columns necessary to display
        the specified Unicode character. Combining characters are meant
        to be combined with other characters and, as such, have 0 width.

      NNootteess
        If the library is not in UTF-8 mode, then the current locale
        will be used.

      SSeeee AAllssoo
        SLwchar_isspace, SLwchar_iscntrl

  22..44..  SSLLwwcchhaarr__iissaallnnuumm

      SSyynnooppssiiss
        Determine if a Unicode character is alphanumeric

      UUssaaggee
        int SLwchar_isalnum (SLwchar_Type wc)

      DDeessccrriippttiioonn
        SLwchar_isalnum returns a non-zero value if the Unicode
        character is alphanumeric, otherwise it returns 0.

      NNootteess
        If the library is not in UTF-8 mode, then the current locale
        will be used.

      SSeeee AAllssoo
        SLwchar_isalpha, SLwchar_isdigit, SLwchar_iscntrl

  22..55..  SSLLwwcchhaarr__iissaallpphhaa

      SSyynnooppssiiss
        Determine if a Unicode character is an alphabetic character

      UUssaaggee
        int SLwchar_isalpha (SLwchar_Type wc)

      DDeessccrriippttiioonn
        SLwchar_isalpha returns a non-zero value if the Unicode
        character is alphabetic, otherwise it returns 0.

      NNootteess
        If the library is not in UTF-8 mode, then the current locale
        will be used.

      SSeeee AAllssoo
        SLwchar_isalnum, SLwchar_isalpha, SLwchar_isdigit,
        SLwchar_iscntrl

  22..66..  SSLLwwcchhaarr__iissbbllaannkk

      SSyynnooppssiiss
        Determine if a Unicode character is a blank

      UUssaaggee
        int SLwchar_isblank (SLwchar_Type wc)

      DDeessccrriippttiioonn
        SLwchar_isblank returns a non-zero value if the Unicode
        character is a blank one (space or tab), otherwise it returns 0.

      NNootteess
        If the library is not in UTF-8 mode, then the current locale
        will be used.
      SSeeee AAllssoo
        SLwchar_isspace, SLwchar_isalpha, SLwchar_isdigit,
        SLwchar_iscntrl

  22..77..  SSLLwwcchhaarr__iissccnnttrrll

      SSyynnooppssiiss
        Determine if a Unicode character is a control character

      UUssaaggee
        int SLwchar_iscntrl (SLwchar_Type wc)

      DDeessccrriippttiioonn
        SLwchar_isblank returns a non-zero value if the Unicode
        character is a control character, otherwise it returns 0.

      NNootteess
        If the library is not in UTF-8 mode, then the current locale
        will be used.

      SSeeee AAllssoo
        SLwchar_isspace, SLwchar_isalpha, SLwchar_isdigit,
        SLwchar_isprint

  22..88..  SSLLwwcchhaarr__iissddiiggiitt

      SSyynnooppssiiss
        Determine if a Unicode character is a digit

      UUssaaggee
        int SLwchar_isdigit (SLwchar_Type wc)

      DDeessccrriippttiioonn
        This function returns a non-zero value if the specified Unicode
        character is a digit, otherwise it returns 0.

      NNootteess
        If the library is not in UTF-8 mode, then the current locale
        will be used.

      SSeeee AAllssoo
        SLwchar_isspace, SLwchar_isalpha, SLwchar_isxdigit,
        SLwchar_isprint

  22..99..  SSLLwwcchhaarr__iissggrraapphh

      SSyynnooppssiiss
        Determine if a non-space Unicode character is printable

      UUssaaggee
        int SLwchar_isgraph (SLwchar_Type wc)

      DDeessccrriippttiioonn
        This function returns a non-zero value if the specified Unicode
        character is a non-space printable character, otherwise it
        returns 0.

      NNootteess
        If the library is not in UTF-8 mode, then the current locale
        will be used.

      SSeeee AAllssoo
        SLwchar_isspace, SLwchar_isalpha, SLwchar_isdigit,
        SLwchar_isprint

  22..1100..  SSLLwwcchhaarr__iisslloowweerr

      SSyynnooppssiiss
        Determine if a Unicode character is alphanumeric

      UUssaaggee
        int SLwchar_islower (SLwchar_Type wc)

      DDeessccrriippttiioonn
        This function returns a non-zero value if the specified Unicode
        character is a lowercase one, otherwise it returns 0.

      NNootteess
        If the library is not in UTF-8 mode, then the current locale
        will be used.

      SSeeee AAllssoo
        SLwchar_isupper, SLwchar_isspace, SLwchar_isalpha,
        SLwchar_isdigit, SLwchar_iscntrl

  22..1111..  SSLLwwcchhaarr__iisspprriinntt

      SSyynnooppssiiss
        Determine if a Unicode character is printable

      UUssaaggee
        int SLwchar_isprint (SLwchar_Type wc)

      DDeessccrriippttiioonn
        This function returns a non-zero value if the specified Unicode
        character is a printable one (includes space), otherwise it
        returns 0.

      NNootteess
        If the library is not in UTF-8 mode, then the current locale
        will be used.

      SSeeee AAllssoo
        SLwchar_isgraph, SLwchar_isspace, SLwchar_isalpha,
        SLwchar_isdigit

  22..1122..  SSLLwwcchhaarr__iissppuunncctt

      SSyynnooppssiiss
        Determine if a Unicode character is a punctuation character

      UUssaaggee
        int SLwchar_ispunct (SLwchar_Type wc)

      DDeessccrriippttiioonn
        This function returns a non-zero value if the specified Unicode
        character is a punctuation character, otherwise it returns 0.

      NNootteess
        If the library is not in UTF-8 mode, then the current locale
        will be used.

      SSeeee AAllssoo
        SLwchar_isspace, SLwchar_isalpha, SLwchar_isdigit,
        SLwchar_isprint

  22..1133..  SSLLwwcchhaarr__iissssppaaccee

      SSyynnooppssiiss
        Determine if a Unicode character is a whitespace character

      UUssaaggee
        int SLwchar_isspace (SLwchar_Type wc)

      DDeessccrriippttiioonn
        This function returns a non-zero value if the specified Unicode
        character is a whitespace character, otherwise it returns 0.

      NNootteess
        If the library is not in UTF-8 mode, then the current locale
        will be used.

      SSeeee AAllssoo
        SLwchar_isblank, SLwchar_isalpha, SLwchar_isdigit,
        SLwchar_ispunct

  22..1144..  SSLLwwcchhaarr__iissuuppppeerr

      SSyynnooppssiiss
        Determine if a Unicode character is uppercase

      UUssaaggee
        int SLwchar_isupper (SLwchar_Type wc)

      DDeessccrriippttiioonn
        This function returns a non-zero value if the specified Unicode
        character is an uppercase character, otherwise it returns 0.

      NNootteess
        If the library is not in UTF-8 mode, then the current locale
        will be used.

      SSeeee AAllssoo
        SLwchar_islower, SLwchar_isspace, SLwchar_isalpha,
        SLwchar_isdigit

  22..1155..  SSLLwwcchhaarr__iissxxddiiggiitt

      SSyynnooppssiiss
        Determine if a Unicode character is a hexidecimal digit

      UUssaaggee
        int SLwchar_isxdigit (SLwchar_Type wc)

      DDeessccrriippttiioonn
        This function returns a non-zero value if the specified Unicode
        character is a hexadecimal digit character, otherwise it returns
        0.

      NNootteess
        If the library is not in UTF-8 mode, then the current locale
        will be used.

      SSeeee AAllssoo
        SLwchar_isdigit, SLwchar_isspace, SLwchar_isalpha,
        SLwchar_ispunct

  33..  SSLLsseeaarrcchh iinntteerrffaaccee FFuunnccttiioonnss

  33..11..  SSLLsseeaarrcchh__nneeww

      SSyynnooppssiiss
        Create an SLsearch_Type object

      UUssaaggee
        SLsearch_Type *SLsearch_new (SLuchar_Type *key, int
        search_flags)

      DDeessccrriippttiioonn
        The SLsearch_new function instantiates an SLsearch_Type object
        for use in ordinary searches (non-regular expression) by the
        functions in the SLsearch interface. The first argument key is a
        pointer to a null terminated string that specifies the character
        string to be searched. This character string may not contain any
        embedded null characters.

        The second argument search_flags is used to specify how the
        search is to be performed. It is a bit-mapped integer whose
        value is constructed by the bitwise-or of zero or more of the
        following:

             SLSEARCH_CASELESS
               The search shall be performed in a case-insensitive manner.

             SLSEARCH_UTF8
               Both the search string and the text to be searched is UTF-8
               encoded.

     Upon sucess, the function returns the newly created object, and
     NULL otherwise. When the search object is nolonger needed, it
     should be freed via the SLsearch_delete function.

      SSeeee AAllssoo
        SLsearch_delete, SLsearch_forward, SLsearch_backward

  33..22..  SSLLsseeaarrcchh__ddeelleettee

      SSyynnooppssiiss
        Free the memory associated with a SLsearch_Type object

      UUssaaggee
        SLsearch_delete (SLsearch_Type *)

      DDeessccrriippttiioonn
        This function should be called to free the memory associated
        with a SLsearch_Type object created by the SLsearch_new
        function. Failure to do so will result in a memory leak.

      SSeeee AAllssoo
        SLsearch_new, SLsearch_forward, SLsearch_backward

  33..33..  SSLLsseeaarrcchh__ffoorrwwaarrdd

      SSyynnooppssiiss
        Search forward in a buffer

      UUssaaggee
        SLuchar_Type SLsearch_forward (st, pmin, pmax)

             SLsearch_Type *st;
             SLuchar_Type *pmin, *pmax;

      DDeessccrriippttiioonn
        The SLsearch_forward function searches forward in the buffer
        defined by the pointers pmin and pmax. The starting point for
        the search is at the beginning of the buffer at pmin. At no
        point will the bytes at pmax and beyond be examined. The first
        parameter st, obtained by a prior call to SLsearch_new,
        specifies the object to found.  be found from a previous call to
        SLsearch_new.

        If the object was found, the pointer to the beginning of it will
        be returned. Otherwise, SLsearch_forward will return NULL.  The
        length of the object may be obtained via the SLsearch_match_len
        function.

      NNootteess
        This function uses the Boyer-Moore search algorithm when
        possible.

      SSeeee AAllssoo
        SLsearch_new, SLsearch_backward, SLsearch_delete,
        SLsearch_match_len

  33..44..  SSLLsseeaarrcchh__bbaacckkwwaarrdd

      SSyynnooppssiiss
        Search backward in a buffer
      UUssaaggee
        SLuchar_Type SLsearch_forward (st, pmin, pstart, pmax)

             SLsearch_Type *st;
             SLuchar_Type *pmin, *pstart, *pmax;

      DDeessccrriippttiioonn
        The SLsearch_forward function searches backward in the buffer
        defined by the pointers pmin and pmax. The starting point for
        the search is at the position pstart. At no point will the bytes
        at pmax and beyond be examined. The first parameter st, obtained
        by a prior call to SLsearch_new, specifies the object to found.

        If the object was found, the pointer to the beginning of it will
        be returned. Otherwise, SLsearch_forward will return NULL.  The
        length of the object may be obtained via the SLsearch_match_len
        function.

      NNootteess
        This function uses the Boyer-Moore search algorithm when
        possible.

        It is possible for the end of match to appear after the point
        where the search began (pstart).

      SSeeee AAllssoo
        SLsearch_new, SLsearch_forward, SLsearch_delete,
        SLsearch_match_len

  33..55..  SSLLsseeaarrcchh__mmaattcchh__lleenn

      SSyynnooppssiiss
        Get the length of the previous match

      UUssaaggee
        unsigned int SLsearch_match_len (SLsearch_Type *st)

      DDeessccrriippttiioonn
        The SLsearch_match_len function returns the length of the match
        from the most recent search involving the specified
        SLsearch_Type object. If the most recent search was
        unsuccessful, the function will return 0.

      SSeeee AAllssoo
        SLsearch_forward, SLsearch_backward, SLsearch_new,
        SLsearch_delete

  44..  SSccrreeeenn MMaannaaggeemmeenntt ((SSLLssmmgg)) ffuunnccttiioonnss

  44..11..  SSLLssmmgg__ffiillll__rreeggiioonn

      SSyynnooppssiiss
        Fill a rectangular region with a character

      UUssaaggee
        void SLsmg_fill_region (r, c, nr, nc, ch)

              int r
              int c
              unsigned int nr
              unsigned int nc
              unsigned char ch

      DDeessccrriippttiioonn
        The SLsmg_fill_region function may be used to a rectangular
        region with the character ch in the current color.  The
        rectangle's upper left corner is at row r and column c, and
        spans nr rows and nc columns. The position of the virtual cursor
        will be left at (r, c).

      SSeeee AAllssoo
        SLsmg_write_char, SLsmg_set_color

  44..22..  SSLLssmmgg__sseett__cchhaarr__sseett

      SSyynnooppssiiss
        Turn on or off line drawing characters

      UUssaaggee
        void SLsmg_set_char_set (int a);

      DDeessccrriippttiioonn
        SLsmg_set_char_set may be used to select or deselect the line
        drawing character set as the current character set. If a is non-
        zero, the line drawing character set will be selected.
        Otherwise, the standard character set will be selected.

      NNootteess
        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.

      SSeeee AAllssoo
        SLsmg_write_char, SLtt_get_terminfo

  44..33..  iinntt SSLLssmmgg__SSccrroollll__HHaasshh__BBoorrddeerr;;

      SSyynnooppssiiss
        Set the size of the border for the scroll hash

      UUssaaggee
        int SLsmg_Scroll_Hash_Border = 0;

      DDeessccrriippttiioonn
        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.

      SSeeee AAllssoo
        SLsmg_refresh

  44..44..  SSLLssmmgg__ssuussppeenndd__ssmmgg

      SSyynnooppssiiss
        Suspend screen management

      UUssaaggee
        int SLsmg_suspend_smg (void)

      DDeessccrriippttiioonn
        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 SLsmg_resume_smg should be called after suspension.

        It returns zero upon success, or -1 upon error.

        This function is similar to SLsmg_reset_smg except that the
        state of the display prior to calling SLsmg_suspend_smg is
        saved.

      SSeeee AAllssoo
        SLsmg_resume_smg, SLsmg_reset_smg

  44..55..  SSLLssmmgg__rreessuummee__ssmmgg

      SSyynnooppssiiss
        Resume screen management

      UUssaaggee
        int SLsmg_resume_smg (void)

      DDeessccrriippttiioonn
        SLsmg_resume_smg should be called after SLsmg_suspend_smg to
        redraw the display exactly like it was before SLsmg_suspend_smg
        was called. It returns zero upon success, or -1 upon error.

      SSeeee AAllssoo
        SLsmg_suspend_smg

  44..66..  SSLLssmmgg__eerraassee__eeooll

      SSyynnooppssiiss
        Erase to the end of the row

      UUssaaggee
        void SLsmg_erase_eol (void);
      DDeessccrriippttiioonn
        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.

      SSeeee AAllssoo
        SLsmg_gotorc, SLsmg_erase_eos, SLsmg_fill_region

  44..77..  SSLLssmmgg__ggoottoorrcc

      SSyynnooppssiiss
        Move the virtual cursor

      UUssaaggee
        void SLsmg_gotorc (int r, int c)

      DDeessccrriippttiioonn
        The SLsmg_gotorc function moves the virtual cursor to the row r
        and column c. The first row and first column is specified by r =
        0 and c = 0.

      SSeeee AAllssoo
        SLsmg_refresh

  44..88..  SSLLssmmgg__eerraassee__eeooss

      SSyynnooppssiiss
        Erase to the end of the screen

      UUssaaggee
        void SLsmg_erase_eos (void);

      DDeessccrriippttiioonn
        The SLsmg_erase_eos is like 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.

      SSeeee AAllssoo
        SLsmg_erase_eol

  44..99..  SSLLssmmgg__rreevveerrssee__vviiddeeoo

      SSyynnooppssiiss
        Set the current color to 1

      UUssaaggee
        void SLsmg_reverse_video (void);

      DDeessccrriippttiioonn
        This function is nothing more than SLsmg_set_color(1).

      SSeeee AAllssoo
        SLsmg_set_color

  44..1100..  SSLLssmmgg__sseett__ccoolloorr ((iinntt))

      SSyynnooppssiiss
        Set the current color

      UUssaaggee
        void SLsmg_set_color (int c);

      DDeessccrriippttiioonn
        SLsmg_set_color is used to set the current color. The parameter
        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 SLtt_set_color
        function.

      EExxaammppllee
        This example defines color 7 to be green foreground on black
        background and then displays some text in this color:

                SLtt_set_color (7, NULL, "green", "black");
                SLsmg_set_color (7);
                SLsmg_write_string ("Hello");
                SLsmg_refresh ();

      NNootteess
        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 SLsmg
        routines. The lower level SLtt interface converts the color
        descriptors to actual colors. Thus

                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 ();

     will result in "hello" displayed in red on blue and _n_o_t green on
     black.

      SSeeee AAllssoo
        SLtt_set_color, SLtt_set_color_object

  44..1111..  SSLLssmmgg__nnoorrmmaall__vviiddeeoo

      SSyynnooppssiiss
        Set the current color to 0

      UUssaaggee
        void SLsmg_normal_video (void);

      DDeessccrriippttiioonn
        SLsmg_normal_video sets the current color descriptor to 0.

      SSeeee AAllssoo
        SLsmg_set_color

  44..1122..  SSLLssmmgg__pprriinnttff

      SSyynnooppssiiss
        Format a string on the virtual display

      UUssaaggee
        void SLsmg_printf (char *fmt, ...)

      DDeessccrriippttiioonn
        SLsmg_printf format a printf style variable argument list and
        writes it on the virtual display. The virtual cursor will be
        moved to the end of the string.

      SSeeee AAllssoo
        SLsmg_write_string, SLsmg_vprintf

  44..1133..  SSLLssmmgg__vvpprriinnttff

      SSyynnooppssiiss
        Format a string on the virtual display

      UUssaaggee
        void SLsmg_vprintf (char *fmt, va_list ap)

      DDeessccrriippttiioonn
        SLsmg_vprintf formats a string in the manner of _v_p_r_i_n_t_f and
        writes the result to the display. The virtual cursor is advanced
        to the end of the string.

      SSeeee AAllssoo
        SLsmg_write_string, SLsmg_printf

  44..1144..  SSLLssmmgg__wwrriittee__ssttrriinngg

      SSyynnooppssiiss
        Write a character string on the display

      UUssaaggee
        void SLsmg_write_string (char *s)

      DDeessccrriippttiioonn
        The function SLsmg_write_string displays the string s on the
        virtual display at the current position and moves the position
        to the end of the string.

      SSeeee AAllssoo
        SLsmg_printf, SLsmg_write_nstring

  44..1155..  SSLLssmmgg__wwrriittee__nnssttrriinngg

      SSyynnooppssiiss
        Write the first n characters of a string on the display

      UUssaaggee
        void SLsmg_write_nstring (char *s, unsigned int n);

      DDeessccrriippttiioonn
        SLsmg_write_nstring writes the first n characters of s to this
        virtual display. If the length of the string s is less than n,
        the spaces will used until n characters have been written. s can
        be NULL, in which case n spaces will be written.

      SSeeee AAllssoo
        SLsmg_write_string, SLsmg_write_nchars

  44..1166..  SSLLssmmgg__wwrriittee__cchhaarr

      SSyynnooppssiiss
        Write a character to the virtual display

      UUssaaggee
        void SLsmg_write_char (char ch);

      DDeessccrriippttiioonn
        SLsmg_write_char writes the character ch to the virtual display.

      SSeeee AAllssoo
        SLsmg_write_nchars, SLsmg_write_string

  44..1177..  SSLLssmmgg__wwrriittee__nncchhaarrss

      SSyynnooppssiiss
        Write n characters to the virtual display

      UUssaaggee
        void SLsmg_write_nchars (char *s, unsigned int n);

      DDeessccrriippttiioonn
        SLsmg_write_nchars writes at most n characters from the string s
        to the display. If the length of s is less than n, the whole
        length of the string will get written.

        This function differs from SLsmg_write_nstring in that
        SLsmg_write_nstring will pad the string to write exactly n
        characters. SLsmg_write_nchars does not perform any padding.

      SSeeee AAllssoo
        SLsmg_write_nchars, SLsmg_write_nstring

  44..1188..  SSLLssmmgg__wwrriittee__wwrraappppeedd__ssttrriinngg

      SSyynnooppssiiss
        Write a string to the display with wrapping

      UUssaaggee
        void SLsmg_write_wrapped_string (s, r, c, nr, nc, fill)

              char *s
              int r, c
              unsigned int nr, nc
              int fill

      DDeessccrriippttiioonn
        SLsmg_write_wrapped_string writes the string s to the virtual
        display. The string will be confined to the rectangular region
        whose upper right corner is at row r and column c, and consists
        of nr rows and nc columns. The string will be wrapped at the
        boundaries of the box. If fill is non-zero, the last line to
        which characters have been written will get padded with spaces.

      NNootteess
        This function does not wrap on word boundaries. However, it will
        wrap when a newline charater is encountered.

      SSeeee AAllssoo
        SLsmg_write_string

  44..1199..  SSLLssmmgg__ccllss

      SSyynnooppssiiss
        Clear the virtual display

      UUssaaggee
        void SLsmg_cls (void)

      DDeessccrriippttiioonn
        SLsmg_cls erases the virtual display using the current color.
        This will cause the physical display to get cleared the next
        time SLsmg_refresh is called.

      NNootteess
        This function is not the same as

               SLsmg_gotorc (0,0); SLsmg_erase_eos ();

     since these statements do not guarantee that the physical screen
     will get cleared.

      SSeeee AAllssoo
        SLsmg_refresh, SLsmg_erase_eos

  44..2200..  SSLLssmmgg__rreeffrreesshh

      SSyynnooppssiiss
        Update physical screen

      UUssaaggee
        void SLsmg_refresh (void)

      DDeessccrriippttiioonn
        The SLsmg_refresh function updates the physical display to look
        like the virtual display.

      SSeeee AAllssoo
        SLsmg_suspend_smg, SLsmg_init_smg, SLsmg_reset_smg

  44..2211..  SSLLssmmgg__ttoouucchh__lliinneess

      SSyynnooppssiiss
        Mark lines on the virtual display for redisplay

      UUssaaggee
        void SLsmg_touch_lines (int r, unsigned int nr)

      DDeessccrriippttiioonn
        SLsmg_touch_lines marks the nr lines on the virtual display
        starting at row r for redisplay upon the next call to
        SLsmg_refresh.

      NNootteess
        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 SLsmg screen management routines.
        This function is provided only for curses compatibility.

      SSeeee AAllssoo
        SLsmg_refresh

  44..2222..  SSLLssmmgg__iinniitt__ssmmgg

      SSyynnooppssiiss
        Initialize the SLsmg routines

      UUssaaggee
        int SLsmg_init_smg (void)

      DDeessccrriippttiioonn
        The SLsmg_init_smg function initializes the SLsmg screen
        management routines. Specifically, this function allocates space
        for the virtual display and calls 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 SLtt routines are initialized via
        SLtt_get_terminfo before calling 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.

      SSeeee AAllssoo
        SLsmg_reset_smg

  44..2233..  SSLLssmmgg__rreesseett__ssmmgg

      SSyynnooppssiiss
        Reset the SLsmg routines

      UUssaaggee
        int SLsmg_reset_smg (void);

      DDeessccrriippttiioonn
        SLsmg_reset_smg resets the SLsmg screen management routines by
        freeing all memory allocated while it was active. It also calls
        SLtt_reset_video to put the terminal's display in it default
        state.

      SSeeee AAllssoo
        SLsmg_init_smg

  44..2244..  SSLLssmmgg__cchhaarr__aatt

      SSyynnooppssiiss
        Get the character at the current position on the virtual display

      UUssaaggee
        unsigned short SLsmg_char_at(void)

      DDeessccrriippttiioonn
        The SLsmg_char_at function returns the character and its color
        at the current position on the virtual display.

      SSeeee AAllssoo
        SLsmg_read_raw, SLsmg_write_char

  44..2255..  SSLLssmmgg__sseett__ssccrreeeenn__ssttaarrtt

      SSyynnooppssiiss
        Set the origin of the virtual display

      UUssaaggee
        void SLsmg_set_screen_start (int *r, int *c)

      DDeessccrriippttiioonn
        SLsmg_set_screen_start sets the origin of the virtual display to
        the row *r and the column *c. If either r or c is NULL, then the
        corresponding value will be set to 0.  Otherwise, the location
        specified by the pointers will be updated to reflect the old
        origin.

        See slang/demo/pager.c for how this function may be used to
        scroll horizontally.

      SSeeee AAllssoo
        SLsmg_init_smg

  44..2266..  SSLLssmmgg__ddrraaww__hhlliinnee

      SSyynnooppssiiss
        Draw a horizontal line

      UUssaaggee
        void SLsmg_draw_hline (unsigned int len)

      DDeessccrriippttiioonn
        The SLsmg_draw_hline function draws a horizontal line of length
        len on the virtual display. The position of the virtual cursor
        is left at the end of the line.

      SSeeee AAllssoo
        SLsmg_draw_vline

  44..2277..  SSLLssmmgg__ddrraaww__vvlliinnee

      SSyynnooppssiiss
        Draw a vertical line

      UUssaaggee
        void SLsmg_draw_vline (unsigned int len);

      DDeessccrriippttiioonn
        The SLsmg_draw_vline function draws a vertical line of length
        len on the virtual display. The position of the virtual cursor
        is left at the end of the line.

      SSeeee AAllssoo
        ??

  44..2288..  SSLLssmmgg__ddrraaww__oobbjjeecctt

      SSyynnooppssiiss
        Draw an object from the alternate character set

      UUssaaggee
        void SLsmg_draw_object (int r, int c, unsigned char obj)

      DDeessccrriippttiioonn
        The SLsmg_draw_object function may be used to place the object
        specified by obj at row r and column c. The object is really a
        character from the alternate character set and may be specified
        using one of the following constants:

              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

      SSeeee AAllssoo
        SLsmg_draw_vline, SLsmg_draw_hline, SLsmg_draw_box

  44..2299..  SSLLssmmgg__ddrraaww__bbooxx

      SSyynnooppssiiss
        Draw a box on the virtual display

      UUssaaggee
        void SLsmg_draw_box (int r, int c, unsigned int dr, unsigned int
        dc)

      DDeessccrriippttiioonn
        SLsmg_draw_box uses the SLsmg_draw_hline and SLsmg_draw_vline
        functions to draw a rectangular box on the virtual display. The
        box's upper left corner is placed at row r and column c. The
        width and length of the box is specified by dc and dr,
        respectively.

      SSeeee AAllssoo
        SLsmg_draw_vline, SLsmg_draw_hline, SLsmg_draw_object

  44..3300..  SSLLssmmgg__sseett__ccoolloorr__iinn__rreeggiioonn

      SSyynnooppssiiss
        Change the color of a specifed region

      UUssaaggee
        void SLsmg_set_color_in_region (color, r, c, dr, dc)

            int color;
            int r, c;
            unsigned int dr, dc;

      DDeessccrriippttiioonn
        SLsmg_set_color_in_region may be used to change the color of a
        rectangular region whose upper left corner is given by (r,c),
        and whose width and height is given by dc and dr, respectively.
        The color of the region is given by the color parameter.

      SSeeee AAllssoo
        SLsmg_draw_box, SLsmg_set_color

  44..3311..  SSLLssmmgg__ggeett__ccoolluummnn

      SSyynnooppssiiss
        Get the column of the virtual cursor

      UUssaaggee
        int SLsmg_get_column(void);

      DDeessccrriippttiioonn
        The SLsmg_get_column function returns the current column of the
        virtual cursor on the virtual display.

      SSeeee AAllssoo
        SLsmg_get_row, SLsmg_gotorc

  44..3322..  SSLLssmmgg__ggeett__rrooww

      SSyynnooppssiiss
        Get the row of the virtual cursor

      UUssaaggee
        int SLsmg_get_row(void);

      DDeessccrriippttiioonn
        The SLsmg_get_row function returns the current row of the
        virtual cursor on the virtual display.

      SSeeee AAllssoo
        SLsmg_get_column, SLsmg_gotorc

  44..3333..  SSLLssmmgg__ffoorrwwaarrdd

      SSyynnooppssiiss
        Move the virtual cursor forward n columns

      UUssaaggee
        void SLsmg_forward (int n);

      DDeessccrriippttiioonn
        The SLsmg_forward function moves the virtual cursor forward n
        columns.

      SSeeee AAllssoo
        SLsmg_gotorc

  44..3344..  SSLLssmmgg__wwrriittee__ccoolloorr__cchhaarrss

      SSyynnooppssiiss
        Write characters with color descriptors to virtual display

      UUssaaggee
        void SLsmg_write_color_chars (unsigned short *s, unsigned int
        len)

      DDeessccrriippttiioonn
        The SLsmg_write_color_chars function may be used to write len
        characters, each with a different color descriptor to the
        virtual display. Each character and its associated color are
        encoded as an unsigned short such that the lower eight bits form
        the character and the next eight bits form the color.

      SSeeee AAllssoo
        SLsmg_char_at, SLsmg_write_raw

  44..3355..  SSLLssmmgg__rreeaadd__rraaww

      SSyynnooppssiiss
        Read characters from the virtual display

      UUssaaggee
        unsigned int SLsmg_read_raw (unsigned short *buf, unsigned int
        len)

      DDeessccrriippttiioonn
        SLsmg_read_raw attempts to read len characters from the current
        position on the virtual display into the buffer specified by
        buf. It returns the number of characters actually read. This
        number will be less than len if an attempt is made to read past
        the right margin of the display.

      NNootteess
        The purpose of the pair of functions, SLsmg_read_raw and
        SLsmg_write_raw, is to permit one to copy the contents of one
        region of the virtual display to another region.

      SSeeee AAllssoo
        SLsmg_char_at, SLsmg_write_raw

  44..3366..  SSLLssmmgg__wwrriittee__rraaww

      SSyynnooppssiiss
        Write characters directly to the virtual display

      UUssaaggee
        unsigned int SLsmg_write_raw (unsigned short *buf, unsigned int
        len)

      DDeessccrriippttiioonn
        The SLsmg_write_raw function attempts to write len characters
        specified by buf to the display at the current position. It
        returns the number of characters successfully written, which
        will be less than len if an attempt is made to write past the
        right margin.

      NNootteess
        The purpose of the pair of functions, SLsmg_read_raw and
        SLsmg_write_raw, is to permit one to copy the contents of one
        region of the virtual display to another region.

      SSeeee AAllssoo
        SLsmg_read_raw

  55..  FFuunnccttiioonnss tthhaatt ddeeaall wwiitthh tthhee iinntteerrpprreetteerr

  55..11..  SSLLaallllooccaattee__llooaadd__ttyyppee

      SSyynnooppssiiss
        Allocate a SLang_Load_Type object

      UUssaaggee
        SLang_Load_Type *SLallocate_load_type (char *name)

      DDeessccrriippttiioonn
        The SLallocate_load_type function allocates and initializes
        space for a SLang_Load_Type object and returns it. Upon failure,
        the function returns NULL. The parameter name must uniquely
        identify the object. For example, if the object represents a
        file, then name could be the absolute path name of the file.

      SSeeee AAllssoo
        SLdeallocate_load_type, SLang_load_object

  55..22..  SSLLddeeaallllooccaattee__llooaadd__ttyyppee

      SSyynnooppssiiss
        Free a SLang_Load_Type object

      UUssaaggee
        void SLdeallocate_load_type (SLang_Load_Type *slt)

      DDeessccrriippttiioonn
        This function frees the memory associated with a SLang_Load_Type
        object that was acquired from a call to the SLallocate_load_type
        function.

      SSeeee AAllssoo
        SLallocate_load_type, SLang_load_object

  55..33..  SSLLaanngg__llooaadd__oobbjjeecctt

      SSyynnooppssiiss
        Load an object into the interpreter

      UUssaaggee
        int SLang_load_object (SLang_Load_Type *obj)
      DDeessccrriippttiioonn
        The function SLang_load_object is a generic function that may be
        used to loaded an object of type SLang_Load_Type into the
        interpreter. For example, the functions SLang_load_file and
        SLang_load_string are wrappers around this function to load a
        file and a string, respectively.

      SSeeee AAllssoo
        SLang_load_file, SLang_load_string, SLallocate_load_type

  55..44..  SSLLccllaassss__aallllooccaattee__ccllaassss

      SSyynnooppssiiss
        Allocate a class for a new data type

      UUssaaggee
        SLang_Class_Type *SLclass_allocate_class (char *name)

      DDeessccrriippttiioonn
        The purpose of this function is to allocate and initialize space
        that defines a new data type or class called name. If
        successful, a pointer to the class is returned, or upon failure
        the function returns 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 SLclass_set_push_function, and the data
        type must be registered with the interpreter via
        SLclass_register_class. See the SS--LLaanngg library programmer's
        guide for more information.

      SSeeee AAllssoo
        SLclass_register_class, SLclass_set_push_function

  55..55..  SSLLccllaassss__rreeggiisstteerr__ccllaassss

      SSyynnooppssiiss
        Register a new data type with the interpreter

      UUssaaggee
        int SLclass_register_class (cl, type, sizeof_type, class_type)

              SLang_Class_Type *cl
              SLtype type
              unsigned int sizeof_type
              SLclass_Type class_type

      DDeessccrriippttiioonn
        The SLclass_register_class function is used to register a new
        class or data type with the interpreter. If successful, the
        function returns 0, or upon failure, it returns -1.

        The first parameter, cl, must have been previously obtained via
        the SLclass_allocate_class function.
        The second parameter, type specifies the data type of the new
        class. If set to SLANG_VOID_TYPE then the library will
        automatically allocate an unused value for the class (the
        allocated value can then be found using the SLclass_get_class_id
        function), otherwise a value greater than 255 should be used.
        The values in the range 0-255 are reserved for internal use by
        the library.

        The size that the data type represents in bytes is specified by
        the third parameter, 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 SLANG_CLASS_TYPE_VECTOR
        or SLANG_CLASS_TYPE_SCALAR. For pointer objects, the value of
        this parameter is just sizeof(void *).

        The final parameter specifies the class type of the data type.
        It must be one of the values:

               SLANG_CLASS_TYPE_SCALAR
               SLANG_CLASS_TYPE_VECTOR
               SLANG_CLASS_TYPE_PTR
               SLANG_CLASS_TYPE_MMT

     The SLANG_CLASS_TYPE_SCALAR indicates that the new data type is a
     scalar. Examples of scalars in SLANG_INT_TYPE and SLANG_DOU-
     BLE_TYPE.

     Setting 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 SLANG_COMPLEX_TYPE, which
     represents complex numbers.

     SLANG_CLASS_TYPE_PTR specifies the data type is of a pointer type.
     Examples of data types of this class include SLANG_STRING_TYPE and
     SLANG_ARRAY_TYPE. Such types must provide for their own memory
     management.

     Data types of class 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 _m_e_m_o_r_y
     _m_a_n_a_g_e_d _t_y_p_e. An example of this data type is the
     SLANG_FILEPTR_TYPE.

      NNootteess
        See the _S_-_L_a_n_g _L_i_b_r_a_r_y _C _P_r_o_g_r_a_m_m_e_r_'_s _G_u_i_d_e for more
        information.

      SSeeee AAllssoo
        SLclass_allocate_class, SLclass_get_class_id

  55..66..  SSLLccllaassss__sseett__ssttrriinngg__ffuunnccttiioonn

      SSyynnooppssiiss
        Set a data type's string representation callback

      UUssaaggee
        int SLclass_set_string_function (cl, sfun)

        SLang_Class_Type *cl
        char *(*sfun) (SLtype, VOID_STAR);

      DDeessccrriippttiioonn
        The SLclass_set_string_function routine is used to define a
        callback function, sfun, that will be used when a string
        representation of an object of the data type represented by cl
        is needed. cl must have already been obtained via a call to
        SLclass_allocate_class. When called, sfun will be passed two
        arguments: an SLtype which represents the data type, and the
        address of the object for which a string represetation is
        required. The callback function must return a _m_a_l_l_o_c_e_d string.

        Upon success, SLclass_set_string_function returns zero, or upon
        error it returns -1.

      EExxaammppllee
        A callback function that handles both SLANG_STRING_TYPE and
        SLANG_INT_TYPE variables looks like:

               char *string_and_int_callback (SLtype 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;
               }

      NNootteess
        The default string callback simply returns the name of the data
        type.

      SSeeee AAllssoo
        SLclass_allocate_class, SLclass_register_class

  55..77..  SSLLccllaassss__sseett__ddeessttrrooyy__ffuunnccttiioonn

      SSyynnooppssiiss
        Set the destroy method callback for a data type

      UUssaaggee
        int SLclass_set_destroy_function (cl, destroy_fun)

              SLang_Class_Type *cl
              void (*destroy_fun) (SLtype, VOID_STAR);

      DDeessccrriippttiioonn
        SLclass_set_destroy_function is used to set the destroy callback
        for a data type. The data type's class cl must have been
        previously obtained via a call to SLclass_allocate_class.  When
        called, destroy_fun will be passed two arguments: an SLtype
        which represents the data type, and the address of the object to
        be destroyed.

        SLclass_set_destroy_function returns zero upon success, and -1
        upon failure.

      EExxaammppllee
        The destroy method for SLANG_STRING_TYPE looks like:

              static void string_destroy (SLtype type, VOID_STAR ptr)
              {
                 char *s = *(char **) ptr;
                 if (s != NULL) SLang_free_slstring (*(char **) s);
              }

      NNootteess
        Data types of class SLANG_CLASS_TYPE_SCALAR do not require a
        destroy callback. However, other classes do.

      SSeeee AAllssoo
        SLclass_allocate_class, SLclass_register_class

  55..88..  SSLLccllaassss__sseett__ppuusshh__ffuunnccttiioonn

      SSyynnooppssiiss
        Set the push callback for a new data type

      UUssaaggee
        int SLclass_set_push_function (cl, push_fun)

              SLang_Class_Type *cl
              int (*push_fun) (SLtype, VOID_STAR);

      DDeessccrriippttiioonn
        SLclass_set_push_function is used to set the push callback for a
        new data type specified by cl, which must have been previously
        obtained via SLclass_allocate_class.

        The parameter push_fun is a pointer to the push callback. It is
        required to take two arguments: an SLtype representing the data
        type, and the address of the object to be pushed. It must return
        zero upon success, or -1 upon failure.

        SLclass_set_push_function returns zero upon success, or -1 upon
        failure.

      EExxaammppllee
        The push callback for SLANG_COMPLEX_TYPE looks like:

           static int complex_push (SLtype type, VOID_STAR ptr)
           {
              double *z = *(double **) ptr;
              return SLang_push_complex (z[0], z[1]);
           }

      SSeeee AAllssoo
        SLclass_allocate_class, SLclass_register_class

  55..99..  SSLLccllaassss__sseett__ppoopp__ffuunnccttiioonn

      SSyynnooppssiiss
        Set the pop callback for a new data type

      UUssaaggee
        int SLclass_set_pop_function (cl, pop_fun)

              SLang_Class_Type *cl
              int (*pop_fun) (SLtype, VOID_STAR);

      DDeessccrriippttiioonn
        SLclass_set_pop_function is used to set the callback for popping
        an object from the stack for a new data type specified by cl,
        which must have been previously obtained via
        SLclass_allocate_class.

        The parameter 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.

        SLclass_set_pop_function returns zero upon success, or -1 upon
        failure.

      EExxaammppllee
        The pop callback for SLANG_COMPLEX_TYPE looks like:

                static int complex_push (SLtype type, VOID_STAR ptr)
                {
                   double *z = *(double **) ptr;
                   return SLang_pop_complex (&z[0], &z[1]);
                }

      SSeeee AAllssoo
        SLclass_allocate_class, SLclass_register_class

  55..1100..  SSLLccllaassss__ggeett__ddaattaattyyppee__nnaammee

      SSyynnooppssiiss
        Get the name of a data type

      UUssaaggee
        char *SLclass_get_datatype_name (SLtype type)

      DDeessccrriippttiioonn
        The SLclass_get_datatype_name function returns the name of the
        data type specified by type. For example, if type is
        SLANG_INT_TYPE, the string "Integer_Type" will be returned.

        This function returns a pointer that should not be modified or
        freed.

      SSeeee AAllssoo
        SLclass_allocate_class, SLclass_register_class

  55..1111..  SSLLaanngg__ffrreeee__mmmmtt

      SSyynnooppssiiss
        Free a memory managed type

      UUssaaggee
        void SLang_free_mmt (SLang_MMT_Type *mmt)

      DDeessccrriippttiioonn
        The SLang_MMT_Type function is used to free a memory managed
        data type.

      SSeeee AAllssoo
        SLang_object_from_mmt, SLang_create_mmt

  55..1122..  SSLLaanngg__oobbjjeecctt__ffrroomm__mmmmtt

      SSyynnooppssiiss
        Get a pointer to the value of a memory managed type

      UUssaaggee
        VOID_STAR SLang_object_from_mmt (SLang_MMT_Type *mmt)

      DDeessccrriippttiioonn
        The SLang_object_from_mmt function returns a pointer to the
        actual object whose memory is being managed by the interpreter.

      SSeeee AAllssoo
        SLang_free_mmt, SLang_create_mmt

  55..1133..  SSLLaanngg__ccrreeaattee__mmmmtt

      SSyynnooppssiiss
        Create a memory managed data type

      UUssaaggee
        SLang_MMT_Type *SLang_create_mmt (SLtype t, VOID_STAR ptr)

      DDeessccrriippttiioonn
        The 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 ptr which
        represents the application defined data type of type t.

      SSeeee AAllssoo
        SLang_object_from_mmt, SLang_push_mmt, SLang_free_mmt

  55..1144..  SSLLaanngg__ppuusshh__mmmmtt

      SSyynnooppssiiss
        Push a memory managed type

      UUssaaggee
        int SLang_push_mmt (SLang_MMT_Type *mmt)

      DDeessccrriippttiioonn
        This function is used to push a memory managed type onto the
        interpreter stack. It returns zero upon success, or -1 upon
        failure.

      SSeeee AAllssoo
        SLang_create_mmt, SLang_pop_mmt

  55..1155..  SSLLaanngg__ppoopp__mmmmtt

      SSyynnooppssiiss
        Pop a memory managed data type

      UUssaaggee
        SLang_MMT_Type *SLang_pop_mmt (SLtype t)

      DDeessccrriippttiioonn
        The SLang_pop_mmt function may be used to pop a memory managed
        type of type t from the stack. It returns a pointer to the
        memory managed object upon success, or NULL upon failure. The
        function SLang_object_from_mmt should be used to access the
        actual pointer to the data type.

      SSeeee AAllssoo
        SLang_object_from_mmt, SLang_push_mmt

  55..1166..  SSLLaanngg__iinncc__mmmmtt

      SSyynnooppssiiss
        Increment a memory managed type reference count

      UUssaaggee
        void SLang_inc_mmt (SLang_MMT_Type *mmt);

      DDeessccrriippttiioonn
        The SLang_inc_mmt function may be used to increment the
        reference count associated with the memory managed data type
        given by mmt.

      SSeeee AAllssoo
        SLang_free_mmt, SLang_create_mmt, SLang_pop_mmt, SLang_pop_mmt

  55..1177..  SSLLaadddd__iinnttrriinn__ffuunn__ttaabbllee

      SSyynnooppssiiss
        Add a table of intrinsic functions to the interpreter

      UUssaaggee
        int SLadd_intrin_fun_table(SLang_Intrin_Fun_Type *tbl, char
        *pp_name);

      DDeessccrriippttiioonn
        The SLadd_intrin_fun_table function adds an array, or table, of
        SLang_Intrin_Fun_Type objects to the interpreter. The first
        parameter, tbl specifies the table to be added. The second
        parameter pp_name, if non-NULL will be added to the list of
        preprocessor symbols.

        This function returns -1 upon failure or zero upon success.

      NNootteess
        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.

      SSeeee AAllssoo
        SLadd_intrin_var_table, SLadd_intrinsic_function,
        SLdefine_for_ifdef

  55..1188..  SSLLaadddd__iinnttrriinn__vvaarr__ttaabbllee

      SSyynnooppssiiss
        Add a table of intrinsic variables to the interpreter

      UUssaaggee
        int SLadd_intrin_var_table (SLang_Intrin_Var_Type *tbl, char
        *pp_name);

      DDeessccrriippttiioonn
        The SLadd_intrin_var_table function adds an array, or table, of
        SLang_Intrin_Var_Type objects to the interpreter. The first
        parameter, tbl specifies the table to be added. The second
        parameter pp_name, if non-NULL will be added to the list of
        preprocessor symbols.

        This function returns -1 upon failure or zero upon success.

      NNootteess
        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.

      SSeeee AAllssoo
        SLadd_intrin_var_table, SLadd_intrinsic_function,
        SLdefine_for_ifdef

  55..1199..  SSLLaanngg__llooaadd__ffiillee

      SSyynnooppssiiss
        Load a file into the interpreter

      UUssaaggee
        int SLang_load_file (char *fn)

      DDeessccrriippttiioonn
        The SLang_load_file function opens the file whose name is
        specified by fn and feeds it to the interpreter, line by line,
        for execution. If fn is NULL, the function will take input from
        stdin.

        If no error occurs, it returns 0; otherwise, it returns -1, and
        sets SLang_Error accordingly. For example, if it fails to open
        the file, it will return -1 with SLang_Error set to
        SL_OBJ_NOPEN.

      NNootteess
        If the hook SLang_Load_File_Hook declared as

                int (*SLang_Load_File_Hook)(char *);

     is non-NULL, the function point to by it will be used to load the
     file. For example, the jjeedd editor uses this hook to load files via
     its own routines.

      SSeeee AAllssoo
        SLang_load_object, SLang_load_string

  55..2200..  SSLLaanngg__rreessttaarrtt

      SSyynnooppssiiss
        Reset the interpreter after an error

      UUssaaggee
        void SLang_restart (int full)

      DDeessccrriippttiioonn
        The SLang_restart function should be called by the application
        at top level if an error occurs. If the parameter full is non-
        zero, any objects on the SS--LLaanngg 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 setjmp/longjmp is
        called).

        Calling SLang_restart does not reset the global variable
        SLang_Error to zero. It is up to the application to reset that
        variable to zero after calling SLang_restart.

      EExxaammppllee

                while (1)
                  {
                     if (SLang_Error)
                       {
                          SLang_restart (1);
                          SLang_Error = 0;
                       }
                     (void) SLang_load_file (NULL);
                  }

      SSeeee AAllssoo
        SLang_init_slang, SLang_load_file

  55..2211..  SSLLaanngg__bbyyttee__ccoommppiillee__ffiillee

      SSyynnooppssiiss
        Byte-compile a file for faster loading

      UUssaaggee
        int SLang_byte_compile_file(char *fn, int reserved)

      DDeessccrriippttiioonn
        The SLang_byte_compile_file function ``byte-compiles'' the file
        fn for faster loading by the interpreter. This produces a new
        file whose filename is equivalent to the one specified by fn,
        except that a 'c' is appended to the name. For example, if fn is
        set to init.sl, then the new file will have the name
        exmp{init.slc}. The meaning of the second parameter, reserved,
        is reserved for future use. For now, set it to 0.

        The function returns zero upon success, or -1 upon error and
        sets SLang_Error accordingly.

      SSeeee AAllssoo
        SLang_load_file, SLang_init_slang

  55..2222..  SSLLaanngg__aauuttoollooaadd

      SSyynnooppssiiss
        Autoload a function from a file

      UUssaaggee
        int SLang_autoload(char *funct, char *filename)

      DDeessccrriippttiioonn
        The SLang_autoload function may be used to associate a slang
        function name funct with the file filename such that if funct
        has not already been defined when needed, it will be loaded from
        filename.

        SLang_autoload has no effect if funct has already been defined.
        Otherwise it declares funct as a user-defined SS--LLaanngg function.
        It returns 0 upon success, or -1 upon error.

      SSeeee AAllssoo
        SLang_load_file, SLang_is_defined

  55..2233..  SSLLaanngg__llooaadd__ssttrriinngg

      SSyynnooppssiiss
        Interpret a string

      UUssaaggee
        int SLang_load_string(char *str)

      DDeessccrriippttiioonn
        The SLang_load_string function feeds the string specified by str
        to the interpreter for execution. It returns zero upon success,
        or -1 upon failure.

      SSeeee AAllssoo
        SLang_load_file, SLang_load_object

  55..2244..  SSLLddoo__ppoopp

      SSyynnooppssiiss
        Delete an object from the stack

      UUssaaggee
        int SLdo_pop(void)

      DDeessccrriippttiioonn
        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 -1 upon error (most likely due to
        a stack-underflow).

      SSeeee AAllssoo
        SLdo_pop_n, SLang_pop_integer, SLang_pop_string

  55..2255..  SSLLddoo__ppoopp__nn

      SSyynnooppssiiss
        Delete n objects from the stack

      UUssaaggee
        int SLdo_pop_n (unsigned int n)

      DDeessccrriippttiioonn
        The SLdo_pop_n function removes the top n objects from the
        interpreter's run-time stack and frees all memory associated
        with the objects. It returns zero upon success, or -1 upon error
        (most likely due to a stack-underflow).

      SSeeee AAllssoo
        SLdo_pop, SLang_pop_integer, SLang_pop_string

  55..2266..  SSLLaanngg__ppoopp__iinntteeggeerr

      SSyynnooppssiiss
        Pop an integer off the stack

      UUssaaggee
        int SLang_pop_integer (int *i)

      DDeessccrriippttiioonn
        The SLang_pop_integer function removes an integer from the top
        of the interpreter's run-time stack and returns its value via
        the pointer i. If successful, it returns zero. However, if the
        top stack item is not of type SLANG_INT_TYPE, or the stack is
        empty, the function will return -1 and set SLang_Error
        accordingly.

      SSeeee AAllssoo
        SLang_push_integer, SLang_pop_double

  55..2277..  SSLLppoopp__ssttrriinngg

      SSyynnooppssiiss
        Pop a string from the stack

      UUssaaggee
        int SLpop_string (char **strptr);

      DDeessccrriippttiioonn
        The 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 free or SLfree. If
        successful, SLpop_string returns zero. However, if the top stack
        item is not of type SLANG_STRING_TYPE, or the stack is empty,
        the function will return -1 and set SLang_Error accordingly.

      EExxaammppllee

                define print_string (void)
                {
                   char *s;
                   if (-1 == SLpop_string (&s))
                     return;
                   fputs (s, stdout);
                   SLfree (s);
                }

      NNootteess
        This function should not be confused with SLang_pop_slstring,
        which pops a _h_a_s_h_e_d string from the stack.

      SSeeee AAllssoo
        SLang_pop_slstring. SLfree

  55..2288..  SSLLaanngg__ppoopp__ssttrriinngg

      SSyynnooppssiiss
        Pop a string from the stack

      UUssaaggee
        int SLang_pop_string(char **strptr, int *do_free)

      DDeessccrriippttiioonn
        The SLpop_string function pops a string from the stack and
        returns it as a malloced pointer via strptr. After the function
        returns, the integer pointed to by the second parameter will be
        set to a non-zero value if *strptr should be freed via free or
        SLfree. If successful, SLpop_string returns zero. However, if
        the top stack item is not of type SLANG_STRING_TYPE, or the
        stack is empty, the function will return -1 and set SLang_Error
        accordingly.

      NNootteess
        This function is considered obsolete and should not be used by
        applications. If one requires a malloced string for
        modification, SLpop_string should be used. If one requires a
        constant string that will not be modifed by the application,
        SLang_pop_slstring should be used.

      SSeeee AAllssoo
        SLang_pop_slstring, SLpop_string

  55..2299..  SSLLaanngg__ppoopp__ssllssttrriinngg

      SSyynnooppssiiss
        Pop a hashed string from the stack

      UUssaaggee
        int SLang_pop_slstring (char **s_ptr)

      DDeessccrriippttiioonn
        The SLang_pop_slstring function pops a hashed string from the SS--
        LLaanngg run-time stack and returns it via s_ptr. It returns zero if
        successful, or -1 upon failure. The resulting string should be
        freed via a call to SLang_free_slstring after use.

      EExxaammppllee

             void print_string (void)
             {
                char *s;
                if (-1 == SLang_pop_slstring (&s))
                  return;
                fprintf (stdout, "%s\n", s);
                SLang_free_slstring (s);
             }

      NNootteess
        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 _n_e_v_e_r free a hashed string using free or SLfree. In
        addition, one must never make any attempt to modify a hashed
        string and doing so will result in memory corruption.

      SSeeee AAllssoo
        SLang_free_slstring, SLpop_string

  55..3300..  SSLLaanngg__ppoopp__ddoouubbllee

      SSyynnooppssiiss
        Pop a double from the stack

      UUssaaggee
        int SLang_pop_double (double *dptr)

      DDeessccrriippttiioonn
        The SLang_pop_double function pops a double precision number
        from the stack and returns it via dptr. This function returns 0
        upon success, otherwise it returns -1 and sets SLang_Error
        accordingly.

      SSeeee AAllssoo
        SLang_pop_integer, SLang_push_double

  55..3311..  SSLLaanngg__ppoopp__ccoommpplleexx

      SSyynnooppssiiss
        Pop a complex number from the stack

      UUssaaggee
        int SLang_pop_complex (double *re, double *im)

      DDeessccrriippttiioonn
        SLang_pop_complex pops a complex number from the stack and
        returns it via the parameters re and im as the real and
        imaginary parts of the complex number, respectively. This
        function automatically converts objects of type
        SLANG_DOUBLE_TYPE and SLANG_INT_TYPE to SLANG_COMPLEX_TYPE, if
        necessary.  It returns zero upon success, or -1 upon error
        setting SLang_Error accordingly.

      SSeeee AAllssoo
        SLang_pop_integer, SLang_pop_double, SLang_push_complex

  55..3322..  SSLLaanngg__ppuusshh__ccoommpplleexx

      SSyynnooppssiiss
        Push a complex number onto the stack

      UUssaaggee
        int SLang_push_complex (double re, double im)

      DDeessccrriippttiioonn
        SLang_push_complex may be used to push the complex number whose
        real and imaginary parts are given by re and im, respectively.
        It returns zero upon success, or -1 upon error setting
        SLang_Error accordingly.

      SSeeee AAllssoo
        SLang_pop_complex, SLang_push_double

  55..3333..  SSLLaanngg__ppuusshh__ddoouubbllee

      SSyynnooppssiiss
        Push a double onto the stack

      UUssaaggee
        int SLang_push_double(double d)

      DDeessccrriippttiioonn
        SLang_push_double may be used to push the double precision
        floating point number d onto the interpreter's run-time stack.
        It returns zero upon success, or -1 upon error setting
        SLang_Error accordingly.

      SSeeee AAllssoo
        SLang_pop_double, SLang_push_integer

  55..3344..  SSLLaanngg__ppuusshh__ssttrriinngg

      SSyynnooppssiiss
        Push a string onto the stack

      UUssaaggee
        int SLang_push_string (char *s)

      DDeessccrriippttiioonn
        SLang_push_string pushes a copy of the string specified by s
        onto the interpreter's run-time stack. It returns zero upon
        success, or -1 upon error setting SLang_Error accordingly.

      NNootteess
        If s is NULL, this function pushes NULL (SLANG_NULL_TYPE) onto
        the stack.

      SSeeee AAllssoo
        SLang_push_malloced_string

  55..3355..  SSLLaanngg__ppuusshh__iinntteeggeerr

      SSyynnooppssiiss
        Push an integer onto the stack

      UUssaaggee
        int SLang_push_integer (int i)

      DDeessccrriippttiioonn
        SLang_push_integer the integer i onto the interpreter's run-time
        stack. It returns zero upon success, or -1 upon error setting
        SLang_Error accordingly.

      SSeeee AAllssoo
        SLang_pop_integer, SLang_push_double, SLang_push_string

  55..3366..  SSLLaanngg__ppuusshh__mmaalllloocceedd__ssttrriinngg

      SSyynnooppssiiss
        Push a malloced string onto the stack

      UUssaaggee
        int SLang_push_malloced_string (char *s);

      DDeessccrriippttiioonn
        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 SLang_Error accordingly.

      EExxaammppllee
        The following example illustrates that it is up to the calling
        routine to free the string if SLang_push_malloced_string fails:

                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;
                }

      EExxaammppllee
        The function SLang_create_slstring returns a hashed string.
        Such a string may not be malloced and should not be passed to
        SLang_push_malloced_string.

      NNootteess
        If s is NULL, this function pushes NULL (SLANG_NULL_TYPE) onto
        the stack.

      SSeeee AAllssoo
        SLang_push_string, SLmake_string

  55..3377..  SSLLaanngg__iiss__ddeeffiinneedd

      SSyynnooppssiiss
        Check to see if the interpreter defines an object

      UUssaaggee
        int SLang_is_defined (char *nm)

      DDeessccrriippttiioonn
        The SLang_is_defined function may be used to determine whether
        or not a variable or function whose name is given by em has been
        defined. It returns zero if no such object has been defined.
        Otherwise it returns a non-zero value according to the following
        table:

                1    intrinsic function
                2    user-defined slang function
               -1    intrinsic variable
               -2    user-defined global variable

     Note that variables correspond to negative numbers and functions
     are represented by positive numbers.

      SSeeee AAllssoo
        SLadd_intrinsic_function, SLang_run_hooks,
        SLang_execute_function

  55..3388..  SSLLaanngg__rruunn__hhooookkss

      SSyynnooppssiiss
        Run a user-defined hook with arguments

      UUssaaggee
        int SLang_run_hooks (char *fname, unsigned int n, ...)

      DDeessccrriippttiioonn
        The SLang_run_hooks function may be used to execute a user-
        defined function named fname. Before execution of the function,
        the n string arguments specified by the variable parameter list
        are pushed onto the stack. If the function fname does not exist,
        SLang_run_hooks returns zero; otherwise, it returns 1 upon
        successful execution of the function, or -1 if an error
        occurred.

      EExxaammppllee
        The jjeedd editor uses SLang_run_hooks to setup the mode of a
        buffer based on the filename extension of the file associated
        with the buffer:

                char *ext = get_filename_extension (filename);
                if (ext == NULL) return -1;
                if (-1 == SLang_run_hooks ("mode_hook", 1, ext))
                  return -1;
                return 0;

      SSeeee AAllssoo
        SLang_is_defined, SLang_execute_function

  55..3399..  SSLLaanngg__eexxeeccuuttee__ffuunnccttiioonn

      SSyynnooppssiiss
        Execute a user or intrinsic function

      UUssaaggee
        int SLang_execute_function (char *fname)

      DDeessccrriippttiioonn
        This function may be used to execute either a user-defined
        function or an intrinisic function. The name of the function is
        specified by fname. It returns zero if fname is not defined, or
        1 if the function was successfully executed, or -1 upon error.

      NNootteess
        The function SLexecute_function may be a better alternative for
        some uses.

      SSeeee AAllssoo
        SLang_run_hooks, SLexecute_function, SLang_is_defined

  55..4400..  SSLLaanngg__ggeett__ffuunnccttiioonn

      SSyynnooppssiiss
        Get a pointer to a SS--LLaanngg function

      UUssaaggee
        SLang_Name_Type *SLang_get_function (char *fname)

      DDeessccrriippttiioonn
        This function returns a pointer to the internal SS--LLaanngg table
        entry of a function whose name is given by fname. It returns
        NULL upon failure. The value returned by this function can be
        used SLexecute_function to call the function directly from C.

      SSeeee AAllssoo
        SLexecute_function

  55..4411..  SSLLeexxeeccuuttee__ffuunnccttiioonn

      SSyynnooppssiiss
        Execute a SS--LLaanngg or intrinsic function

      UUssaaggee
        int SLexecute_function (SLang_Name_Type *nt)

      DDeessccrriippttiioonn
        The SLexecute_function allows an application to call the SS--LLaanngg
        function specified by the SLang_Name_Type pointer nt. This
        parameter must be non NULL and must have been previously
        obtained by a call to SLang_get_function.
      EExxaammppllee
        Consider the SS--LLaanngg function:

               define my_fun (x)
               {
                  return x^2 - 2;
               }

     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 SLang_execute_function by passing the string
     "my_fun". A better way that is much faster is to use SLexe-
     cute_function:

                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))
                          return -1;

                        sum += y;
                     }
                   return sum;
                }

     Although not necessary in this case, SLang_start_arg_list and
     SLang_end_arg_list were used to provide the function with informa-
     tion about the number of parameters passed to it.

      SSeeee AAllssoo
        SLang_get_function, SLang_start_arg_list, SLang_end_arg_list

  55..4422..  SSLLaanngg__ppeeeekk__aatt__ssttaacckk

      SSyynnooppssiiss
        Find the type of object on the top of the stack

      UUssaaggee
        int SLang_peek_at_stack (void)

      DDeessccrriippttiioonn
        The 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.

      SSeeee AAllssoo
        SLang_pop_string, SLang_pop_integer

  55..4433..  SSLLaanngg__ppoopp__ffiilleeppttrr

      SSyynnooppssiiss
        Pop a file pointer

      UUssaaggee
        int SLang_pop_fileptr (SLang_MMT_Type **mmt, FILE **fp)

      DDeessccrriippttiioonn
        SLang_pop_fileptr pops a file pointer from the SS--LLaanngg run-time
        stack. It returns zero upon success, or -1 upon failure.

        A SS--LLaanngg file pointer (SLANG_FILEPTR_TYPE) is actually a memory
        managed object. For this reason, SLang_pop_fileptr also returns
        the memory managed object via the argument list. It is up to the
        calling routine to call SLang_free_mmt to free the object.

      EExxaammppllee
        The following example illustrates an application defined
        intrinsic function that writes a user defined double precision
        number to a file. Note the use of SLang_free_mmt:

               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;
               }

     This function can be used by a SS--LLaanngg function as follows:

          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");
          }

      SSeeee AAllssoo
        SLang_free_mmt, SLang_pop_double

  55..4444..  SSLLaadddd__iinnttrriinnssiicc__ffuunnccttiioonn

      SSyynnooppssiiss
        Add a new intrinsic function to the interpreter

      UUssaaggee
        int SLadd_intrinsic_function (name, f, type, nargs, ...)

              char *name
              FVOID_STAR f
              SLtype type
              unsigned int nargs

      DDeessccrriippttiioonn
        The SLadd_intrinsic_function function may be used to add a new
        intrinsic function. The SS--LLaanngg name of the function is specified
        by name and the actual function pointer is given by f, cast to
        FVOID_STAR. The third parameter, type specifies the return type
        of the function and must be one of the following values:

              SLANG_VOID_TYPE   (returns nothing)
              SLANG_INT_TYPE    (returns int)
              SLANG_DOUBLE_TYPE (returns double)
              SLANG_STRING_TYPE (returns char *)

     The nargs parameter specifies the number of parameters to pass to
     the function. The variable argument list following nargs must con-
     sists of nargs integers which specify the data type of each argu-
     ment.

     The function returns zero upon success or -1 upon failure.

      EExxaammppllee
        The jjeedd editor uses this function to change the system intrinsic
        function to the following:

               static int jed_system (char *cmd)
               {
                  if (Jed_Secure_Mode)
                    {
                       msg_error ("Access denied.");
                       return -1;
                    }
                  return SLsystem (cmd);
               }

     After initializing the interpreter with SLang_init_slang, jjeedd calls
     SLadd_intrinsic_function to substitute the above definition for the
     default SS--LLaanngg definition:

               if (-1 == SLadd_intrinsic_function ("system", (FVOID_STAR)jed_system,
                                                   SLANG_INT_TYPE, 1,
                                                   SLANG_STRING_TYPE))
                 return -1;

      SSeeee AAllssoo
        SLadd_intrinsic_variable, SLadd_intrinsic_array

  55..4455..  SSLLaadddd__iinnttrriinnssiicc__vvaarriiaabbllee

      SSyynnooppssiiss
        Add an intrinsic variable to the interpreter

      UUssaaggee
        int SLadd_intrinsic_variable (name, addr, type, rdonly)

              char *name
              VOID_STAR addr
              SLtype type
              int rdonly

      DDeessccrriippttiioonn
        The SLadd_intrinsic_variable function adds an intrinsic variable
        called name to the interpeter. The second parameter addr
        specifies the address of the variable (cast to VOID_STAR). The
        third parameter, type, specifies the data type of the variable.
        If the fourth parameter, rdonly, is non-zero, the variable will
        interpreted by the interpreter as read-only.

        If successful, SLadd_intrinsic_variable returns zero, otherwise
        it returns -1.

      EExxaammppllee
        Suppose that My_Global_Int is a global variable (at least not a
        local one):

              int My_Global_Int;

     It can be added to the interpreter via the function call

              if (-1 == SLadd_intrinsic_variable ("MyGlobalInt",
                                                  (VOID_STAR)&My_Global_Int,
                                                  SLANG_INT_TYPE, 0))
                exit (1);

      NNootteess
        The current implementation requires all pointer type intrinsic
        variables to be read-only. For example,

              char *My_Global_String;

     is of type SLANG_STRING_TYPE, and must be declared as read-only.
     Finally, not that

             char My_Global_Char_Buf[256];

     is _n_o_t a SLANG_STRING_TYPE object. This difference is very impor-
     tant because internally the interpreter dereferences the address
     passed to it to get to the value of the variable.

      SSeeee AAllssoo
        SLadd_intrinsic_function, SLadd_intrinsic_array

  55..4466..  SSLLccllaassss__aadddd__uunnaarryy__oopp

      SSyynnooppssiiss
        ??

      UUssaaggee
        int SLclass_add_unary_op (SLtype,int (*) (int, SLtype,
        VOID_STAR, unsigned int, VOID_STAR), int (*) (int, SLtype,
        SLtype *));

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??
  55..4477..  SSLLccllaassss__aadddd__aapppp__uunnaarryy__oopp

      SSyynnooppssiiss
        ??

      UUssaaggee
        int SLclass_add_app_unary_op (SLtype, int (*) (int,SLtype,
        VOID_STAR, unsigned int,VOID_STAR),int (*) (int, SLtype, SLtype
        *));

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  55..4488..  SSLLccllaassss__aadddd__bbiinnaarryy__oopp

      SSyynnooppssiiss
        ??

      UUssaaggee
        int SLclass_add_binary_op (SLtype, SLtype,int (*)(int, SLtype,
        VOID_STAR, unsigned int,SLtype, VOID_STAR, unsigned
        int,VOID_STAR),int (*) (int, SLtype, SLtype, SLtype *));

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  55..4499..  SSLLccllaassss__aadddd__mmaatthh__oopp

      SSyynnooppssiiss
        ??

      UUssaaggee
        int SLclass_add_math_op (SLtype,int (*)(int,SLtype, VOID_STAR,
        unsigned int,VOID_STAR),int (*)(int, SLtype, SLtype *));

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  55..5500..  SSLLccllaassss__aadddd__ttyyppeeccaasstt

      SSyynnooppssiiss
        ??

      UUssaaggee
        int SLclass_add_typecast (SLtype, SLtype int (*)_PROTO((SLtype,
        VOID_STAR, unsigned int,SLtype, VOID_STAR)),int);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  66..  LLiibbrraarryy IInniittiiaalliizzaattiioonn FFuunnccttiioonnss

  66..11..  SSLLaanngg__iinniitt__ssllaanngg

      SSyynnooppssiiss
        Initialize the interpreter

      UUssaaggee
        int SLang_init_slang (void)

      DDeessccrriippttiioonn
        The SLang_init_slang function must be called by all applications
        that use the SS--LLaanngg interpreter. It initializes the interpreter,
        defines the built-in data types, and adds a set of core
        intrinsic functions.

        The function returns 0 upon success, or -1 upon failure.

      SSeeee AAllssoo
        SLang_init_slfile, SLang_init_slmath, SLang_init_slunix

  66..22..  SSLLaanngg__iinniitt__ssllffiillee

      SSyynnooppssiiss
        Initialize the interpreter file I/O intrinsics

      UUssaaggee
        int SLang_init_slfile (void)

      DDeessccrriippttiioonn
        This function initializes the interpreters file I/O intrinsic
        functions. This function adds intrinsic functions such as fopen,
        fclose, and fputs to the interpreter.  It returns 0 if
        successful, or -1 upon error.

      NNootteess
        Before this function can be called, it is first necessary to
        call SLang_init_slang. It also adds the preprocessor symbol
        __SLFILE__ to the interpreter.

      SSeeee AAllssoo
        SLang_init_slang, SLang_init_slunix, SLang_init_slmath

  66..33..  SSLLaanngg__iinniitt__ssllmmaatthh

      SSyynnooppssiiss
        Initialize the interpreter math intrinsics

      UUssaaggee
        int SLang_init_slmath (void)

      DDeessccrriippttiioonn
        The SLang_init_slmath function initializes the interpreter's
        mathematical intrinsic functions and makes them available to the
        language. The intrinsic functions include sin, cos, tan, etc...
        It returns 0 if successful, or -1 upon failure.

      NNootteess
        This function must be called after SLang_init_slang. It adds the
        preprocessor symbol __SLMATH__ to the interpreter.

      SSeeee AAllssoo
        SLang_init_slang, SLang_init_slfile, SLang_init_slunix

  66..44..  SSLLaanngg__iinniitt__sslluunniixx

      SSyynnooppssiiss
        Make available some unix system calls to the interpreter

      UUssaaggee
        int SLang_init_slunix (void)

      DDeessccrriippttiioonn
        The 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
        SLang_init_slunix include chmod, chown, and stat_file. It
        returns 0 if successful, or -1 upon failure.

      NNootteess
        This function must be called after SLang_init_slang. It adds the
        preprocessor symbol __SLUNIX__ to the interpreter.

      SSeeee AAllssoo
        SLang_init_slang, SLang_init_slfile, SLang_init_slmath

  77..  MMiisscceellllaanneeoouuss FFuunnccttiioonnss

  77..11..  SSLLccuurrrreenntt__ttiimmee__ssttrriinngg

      SSyynnooppssiiss
        Get the current time as a string

      UUssaaggee
        char *SLcurrent_time_string (void)

      DDeessccrriippttiioonn
        The SLcurrent_time_string function uses the C library function
        ctime to obtain a string representation of the current date and
        time in the form

          "Wed Dec 10 12:50:28 1997"

     However, unlike the 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.

      SSeeee AAllssoo
        SLmake_string

  77..22..  SSLLaattooii

      SSyynnooppssiiss
        Convert a text string to an integer

      UUssaaggee
        int SLatoi(unsigned char *str

      DDeessccrriippttiioonn
        SLatoi parses the string str to interpret it as an integer
        value. Unlike atoi, SLatoi can also parse strings containing
        integers expressed in hexidecimal (e.g., "0x7F") and octal
        (e.g., "012".)  notation.

      SSeeee AAllssoo
        SLang_guess_type

  77..33..  SSLLeexxttrraacctt__lliisstt__eelleemmeenntt

      SSyynnooppssiiss
        Extract a substring of a delimited string

      UUssaaggee
        int SLextract_list_element (dlist, nth, delim, buf, buflen)

              char *dlist;
              unsigned int nth;
              char delim;
              char *buf;
              unsigned int buflen;

      DDeessccrriippttiioonn
        SLextract_list_element may be used to obtain the nth element of
        a list of strings, dlist, that are delimited by the character
        delim. The routine copies the nth element of dlist to the buffer
        buf whose size is buflen characters. It returns zero upon
        success, or -1 if dlist does not contain an nth element.

      EExxaammppllee
        A delimited list of strings may be turned into an array of
        strings as follows. For conciseness, all malloc error checking
        has been omitted.

              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;
              }

      SSeeee AAllssoo
        SLmalloc, SLmake_string

  88..  EErrrroorr aanndd MMeessssaaggiinngg FFuunnccttiioonnss

  88..11..  SSLLaanngg__vveerrrroorr

      SSyynnooppssiiss
        Signal an error with a message

      UUssaaggee
        void SLang_verror (int code, char *fmt, ...);

      DDeessccrriippttiioonn
        The SLang_verror function sets SLang_Error to code if
        SLang_Error is 0. It also displays the error message implied by
        the printf variable argument list using fmt as the format.

      EExxaammppllee

                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;
                }

      SSeeee AAllssoo
        SLang_vmessage, SLang_exit_error

  88..22..  SSLLaanngg__ddooeerrrroorr

      SSyynnooppssiiss
        Signal an error

      UUssaaggee
        void SLang_doerror (char *err_str)

      DDeessccrriippttiioonn
        The SLang_doerror function displays the string err_str to the
        error device and signals a SS--LLaanngg error.

      NNootteess
        SLang_doerror is considered to obsolete. Applications should use
        the SLang_verror function instead.

      SSeeee AAllssoo
        SLang_verror, SLang_exit_error

  88..33..  SSLLaanngg__vvmmeessssaaggee

      SSyynnooppssiiss
        Display a message to the message device

      UUssaaggee
        void SLang_vmessage (char *fmt, ...)

      DDeessccrriippttiioonn
        This function prints a printf style formatted variable argument
        list to the message device. The default message device is
        stdout.

      SSeeee AAllssoo
        SLang_verror

  88..44..  SSLLaanngg__eexxiitt__eerrrroorr

      SSyynnooppssiiss
        Exit the program and display an error message

      UUssaaggee
        void SLang_exit_error (char *fmt, ...)

      DDeessccrriippttiioonn
        The SLang_exit_error function terminates the program and
        displays an error message using a printf type variable argument
        list. The default behavior to this function is to write the
        message to stderr and exit with the exit system call.

        If the function pointer 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:

               void (*SLang_Exit_Error_Hook)(char *, va_list);

      SSeeee AAllssoo
        SLang_verror, exit

  99..  SSttrriinngg aanndd MMeemmoorryy AAllllooccaattiioonn FFuunnccttiioonnss

  99..11..  SSLLmmaakkee__ssttrriinngg

      SSyynnooppssiiss
        Duplicate a string

      UUssaaggee
        char *SLmake_string (char *s)

      DDeessccrriippttiioonn
        The SLmake_string function creates a new copy of the string s,
        via malloc, and returns it. Upon failure it returns NULL. Since
        the resulting string is malloced, it should be freed when
        nolonger needed via a call to either free or SLfree.

      NNootteess
        SLmake_string should not be confused with the function
        SLang_create_slstring, which performs a similar function.

      SSeeee AAllssoo
        SLmake_nstring, SLfree, SLmalloc, SLang_create_slstring

  99..22..  SSLLmmaakkee__nnssttrriinngg

      SSyynnooppssiiss
        Duplicate a substring

      UUssaaggee
        char *SLmake_nstring (char *s, unsigned int n)

      DDeessccrriippttiioonn
        This function is like SLmake_string except that it creates a
        null terminated string formed from the first n characters of s.
        Upon failure, it returns NULL, otherwise it returns the new
        string. When nolonger needed, the returned string should be
        freed with SLfree.

      SSeeee AAllssoo
        SLmake_string, SLfree, SLang_create_nslstring

  99..33..  SSLLaanngg__ccrreeaattee__nnssllssttrriinngg

      SSyynnooppssiiss
        Created a hashed substring

      UUssaaggee
        char *SLang_create_nslstring (char *s, unsigned int n)

      DDeessccrriippttiioonn
        SLang_create_nslstring is like SLang_create_slstring except that
        only the first n characters of s are used to create the hashed
        string. Upon error, it returns NULL, otherwise it returns the
        hashed substring. Such a string must be freed by the function
        SLang_free_slstring.

      NNootteess
        Do not use free or SLfree to free the string returned by
        SLang_create_slstring or 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 SLmake_string or SLmake_nstring should be
        used instead.

      SSeeee AAllssoo
        SLang_free_slstring, SLang_create_slstring, SLmake_nstring

  99..44..  SSLLaanngg__ccrreeaattee__ssllssttrriinngg

      SSyynnooppssiiss
        Create a hashed string

      UUssaaggee
        char *SLang_create_slstring (char *s)

      DDeessccrriippttiioonn
        The SLang_create_slstring creates a copy of s and returns it as
        a hashed string. Upon error, the function returns NULL,
        otherwise it returns the hashed string. Such a string must only
        be freed via the SLang_free_slstring function.

      NNootteess
        Do not use free or SLfree to free the string returned by
        SLang_create_slstring or 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 SLmake_string or SLmake_nstring should be
        used instead.

      SSeeee AAllssoo
        SLang_free_slstring, SLang_create_nslstring, SLmake_string

  99..55..  SSLLaanngg__ffrreeee__ssllssttrriinngg

      SSyynnooppssiiss
        Free a hashed string

      UUssaaggee
        void SLang_free_slstring (char *s)
      DDeessccrriippttiioonn
        The SLang_free_slstring function is used to free a hashed string
        such as one returned by SLang_create_slstring,
        SLang_create_nslstring, or SLang_create_static_slstring.  If s
        is NULL, the routine does nothing.

      SSeeee AAllssoo
        SLang_create_slstring, SLang_create_nslstring,
        SLang_create_static_slstring

  99..66..  SSLLaanngg__ccoonnccaatt__ssllssttrriinnggss

      SSyynnooppssiiss
        Concatenate two strings to produce a hashed string

      UUssaaggee
        char *SLang_concat_slstrings (char *a, char *b)

      DDeessccrriippttiioonn
        The SLang_concat_slstrings function concatenates two strings, a
        and b, and returns the result as a hashed string.  Upon failure,
        NULL is returned.

      NNootteess
        A hashed string can only be freed using SLang_free_slstring.
        Never use free or SLfree to free a hashed string, otherwise
        memory corruption will result.

      SSeeee AAllssoo
        SLang_free_slstring, SLang_create_slstring

  99..77..  SSLLaanngg__ccrreeaattee__ssttaattiicc__ssllssttrriinngg

      SSyynnooppssiiss
        Create a hashed string

      UUssaaggee
        char *SLang_create_static_slstring (char *s_literal)

      DDeessccrriippttiioonn
        The SLang_create_static_slstring creates a hashed string from
        the string literal s_literal and returns the result. Upon
        failure it returns NULL.

      EExxaammppllee

               char *create_hello (void)
               {
                  return SLang_create_static_slstring ("hello");
               }

      NNootteess
        This function should only be used with string literals.

      SSeeee AAllssoo
        SLang_create_slstring, SLang_create_nslstring

  99..88..  SSLLmmaalllloocc

      SSyynnooppssiiss
        Allocate some memory

      UUssaaggee
        char *SLmalloc (unsigned int nbytes)

      DDeessccrriippttiioonn
        This function uses malloc to allocate nbytes of memory.  Upon
        error it returns NULL; otherwise it returns a pointer to the
        allocated memory. One should use SLfree to free the memory after
        use.

      SSeeee AAllssoo
        SLfree, SLrealloc, SLcalloc

  99..99..  SSLLccaalllloocc

      SSyynnooppssiiss
        Allocate some memory

      UUssaaggee
        char *SLcalloc (unsigned int num_elem, unsigned int elem_size)

      DDeessccrriippttiioonn
        This function uses calloc to allocate memory for num_elem
        objects with each of size elem_size and returns the result. In
        addition, the newly allocated memory is zeroed.  Upon error it
        returns NULL; otherwise it returns a pointer to the allocated
        memory. One should use SLfree to free the memory after use.

      SSeeee AAllssoo
        SLmalloc, SLrealloc, SLfree

  99..1100..  SSLLffrreeee

      SSyynnooppssiiss
        Free some allocated memory

      UUssaaggee
        void SLfree (char *ptr)

      DDeessccrriippttiioonn
        The SLfree function deallocates the memory specified by ptr,
        which may be NULL in which case the function does nothing.

      NNootteess
        Never use this function to free a hashed string returned by one
        of the family of slstring functions, e.g., SLang_pop_slstring.

      SSeeee AAllssoo
        SLmalloc, SLcalloc, SLrealloc, SLmake_string

  99..1111..  SSLLrreeaalllloocc

      SSyynnooppssiiss
        Resize a dynamic memory block

      UUssaaggee
        char *SLrealloc (char *ptr, unsigned int new_size)

      DDeessccrriippttiioonn
        The SLrealloc uses the realloc function to resize the memory
        block specified by ptr to the new size new_size.  If ptr is
        NULL, the function call is equivalent to SLmalloc(new_size).
        Similarly, if new_size is zero, the function call is equivalent
        to SLfree(ptr).

        If the function fails, or if new_size is zero, NULL is returned.
        Otherwise a pointer is returned to the (possibly moved) new
        block of memory.

      SSeeee AAllssoo
        SLfree, SLmalloc, SLcalloc

  1100..  KKeeyybbooaarrdd IInnppuutt FFuunnccttiioonnss

  1100..11..  SSLLaanngg__iinniitt__ttttyy

      SSyynnooppssiiss
        Initialize the terminal keyboard interface

      UUssaaggee
        int SLang_init_tty (int intr_ch, int no_flow_ctrl, int opost)

      DDeessccrriippttiioonn
        SLang_init_tty initializes the terminal for single character
        input. If the first parameter 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 SIGINT signal. Otherwise, if it is -1,
        the interrupt character will be left unchanged.

        If the second parameter no_flow_ctrl is non-zero, flow control
        (XON/XOFF) processing will be enabled.

        If the last parmeter opost is non-zero, output processing by the
        terminal will be enabled. If one intends to use this function in
        conjunction with the SS--LLaanngg screen management routines (SLsmg),
        this paramete shold be set to zero.

        SLang_init_tty returns zero upon success, or -1 upon error.

      NNootteess
        Terminal I/O is a complex subject. The SS--LLaanngg interface presents
        a simplification that the author has found useful in practice.
        For example, the only special character processing that
        SLang_init_tty enables is that of the SIGINT character, and the
        generation of other signals via the keyboard is disabled.
        However, generation of the job control signal SIGTSTP is
        possible via the SLtty_set_suspend_state function.

        Under Unix, the integer variable SLang_TT_Read_FD is used to
        specify the input descriptor for the terminal. If
        SLang_TT_Read_FD represents a terminal device as determined via
        the isatty system call, then it will be used as the terminal
        file descriptor. Otherwise, the terminal device /dev/tty will
        used as the input device. The default value of SLang_TT_Read_FD
        is -1 which causes /dev/tty to be used. So, if you prefer to use
        stdin for input, then set SLang_TT_Read_FD to fileno(stdin)
        _b_e_f_o_r_e calling SLang_init_tty.

        If the variable 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 SLang_TT_Baud_Rate to that
        value.

      SSeeee AAllssoo
        SLang_reset_tty, SLang_getkey, SLtty_set_suspend_state

  1100..22..  SSLLaanngg__rreesseett__ttttyy

      SSyynnooppssiiss
        Reset the terminal

      UUssaaggee
        void SLang_reset_tty (void)

      DDeessccrriippttiioonn
        SLang_reset_tty resets the terminal interface back to the state
        it was in before SLang_init_tty was called.

      SSeeee AAllssoo
        SLang_init_tty

  1100..33..  SSLLttttyy__sseett__ssuussppeenndd__ssttaattee

      SSyynnooppssiiss
        Enable or disable keyboard suspension

      UUssaaggee
        void SLtty_set_suspend_state (int s)

      DDeessccrriippttiioonn
        The SLtty_set_suspend_state function may be used to enable or
        disable keyboard generation of the SIGTSTP job control signal.
        If 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 SLang_init_tty. The SLang_init_tty always
        disables the generation of SIGTSTP via the keyboard.

      SSeeee AAllssoo
        SLang_init_tty
  1100..44..  SSLLaanngg__ggeettkkeeyy

      SSyynnooppssiiss
        Read a character from the keyboard

      UUssaaggee
        unsigned int SLang_getkey (void);

      DDeessccrriippttiioonn
        The SLang_getkey reads a single character from the terminal and
        returns it. The terminal must first be initialized via a call to
        SLang_init_tty before this function can be called. Upon success,
        SLang_getkey returns the character read from the terminal,
        otherwise it returns SLANG_GETKEY_ERROR.

      SSeeee AAllssoo
        SLang_init_tty, SLang_input_pending, SLang_ungetkey

  1100..55..  SSLLaanngg__uunnggeettkkeeyy__ssttrriinngg

      SSyynnooppssiiss
        Unget a key string

      UUssaaggee
        int SLang_ungetkey_string (unsigned char *buf, unsigned int n)

      DDeessccrriippttiioonn
        The SLang_ungetkey_string function may be used to push the n
        characters pointed to by buf onto the buffered input stream that
        SLgetkey uses. If there is not enough room for the characters,
        -1 is returned and none are buffered. Otherwise, it returns
        zero.

      NNootteess
        The difference between SLang_buffer_keystring and
        SLang_ungetkey_string is that the SLang_buffer_keystring appends
        the characters to the end of the getkey buffer, whereas
        SLang_ungetkey_string inserts the characters at the beginning of
        the input buffer.

      SSeeee AAllssoo
        SLang_ungetkey, SLang_getkey

  1100..66..  SSLLaanngg__bbuuffffeerr__kkeeyyssttrriinngg

      SSyynnooppssiiss
        Append a keystring to the input buffer

      UUssaaggee
        int SLang_buffer_keystring (unsigned char *b, unsigned int len)

      DDeessccrriippttiioonn
        SLang_buffer_keystring places the len characters specified by b
        at the _e_n_d of the buffer that SLang_getkey uses. Upon success it
        returns 0; otherwise, no characters are buffered and it returns
        -1.

      NNootteess
        The difference between SLang_buffer_keystring and
        SLang_ungetkey_string is that the SLang_buffer_keystring appends
        the characters to the end of the getkey buffer, whereas
        SLang_ungetkey_string inserts the characters at the beginning of
        the input buffer.

      SSeeee AAllssoo
        SLang_getkey, SLang_ungetkey, SLang_ungetkey_string

  1100..77..  SSLLaanngg__uunnggeettkkeeyy

      SSyynnooppssiiss
        Push a character back onto the input buffer

      UUssaaggee
        int SLang_ungetkey (unsigned char ch)

      DDeessccrriippttiioonn
        SLang_ungetkey pushes the character ch back onto the SLgetkey
        input stream. Upon success, it returns zero, otherwise it
        returns 1.

      EExxaammppllee
        This function is implemented as:

              int SLang_ungetkey (unsigned char ch)
              {
                 return SLang_ungetkey_string(&ch, 1);
              }

      SSeeee AAllssoo
        SLang_getkey, SLang_ungetkey_string

  1100..88..  SSLLaanngg__fflluusshh__iinnppuutt

      SSyynnooppssiiss
        Discard all keyboard input waiting to be read

      UUssaaggee
        void SLang_flush_input (void)

      DDeessccrriippttiioonn
        SLang_flush_input discards all input characters waiting to be
        read by the SLang_getkey function.

      SSeeee AAllssoo
        SLang_getkey

  1100..99..  SSLLaanngg__iinnppuutt__ppeennddiinngg

      SSyynnooppssiiss
        Check to see if input is pending

      UUssaaggee
        int SLang_input_pending (int tsecs)

      DDeessccrriippttiioonn
        SLang_input_pending may be used to see if an input character is
        available to be read without causing SLang_getkey to block.  It
        will wait up to tsecs tenths of a second if no characters are
        immediately available for reading. If tsecs is less than zero,
        then SLang_input_pending will wait -tsecs milliseconds for
        input, otherwise tsecs represents 1/10 of a second intervals.

      NNootteess
        Not all systems support millisecond resolution.

      SSeeee AAllssoo
        SLang_getkey

  1100..1100..  SSLLaanngg__sseett__aabboorrtt__ssiiggnnaall

      SSyynnooppssiiss
        Set the signal to trap SIGINT

      UUssaaggee
        void SLang_set_abort_signal (void (*f)(int));

      DDeessccrriippttiioonn
        SLang_set_abort_signal sets the function that gets triggered
        when the user presses the interrupt key (SIGINT) to the function
        f. If f is NULL the default handler will get installed.

      EExxaammppllee
        The default interrupt handler on a Unix system is:

               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);
             }

      NNootteess
        For Unix programmers, the name of this function may appear
        misleading since it is associated with SIGINT and not SIGABRT.
        The origin of the name stems from the original intent of the
        function: to allow the user to abort the running of a SS--LLaanngg
        interpreter function.

      SSeeee AAllssoo
        SLang_init_tty, SLsignal_intr

  1111..  KKeeyymmaapp FFuunnccttiioonnss

  1111..11..  SSLLkkmm__ddeeffiinnee__kkeeyy

      SSyynnooppssiiss
        Define a key in a keymap

      UUssaaggee
        int SLkm_define_key (char *seq, FVOID_STAR f, SLKeyMap_List_Type
        *km)

      DDeessccrriippttiioonn
        SLkm_define_key associates the key sequence seq with the
        function pointer f in the keymap specified by km. Upon success,
        it returns zero, otherwise it returns a negative integer upon
        error.

      SSeeee AAllssoo
        SLkm_define_keysym, SLang_define_key

  1111..22..  SSLLaanngg__ddeeffiinnee__kkeeyy

      SSyynnooppssiiss
        Define a key in a keymap

      UUssaaggee
        int SLang_define_key(char *seq, char *fun, SLKeyMap_List_Type
        *km)

      DDeessccrriippttiioonn
        SLang_define_key associates the key sequence seq with the
        function whose name is fun in the keymap specified by km.

      SSeeee AAllssoo
        SLkm_define_keysym, SLkm_define_key

  1111..33..  SSLLkkmm__ddeeffiinnee__kkeeyyssyymm

      SSyynnooppssiiss
        Define a keysym in a keymap

      UUssaaggee
        int SLkm_define_keysym (seq, ks, km)

                char *seq;
                unsigned int ks;
                SLKeyMap_List_Type *km;

      DDeessccrriippttiioonn
        SLkm_define_keysym associates the key sequence seq with the
        keysym ks in the keymap km. Keysyms whose value is less than or
        equal to 0x1000 is reserved by the library and should not be
        used.

      SSeeee AAllssoo
        SLkm_define_key, SLang_define_key

  1111..44..  SSLLaanngg__uunnddeeffiinnee__kkeeyy

      SSyynnooppssiiss
        Undefined a key from a keymap

      UUssaaggee
        void SLang_undefine_key(char *seq, SLKeyMap_List_Type *km);

      DDeessccrriippttiioonn
        SLang_undefine_key removes the key sequence seq from the keymap
        km.

      SSeeee AAllssoo
        SLang_define_key

  1111..55..  SSLLaanngg__ccrreeaattee__kkeeyymmaapp

      SSyynnooppssiiss
        Create a new keymap

      UUssaaggee
        SLKeyMap_List_Type *SLang_create_keymap (name, km)

               char *name;
               SLKeyMap_List_Type *km;

      DDeessccrriippttiioonn
        SLang_create_keymap creates a new keymap called name by copying
        the key definitions from the keymap km. If km is NULL, the newly
        created keymap will be empty and it is up to the calling routine
        to initialize it via the SLang_define_key and SLkm_define_keysym
        functions.  SLang_create_keymap returns a pointer to the new
        keymap, or NULL upon failure.

      SSeeee AAllssoo
        SLang_define_key, SLkm_define_keysym

  1111..66..  SSLLaanngg__ddoo__kkeeyy

      SSyynnooppssiiss
        Read a keysequence and return its keymap entry

      UUssaaggee
        SLang_Key_Type *SLang_do_key (kml, getkey)

          SLKeyMap_List_Type *kml;
          int (*getkey)(void);

      DDeessccrriippttiioonn
        The SLang_do_key function reads characters using the function
        specified by the getkey function pointer and uses the key
        sequence to return the appropriate entry in the keymap specified
        by kml.

        SLang_do_key returns NULL if the key sequence is not defined by
        the keymap, otherwise it returns a pointer to an object of type
        SLang_Key_Type, which is defined in slang.h as

               #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;

     The type field specifies which field of the union f should be used.
     If type is SLKEY_F_INTERPRET, then f.s is a string that should be
     passed to the interpreter for evaluation. If type is
     SLKEY_F_INTRINSIC, then f.f refers to function that should be
     called. Otherwise, type is SLKEY_F_KEYSYM and f.keysym represents
     the value of the keysym that is associated with the key sequence.

      SSeeee AAllssoo
        SLkm_define_keysym, SLkm_define_key

  1111..77..  SSLLaanngg__ffiinndd__kkeeyy__ffuunnccttiioonn

      SSyynnooppssiiss
        Obtain a function pointer associated with a keymap

      UUssaaggee
        FVOID_STAR SLang_find_key_function (fname, km);

              char *fname;
              SLKeyMap_List_Type *km;

      DDeessccrriippttiioonn
        The SLang_find_key_function routine searches through the
        SLKeymap_Function_Type list of functions associated with the
        keymap km for the function with name fname.  If a matching
        function is found, a pointer to the function will be returned,
        otherwise SLang_find_key_function will return NULL.

      SSeeee AAllssoo
        SLang_create_keymap, SLang_find_keymap

  1111..88..  SSLLaanngg__ffiinndd__kkeeyymmaapp

      SSyynnooppssiiss
        Find a keymap

      UUssaaggee
        SLKeyMap_List_Type *SLang_find_keymap (char *keymap_name);

      DDeessccrriippttiioonn
        The SLang_find_keymap function searches through the list of
        keymaps looking for one whose name is keymap_name. If a matching
        keymap is found, the function returns a pointer to the keymap.
        It returns NULL if no such keymap exists.

      SSeeee AAllssoo
        SLang_create_keymap, SLang_find_key_function

  1111..99..  SSLLaanngg__pprroocceessss__kkeeyyssttrriinngg

      SSyynnooppssiiss
        Un-escape a key-sequence

      UUssaaggee
        char *SLang_process_keystring (char *kseq);

      DDeessccrriippttiioonn
        The SLang_process_keystring function converts an escaped key
        sequence to its raw form by converting two-character
        combinations such as ^A to the _s_i_n_g_l_e character Ctrl-A (ASCII
        1). In addition, if the key sequence contains constructs such as
        ^(XX), where XX represents a two-character termcap specifier,
        the termcap escape sequence will be looked up and substituted.

        Upon success, 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 NULL
        upon failure.

      EExxaammppllee
        Consider the following examples:

               SLang_process_keystring ("^X^C");
               SLang_process_keystring ("^[[A");

     The first example will return a pointer to a buffer of three
     characters whose ASCII values are given by {3,24,3}. Similarly, the
     second example will return a pointer to the four characters
     {4,27,91,65}. Finally, the result of

               SLang_process_keystring ("^[^(ku)");

     will depend upon the termcap/terminfo capability "ku", which repre-
     sents the escape sequence associated with the terminal's UP arrow
     key. For an ANSI terminal whose UP arrow produces "ESC [ A", the
     result will be 5,27,27,91,65.

      NNootteess
        SLang_process_keystring returns a pointer to a static area that
        will be overwritten on subsequent calls.

      SSeeee AAllssoo
        SLang_define_key, SLang_make_keystring

  1111..1100..  SSLLaanngg__mmaakkee__kkeeyyssttrriinngg

      SSyynnooppssiiss
        Make a printable key sequence

      UUssaaggee
        char *SLang_make_keystring (unsigned char *ks);

      DDeessccrriippttiioonn
        The SLang_make_keystring function takes a raw key sequence ks
        and converts it to a printable form by converting characters
        such as ASCII 1 (ctrl-A) to ^A. That is, it performs the
        opposite function of SLang_process_keystring.

      NNootteess
        This function returns a pointer to a static area that will be
        overwritten on the next call to SLang_make_keystring.

      SSeeee AAllssoo
        SLang_process_keystring

  1122..  UUnnddooccuummeenntteedd FFuunnccttiioonnss

  The following functions are not yet documented:

  1122..11..  SSLLpprreepp__ooppeenn__pprreepp

      SSyynnooppssiiss
        ??

      UUssaaggee
        int SLprep_open_prep (SLPreprocess_Type *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..22..  SSLLpprreepp__cclloossee__pprreepp

      SSyynnooppssiiss
        ??

      UUssaaggee
        void SLprep_close_prep (SLPreprocess_Type *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..33..  SSLLpprreepp__lliinnee__ookk

      SSyynnooppssiiss
        ??

      UUssaaggee
        int SLprep_line_ok (char *, SLPreprocess_Type *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..44..  SSLLddeeffiinnee__ffoorr__iiffddeeff

      SSyynnooppssiiss
        ??

      UUssaaggee
        int SLdefine_for_ifdef (char *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..55..  SSLLaanngg__RReeaadd__LLiinnee__TTyyppee ** SSLLaanngg__rrlliinnee__ssaavvee__lliinnee
  ((SSLLaanngg__RRLLiinnee__IInnffoo__TTyyppee **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        SLang_Read_Line_Type * SLang_rline_save_line
        (SLang_RLine_Info_Type *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..66..  iinntt SSLLaanngg__iinniitt__rreeaaddlliinnee ((SSLLaanngg__RRLLiinnee__IInnffoo__TTyyppee **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        int SLang_init_readline (SLang_RLine_Info_Type *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..77..  iinntt SSLLaanngg__rreeaadd__lliinnee ((SSLLaanngg__RRLLiinnee__IInnffoo__TTyyppee **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        int SLang_read_line (SLang_RLine_Info_Type *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..88..  iinntt SSLLaanngg__rrlliinnee__iinnsseerrtt ((cchhaarr **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        int SLang_rline_insert (char *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..99..  vvooiidd SSLLrrlliinnee__rreeddrraaww ((SSLLaanngg__RRLLiinnee__IInnffoo__TTyyppee **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        void SLrline_redraw (SLang_RLine_Info_Type *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..1100..  iinntt SSLLtttt__fflluusshh__oouuttppuutt ((vvooiidd));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        int SLtt_flush_output (void);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..1111..  vvooiidd SSLLtttt__sseett__ssccrroollll__rreeggiioonn((iinntt,, iinntt));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        void SLtt_set_scroll_region(int, int);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..1122..  vvooiidd SSLLtttt__rreesseett__ssccrroollll__rreeggiioonn((vvooiidd));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        void SLtt_reset_scroll_region(void);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..1133..  vvooiidd SSLLtttt__rreevveerrssee__vviiddeeoo ((iinntt));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        void SLtt_reverse_video (int);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..1144..  vvooiidd SSLLtttt__bboolldd__vviiddeeoo ((vvooiidd));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        void SLtt_bold_video (void);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..1155..  vvooiidd SSLLtttt__bbeeggiinn__iinnsseerrtt((vvooiidd));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        void SLtt_begin_insert(void);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..1166..  vvooiidd SSLLtttt__eenndd__iinnsseerrtt((vvooiidd));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        void SLtt_end_insert(void);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..1177..  vvooiidd SSLLtttt__ddeell__eeooll((vvooiidd));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        void SLtt_del_eol(void);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..1188..  vvooiidd SSLLtttt__ggoottoo__rrcc ((iinntt,, iinntt));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        void SLtt_goto_rc (int, int);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..1199..  vvooiidd SSLLtttt__ddeelleettee__nnlliinneess((iinntt));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        void SLtt_delete_nlines(int);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..2200..  vvooiidd SSLLtttt__ddeelleettee__cchhaarr((vvooiidd));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        void SLtt_delete_char(void);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..2211..  vvooiidd SSLLtttt__eerraassee__lliinnee((vvooiidd));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        void SLtt_erase_line(void);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..2222..  vvooiidd SSLLtttt__nnoorrmmaall__vviiddeeoo((vvooiidd));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        void SLtt_normal_video(void);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..2233..  vvooiidd SSLLtttt__ccllss((vvooiidd));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        void SLtt_cls(void);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..2244..  vvooiidd SSLLtttt__bbeeeepp((vvooiidd));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        void SLtt_beep(void);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..2255..  vvooiidd SSLLtttt__rreevveerrssee__iinnddeexx((iinntt));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        void SLtt_reverse_index(int);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..2266..  vvooiidd SSLLtttt__ssmmaarrtt__ppuuttss((uunnssiiggnneedd sshhoorrtt **,, uunnssiiggnneedd sshhoorrtt **,, iinntt,,
  iinntt));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        void SLtt_smart_puts(unsigned short *, unsigned short *, int,
        int);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..2277..  vvooiidd SSLLtttt__wwrriittee__ssttrriinngg ((cchhaarr **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        void SLtt_write_string (char *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..2288..  vvooiidd SSLLtttt__ppuuttcchhaarr((cchhaarr));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        void SLtt_putchar(char);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..2299..  iinntt SSLLtttt__iinniitt__vviiddeeoo ((vvooiidd));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        int SLtt_init_video (void);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..3300..  iinntt SSLLtttt__rreesseett__vviiddeeoo ((vvooiidd));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        int SLtt_reset_video (void);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..3311..  vvooiidd SSLLtttt__ggeett__tteerrmmiinnffoo((vvooiidd));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        void SLtt_get_terminfo(void);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..3322..  vvooiidd SSLLtttt__ggeett__ssccrreeeenn__ssiizzee ((vvooiidd));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        void SLtt_get_screen_size (void);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..3333..  iinntt SSLLtttt__sseett__ccuurrssoorr__vviissiibbiilliittyy ((iinntt));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        int SLtt_set_cursor_visibility (int);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..3344..  iinntt SSLLtttt__iinniittiiaalliizzee ((cchhaarr **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        int SLtt_initialize (char *);

      DDeessccrriippttiioonn
        ??
      SSeeee AAllssoo
        ??

  1122..3355..  vvooiidd SSLLtttt__eennaabbllee__ccuurrssoorr__kkeeyyss((vvooiidd));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        void SLtt_enable_cursor_keys(void);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..3366..  vvooiidd SSLLtttt__sseett__tteerrmm__vvttxxxxxx((iinntt **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        void SLtt_set_term_vtxxx(int *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..3377..  vvooiidd SSLLtttt__sseett__ccoolloorr__eesscc ((iinntt,, cchhaarr **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        void SLtt_set_color_esc (int, char *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..3388..  vvooiidd SSLLtttt__wwiiddee__wwiiddtthh((vvooiidd));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        void SLtt_wide_width(void);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..3399..  vvooiidd SSLLtttt__nnaarrrrooww__wwiiddtthh((vvooiidd));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        void SLtt_narrow_width(void);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..4400..  iinntt SSLLtttt__sseett__mmoouussee__mmooddee ((iinntt,, iinntt));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        int SLtt_set_mouse_mode (int, int);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..4411..  vvooiidd SSLLtttt__sseett__aalltt__cchhaarr__sseett ((iinntt));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        void SLtt_set_alt_char_set (int);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..4422..  iinntt SSLLtttt__wwrriittee__ttoo__ssttaattuuss__lliinnee ((cchhaarr **,, iinntt));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        int SLtt_write_to_status_line (char *, int);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..4433..  vvooiidd SSLLtttt__ddiissaabbllee__ssttaattuuss__lliinnee ((vvooiidd));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        void SLtt_disable_status_line (void);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..4444..  cchhaarr **SSLLtttt__ttggeettssttrr ((cchhaarr **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        char *SLtt_tgetstr (char *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..4455..  iinntt SSLLtttt__ttggeettnnuumm ((cchhaarr **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        int SLtt_tgetnum (char *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..4466..  iinntt SSLLtttt__ttggeettffllaagg ((cchhaarr **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        int SLtt_tgetflag (char *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..4477..  cchhaarr **SSLLtttt__ttiiggeetteenntt ((cchhaarr **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        char *SLtt_tigetent (char *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..4488..  cchhaarr **SSLLtttt__ttiiggeettssttrr ((cchhaarr **,, cchhaarr ****));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        char *SLtt_tigetstr (char *, char **);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..4499..  iinntt SSLLtttt__ttiiggeettnnuumm ((cchhaarr **,, cchhaarr ****));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        int SLtt_tigetnum (char *, char **);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..5500..  SSLLtttt__CChhaarr__TTyyppee SSLLtttt__ggeett__ccoolloorr__oobbjjeecctt ((iinntt));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        SLtt_Char_Type SLtt_get_color_object (int);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..5511..  vvooiidd SSLLtttt__sseett__ccoolloorr__oobbjjeecctt ((iinntt,, SSLLtttt__CChhaarr__TTyyppee));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        void SLtt_set_color_object (int, SLtt_Char_Type);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..5522..  vvooiidd SSLLtttt__sseett__ccoolloorr ((iinntt,, cchhaarr **,, cchhaarr **,, cchhaarr **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        void SLtt_set_color (int, char *, char *, char *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..5533..  vvooiidd SSLLtttt__sseett__mmoonnoo ((iinntt,, cchhaarr **,, SSLLtttt__CChhaarr__TTyyppee));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        void SLtt_set_mono (int, char *, SLtt_Char_Type);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..5544..  vvooiidd SSLLtttt__aadddd__ccoolloorr__aattttrriibbuuttee ((iinntt,, SSLLtttt__CChhaarr__TTyyppee));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        void SLtt_add_color_attribute (int, SLtt_Char_Type);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..5555..  vvooiidd SSLLtttt__sseett__ccoolloorr__ffggbbgg ((iinntt,, SSLLtttt__CChhaarr__TTyyppee,,
  SSLLtttt__CChhaarr__TTyyppee));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        void SLtt_set_color_fgbg (int, SLtt_Char_Type, SLtt_Char_Type);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..5566..  iinntt SSLLkkpp__ddeeffiinnee__kkeeyyssyymm ((cchhaarr **,, uunnssiiggnneedd iinntt));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        int SLkp_define_keysym (char *, unsigned int);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..5577..  iinntt SSLLkkpp__iinniitt ((vvooiidd));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        int SLkp_init (void);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..5588..  iinntt SSLLkkpp__ggeettkkeeyy ((vvooiidd));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        int SLkp_getkey (void);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..5599..  iinntt SSLLssccrroollll__ffiinndd__ttoopp ((SSLLssccrroollll__WWiinnddooww__TTyyppee **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        int SLscroll_find_top (SLscroll_Window_Type *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..6600..  iinntt SSLLssccrroollll__ffiinndd__lliinnee__nnuumm ((SSLLssccrroollll__WWiinnddooww__TTyyppee **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        int SLscroll_find_line_num (SLscroll_Window_Type *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..6611..  uunnssiiggnneedd iinntt SSLLssccrroollll__nneexxtt__nn ((SSLLssccrroollll__WWiinnddooww__TTyyppee **,, uunnssiiggnneedd
  iinntt));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        unsigned int SLscroll_next_n (SLscroll_Window_Type *, unsigned
        int);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..6622..  uunnssiiggnneedd iinntt SSLLssccrroollll__pprreevv__nn ((SSLLssccrroollll__WWiinnddooww__TTyyppee **,, uunnssiiggnneedd
  iinntt));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        unsigned int SLscroll_prev_n (SLscroll_Window_Type *, unsigned
        int);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..6633..  iinntt SSLLssccrroollll__ppaaggeeuupp ((SSLLssccrroollll__WWiinnddooww__TTyyppee **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        int SLscroll_pageup (SLscroll_Window_Type *);
      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..6644..  iinntt SSLLssccrroollll__ppaaggeeddoowwnn ((SSLLssccrroollll__WWiinnddooww__TTyyppee **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        int SLscroll_pagedown (SLscroll_Window_Type *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..6655..  SSLLSSiigg__FFuunn__TTyyppee **SSLLssiiggnnaall ((iinntt,, SSLLSSiigg__FFuunn__TTyyppee **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        SLSig_Fun_Type *SLsignal (int, SLSig_Fun_Type *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..6666..  SSLLSSiigg__FFuunn__TTyyppee **SSLLssiiggnnaall__iinnttrr ((iinntt,, SSLLSSiigg__FFuunn__TTyyppee **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        SLSig_Fun_Type *SLsignal_intr (int, SLSig_Fun_Type *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..6677..  iinntt SSLLssiigg__bblloocckk__ssiiggnnaallss ((vvooiidd));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        int SLsig_block_signals (void);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..6688..  iinntt SSLLssiigg__uunnbblloocckk__ssiiggnnaallss ((vvooiidd));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        int SLsig_unblock_signals (void);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..6699..  iinntt SSLLssyysstteemm ((cchhaarr **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        int SLsystem (char *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..7700..  vvooiidd SSLLaadddd__aatt__hhaannddlleerr ((lloonngg **,, cchhaarr **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        void SLadd_at_handler (long *, char *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..7711..  vvooiidd SSLLaanngg__ddeeffiinnee__ccaassee((iinntt **,, iinntt **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        void SLang_define_case(int *, int *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..7722..  vvooiidd SSLLaanngg__iinniitt__ccaassee__ttaabblleess ((vvooiidd));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        void SLang_init_case_tables (void);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..7733..  uunnssiiggnneedd cchhaarr **SSLLaanngg__rreeggeexxpp__mmaattcchh((uunnssiiggnneedd cchhaarr **,, uunnssiiggnneedd
  iinntt,, SSLLRReeggeexxpp__TTyyppee **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        unsigned char *SLang_regexp_match(unsigned char *, unsigned int,
        SLRegexp_Type *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..7744..  iinntt SSLLaanngg__rreeggeexxpp__ccoommppiillee ((SSLLRReeggeexxpp__TTyyppee **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        int SLang_regexp_compile (SLRegexp_Type *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..7755..  cchhaarr **SSLLrreeggeexxpp__qquuoottee__ssttrriinngg ((cchhaarr **,, cchhaarr **,, uunnssiiggnneedd iinntt));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        char *SLregexp_quote_string (char *, char *, unsigned int);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..7766..  iinntt SSLLccmmdd__eexxeeccuuttee__ssttrriinngg ((cchhaarr **,, SSLLccmmdd__CCmmdd__TTaabbllee__TTyyppee **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        int SLcmd_execute_string (char *, SLcmd_Cmd_Table_Type *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..7777..  SSLLccoommpplleexx__aabbss

      SSyynnooppssiiss
        Returns the norm of a complex number

      UUssaaggee
        double SLcomplex_abs (double *z)}

      DDeessccrriippttiioonn
        The SLcomplex_abs function returns the absolute value or the
        norm of the complex number given by z.
      SSeeee AAllssoo
        SLcomplex_times

  1122..7788..  ddoouubbllee **SSLLccoommpplleexx__ttiimmeess ((ddoouubbllee **,, ddoouubbllee **,, ddoouubbllee **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        double *SLcomplex_times (double *, double *, double *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..7799..  ddoouubbllee **SSLLccoommpplleexx__ddiivviiddee ((ddoouubbllee **,, ddoouubbllee **,, ddoouubbllee **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        double *SLcomplex_divide (double *, double *, double *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..8800..  ddoouubbllee **SSLLccoommpplleexx__ssiinn ((ddoouubbllee **,, ddoouubbllee **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        double *SLcomplex_sin (double *, double *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..8811..  ddoouubbllee **SSLLccoommpplleexx__ccooss ((ddoouubbllee **,, ddoouubbllee **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        double *SLcomplex_cos (double *, double *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..8822..  ddoouubbllee **SSLLccoommpplleexx__ttaann ((ddoouubbllee **,, ddoouubbllee **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        double *SLcomplex_tan (double *, double *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..8833..  ddoouubbllee **SSLLccoommpplleexx__aassiinn ((ddoouubbllee **,, ddoouubbllee **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        double *SLcomplex_asin (double *, double *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..8844..  ddoouubbllee **SSLLccoommpplleexx__aaccooss ((ddoouubbllee **,, ddoouubbllee **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        double *SLcomplex_acos (double *, double *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..8855..  ddoouubbllee **SSLLccoommpplleexx__aattaann ((ddoouubbllee **,, ddoouubbllee **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        double *SLcomplex_atan (double *, double *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..8866..  ddoouubbllee **SSLLccoommpplleexx__eexxpp ((ddoouubbllee **,, ddoouubbllee **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        double *SLcomplex_exp (double *, double *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..8877..  ddoouubbllee **SSLLccoommpplleexx__lloogg ((ddoouubbllee **,, ddoouubbllee **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        double *SLcomplex_log (double *, double *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..8888..  ddoouubbllee **SSLLccoommpplleexx__lloogg1100 ((ddoouubbllee **,, ddoouubbllee **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        double *SLcomplex_log10 (double *, double *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..8899..  ddoouubbllee **SSLLccoommpplleexx__ssqqrrtt ((ddoouubbllee **,, ddoouubbllee **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        double *SLcomplex_sqrt (double *, double *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..9900..  ddoouubbllee **SSLLccoommpplleexx__ssiinnhh ((ddoouubbllee **,, ddoouubbllee **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        double *SLcomplex_sinh (double *, double *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..9911..  ddoouubbllee **SSLLccoommpplleexx__ccoosshh ((ddoouubbllee **,, ddoouubbllee **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        double *SLcomplex_cosh (double *, double *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..9922..  ddoouubbllee **SSLLccoommpplleexx__ttaannhh ((ddoouubbllee **,, ddoouubbllee **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        double *SLcomplex_tanh (double *, double *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..9933..  ddoouubbllee **SSLLccoommpplleexx__ppooww ((ddoouubbllee **,, ddoouubbllee **,, ddoouubbllee **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        double *SLcomplex_pow (double *, double *, double *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..9944..  ddoouubbllee SSLLmmaatthh__hhyyppoott ((ddoouubbllee xx,, ddoouubbllee yy));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        double SLmath_hypot (double x, double y);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  extern double *SLcomplex_asinh (double *, double *);

  1122..9955..  ddoouubbllee **SSLLccoommpplleexx__aaccoosshh ((ddoouubbllee **,, ddoouubbllee **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        double *SLcomplex_acosh (double *, double *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..9966..  ddoouubbllee **SSLLccoommpplleexx__aattaannhh ((ddoouubbllee **,, ddoouubbllee **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        double *SLcomplex_atanh (double *, double *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..9977..  cchhaarr **SSLLddeebbuugg__mmaalllloocc ((uunnssiiggnneedd lloonngg));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        char *SLdebug_malloc (unsigned long);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..9988..  cchhaarr **SSLLddeebbuugg__ccaalllloocc ((uunnssiiggnneedd lloonngg,, uunnssiiggnneedd lloonngg));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        char *SLdebug_calloc (unsigned long, unsigned long);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..9999..  cchhaarr **SSLLddeebbuugg__rreeaalllloocc ((cchhaarr **,, uunnssiiggnneedd lloonngg));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        char *SLdebug_realloc (char *, unsigned long);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..110000..  vvooiidd SSLLddeebbuugg__ffrreeee ((cchhaarr **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        void SLdebug_free (char *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..110011..  vvooiidd SSLLmmaalllloocc__dduummpp__ssttaattiissttiiccss ((vvooiidd));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        void SLmalloc_dump_statistics (void);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..110022..  cchhaarr **SSLLssttrrccppyy((rreeggiisstteerr cchhaarr **,, rreeggiisstteerr cchhaarr **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        char *SLstrcpy(register char *, register char *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..110033..  iinntt SSLLssttrrccmmpp((rreeggiisstteerr cchhaarr **,, rreeggiisstteerr cchhaarr **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        int SLstrcmp(register char *, register char *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..110044..  cchhaarr **SSLLssttrrnnccppyy((cchhaarr **,, rreeggiisstteerr cchhaarr **,, rreeggiisstteerr iinntt));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        char *SLstrncpy(char *, register char *, register int);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..110055..  vvooiidd SSLLmmeemmsseett ((cchhaarr **,, cchhaarr,, iinntt));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        void SLmemset (char *, char, int);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..110066..  vvooiidd SSLLeexxppaanndd__eessccaappeedd__ssttrriinngg ((rreeggiisstteerr cchhaarr **,, rreeggiisstteerr cchhaarr
  **,, rreeggiisstteerr cchhaarr **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        void SLexpand_escaped_string (register char *, register char *,
        register char *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..110077..  vvooiidd SSLLmmaakkee__lluutt ((uunnssiiggnneedd cchhaarr **,, uunnssiiggnneedd cchhaarr **,, uunnssiiggnneedd
  cchhaarr));;

      SSyynnooppssiiss
        ??

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

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

  1122..110088..  iinntt SSLLaanngg__gguueessss__ttyyppee ((cchhaarr **));;

      SSyynnooppssiiss
        ??

      UUssaaggee
        int SLang_guess_type (char *);

      DDeessccrriippttiioonn
        ??

      SSeeee AAllssoo
        ??

