|
Server : Apache/2.2.17 (Unix) mod_ssl/2.2.17 OpenSSL/0.9.8e-fips-rhel5 DAV/2 PHP/5.2.17 System : Linux localhost 2.6.18-419.el5 #1 SMP Fri Feb 24 22:47:42 UTC 2017 x86_64 User : nobody ( 99) PHP Version : 5.2.17 Disable Function : NONE Directory : /proc/21571/root/usr/share/doc/slang-devel-2.0.6/ |
Upload File : |
{The [1mS-Lang [22mC Library Reference}
John E. Davis, davis@space.mit.edu
Dec 21, 2005
____________________________________________________________
[1m1. Functions dealing with UTF-8 encoded strings[0m
[1m1.1. SLutf8_skip_char[0m
[1mSynopsis[0m
Skip past a UTF-8 encoded character
[1mUsage[0m
SLuchar_Type *SLutf8_skip_char (SLuchar_Type *u, SLuchar_Type
*umax)
[1mDescription[0m
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.
[1mNotes[0m
Unicode combining characters are treated as distinct characters
by this function.
[1mSee Also[0m
SLutf8_skip_chars, SLutf8_bskip_char, SLutf8_strlen
[1m1.2. SLutf8_skip_chars[0m
[1mSynopsis[0m
Skip past a specified number of characters in a UTF-8 encoded
string
[1mUsage[0m
SLuchar_Type *SLutf8_skip_chars (u, umax, num, dnum,
ignore_combining)
SLuchar_Type *u, *umax;
unsigned int num;
unsigned int *dnum;
int ignore_combining;
[1mDescription[0m
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.
[1mSee Also[0m
SLutf8_skip_char, SLutf8_bskip_chars
[1m1.3. SLutf8_bskip_char[0m
[1mSynopsis[0m
Skip backward past a UTF-8 encoded character
[1mUsage[0m
SLuchar_Type *SLutf8_bskip_char (SLuchar_Type *umin,
SLuchar_Type *u)
[1mDescription[0m
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.
[1mSee Also[0m
SLutf8_bskip_chars, SLutf8_skip_char
[1m1.4. SLutf8_bskip_chars[0m
[1mSynopsis[0m
Skip backward past a specified number of UTF-8 encoded
characters
[1mUsage[0m
SLuchar_Type *SLutf8_bskip_chars (umin, u, num, dnum,
ignore_combining)
SLuchar_Type *umin, *u;
unsigned int num;
unsigned int *dnum;
int ignore_combining;
[1mDescription[0m
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.
[1mSee Also[0m
SLutf8_skip_char, SLutf8_bskip_chars
[1m1.5. SLutf8_decode[0m
[1mSynopsis[0m
Decode a UTF-8 encoded character sequence
[1mUsage[0m
SLuchar_Type *SLutf8_decode (u, umax, w, nconsumedp
SLuchar_Type *u, *umax;
SLwchar_Type *w;
unsigned int *nconsumedp;
[1mDescription[0m
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.
[1mSee Also[0m
SLutf8_decode, SLutf8_strlen, SLutf8_skip_char
[1m1.6. SLutf8_encode[0m
[1mSynopsis[0m
UTF-8 encode a character
[1mUsage[0m
SLuchar_Type *SLutf8_encode (w, u, ulen)
SLwchar_Type w;
SLuchar_Type *u;
unsigned int ulen;
[1mDescription[0m
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.
[1mNotes[0m
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.
[1mSee Also[0m
SLutf8_decode, SLutf8_encode_bytes, SLutf8_encode_null_terminate
[1m1.7. SLutf8_strlen[0m
[1mSynopsis[0m
Determine the number of characters in a UTF-8 sequence
[1mUsage[0m
unsigned int SLutf8_strlen (SLuchar_Type *s, int
ignore_combining)
[1mDescription[0m
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.
[1mSee Also[0m
SLutf8_skip_chars, SLutf8_decode
[1m1.8. SLutf8_extract_utf8_char[0m
[1mSynopsis[0m
Extract a UTF-8 encoded character
[1mUsage[0m
SLuchar_Type *SLutf8_extract_utf8_char (u, umax, buf)
SLuchar_Type *u, *umax, *buf;
[1mDescription[0m
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.
[1mNotes[0m
One may think of this function as the single byte analogue of
if (u < umax)
{
buf[0] = *u++;
buf[1] = 0;
}
[1mSee Also[0m
SLutf8_decode, SLutf8_skip_char
[1m1.9. SLutf8_encode_null_terminate[0m
[1mSynopsis[0m
UTF-8 encode a character and null terminate the result
[1mUsage[0m
SLuchar_Type *SLutf8_encode_null_terminate (w, buf)
SLwchar_Type w;
SLuchar_Type *buf;
[1mDescription[0m
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.
[1mSee Also[0m
SLutf8_encode
[1m1.10. SLutf8_strup[0m
[1mSynopsis[0m
Uppercase a UTF-8 encoded string
[1mUsage[0m
SLuchar_Type *SLutf8_strup (SLuchar_Type *u, SLuchar_Type *umax)
[1mDescription[0m
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.
[1mSee Also[0m
SLutf8_strlow, SLwchar_toupper
[1m1.11. SLutf8_strlo[0m
[1mSynopsis[0m
Lowercase a UTF-8 encoded string
[1mUsage[0m
SLuchar_Type *SLutf8_strlo (SLuchar_Type *u, SLuchar_Type *umax)
[1mDescription[0m
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.
[1mSee Also[0m
SLutf8_strlow, SLwchar_toupper
[1m1.12. SLutf8_subst_wchar[0m
[1mSynopsis[0m
Replace a character in a UTF-8 encoded string
[1mUsage[0m
SLstr_Type *SLutf8_subst_wchar (u, umax, wch,
nth,ignore_combining)
SLuchar_Type *u, *umax;
SLwchar_Type wch;
unsigned int nth;
int ignore_combining;
[1mDescription[0m
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.
[1mSee Also[0m
SLutf8_strup, SLutf8_strlow, SLutf8_skip_chars, SLutf8_strlen
[1m1.13. SLutf8_compare[0m
[1mSynopsis[0m
Compare two UTF-8 encoded sequences
[1mUsage[0m
int SLutf8_compare (a, amax, b, bmax, nchars, case_sensitive)
SLuchar_Type *a, *amax;
SLuchar_Type *b, *bmax;
unsigned int nchars;
int case_sensitive;
[1mDescription[0m
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.
[1mNotes[0m
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.
[1mSee Also[0m
SLutf8_strup, SLutf8_strlen, SLutf8_strlen
[1m2. Character classification functions[0m
[1m2.1. SLwchar_toupper[0m
[1mSynopsis[0m
Uppercase a Unicode character
[1mUsage[0m
SLwchar_Type SLwchar_toupper (SLwchar_Type wc)
[1mDescription[0m
SLwchar_toupper returns the uppercase equivalent of the
specified character.
[1mNotes[0m
If the library is not in UTF-8 mode, then the current locale
will be used.
[1mSee Also[0m
SLwchar_tolower, SLwchar_isupper, SLutf8_strup
[1m2.2. SLwchar_tolower[0m
[1mSynopsis[0m
Lowercase a Unicode character
[1mUsage[0m
SLwchar_Type SLwchar_tolower (SLwchar_Type wc)
[1mDescription[0m
SLwchar_tolower returns the lowercase equivalent of the
specified character.
[1mNotes[0m
If the library is not in UTF-8 mode, then the current locale
will be used.
[1mSee Also[0m
SLwchar_toupper, SLwchar_islower, SLutf8_strlow
[1m2.3. SLwchar_wcwidth[0m
[1mSynopsis[0m
Determine the displayable width of a wide character
[1mUsage[0m
int SLwchar_wcwidth (SLwchar_Type wc)
[1mDescription[0m
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.
[1mNotes[0m
If the library is not in UTF-8 mode, then the current locale
will be used.
[1mSee Also[0m
SLwchar_isspace, SLwchar_iscntrl
[1m2.4. SLwchar_isalnum[0m
[1mSynopsis[0m
Determine if a Unicode character is alphanumeric
[1mUsage[0m
int SLwchar_isalnum (SLwchar_Type wc)
[1mDescription[0m
SLwchar_isalnum returns a non-zero value if the Unicode
character is alphanumeric, otherwise it returns 0.
[1mNotes[0m
If the library is not in UTF-8 mode, then the current locale
will be used.
[1mSee Also[0m
SLwchar_isalpha, SLwchar_isdigit, SLwchar_iscntrl
[1m2.5. SLwchar_isalpha[0m
[1mSynopsis[0m
Determine if a Unicode character is an alphabetic character
[1mUsage[0m
int SLwchar_isalpha (SLwchar_Type wc)
[1mDescription[0m
SLwchar_isalpha returns a non-zero value if the Unicode
character is alphabetic, otherwise it returns 0.
[1mNotes[0m
If the library is not in UTF-8 mode, then the current locale
will be used.
[1mSee Also[0m
SLwchar_isalnum, SLwchar_isalpha, SLwchar_isdigit,
SLwchar_iscntrl
[1m2.6. SLwchar_isblank[0m
[1mSynopsis[0m
Determine if a Unicode character is a blank
[1mUsage[0m
int SLwchar_isblank (SLwchar_Type wc)
[1mDescription[0m
SLwchar_isblank returns a non-zero value if the Unicode
character is a blank one (space or tab), otherwise it returns 0.
[1mNotes[0m
If the library is not in UTF-8 mode, then the current locale
will be used.
[1mSee Also[0m
SLwchar_isspace, SLwchar_isalpha, SLwchar_isdigit,
SLwchar_iscntrl
[1m2.7. SLwchar_iscntrl[0m
[1mSynopsis[0m
Determine if a Unicode character is a control character
[1mUsage[0m
int SLwchar_iscntrl (SLwchar_Type wc)
[1mDescription[0m
SLwchar_isblank returns a non-zero value if the Unicode
character is a control character, otherwise it returns 0.
[1mNotes[0m
If the library is not in UTF-8 mode, then the current locale
will be used.
[1mSee Also[0m
SLwchar_isspace, SLwchar_isalpha, SLwchar_isdigit,
SLwchar_isprint
[1m2.8. SLwchar_isdigit[0m
[1mSynopsis[0m
Determine if a Unicode character is a digit
[1mUsage[0m
int SLwchar_isdigit (SLwchar_Type wc)
[1mDescription[0m
This function returns a non-zero value if the specified Unicode
character is a digit, otherwise it returns 0.
[1mNotes[0m
If the library is not in UTF-8 mode, then the current locale
will be used.
[1mSee Also[0m
SLwchar_isspace, SLwchar_isalpha, SLwchar_isxdigit,
SLwchar_isprint
[1m2.9. SLwchar_isgraph[0m
[1mSynopsis[0m
Determine if a non-space Unicode character is printable
[1mUsage[0m
int SLwchar_isgraph (SLwchar_Type wc)
[1mDescription[0m
This function returns a non-zero value if the specified Unicode
character is a non-space printable character, otherwise it
returns 0.
[1mNotes[0m
If the library is not in UTF-8 mode, then the current locale
will be used.
[1mSee Also[0m
SLwchar_isspace, SLwchar_isalpha, SLwchar_isdigit,
SLwchar_isprint
[1m2.10. SLwchar_islower[0m
[1mSynopsis[0m
Determine if a Unicode character is alphanumeric
[1mUsage[0m
int SLwchar_islower (SLwchar_Type wc)
[1mDescription[0m
This function returns a non-zero value if the specified Unicode
character is a lowercase one, otherwise it returns 0.
[1mNotes[0m
If the library is not in UTF-8 mode, then the current locale
will be used.
[1mSee Also[0m
SLwchar_isupper, SLwchar_isspace, SLwchar_isalpha,
SLwchar_isdigit, SLwchar_iscntrl
[1m2.11. SLwchar_isprint[0m
[1mSynopsis[0m
Determine if a Unicode character is printable
[1mUsage[0m
int SLwchar_isprint (SLwchar_Type wc)
[1mDescription[0m
This function returns a non-zero value if the specified Unicode
character is a printable one (includes space), otherwise it
returns 0.
[1mNotes[0m
If the library is not in UTF-8 mode, then the current locale
will be used.
[1mSee Also[0m
SLwchar_isgraph, SLwchar_isspace, SLwchar_isalpha,
SLwchar_isdigit
[1m2.12. SLwchar_ispunct[0m
[1mSynopsis[0m
Determine if a Unicode character is a punctuation character
[1mUsage[0m
int SLwchar_ispunct (SLwchar_Type wc)
[1mDescription[0m
This function returns a non-zero value if the specified Unicode
character is a punctuation character, otherwise it returns 0.
[1mNotes[0m
If the library is not in UTF-8 mode, then the current locale
will be used.
[1mSee Also[0m
SLwchar_isspace, SLwchar_isalpha, SLwchar_isdigit,
SLwchar_isprint
[1m2.13. SLwchar_isspace[0m
[1mSynopsis[0m
Determine if a Unicode character is a whitespace character
[1mUsage[0m
int SLwchar_isspace (SLwchar_Type wc)
[1mDescription[0m
This function returns a non-zero value if the specified Unicode
character is a whitespace character, otherwise it returns 0.
[1mNotes[0m
If the library is not in UTF-8 mode, then the current locale
will be used.
[1mSee Also[0m
SLwchar_isblank, SLwchar_isalpha, SLwchar_isdigit,
SLwchar_ispunct
[1m2.14. SLwchar_isupper[0m
[1mSynopsis[0m
Determine if a Unicode character is uppercase
[1mUsage[0m
int SLwchar_isupper (SLwchar_Type wc)
[1mDescription[0m
This function returns a non-zero value if the specified Unicode
character is an uppercase character, otherwise it returns 0.
[1mNotes[0m
If the library is not in UTF-8 mode, then the current locale
will be used.
[1mSee Also[0m
SLwchar_islower, SLwchar_isspace, SLwchar_isalpha,
SLwchar_isdigit
[1m2.15. SLwchar_isxdigit[0m
[1mSynopsis[0m
Determine if a Unicode character is a hexidecimal digit
[1mUsage[0m
int SLwchar_isxdigit (SLwchar_Type wc)
[1mDescription[0m
This function returns a non-zero value if the specified Unicode
character is a hexadecimal digit character, otherwise it returns
0.
[1mNotes[0m
If the library is not in UTF-8 mode, then the current locale
will be used.
[1mSee Also[0m
SLwchar_isdigit, SLwchar_isspace, SLwchar_isalpha,
SLwchar_ispunct
[1m3. SLsearch interface Functions[0m
[1m3.1. SLsearch_new[0m
[1mSynopsis[0m
Create an SLsearch_Type object
[1mUsage[0m
SLsearch_Type *SLsearch_new (SLuchar_Type *key, int
search_flags)
[1mDescription[0m
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.
[1mSee Also[0m
SLsearch_delete, SLsearch_forward, SLsearch_backward
[1m3.2. SLsearch_delete[0m
[1mSynopsis[0m
Free the memory associated with a SLsearch_Type object
[1mUsage[0m
SLsearch_delete (SLsearch_Type *)
[1mDescription[0m
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.
[1mSee Also[0m
SLsearch_new, SLsearch_forward, SLsearch_backward
[1m3.3. SLsearch_forward[0m
[1mSynopsis[0m
Search forward in a buffer
[1mUsage[0m
SLuchar_Type SLsearch_forward (st, pmin, pmax)
SLsearch_Type *st;
SLuchar_Type *pmin, *pmax;
[1mDescription[0m
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.
[1mNotes[0m
This function uses the Boyer-Moore search algorithm when
possible.
[1mSee Also[0m
SLsearch_new, SLsearch_backward, SLsearch_delete,
SLsearch_match_len
[1m3.4. SLsearch_backward[0m
[1mSynopsis[0m
Search backward in a buffer
[1mUsage[0m
SLuchar_Type SLsearch_forward (st, pmin, pstart, pmax)
SLsearch_Type *st;
SLuchar_Type *pmin, *pstart, *pmax;
[1mDescription[0m
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.
[1mNotes[0m
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).
[1mSee Also[0m
SLsearch_new, SLsearch_forward, SLsearch_delete,
SLsearch_match_len
[1m3.5. SLsearch_match_len[0m
[1mSynopsis[0m
Get the length of the previous match
[1mUsage[0m
unsigned int SLsearch_match_len (SLsearch_Type *st)
[1mDescription[0m
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.
[1mSee Also[0m
SLsearch_forward, SLsearch_backward, SLsearch_new,
SLsearch_delete
[1m4. Screen Management (SLsmg) functions[0m
[1m4.1. SLsmg_fill_region[0m
[1mSynopsis[0m
Fill a rectangular region with a character
[1mUsage[0m
void SLsmg_fill_region (r, c, nr, nc, ch)
int r
int c
unsigned int nr
unsigned int nc
unsigned char ch
[1mDescription[0m
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).
[1mSee Also[0m
SLsmg_write_char, SLsmg_set_color
[1m4.2. SLsmg_set_char_set[0m
[1mSynopsis[0m
Turn on or off line drawing characters
[1mUsage[0m
void SLsmg_set_char_set (int a);
[1mDescription[0m
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.
[1mNotes[0m
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.
[1mSee Also[0m
SLsmg_write_char, SLtt_get_terminfo
[1m4.3. int SLsmg_Scroll_Hash_Border;[0m
[1mSynopsis[0m
Set the size of the border for the scroll hash
[1mUsage[0m
int SLsmg_Scroll_Hash_Border = 0;
[1mDescription[0m
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.
[1mSee Also[0m
SLsmg_refresh
[1m4.4. SLsmg_suspend_smg[0m
[1mSynopsis[0m
Suspend screen management
[1mUsage[0m
int SLsmg_suspend_smg (void)
[1mDescription[0m
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.
[1mSee Also[0m
SLsmg_resume_smg, SLsmg_reset_smg
[1m4.5. SLsmg_resume_smg[0m
[1mSynopsis[0m
Resume screen management
[1mUsage[0m
int SLsmg_resume_smg (void)
[1mDescription[0m
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.
[1mSee Also[0m
SLsmg_suspend_smg
[1m4.6. SLsmg_erase_eol[0m
[1mSynopsis[0m
Erase to the end of the row
[1mUsage[0m
void SLsmg_erase_eol (void);
[1mDescription[0m
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.
[1mSee Also[0m
SLsmg_gotorc, SLsmg_erase_eos, SLsmg_fill_region
[1m4.7. SLsmg_gotorc[0m
[1mSynopsis[0m
Move the virtual cursor
[1mUsage[0m
void SLsmg_gotorc (int r, int c)
[1mDescription[0m
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.
[1mSee Also[0m
SLsmg_refresh
[1m4.8. SLsmg_erase_eos[0m
[1mSynopsis[0m
Erase to the end of the screen
[1mUsage[0m
void SLsmg_erase_eos (void);
[1mDescription[0m
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.
[1mSee Also[0m
SLsmg_erase_eol
[1m4.9. SLsmg_reverse_video[0m
[1mSynopsis[0m
Set the current color to 1
[1mUsage[0m
void SLsmg_reverse_video (void);
[1mDescription[0m
This function is nothing more than SLsmg_set_color(1).
[1mSee Also[0m
SLsmg_set_color
[1m4.10. SLsmg_set_color (int)[0m
[1mSynopsis[0m
Set the current color
[1mUsage[0m
void SLsmg_set_color (int c);
[1mDescription[0m
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.
[1mExample[0m
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 ();
[1mNotes[0m
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 [4mnot[24m green on
black.
[1mSee Also[0m
SLtt_set_color, SLtt_set_color_object
[1m4.11. SLsmg_normal_video[0m
[1mSynopsis[0m
Set the current color to 0
[1mUsage[0m
void SLsmg_normal_video (void);
[1mDescription[0m
SLsmg_normal_video sets the current color descriptor to 0.
[1mSee Also[0m
SLsmg_set_color
[1m4.12. SLsmg_printf[0m
[1mSynopsis[0m
Format a string on the virtual display
[1mUsage[0m
void SLsmg_printf (char *fmt, ...)
[1mDescription[0m
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.
[1mSee Also[0m
SLsmg_write_string, SLsmg_vprintf
[1m4.13. SLsmg_vprintf[0m
[1mSynopsis[0m
Format a string on the virtual display
[1mUsage[0m
void SLsmg_vprintf (char *fmt, va_list ap)
[1mDescription[0m
SLsmg_vprintf formats a string in the manner of [4mvprintf[24m and
writes the result to the display. The virtual cursor is
advanced to the end of the string.
[1mSee Also[0m
SLsmg_write_string, SLsmg_printf
[1m4.14. SLsmg_write_string[0m
[1mSynopsis[0m
Write a character string on the display
[1mUsage[0m
void SLsmg_write_string (char *s)
[1mDescription[0m
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.
[1mSee Also[0m
SLsmg_printf, SLsmg_write_nstring
[1m4.15. SLsmg_write_nstring[0m
[1mSynopsis[0m
Write the first n characters of a string on the display
[1mUsage[0m
void SLsmg_write_nstring (char *s, unsigned int n);
[1mDescription[0m
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.
[1mSee Also[0m
SLsmg_write_string, SLsmg_write_nchars
[1m4.16. SLsmg_write_char[0m
[1mSynopsis[0m
Write a character to the virtual display
[1mUsage[0m
void SLsmg_write_char (char ch);
[1mDescription[0m
SLsmg_write_char writes the character ch to the virtual display.
[1mSee Also[0m
SLsmg_write_nchars, SLsmg_write_string
[1m4.17. SLsmg_write_nchars[0m
[1mSynopsis[0m
Write n characters to the virtual display
[1mUsage[0m
void SLsmg_write_nchars (char *s, unsigned int n);
[1mDescription[0m
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.
[1mSee Also[0m
SLsmg_write_nchars, SLsmg_write_nstring
[1m4.18. SLsmg_write_wrapped_string[0m
[1mSynopsis[0m
Write a string to the display with wrapping
[1mUsage[0m
void SLsmg_write_wrapped_string (s, r, c, nr, nc, fill)
char *s
int r, c
unsigned int nr, nc
int fill
[1mDescription[0m
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.
[1mNotes[0m
This function does not wrap on word boundaries. However, it
will wrap when a newline charater is encountered.
[1mSee Also[0m
SLsmg_write_string
[1m4.19. SLsmg_cls[0m
[1mSynopsis[0m
Clear the virtual display
[1mUsage[0m
void SLsmg_cls (void)
[1mDescription[0m
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.
[1mNotes[0m
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.
[1mSee Also[0m
SLsmg_refresh, SLsmg_erase_eos
[1m4.20. SLsmg_refresh[0m
[1mSynopsis[0m
Update physical screen
[1mUsage[0m
void SLsmg_refresh (void)
[1mDescription[0m
The SLsmg_refresh function updates the physical display to look
like the virtual display.
[1mSee Also[0m
SLsmg_suspend_smg, SLsmg_init_smg, SLsmg_reset_smg
[1m4.21. SLsmg_touch_lines[0m
[1mSynopsis[0m
Mark lines on the virtual display for redisplay
[1mUsage[0m
void SLsmg_touch_lines (int r, unsigned int nr)
[1mDescription[0m
SLsmg_touch_lines marks the nr lines on the virtual display
starting at row r for redisplay upon the next call to
SLsmg_refresh.
[1mNotes[0m
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.
[1mSee Also[0m
SLsmg_refresh
[1m4.22. SLsmg_init_smg[0m
[1mSynopsis[0m
Initialize the SLsmg routines
[1mUsage[0m
int SLsmg_init_smg (void)
[1mDescription[0m
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.
[1mSee Also[0m
SLsmg_reset_smg
[1m4.23. SLsmg_reset_smg[0m
[1mSynopsis[0m
Reset the SLsmg routines
[1mUsage[0m
int SLsmg_reset_smg (void);
[1mDescription[0m
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.
[1mSee Also[0m
SLsmg_init_smg
[1m4.24. SLsmg_char_at[0m
[1mSynopsis[0m
Get the character at the current position on the virtual display
[1mUsage[0m
unsigned short SLsmg_char_at(void)
[1mDescription[0m
The SLsmg_char_at function returns the character and its color
at the current position on the virtual display.
[1mSee Also[0m
SLsmg_read_raw, SLsmg_write_char
[1m4.25. SLsmg_set_screen_start[0m
[1mSynopsis[0m
Set the origin of the virtual display
[1mUsage[0m
void SLsmg_set_screen_start (int *r, int *c)
[1mDescription[0m
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.
[1mSee Also[0m
SLsmg_init_smg
[1m4.26. SLsmg_draw_hline[0m
[1mSynopsis[0m
Draw a horizontal line
[1mUsage[0m
void SLsmg_draw_hline (unsigned int len)
[1mDescription[0m
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.
[1mSee Also[0m
SLsmg_draw_vline
[1m4.27. SLsmg_draw_vline[0m
[1mSynopsis[0m
Draw a vertical line
[1mUsage[0m
void SLsmg_draw_vline (unsigned int len);
[1mDescription[0m
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.
[1mSee Also[0m
??
[1m4.28. SLsmg_draw_object[0m
[1mSynopsis[0m
Draw an object from the alternate character set
[1mUsage[0m
void SLsmg_draw_object (int r, int c, unsigned char obj)
[1mDescription[0m
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
[1mSee Also[0m
SLsmg_draw_vline, SLsmg_draw_hline, SLsmg_draw_box
[1m4.29. SLsmg_draw_box[0m
[1mSynopsis[0m
Draw a box on the virtual display
[1mUsage[0m
void SLsmg_draw_box (int r, int c, unsigned int dr, unsigned int
dc)
[1mDescription[0m
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.
[1mSee Also[0m
SLsmg_draw_vline, SLsmg_draw_hline, SLsmg_draw_object
[1m4.30. SLsmg_set_color_in_region[0m
[1mSynopsis[0m
Change the color of a specifed region
[1mUsage[0m
void SLsmg_set_color_in_region (color, r, c, dr, dc)
int color;
int r, c;
unsigned int dr, dc;
[1mDescription[0m
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.
[1mSee Also[0m
SLsmg_draw_box, SLsmg_set_color
[1m4.31. SLsmg_get_column[0m
[1mSynopsis[0m
Get the column of the virtual cursor
[1mUsage[0m
int SLsmg_get_column(void);
[1mDescription[0m
The SLsmg_get_column function returns the current column of the
virtual cursor on the virtual display.
[1mSee Also[0m
SLsmg_get_row, SLsmg_gotorc
[1m4.32. SLsmg_get_row[0m
[1mSynopsis[0m
Get the row of the virtual cursor
[1mUsage[0m
int SLsmg_get_row(void);
[1mDescription[0m
The SLsmg_get_row function returns the current row of the
virtual cursor on the virtual display.
[1mSee Also[0m
SLsmg_get_column, SLsmg_gotorc
[1m4.33. SLsmg_forward[0m
[1mSynopsis[0m
Move the virtual cursor forward n columns
[1mUsage[0m
void SLsmg_forward (int n);
[1mDescription[0m
The SLsmg_forward function moves the virtual cursor forward n
columns.
[1mSee Also[0m
SLsmg_gotorc
[1m4.34. SLsmg_write_color_chars[0m
[1mSynopsis[0m
Write characters with color descriptors to virtual display
[1mUsage[0m
void SLsmg_write_color_chars (unsigned short *s, unsigned int
len)
[1mDescription[0m
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.
[1mSee Also[0m
SLsmg_char_at, SLsmg_write_raw
[1m4.35. SLsmg_read_raw[0m
[1mSynopsis[0m
Read characters from the virtual display
[1mUsage[0m
unsigned int SLsmg_read_raw (unsigned short *buf, unsigned int
len)
[1mDescription[0m
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.
[1mNotes[0m
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.
[1mSee Also[0m
SLsmg_char_at, SLsmg_write_raw
[1m4.36. SLsmg_write_raw[0m
[1mSynopsis[0m
Write characters directly to the virtual display
[1mUsage[0m
unsigned int SLsmg_write_raw (unsigned short *buf, unsigned int
len)
[1mDescription[0m
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.
[1mNotes[0m
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.
[1mSee Also[0m
SLsmg_read_raw
[1m5. Functions that deal with the interpreter[0m
[1m5.1. SLallocate_load_type[0m
[1mSynopsis[0m
Allocate a SLang_Load_Type object
[1mUsage[0m
SLang_Load_Type *SLallocate_load_type (char *name)
[1mDescription[0m
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.
[1mSee Also[0m
SLdeallocate_load_type, SLang_load_object
[1m5.2. SLdeallocate_load_type[0m
[1mSynopsis[0m
Free a SLang_Load_Type object
[1mUsage[0m
void SLdeallocate_load_type (SLang_Load_Type *slt)
[1mDescription[0m
This function frees the memory associated with a SLang_Load_Type
object that was acquired from a call to the SLallocate_load_type
function.
[1mSee Also[0m
SLallocate_load_type, SLang_load_object
[1m5.3. SLang_load_object[0m
[1mSynopsis[0m
Load an object into the interpreter
[1mUsage[0m
int SLang_load_object (SLang_Load_Type *obj)
[1mDescription[0m
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.
[1mSee Also[0m
SLang_load_file, SLang_load_string, SLallocate_load_type
[1m5.4. SLclass_allocate_class[0m
[1mSynopsis[0m
Allocate a class for a new data type
[1mUsage[0m
SLang_Class_Type *SLclass_allocate_class (char *name)
[1mDescription[0m
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 [1mS-Lang [22mlibrary programmer's
guide for more information.
[1mSee Also[0m
SLclass_register_class, SLclass_set_push_function
[1m5.5. SLclass_register_class[0m
[1mSynopsis[0m
Register a new data type with the interpreter
[1mUsage[0m
int SLclass_register_class (cl, type, sizeof_type, class_type)
SLang_Class_Type *cl
SLtype type
unsigned int sizeof_type
SLclass_Type class_type
[1mDescription[0m
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
[4mmemory[24m [4mmanaged[24m [4mtype[24m. An example of this data type is the
SLANG_FILEPTR_TYPE.
[1mNotes[0m
See the [4mS-Lang[24m [4mLibrary[24m [4mC[24m [4mProgrammer's[24m [4mGuide[24m for more
information.
[1mSee Also[0m
SLclass_allocate_class, SLclass_get_class_id
[1m5.6. SLclass_set_string_function[0m
[1mSynopsis[0m
Set a data type's string representation callback
[1mUsage[0m
int SLclass_set_string_function (cl, sfun)
SLang_Class_Type *cl
char *(*sfun) (SLtype, VOID_STAR);
[1mDescription[0m
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 [4mmalloced[24m string.
Upon success, SLclass_set_string_function returns zero, or upon
error it returns -1.
[1mExample[0m
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;
}
[1mNotes[0m
The default string callback simply returns the name of the data
type.
[1mSee Also[0m
SLclass_allocate_class, SLclass_register_class
[1m5.7. SLclass_set_destroy_function[0m
[1mSynopsis[0m
Set the destroy method callback for a data type
[1mUsage[0m
int SLclass_set_destroy_function (cl, destroy_fun)
SLang_Class_Type *cl
void (*destroy_fun) (SLtype, VOID_STAR);
[1mDescription[0m
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.
[1mExample[0m
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);
}
[1mNotes[0m
Data types of class SLANG_CLASS_TYPE_SCALAR do not require a
destroy callback. However, other classes do.
[1mSee Also[0m
SLclass_allocate_class, SLclass_register_class
[1m5.8. SLclass_set_push_function[0m
[1mSynopsis[0m
Set the push callback for a new data type
[1mUsage[0m
int SLclass_set_push_function (cl, push_fun)
SLang_Class_Type *cl
int (*push_fun) (SLtype, VOID_STAR);
[1mDescription[0m
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.
[1mExample[0m
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]);
}
[1mSee Also[0m
SLclass_allocate_class, SLclass_register_class
[1m5.9. SLclass_set_pop_function[0m
[1mSynopsis[0m
Set the pop callback for a new data type
[1mUsage[0m
int SLclass_set_pop_function (cl, pop_fun)
SLang_Class_Type *cl
int (*pop_fun) (SLtype, VOID_STAR);
[1mDescription[0m
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.
[1mExample[0m
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]);
}
[1mSee Also[0m
SLclass_allocate_class, SLclass_register_class
[1m5.10. SLclass_get_datatype_name[0m
[1mSynopsis[0m
Get the name of a data type
[1mUsage[0m
char *SLclass_get_datatype_name (SLtype type)
[1mDescription[0m
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.
[1mSee Also[0m
SLclass_allocate_class, SLclass_register_class
[1m5.11. SLang_free_mmt[0m
[1mSynopsis[0m
Free a memory managed type
[1mUsage[0m
void SLang_free_mmt (SLang_MMT_Type *mmt)
[1mDescription[0m
The SLang_MMT_Type function is used to free a memory managed
data type.
[1mSee Also[0m
SLang_object_from_mmt, SLang_create_mmt
[1m5.12. SLang_object_from_mmt[0m
[1mSynopsis[0m
Get a pointer to the value of a memory managed type
[1mUsage[0m
VOID_STAR SLang_object_from_mmt (SLang_MMT_Type *mmt)
[1mDescription[0m
The SLang_object_from_mmt function returns a pointer to the
actual object whose memory is being managed by the interpreter.
[1mSee Also[0m
SLang_free_mmt, SLang_create_mmt
[1m5.13. SLang_create_mmt[0m
[1mSynopsis[0m
Create a memory managed data type
[1mUsage[0m
SLang_MMT_Type *SLang_create_mmt (SLtype t, VOID_STAR ptr)
[1mDescription[0m
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.
[1mSee Also[0m
SLang_object_from_mmt, SLang_push_mmt, SLang_free_mmt
[1m5.14. SLang_push_mmt[0m
[1mSynopsis[0m
Push a memory managed type
[1mUsage[0m
int SLang_push_mmt (SLang_MMT_Type *mmt)
[1mDescription[0m
This function is used to push a memory managed type onto the
interpreter stack. It returns zero upon success, or -1 upon
failure.
[1mSee Also[0m
SLang_create_mmt, SLang_pop_mmt
[1m5.15. SLang_pop_mmt[0m
[1mSynopsis[0m
Pop a memory managed data type
[1mUsage[0m
SLang_MMT_Type *SLang_pop_mmt (SLtype t)
[1mDescription[0m
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.
[1mSee Also[0m
SLang_object_from_mmt, SLang_push_mmt
[1m5.16. SLang_inc_mmt[0m
[1mSynopsis[0m
Increment a memory managed type reference count
[1mUsage[0m
void SLang_inc_mmt (SLang_MMT_Type *mmt);
[1mDescription[0m
The SLang_inc_mmt function may be used to increment the
reference count associated with the memory managed data type
given by mmt.
[1mSee Also[0m
SLang_free_mmt, SLang_create_mmt, SLang_pop_mmt, SLang_pop_mmt
[1m5.17. SLadd_intrin_fun_table[0m
[1mSynopsis[0m
Add a table of intrinsic functions to the interpreter
[1mUsage[0m
int SLadd_intrin_fun_table(SLang_Intrin_Fun_Type *tbl, char
*pp_name);
[1mDescription[0m
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.
[1mNotes[0m
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.
[1mSee Also[0m
SLadd_intrin_var_table, SLadd_intrinsic_function,
SLdefine_for_ifdef
[1m5.18. SLadd_intrin_var_table[0m
[1mSynopsis[0m
Add a table of intrinsic variables to the interpreter
[1mUsage[0m
int SLadd_intrin_var_table (SLang_Intrin_Var_Type *tbl, char
*pp_name);
[1mDescription[0m
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.
[1mNotes[0m
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.
[1mSee Also[0m
SLadd_intrin_var_table, SLadd_intrinsic_function,
SLdefine_for_ifdef
[1m5.19. SLang_load_file[0m
[1mSynopsis[0m
Load a file into the interpreter
[1mUsage[0m
int SLang_load_file (char *fn)
[1mDescription[0m
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.
[1mNotes[0m
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 [1mjed [22meditor uses this hook to load files via
its own routines.
[1mSee Also[0m
SLang_load_object, SLang_load_string
[1m5.20. SLang_restart[0m
[1mSynopsis[0m
Reset the interpreter after an error
[1mUsage[0m
void SLang_restart (int full)
[1mDescription[0m
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 [1mS-Lang [22mrun 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.
[1mExample[0m
while (1)
{
if (SLang_Error)
{
SLang_restart (1);
SLang_Error = 0;
}
(void) SLang_load_file (NULL);
}
[1mSee Also[0m
SLang_init_slang, SLang_load_file
[1m5.21. SLang_byte_compile_file[0m
[1mSynopsis[0m
Byte-compile a file for faster loading
[1mUsage[0m
int SLang_byte_compile_file(char *fn, int reserved)
[1mDescription[0m
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.
[1mSee Also[0m
SLang_load_file, SLang_init_slang
[1m5.22. SLang_autoload[0m
[1mSynopsis[0m
Autoload a function from a file
[1mUsage[0m
int SLang_autoload(char *funct, char *filename)
[1mDescription[0m
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 [1mS-Lang [22mfunction.
It returns 0 upon success, or -1 upon error.
[1mSee Also[0m
SLang_load_file, SLang_is_defined
[1m5.23. SLang_load_string[0m
[1mSynopsis[0m
Interpret a string
[1mUsage[0m
int SLang_load_string(char *str)
[1mDescription[0m
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.
[1mSee Also[0m
SLang_load_file, SLang_load_object
[1m5.24. SLdo_pop[0m
[1mSynopsis[0m
Delete an object from the stack
[1mUsage[0m
int SLdo_pop(void)
[1mDescription[0m
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).
[1mSee Also[0m
SLdo_pop_n, SLang_pop_integer, SLang_pop_string
[1m5.25. SLdo_pop_n[0m
[1mSynopsis[0m
Delete n objects from the stack
[1mUsage[0m
int SLdo_pop_n (unsigned int n)
[1mDescription[0m
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).
[1mSee Also[0m
SLdo_pop, SLang_pop_integer, SLang_pop_string
[1m5.26. SLang_pop_integer[0m
[1mSynopsis[0m
Pop an integer off the stack
[1mUsage[0m
int SLang_pop_integer (int *i)
[1mDescription[0m
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.
[1mSee Also[0m
SLang_push_integer, SLang_pop_double
[1m5.27. SLpop_string[0m
[1mSynopsis[0m
Pop a string from the stack
[1mUsage[0m
int SLpop_string (char **strptr);
[1mDescription[0m
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.
[1mExample[0m
define print_string (void)
{
char *s;
if (-1 == SLpop_string (&s))
return;
fputs (s, stdout);
SLfree (s);
}
[1mNotes[0m
This function should not be confused with SLang_pop_slstring,
which pops a [4mhashed[24m string from the stack.
[1mSee Also[0m
SLang_pop_slstring. SLfree
[1m5.28. SLang_pop_string[0m
[1mSynopsis[0m
Pop a string from the stack
[1mUsage[0m
int SLang_pop_string(char **strptr, int *do_free)
[1mDescription[0m
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.
[1mNotes[0m
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.
[1mSee Also[0m
SLang_pop_slstring, SLpop_string
[1m5.29. SLang_pop_slstring[0m
[1mSynopsis[0m
Pop a hashed string from the stack
[1mUsage[0m
int SLang_pop_slstring (char **s_ptr)
[1mDescription[0m
The SLang_pop_slstring function pops a hashed string from the [1mS-[0m
[1mLang [22mrun-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.
[1mExample[0m
void print_string (void)
{
char *s;
if (-1 == SLang_pop_slstring (&s))
return;
fprintf (stdout, "%s\n", s);
SLang_free_slstring (s);
}
[1mNotes[0m
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 [4mnever[24m 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.
[1mSee Also[0m
SLang_free_slstring, SLpop_string
[1m5.30. SLang_pop_double[0m
[1mSynopsis[0m
Pop a double from the stack
[1mUsage[0m
int SLang_pop_double (double *dptr)
[1mDescription[0m
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.
[1mSee Also[0m
SLang_pop_integer, SLang_push_double
[1m5.31. SLang_pop_complex[0m
[1mSynopsis[0m
Pop a complex number from the stack
[1mUsage[0m
int SLang_pop_complex (double *re, double *im)
[1mDescription[0m
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.
[1mSee Also[0m
SLang_pop_integer, SLang_pop_double, SLang_push_complex
[1m5.32. SLang_push_complex[0m
[1mSynopsis[0m
Push a complex number onto the stack
[1mUsage[0m
int SLang_push_complex (double re, double im)
[1mDescription[0m
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.
[1mSee Also[0m
SLang_pop_complex, SLang_push_double
[1m5.33. SLang_push_double[0m
[1mSynopsis[0m
Push a double onto the stack
[1mUsage[0m
int SLang_push_double(double d)
[1mDescription[0m
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.
[1mSee Also[0m
SLang_pop_double, SLang_push_integer
[1m5.34. SLang_push_string[0m
[1mSynopsis[0m
Push a string onto the stack
[1mUsage[0m
int SLang_push_string (char *s)
[1mDescription[0m
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.
[1mNotes[0m
If s is NULL, this function pushes NULL (SLANG_NULL_TYPE) onto
the stack.
[1mSee Also[0m
SLang_push_malloced_string
[1m5.35. SLang_push_integer[0m
[1mSynopsis[0m
Push an integer onto the stack
[1mUsage[0m
int SLang_push_integer (int i)
[1mDescription[0m
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.
[1mSee Also[0m
SLang_pop_integer, SLang_push_double, SLang_push_string
[1m5.36. SLang_push_malloced_string[0m
[1mSynopsis[0m
Push a malloced string onto the stack
[1mUsage[0m
int SLang_push_malloced_string (char *s);
[1mDescription[0m
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.
[1mExample[0m
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;
}
[1mExample[0m
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.
[1mNotes[0m
If s is NULL, this function pushes NULL (SLANG_NULL_TYPE) onto
the stack.
[1mSee Also[0m
SLang_push_string, SLmake_string
[1m5.37. SLang_is_defined[0m
[1mSynopsis[0m
Check to see if the interpreter defines an object
[1mUsage[0m
int SLang_is_defined (char *nm)
[1mDescription[0m
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.
Othewise it returns a non-zero value whose meaning is given by
the following table:
1 intrinsic function (SLANG_INTRINSIC)
2 user-defined slang function (SLANG_FUNCTION)
-1 intrinsic variable (SLANG_IVARIABLE)
-2 user-defined global variable (SLANG_GVARIABLE)
[1mSee Also[0m
SLadd_intrinsic_function, SLang_run_hooks,
SLang_execute_function
[1m5.38. SLang_run_hooks[0m
[1mSynopsis[0m
Run a user-defined hook with arguments
[1mUsage[0m
int SLang_run_hooks (char *fname, unsigned int n, ...)
[1mDescription[0m
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.
[1mExample[0m
The [1mjed [22meditor 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;
[1mSee Also[0m
SLang_is_defined, SLang_execute_function
[1m5.39. SLang_execute_function[0m
[1mSynopsis[0m
Execute a user or intrinsic function
[1mUsage[0m
int SLang_execute_function (char *fname)
[1mDescription[0m
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.
[1mNotes[0m
The function SLexecute_function may be a better alternative for
some uses.
[1mSee Also[0m
SLang_run_hooks, SLexecute_function, SLang_is_defined
[1m5.40. SLang_get_function[0m
[1mSynopsis[0m
Get a pointer to a [1mS-Lang [22mfunction
[1mUsage[0m
SLang_Name_Type *SLang_get_function (char *fname)
[1mDescription[0m
This function returns a pointer to the internal [1mS-Lang [22mtable
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.
[1mSee Also[0m
SLexecute_function
[1m5.41. SLexecute_function[0m
[1mSynopsis[0m
Execute a [1mS-Lang [22mor intrinsic function
[1mUsage[0m
int SLexecute_function (SLang_Name_Type *nt)
[1mDescription[0m
The SLexecute_function allows an application to call the [1mS-Lang[0m
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.
[1mExample[0m
Consider the [1mS-Lang [22mfunction:
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.
[1mSee Also[0m
SLang_get_function, SLang_start_arg_list, SLang_end_arg_list
[1m5.42. SLang_peek_at_stack[0m
[1mSynopsis[0m
Find the type of object on the top of the stack
[1mUsage[0m
int SLang_peek_at_stack (void)
[1mDescription[0m
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.
[1mSee Also[0m
SLang_pop_string, SLang_pop_integer
[1m5.43. SLang_pop_fileptr[0m
[1mSynopsis[0m
Pop a file pointer
[1mUsage[0m
int SLang_pop_fileptr (SLang_MMT_Type **mmt, FILE **fp)
[1mDescription[0m
SLang_pop_fileptr pops a file pointer from the [1mS-Lang [22mrun-time
stack. It returns zero upon success, or -1 upon failure.
A [1mS-Lang [22mfile 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.
[1mExample[0m
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 [1mS-Lang [22mfunction 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");
}
[1mSee Also[0m
SLang_free_mmt, SLang_pop_double
[1m5.44. SLadd_intrinsic_function[0m
[1mSynopsis[0m
Add a new intrinsic function to the interpreter
[1mUsage[0m
int SLadd_intrinsic_function (name, f, type, nargs, ...)
char *name
FVOID_STAR f
SLtype type
unsigned int nargs
[1mDescription[0m
The SLadd_intrinsic_function function may be used to add a new
intrinsic function. The [1mS-Lang [22mname 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.
[1mExample[0m
The [1mjed [22meditor 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, [1mjed [22mcalls
SLadd_intrinsic_function to substitute the above definition for the
default [1mS-Lang [22mdefinition:
if (-1 == SLadd_intrinsic_function ("system", (FVOID_STAR)jed_system,
SLANG_INT_TYPE, 1,
SLANG_STRING_TYPE))
return -1;
[1mSee Also[0m
SLadd_intrinsic_variable, SLadd_intrinsic_array
[1m5.45. SLadd_intrinsic_variable[0m
[1mSynopsis[0m
Add an intrinsic variable to the interpreter
[1mUsage[0m
int SLadd_intrinsic_variable (name, addr, type, rdonly)
char *name
VOID_STAR addr
SLtype type
int rdonly
[1mDescription[0m
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.
[1mExample[0m
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);
[1mNotes[0m
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 [4mnot[24m 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.
[1mSee Also[0m
SLadd_intrinsic_function, SLadd_intrinsic_array
[1m5.46. SLclass_add_unary_op[0m
[1mSynopsis[0m
??
[1mUsage[0m
int SLclass_add_unary_op (SLtype,int (*) (int, SLtype,
VOID_STAR, unsigned int, VOID_STAR), int (*) (int, SLtype,
SLtype *));
[1mDescription[0m
??
[1mSee Also[0m
??
[1m5.47. SLclass_add_app_unary_op[0m
[1mSynopsis[0m
??
[1mUsage[0m
int SLclass_add_app_unary_op (SLtype, int (*) (int,SLtype,
VOID_STAR, unsigned int,VOID_STAR),int (*) (int, SLtype, SLtype
*));
[1mDescription[0m
??
[1mSee Also[0m
??
[1m5.48. SLclass_add_binary_op[0m
[1mSynopsis[0m
??
[1mUsage[0m
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 *));
[1mDescription[0m
??
[1mSee Also[0m
??
[1m5.49. SLclass_add_math_op[0m
[1mSynopsis[0m
??
[1mUsage[0m
int SLclass_add_math_op (SLtype,int (*)(int,SLtype, VOID_STAR,
unsigned int,VOID_STAR),int (*)(int, SLtype, SLtype *));
[1mDescription[0m
??
[1mSee Also[0m
??
[1m5.50. SLclass_add_typecast[0m
[1mSynopsis[0m
??
[1mUsage[0m
int SLclass_add_typecast (SLtype, SLtype int (*)_PROTO((SLtype,
VOID_STAR, unsigned int,SLtype, VOID_STAR)),int);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m6. Library Initialization Functions[0m
[1m6.1. SLang_init_slang[0m
[1mSynopsis[0m
Initialize the interpreter
[1mUsage[0m
int SLang_init_slang (void)
[1mDescription[0m
The SLang_init_slang function must be called by all applications
that use the [1mS-Lang [22minterpreter. 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.
[1mSee Also[0m
SLang_init_slfile, SLang_init_slmath, SLang_init_slunix
[1m6.2. SLang_init_slfile[0m
[1mSynopsis[0m
Initialize the interpreter file I/O intrinsics
[1mUsage[0m
int SLang_init_slfile (void)
[1mDescription[0m
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.
[1mNotes[0m
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.
[1mSee Also[0m
SLang_init_slang, SLang_init_slunix, SLang_init_slmath
[1m6.3. SLang_init_slmath[0m
[1mSynopsis[0m
Initialize the interpreter math intrinsics
[1mUsage[0m
int SLang_init_slmath (void)
[1mDescription[0m
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.
[1mNotes[0m
This function must be called after SLang_init_slang. It adds
the preprocessor symbol __SLMATH__ to the interpreter.
[1mSee Also[0m
SLang_init_slang, SLang_init_slfile, SLang_init_slunix
[1m6.4. SLang_init_slunix[0m
[1mSynopsis[0m
Make available some unix system calls to the interpreter
[1mUsage[0m
int SLang_init_slunix (void)
[1mDescription[0m
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.
[1mNotes[0m
This function must be called after SLang_init_slang. It adds
the preprocessor symbol __SLUNIX__ to the interpreter.
[1mSee Also[0m
SLang_init_slang, SLang_init_slfile, SLang_init_slmath
[1m7. Miscellaneous Functions[0m
[1m7.1. SLcurrent_time_string[0m
[1mSynopsis[0m
Get the current time as a string
[1mUsage[0m
char *SLcurrent_time_string (void)
[1mDescription[0m
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.
[1mSee Also[0m
SLmake_string
[1m7.2. SLatoi[0m
[1mSynopsis[0m
Convert a text string to an integer
[1mUsage[0m
int SLatoi(unsigned char *str
[1mDescription[0m
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.
[1mSee Also[0m
SLang_guess_type
[1m7.3. SLextract_list_element[0m
[1mSynopsis[0m
Extract a substring of a delimited string
[1mUsage[0m
int SLextract_list_element (dlist, nth, delim, buf, buflen)
char *dlist;
unsigned int nth;
char delim;
char *buf;
unsigned int buflen;
[1mDescription[0m
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.
[1mExample[0m
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;
}
[1mSee Also[0m
SLmalloc, SLmake_string
[1m8. Error and Messaging Functions[0m
[1m8.1. SLang_verror[0m
[1mSynopsis[0m
Signal an error with a message
[1mUsage[0m
void SLang_verror (int code, char *fmt, ...);
[1mDescription[0m
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.
[1mExample[0m
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;
}
[1mSee Also[0m
SLang_vmessage, SLang_exit_error
[1m8.2. SLang_doerror[0m
[1mSynopsis[0m
Signal an error
[1mUsage[0m
void SLang_doerror (char *err_str)
[1mDescription[0m
The SLang_doerror function displays the string err_str to the
error device and signals a [1mS-Lang [22merror.
[1mNotes[0m
SLang_doerror is considered to obsolete. Applications should
use the SLang_verror function instead.
[1mSee Also[0m
SLang_verror, SLang_exit_error
[1m8.3. SLang_vmessage[0m
[1mSynopsis[0m
Display a message to the message device
[1mUsage[0m
void SLang_vmessage (char *fmt, ...)
[1mDescription[0m
This function prints a printf style formatted variable argument
list to the message device. The default message device is
stdout.
[1mSee Also[0m
SLang_verror
[1m8.4. SLang_exit_error[0m
[1mSynopsis[0m
Exit the program and display an error message
[1mUsage[0m
void SLang_exit_error (char *fmt, ...)
[1mDescription[0m
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);
[1mSee Also[0m
SLang_verror, exit
[1m9. String and Memory Allocation Functions[0m
[1m9.1. SLmake_string[0m
[1mSynopsis[0m
Duplicate a string
[1mUsage[0m
char *SLmake_string (char *s)
[1mDescription[0m
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.
[1mNotes[0m
SLmake_string should not be confused with the function
SLang_create_slstring, which performs a similar function.
[1mSee Also[0m
SLmake_nstring, SLfree, SLmalloc, SLang_create_slstring
[1m9.2. SLmake_nstring[0m
[1mSynopsis[0m
Duplicate a substring
[1mUsage[0m
char *SLmake_nstring (char *s, unsigned int n)
[1mDescription[0m
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.
[1mSee Also[0m
SLmake_string, SLfree, SLang_create_nslstring
[1m9.3. SLang_create_nslstring[0m
[1mSynopsis[0m
Created a hashed substring
[1mUsage[0m
char *SLang_create_nslstring (char *s, unsigned int n)
[1mDescription[0m
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.
[1mNotes[0m
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.
[1mSee Also[0m
SLang_free_slstring, SLang_create_slstring, SLmake_nstring
[1m9.4. SLang_create_slstring[0m
[1mSynopsis[0m
Create a hashed string
[1mUsage[0m
char *SLang_create_slstring (char *s)
[1mDescription[0m
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.
[1mNotes[0m
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.
[1mSee Also[0m
SLang_free_slstring, SLang_create_nslstring, SLmake_string
[1m9.5. SLang_free_slstring[0m
[1mSynopsis[0m
Free a hashed string
[1mUsage[0m
void SLang_free_slstring (char *s)
[1mDescription[0m
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.
[1mSee Also[0m
SLang_create_slstring, SLang_create_nslstring,
SLang_create_static_slstring
[1m9.6. SLang_concat_slstrings[0m
[1mSynopsis[0m
Concatenate two strings to produce a hashed string
[1mUsage[0m
char *SLang_concat_slstrings (char *a, char *b)
[1mDescription[0m
The SLang_concat_slstrings function concatenates two strings, a
and b, and returns the result as a hashed string. Upon failure,
NULL is returned.
[1mNotes[0m
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.
[1mSee Also[0m
SLang_free_slstring, SLang_create_slstring
[1m9.7. SLang_create_static_slstring[0m
[1mSynopsis[0m
Create a hashed string
[1mUsage[0m
char *SLang_create_static_slstring (char *s_literal)
[1mDescription[0m
The SLang_create_static_slstring creates a hashed string from
the string literal s_literal and returns the result. Upon
failure it returns NULL.
[1mExample[0m
char *create_hello (void)
{
return SLang_create_static_slstring ("hello");
}
[1mNotes[0m
This function should only be used with string literals.
[1mSee Also[0m
SLang_create_slstring, SLang_create_nslstring
[1m9.8. SLmalloc[0m
[1mSynopsis[0m
Allocate some memory
[1mUsage[0m
char *SLmalloc (unsigned int nbytes)
[1mDescription[0m
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.
[1mSee Also[0m
SLfree, SLrealloc, SLcalloc
[1m9.9. SLcalloc[0m
[1mSynopsis[0m
Allocate some memory
[1mUsage[0m
char *SLcalloc (unsigned int num_elem, unsigned int elem_size)
[1mDescription[0m
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.
[1mSee Also[0m
SLmalloc, SLrealloc, SLfree
[1m9.10. SLfree[0m
[1mSynopsis[0m
Free some allocated memory
[1mUsage[0m
void SLfree (char *ptr)
[1mDescription[0m
The SLfree function deallocates the memory specified by ptr,
which may be NULL in which case the function does nothing.
[1mNotes[0m
Never use this function to free a hashed string returned by one
of the family of slstring functions, e.g., SLang_pop_slstring.
[1mSee Also[0m
SLmalloc, SLcalloc, SLrealloc, SLmake_string
[1m9.11. SLrealloc[0m
[1mSynopsis[0m
Resize a dynamic memory block
[1mUsage[0m
char *SLrealloc (char *ptr, unsigned int new_size)
[1mDescription[0m
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.
[1mSee Also[0m
SLfree, SLmalloc, SLcalloc
[1m10. Keyboard Input Functions[0m
[1m10.1. SLang_init_tty[0m
[1mSynopsis[0m
Initialize the terminal keyboard interface
[1mUsage[0m
int SLang_init_tty (int intr_ch, int no_flow_ctrl, int opost)
[1mDescription[0m
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 [1mS-Lang [22mscreen management routines
(SLsmg), this paramete shold be set to zero.
SLang_init_tty returns zero upon success, or -1 upon error.
[1mNotes[0m
Terminal I/O is a complex subject. The [1mS-Lang [22minterface
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)
[4mbefore[24m 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.
[1mSee Also[0m
SLang_reset_tty, SLang_getkey, SLtty_set_suspend_state
[1m10.2. SLang_reset_tty[0m
[1mSynopsis[0m
Reset the terminal
[1mUsage[0m
void SLang_reset_tty (void)
[1mDescription[0m
SLang_reset_tty resets the terminal interface back to the state
it was in before SLang_init_tty was called.
[1mSee Also[0m
SLang_init_tty
[1m10.3. SLtty_set_suspend_state[0m
[1mSynopsis[0m
Enable or disable keyboard suspension
[1mUsage[0m
void SLtty_set_suspend_state (int s)
[1mDescription[0m
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.
[1mSee Also[0m
SLang_init_tty
[1m10.4. SLang_getkey[0m
[1mSynopsis[0m
Read a character from the keyboard
[1mUsage[0m
unsigned int SLang_getkey (void);
[1mDescription[0m
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.
[1mSee Also[0m
SLang_init_tty, SLang_input_pending, SLang_ungetkey
[1m10.5. SLang_ungetkey_string[0m
[1mSynopsis[0m
Unget a key string
[1mUsage[0m
int SLang_ungetkey_string (unsigned char *buf, unsigned int n)
[1mDescription[0m
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.
[1mNotes[0m
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.
[1mSee Also[0m
SLang_ungetkey, SLang_getkey
[1m10.6. SLang_buffer_keystring[0m
[1mSynopsis[0m
Append a keystring to the input buffer
[1mUsage[0m
int SLang_buffer_keystring (unsigned char *b, unsigned int len)
[1mDescription[0m
SLang_buffer_keystring places the len characters specified by b
at the [4mend[24m of the buffer that SLang_getkey uses. Upon success
it returns 0; otherwise, no characters are buffered and it
returns -1.
[1mNotes[0m
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.
[1mSee Also[0m
SLang_getkey, SLang_ungetkey, SLang_ungetkey_string
[1m10.7. SLang_ungetkey[0m
[1mSynopsis[0m
Push a character back onto the input buffer
[1mUsage[0m
int SLang_ungetkey (unsigned char ch)
[1mDescription[0m
SLang_ungetkey pushes the character ch back onto the SLgetkey
input stream. Upon success, it returns zero, otherwise it
returns 1.
[1mExample[0m
This function is implemented as:
int SLang_ungetkey (unsigned char ch)
{
return SLang_ungetkey_string(&ch, 1);
}
[1mSee Also[0m
SLang_getkey, SLang_ungetkey_string
[1m10.8. SLang_flush_input[0m
[1mSynopsis[0m
Discard all keyboard input waiting to be read
[1mUsage[0m
void SLang_flush_input (void)
[1mDescription[0m
SLang_flush_input discards all input characters waiting to be
read by the SLang_getkey function.
[1mSee Also[0m
SLang_getkey
[1m10.9. SLang_input_pending[0m
[1mSynopsis[0m
Check to see if input is pending
[1mUsage[0m
int SLang_input_pending (int tsecs)
[1mDescription[0m
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.
[1mNotes[0m
Not all systems support millisecond resolution.
[1mSee Also[0m
SLang_getkey
[1m10.10. SLang_set_abort_signal[0m
[1mSynopsis[0m
Set the signal to trap SIGINT
[1mUsage[0m
void SLang_set_abort_signal (void (*f)(int));
[1mDescription[0m
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.
[1mExample[0m
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);
}
[1mNotes[0m
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 [1mS-Lang[0m
interpreter function.
[1mSee Also[0m
SLang_init_tty, SLsignal_intr
[1m11. Keymap Functions[0m
[1m11.1. SLkm_define_key[0m
[1mSynopsis[0m
Define a key in a keymap
[1mUsage[0m
int SLkm_define_key (char *seq, FVOID_STAR f, SLKeyMap_List_Type
*km)
[1mDescription[0m
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.
[1mSee Also[0m
SLkm_define_keysym, SLang_define_key
[1m11.2. SLang_define_key[0m
[1mSynopsis[0m
Define a key in a keymap
[1mUsage[0m
int SLang_define_key(char *seq, char *fun, SLKeyMap_List_Type
*km)
[1mDescription[0m
SLang_define_key associates the key sequence seq with the
function whose name is fun in the keymap specified by km.
[1mSee Also[0m
SLkm_define_keysym, SLkm_define_key
[1m11.3. SLkm_define_keysym[0m
[1mSynopsis[0m
Define a keysym in a keymap
[1mUsage[0m
int SLkm_define_keysym (seq, ks, km)
char *seq;
unsigned int ks;
SLKeyMap_List_Type *km;
[1mDescription[0m
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.
[1mSee Also[0m
SLkm_define_key, SLang_define_key
[1m11.4. SLang_undefine_key[0m
[1mSynopsis[0m
Undefined a key from a keymap
[1mUsage[0m
void SLang_undefine_key(char *seq, SLKeyMap_List_Type *km);
[1mDescription[0m
SLang_undefine_key removes the key sequence seq from the keymap
km.
[1mSee Also[0m
SLang_define_key
[1m11.5. SLang_create_keymap[0m
[1mSynopsis[0m
Create a new keymap
[1mUsage[0m
SLKeyMap_List_Type *SLang_create_keymap (name, km)
char *name;
SLKeyMap_List_Type *km;
[1mDescription[0m
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.
[1mSee Also[0m
SLang_define_key, SLkm_define_keysym
[1m11.6. SLang_do_key[0m
[1mSynopsis[0m
Read a keysequence and return its keymap entry
[1mUsage[0m
SLang_Key_Type *SLang_do_key (kml, getkey)
SLKeyMap_List_Type *kml;
int (*getkey)(void);
[1mDescription[0m
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.
[1mSee Also[0m
SLkm_define_keysym, SLkm_define_key
[1m11.7. SLang_find_key_function[0m
[1mSynopsis[0m
Obtain a function pointer associated with a keymap
[1mUsage[0m
FVOID_STAR SLang_find_key_function (fname, km);
char *fname;
SLKeyMap_List_Type *km;
[1mDescription[0m
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.
[1mSee Also[0m
SLang_create_keymap, SLang_find_keymap
[1m11.8. SLang_find_keymap[0m
[1mSynopsis[0m
Find a keymap
[1mUsage[0m
SLKeyMap_List_Type *SLang_find_keymap (char *keymap_name);
[1mDescription[0m
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.
[1mSee Also[0m
SLang_create_keymap, SLang_find_key_function
[1m11.9. SLang_process_keystring[0m
[1mSynopsis[0m
Un-escape a key-sequence
[1mUsage[0m
char *SLang_process_keystring (char *kseq);
[1mDescription[0m
The SLang_process_keystring function converts an escaped key
sequence to its raw form by converting two-character
combinations such as ^A to the [4msingle[24m 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.
[1mExample[0m
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.
[1mNotes[0m
SLang_process_keystring returns a pointer to a static area that
will be overwritten on subsequent calls.
[1mSee Also[0m
SLang_define_key, SLang_make_keystring
[1m11.10. SLang_make_keystring[0m
[1mSynopsis[0m
Make a printable key sequence
[1mUsage[0m
char *SLang_make_keystring (unsigned char *ks);
[1mDescription[0m
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.
[1mNotes[0m
This function returns a pointer to a static area that will be
overwritten on the next call to SLang_make_keystring.
[1mSee Also[0m
SLang_process_keystring
[1m12. Undocumented Functions[0m
The following functions are not yet documented:
[1m12.1. SLprep_open_prep[0m
[1mSynopsis[0m
??
[1mUsage[0m
int SLprep_open_prep (SLPreprocess_Type *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.2. SLprep_close_prep[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLprep_close_prep (SLPreprocess_Type *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.3. SLprep_line_ok[0m
[1mSynopsis[0m
??
[1mUsage[0m
int SLprep_line_ok (char *, SLPreprocess_Type *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.4. SLdefine_for_ifdef[0m
[1mSynopsis[0m
??
[1mUsage[0m
int SLdefine_for_ifdef (char *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.5. SLang_Read_Line_Type * SLang_rline_save_line[0m
[1m(SLang_RLine_Info_Type *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
SLang_Read_Line_Type * SLang_rline_save_line
(SLang_RLine_Info_Type *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.6. int SLang_init_readline (SLang_RLine_Info_Type *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
int SLang_init_readline (SLang_RLine_Info_Type *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.7. int SLang_read_line (SLang_RLine_Info_Type *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
int SLang_read_line (SLang_RLine_Info_Type *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.8. int SLang_rline_insert (char *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
int SLang_rline_insert (char *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.9. void SLrline_redraw (SLang_RLine_Info_Type *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLrline_redraw (SLang_RLine_Info_Type *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.10. int SLtt_flush_output (void);[0m
[1mSynopsis[0m
??
[1mUsage[0m
int SLtt_flush_output (void);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.11. void SLtt_set_scroll_region(int, int);[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLtt_set_scroll_region(int, int);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.12. void SLtt_reset_scroll_region(void);[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLtt_reset_scroll_region(void);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.13. void SLtt_reverse_video (int);[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLtt_reverse_video (int);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.14. void SLtt_bold_video (void);[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLtt_bold_video (void);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.15. void SLtt_begin_insert(void);[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLtt_begin_insert(void);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.16. void SLtt_end_insert(void);[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLtt_end_insert(void);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.17. void SLtt_del_eol(void);[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLtt_del_eol(void);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.18. void SLtt_goto_rc (int, int);[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLtt_goto_rc (int, int);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.19. void SLtt_delete_nlines(int);[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLtt_delete_nlines(int);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.20. void SLtt_delete_char(void);[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLtt_delete_char(void);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.21. void SLtt_erase_line(void);[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLtt_erase_line(void);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.22. void SLtt_normal_video(void);[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLtt_normal_video(void);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.23. void SLtt_cls(void);[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLtt_cls(void);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.24. void SLtt_beep(void);[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLtt_beep(void);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.25. void SLtt_reverse_index(int);[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLtt_reverse_index(int);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.26. void SLtt_smart_puts(unsigned short *, unsigned short *, int,[0m
[1mint);[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLtt_smart_puts(unsigned short *, unsigned short *, int,
int);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.27. void SLtt_write_string (char *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLtt_write_string (char *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.28. void SLtt_putchar(char);[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLtt_putchar(char);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.29. int SLtt_init_video (void);[0m
[1mSynopsis[0m
??
[1mUsage[0m
int SLtt_init_video (void);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.30. int SLtt_reset_video (void);[0m
[1mSynopsis[0m
??
[1mUsage[0m
int SLtt_reset_video (void);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.31. void SLtt_get_terminfo(void);[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLtt_get_terminfo(void);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.32. void SLtt_get_screen_size (void);[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLtt_get_screen_size (void);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.33. int SLtt_set_cursor_visibility (int);[0m
[1mSynopsis[0m
??
[1mUsage[0m
int SLtt_set_cursor_visibility (int);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.34. int SLtt_initialize (char *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
int SLtt_initialize (char *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.35. void SLtt_enable_cursor_keys(void);[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLtt_enable_cursor_keys(void);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.36. void SLtt_set_term_vtxxx(int *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLtt_set_term_vtxxx(int *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.37. void SLtt_set_color_esc (int, char *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLtt_set_color_esc (int, char *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.38. void SLtt_wide_width(void);[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLtt_wide_width(void);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.39. void SLtt_narrow_width(void);[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLtt_narrow_width(void);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.40. int SLtt_set_mouse_mode (int, int);[0m
[1mSynopsis[0m
??
[1mUsage[0m
int SLtt_set_mouse_mode (int, int);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.41. void SLtt_set_alt_char_set (int);[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLtt_set_alt_char_set (int);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.42. int SLtt_write_to_status_line (char *, int);[0m
[1mSynopsis[0m
??
[1mUsage[0m
int SLtt_write_to_status_line (char *, int);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.43. void SLtt_disable_status_line (void);[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLtt_disable_status_line (void);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.44. char *SLtt_tgetstr (char *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
char *SLtt_tgetstr (char *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.45. int SLtt_tgetnum (char *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
int SLtt_tgetnum (char *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.46. int SLtt_tgetflag (char *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
int SLtt_tgetflag (char *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.47. char *SLtt_tigetent (char *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
char *SLtt_tigetent (char *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.48. char *SLtt_tigetstr (char *, char **);[0m
[1mSynopsis[0m
??
[1mUsage[0m
char *SLtt_tigetstr (char *, char **);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.49. int SLtt_tigetnum (char *, char **);[0m
[1mSynopsis[0m
??
[1mUsage[0m
int SLtt_tigetnum (char *, char **);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.50. SLtt_Char_Type SLtt_get_color_object (int);[0m
[1mSynopsis[0m
??
[1mUsage[0m
SLtt_Char_Type SLtt_get_color_object (int);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.51. void SLtt_set_color_object (int, SLtt_Char_Type);[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLtt_set_color_object (int, SLtt_Char_Type);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.52. void SLtt_set_color (int, char *, char *, char *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLtt_set_color (int, char *, char *, char *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.53. void SLtt_set_mono (int, char *, SLtt_Char_Type);[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLtt_set_mono (int, char *, SLtt_Char_Type);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.54. void SLtt_add_color_attribute (int, SLtt_Char_Type);[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLtt_add_color_attribute (int, SLtt_Char_Type);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.55. void SLtt_set_color_fgbg (int, SLtt_Char_Type,[0m
[1mSLtt_Char_Type);[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLtt_set_color_fgbg (int, SLtt_Char_Type, SLtt_Char_Type);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.56. int SLkp_define_keysym (char *, unsigned int);[0m
[1mSynopsis[0m
??
[1mUsage[0m
int SLkp_define_keysym (char *, unsigned int);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.57. int SLkp_init (void);[0m
[1mSynopsis[0m
??
[1mUsage[0m
int SLkp_init (void);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.58. int SLkp_getkey (void);[0m
[1mSynopsis[0m
??
[1mUsage[0m
int SLkp_getkey (void);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.59. int SLscroll_find_top (SLscroll_Window_Type *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
int SLscroll_find_top (SLscroll_Window_Type *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.60. int SLscroll_find_line_num (SLscroll_Window_Type *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
int SLscroll_find_line_num (SLscroll_Window_Type *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.61. unsigned int SLscroll_next_n (SLscroll_Window_Type *, unsigned[0m
[1mint);[0m
[1mSynopsis[0m
??
[1mUsage[0m
unsigned int SLscroll_next_n (SLscroll_Window_Type *, unsigned
int);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.62. unsigned int SLscroll_prev_n (SLscroll_Window_Type *, unsigned[0m
[1mint);[0m
[1mSynopsis[0m
??
[1mUsage[0m
unsigned int SLscroll_prev_n (SLscroll_Window_Type *, unsigned
int);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.63. int SLscroll_pageup (SLscroll_Window_Type *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
int SLscroll_pageup (SLscroll_Window_Type *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.64. int SLscroll_pagedown (SLscroll_Window_Type *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
int SLscroll_pagedown (SLscroll_Window_Type *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.65. SLSig_Fun_Type *SLsignal (int, SLSig_Fun_Type *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
SLSig_Fun_Type *SLsignal (int, SLSig_Fun_Type *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.66. SLSig_Fun_Type *SLsignal_intr (int, SLSig_Fun_Type *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
SLSig_Fun_Type *SLsignal_intr (int, SLSig_Fun_Type *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.67. int SLsig_block_signals (void);[0m
[1mSynopsis[0m
??
[1mUsage[0m
int SLsig_block_signals (void);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.68. int SLsig_unblock_signals (void);[0m
[1mSynopsis[0m
??
[1mUsage[0m
int SLsig_unblock_signals (void);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.69. int SLsystem (char *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
int SLsystem (char *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.70. void SLadd_at_handler (long *, char *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLadd_at_handler (long *, char *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.71. void SLang_define_case(int *, int *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLang_define_case(int *, int *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.72. void SLang_init_case_tables (void);[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLang_init_case_tables (void);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.73. unsigned char *SLang_regexp_match(unsigned char *, unsigned[0m
[1mint, SLRegexp_Type *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
unsigned char *SLang_regexp_match(unsigned char *, unsigned int,
SLRegexp_Type *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.74. int SLang_regexp_compile (SLRegexp_Type *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
int SLang_regexp_compile (SLRegexp_Type *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.75. char *SLregexp_quote_string (char *, char *, unsigned int);[0m
[1mSynopsis[0m
??
[1mUsage[0m
char *SLregexp_quote_string (char *, char *, unsigned int);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.76. int SLcmd_execute_string (char *, SLcmd_Cmd_Table_Type *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
int SLcmd_execute_string (char *, SLcmd_Cmd_Table_Type *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.77. SLcomplex_abs[0m
[1mSynopsis[0m
Returns the norm of a complex number
[1mUsage[0m
double SLcomplex_abs (double *z)}
[1mDescription[0m
The SLcomplex_abs function returns the absolute value or the
norm of the complex number given by z.
[1mSee Also[0m
SLcomplex_times
[1m12.78. double *SLcomplex_times (double *, double *, double *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
double *SLcomplex_times (double *, double *, double *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.79. double *SLcomplex_divide (double *, double *, double *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
double *SLcomplex_divide (double *, double *, double *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.80. double *SLcomplex_sin (double *, double *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
double *SLcomplex_sin (double *, double *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.81. double *SLcomplex_cos (double *, double *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
double *SLcomplex_cos (double *, double *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.82. double *SLcomplex_tan (double *, double *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
double *SLcomplex_tan (double *, double *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.83. double *SLcomplex_asin (double *, double *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
double *SLcomplex_asin (double *, double *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.84. double *SLcomplex_acos (double *, double *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
double *SLcomplex_acos (double *, double *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.85. double *SLcomplex_atan (double *, double *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
double *SLcomplex_atan (double *, double *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.86. double *SLcomplex_exp (double *, double *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
double *SLcomplex_exp (double *, double *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.87. double *SLcomplex_log (double *, double *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
double *SLcomplex_log (double *, double *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.88. double *SLcomplex_log10 (double *, double *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
double *SLcomplex_log10 (double *, double *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.89. double *SLcomplex_sqrt (double *, double *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
double *SLcomplex_sqrt (double *, double *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.90. double *SLcomplex_sinh (double *, double *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
double *SLcomplex_sinh (double *, double *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.91. double *SLcomplex_cosh (double *, double *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
double *SLcomplex_cosh (double *, double *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.92. double *SLcomplex_tanh (double *, double *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
double *SLcomplex_tanh (double *, double *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.93. double *SLcomplex_pow (double *, double *, double *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
double *SLcomplex_pow (double *, double *, double *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.94. double SLmath_hypot (double x, double y);[0m
[1mSynopsis[0m
??
[1mUsage[0m
double SLmath_hypot (double x, double y);
[1mDescription[0m
??
[1mSee Also[0m
??
extern double *SLcomplex_asinh (double *, double *);
[1m12.95. double *SLcomplex_acosh (double *, double *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
double *SLcomplex_acosh (double *, double *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.96. double *SLcomplex_atanh (double *, double *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
double *SLcomplex_atanh (double *, double *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.97. char *SLdebug_malloc (unsigned long);[0m
[1mSynopsis[0m
??
[1mUsage[0m
char *SLdebug_malloc (unsigned long);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.98. char *SLdebug_calloc (unsigned long, unsigned long);[0m
[1mSynopsis[0m
??
[1mUsage[0m
char *SLdebug_calloc (unsigned long, unsigned long);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.99. char *SLdebug_realloc (char *, unsigned long);[0m
[1mSynopsis[0m
??
[1mUsage[0m
char *SLdebug_realloc (char *, unsigned long);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.100. void SLdebug_free (char *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLdebug_free (char *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.101. void SLmalloc_dump_statistics (void);[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLmalloc_dump_statistics (void);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.102. char *SLstrcpy(register char *, register char *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
char *SLstrcpy(register char *, register char *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.103. int SLstrcmp(register char *, register char *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
int SLstrcmp(register char *, register char *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.104. char *SLstrncpy(char *, register char *, register int);[0m
[1mSynopsis[0m
??
[1mUsage[0m
char *SLstrncpy(char *, register char *, register int);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.105. void SLmemset (char *, char, int);[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLmemset (char *, char, int);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.106. void SLexpand_escaped_string (register char *, register char[0m
[1m*, register char *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLexpand_escaped_string (register char *, register char *,
register char *);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.107. void SLmake_lut (unsigned char *, unsigned char *, unsigned[0m
[1mchar);[0m
[1mSynopsis[0m
??
[1mUsage[0m
void SLmake_lut (unsigned char *, unsigned char *, unsigned
char);
[1mDescription[0m
??
[1mSee Also[0m
??
[1m12.108. int SLang_guess_type (char *);[0m
[1mSynopsis[0m
??
[1mUsage[0m
int SLang_guess_type (char *);
[1mDescription[0m
??
[1mSee Also[0m
??