1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
|
\variable{_NARGS}
\synopsis{The number of parameters passed to a function}
\usage{Integer_Type _NARGS}
The value of the \var{_NARGS} variable represents the number of
arguments passed to the function. This variable is local to each
function.
\example
This example uses the \var{_NARGS} variable to print the list of
values passed to the function:
#v+
define print_values ()
{
variable arg;
if (_NARGS == 0)
{
message ("Nothing to print");
return;
}
foreach (__pop_args (_NARGS))
{
arg = ();
vmessage ("Argument value is: %S", arg.value);
}
}
#v-
\seealso{__pop_args, __push_args, typeof}
\done
\function{__get_defined_symbols}
\synopsis{Get the symbols defined by the preprocessor}
\usage{Integer_Type __get_defined_symbols ()}
\description
The \var{__get_defined_symbols} functions is used to get the list of
all the symbols defined by the \slang preprocessor. It pushes each
of the symbols on the stack followed by the number of items pushed.
\seealso{is_defined, _apropos, _get_namespaces}
\done
\function{__is_initialized}
\synopsis{Determine whether or not a variable has a value}
\usage{Integer_Type __is_initialized (Ref_Type r)}
\description
This function returns non-zero of the object referenced by \var{r}
is initialized, i.e., whether it has a value. It returns \0 if the
referenced object has not been initialized.
\example
For example, the function:
#v+
define zero ()
{
variable f;
return __is_initialized (&f);
}
#v-
will always return zero, but
#v+
define one ()
{
variable f = 0;
return __is_initialized (&f);
}
#v-
will return one.
\notes
It is easy to see why a reference to the variable must be passed to
\var{__is_initialized} and not the variable itself; otherwise, the
value of the variable would be passed and the variable may have no
value if it was not initialized.
\seealso{__get_reference, __uninitialize, is_defined, typeof, eval}
\done
\function{_apropos}
\synopsis{Generate a list of functions and variables}
\usage{Array_Type _apropos (String_Type ns, String_Type s, Integer_Type flags)}
\description
The \var{_apropos} function may be used to get a list of all defined
objects in the namespace \var{ns} whose name matches the regular
expression \var{s} and whose type matches those specified by
\var{flags}. It returns an array of strings representing the
matches.
The second parameter \var{flags} is a bit mapped value whose bits
are defined according to the following table
#v+
1 Intrinsic Function
2 User-defined Function
4 Intrinsic Variable
8 User-defined Variable
#v-
\example
#v+
define apropos (s)
{
variable n, name, a;
a = _apropos ("Global", s, 0xF);
vmessage ("Found %d matches:", length (a));
foreach (a)
{
name = ();
message (name);
}
}
#v-
prints a list of all matches.
\notes
If the namespace specifier \var{ns} is the empty string \exmp{""},
then the namespace will default to the static namespace of the
current compilation unit.
\seealso{is_defined, sprintf, _get_namespaces}
\done
\function{_function_name}
\synopsis{Returns the name of the currently executing function}
\usage{String_Type _function_name ()}
\description
This function returns the name of the currently executing function.
If called from top-level, it returns the empty string.
\seealso{_trace_function, is_defined}
\done
\function{_get_namespaces}
\synopsis{Returns a list of namespace names}
\usage{String_Type[] _get_namespaces ()}
\description
This function returns a string array containing the names of the
currently defined namespaces.
\seealso{_apropos, use_namespace, implements, __get_defined_symbols}
\done
\variable{_slang_doc_dir}
\synopsis{Installed documentation directory}
\usage{String_Type _slang_doc_dir;}
\description
The \var{_slang_doc_dir} variable is a read-only whose value
specifies the installation location of the \slang documentation.
\seealso{get_doc_string_from_file}
\done
\variable{_slang_version}
\synopsis{The S-Lang library version number}
\usage{Integer_Type _slang_version}
\description
The \var{_slang_version} variable is read-only and whose
value represents the number of the \slang library.
\seealso{_slang_version_string}
\done
\variable{_slang_version_string}
\synopsis{The S-Lang library version number as a string}
\usage{String_Type _slang_version_string}
\description
The \var{_slang_version_string} variable is read-only and whose
value represents the version number of the \slang library.
\seealso{_slang_version}
\done
\function{get_doc_string_from_file}
\synopsis{Read documentation from a file}
\usage{String_Type get_doc_string_from_file (String_Type f, String_Type t)}
\description
\var{get_doc_string_from_file} opens the documentation file \var{f}
and searches it for topic \var{t}. It returns the documentation for
\var{t} upon success, otherwise it returns \var{NULL} upon error.
It will fail if \var{f} could not be opened or does not contain
documentation for the topic.
\seealso{stat_file}
\seealso{_slang_doc_dir}
\done
\function{is_defined}
\synopsis{Indicate whether a variable or function defined.}
\usage{Integer_Type is_defined (String_Type obj)}
\description
This function is used to determine whether or not a function or
variable whose name is \var{obj} has been defined. If \var{obj} is not
defined, the function returns 0. Otherwise, it returns a non-zero
value that defpends on the type of object \var{obj} represents.
Specifically, it returns one of the following values:
#v+
+1 if an intrinsic function
+2 if user defined function
-1 if intrinsic variable
-2 if user defined variable
0 if undefined
#v-
\example
For example, consider the function:
#v+
define runhooks (hook)
{
if (2 == is_defined(hook)) eval(hook);
}
#v-
This function could be called from another \slang function to
allow customization of that function, e.g., if the function
represents a mode, the hook could be called to setup keybindings
for the mode.
\seealso{typeof, eval, autoload, __get_reference, __is_initialized}
\done
|
