Commit | Line | Data |
---|---|---|
12eec8a8 MV |
1 | This file gathers entries that have been automatically generated from |
2 | docstrings in libguile. They are not included in the manual, however, | |
8fc71812 MV |
3 | for various reasons, mostly because they have been deprecated. They |
4 | are here in this file to give docstring.el a chance to update them | |
5 | automatically. | |
12eec8a8 | 6 | |
12eec8a8 MV |
7 | - GOOPS is documented in its own manual. |
8 | ||
8fc71812 MV |
9 | |
10 | ||
11 | @deffn {Scheme Procedure} substring-move-right! | |
12 | implemented by the C function "scm_substring_move_x" | |
13 | @end deffn | |
14 | ||
15 | @deffn {Scheme Procedure} substring-move-left! | |
16 | implemented by the C function "scm_substring_move_x" | |
17 | @end deffn | |
18 | ||
19 | @deffn {Scheme Procedure} gentemp [prefix [obarray]] | |
20 | @deffnx {C Function} scm_gentemp (prefix, obarray) | |
21 | Create a new symbol with a name unique in an obarray. | |
22 | The name is constructed from an optional string @var{prefix} | |
23 | and a counter value. The default prefix is @code{t}. The | |
24 | @var{obarray} is specified as a second optional argument. | |
25 | Default is the system obarray where all normal symbols are | |
26 | interned. The counter is increased by 1 at each | |
27 | call. There is no provision for resetting the counter. | |
28 | @end deffn | |
29 | ||
30 | @deffn {Scheme Procedure} symbol-set! o s v | |
31 | @deffnx {C Function} scm_symbol_set_x (o, s, v) | |
32 | Find the symbol in @var{obarray} whose name is @var{string}, and rebind | |
33 | it to @var{value}. An error is signalled if @var{string} is not present | |
34 | in @var{obarray}. | |
35 | @end deffn | |
36 | ||
37 | @deffn {Scheme Procedure} symbol-bound? o s | |
38 | @deffnx {C Function} scm_symbol_bound_p (o, s) | |
39 | Return @code{#t} if @var{obarray} contains a symbol with name | |
40 | @var{string} bound to a defined value. This differs from | |
41 | @var{symbol-interned?} in that the mere mention of a symbol | |
42 | usually causes it to be interned; @code{symbol-bound?} | |
43 | determines whether a symbol has been given any meaningful | |
44 | value. | |
45 | @end deffn | |
46 | ||
47 | @deffn {Scheme Procedure} symbol-binding o s | |
48 | @deffnx {C Function} scm_symbol_binding (o, s) | |
49 | Look up in @var{obarray} the symbol whose name is @var{string}, and | |
50 | return the value to which it is bound. If @var{obarray} is @code{#f}, | |
51 | use the global symbol table. If @var{string} is not interned in | |
52 | @var{obarray}, an error is signalled. | |
53 | @end deffn | |
54 | ||
55 | @deffn {Scheme Procedure} unintern-symbol o s | |
56 | @deffnx {C Function} scm_unintern_symbol (o, s) | |
57 | Remove the symbol with name @var{string} from @var{obarray}. This | |
58 | function returns @code{#t} if the symbol was present and @code{#f} | |
59 | otherwise. | |
60 | @end deffn | |
61 | ||
62 | @deffn {Scheme Procedure} intern-symbol o s | |
63 | @deffnx {C Function} scm_intern_symbol (o, s) | |
64 | Add a new symbol to @var{obarray} with name @var{string}, bound to an | |
65 | unspecified initial value. The symbol table is not modified if a symbol | |
66 | with this name is already present. | |
67 | @end deffn | |
68 | ||
69 | @deffn {Scheme Procedure} string->obarray-symbol o s [softp] | |
70 | @deffnx {C Function} scm_string_to_obarray_symbol (o, s, softp) | |
71 | Intern a new symbol in @var{obarray}, a symbol table, with name | |
72 | @var{string}. | |
73 | ||
74 | If @var{obarray} is @code{#f}, use the default system symbol table. If | |
75 | @var{obarray} is @code{#t}, the symbol should not be interned in any | |
76 | symbol table; merely return the pair (@var{symbol} | |
77 | . @var{#<undefined>}). | |
78 | ||
79 | The @var{soft?} argument determines whether new symbol table entries | |
80 | should be created when the specified symbol is not already present in | |
81 | @var{obarray}. If @var{soft?} is specified and is a true value, then | |
82 | new entries should not be added for symbols not already present in the | |
83 | table; instead, simply return @code{#f}. | |
84 | @end deffn | |
85 | ||
86 | @deffn {Scheme Procedure} read-and-eval! [port] | |
87 | @deffnx {C Function} scm_read_and_eval_x (port) | |
88 | Read a form from @var{port} (standard input by default), and evaluate it | |
89 | (memoizing it in the process) in the top-level environment. If no data | |
90 | is left to be read from @var{port}, an @code{end-of-file} error is | |
91 | signalled. | |
92 | @end deffn | |
93 | ||
94 | @deffn {Scheme Procedure} sloppy-member x lst | |
95 | @deffnx {C Function} scm_sloppy_member (x, lst) | |
96 | This procedure behaves like @code{member}, but does no type or error checking. | |
97 | Its use is recommended only in writing Guile internals, | |
98 | not for high-level Scheme programs. | |
99 | @end deffn | |
100 | ||
101 | @deffn {Scheme Procedure} sloppy-memv x lst | |
102 | @deffnx {C Function} scm_sloppy_memv (x, lst) | |
103 | This procedure behaves like @code{memv}, but does no type or error checking. | |
104 | Its use is recommended only in writing Guile internals, | |
105 | not for high-level Scheme programs. | |
106 | @end deffn | |
107 | ||
108 | @deffn {Scheme Procedure} sloppy-memq x lst | |
109 | @deffnx {C Function} scm_sloppy_memq (x, lst) | |
110 | This procedure behaves like @code{memq}, but does no type or error checking. | |
111 | Its use is recommended only in writing Guile internals, | |
112 | not for high-level Scheme programs. | |
113 | @end deffn | |
114 | ||
115 | @deffn {Scheme Procedure} builtin-variable name | |
116 | @deffnx {C Function} scm_builtin_variable (name) | |
117 | Do not use this function. | |
118 | @end deffn | |
119 | ||
120 | @deffn {Scheme Procedure} variable-set-name-hint! var hint | |
121 | @deffnx {C Function} scm_variable_set_name_hint (var, hint) | |
122 | Do not use this function. | |
123 | @end deffn | |
124 | ||
125 | @deffn {Scheme Procedure} close-all-ports-except . ports | |
126 | @deffnx {C Function} scm_close_all_ports_except (ports) | |
127 | [DEPRECATED] Close all open file ports used by the interpreter | |
128 | except for those supplied as arguments. This procedure | |
129 | was intended to be used before an exec call to close file descriptors | |
130 | which are not needed in the new process. However it has the | |
131 | undesirable side effect of flushing buffers, so it's deprecated. | |
132 | Use port-for-each instead. | |
133 | @end deffn | |
134 | ||
135 | @deffn {Scheme Procedure} c-clear-registered-modules | |
136 | @deffnx {C Function} scm_clear_registered_modules () | |
137 | Destroy the list of modules registered with the current Guile process. | |
138 | The return value is unspecified. @strong{Warning:} this function does | |
139 | not actually unlink or deallocate these modules, but only destroys the | |
140 | records of which modules have been loaded. It should therefore be used | |
141 | only by module bookkeeping operations. | |
142 | @end deffn | |
143 | ||
144 | @deffn {Scheme Procedure} c-registered-modules | |
145 | @deffnx {C Function} scm_registered_modules () | |
146 | Return a list of the object code modules that have been imported into | |
147 | the current Guile process. Each element of the list is a pair whose | |
148 | car is the name of the module, and whose cdr is the function handle | |
149 | for that module's initializer function. The name is the string that | |
150 | has been passed to scm_register_module_xxx. | |
151 | @end deffn | |
152 | ||
12eec8a8 MV |
153 | @deffn {Scheme Procedure} module-import-interface module sym |
154 | @deffnx {C Function} scm_module_import_interface (module, sym) | |
3323ec06 | 155 | Return the module or interface from which @var{sym} is imported in @var{module}. If @var{sym} is not imported (i.e., it is not defined in @var{module} or it is a module-local binding instead of an imported one), then @code{#f} is returned. |
12eec8a8 MV |
156 | @end deffn |
157 | ||
158 | ||
159 | @deffn {Scheme Procedure} self-evaluating? obj | |
160 | @deffnx {C Function} scm_self_evaluating_p (obj) | |
161 | Return #t for objects which Guile considers self-evaluating | |
162 | @end deffn | |
163 | ||
164 | @deffn {Scheme Procedure} unmemoize-expr m | |
165 | @deffnx {C Function} scm_i_unmemoize_expr (m) | |
166 | Unmemoize the memoized expression @var{m}, | |
167 | @end deffn | |
168 | ||
169 | @deffn {Scheme Procedure} weak-key-alist-vector? obj | |
170 | @deffnx {Scheme Procedure} weak-value-alist-vector? obj | |
171 | @deffnx {Scheme Procedure} doubly-weak-alist-vector? obj | |
172 | @deffnx {C Function} scm_weak_key_alist_vector_p (obj) | |
173 | Return @code{#t} if @var{obj} is the specified weak hash | |
174 | table. Note that a doubly weak hash table is neither a weak key | |
175 | nor a weak value hash table. | |
176 | @end deffn | |
177 | ||
178 | @deffn {Scheme Procedure} make-weak-key-alist-vector [size] | |
179 | @deffnx {Scheme Procedure} make-weak-value-alist-vector size | |
180 | @deffnx {Scheme Procedure} make-doubly-weak-alist-vector size | |
181 | @deffnx {C Function} scm_make_weak_key_alist_vector (size) | |
182 | Return a weak hash table with @var{size} buckets. As with any | |
183 | hash table, choosing a good size for the table requires some | |
184 | caution. | |
185 | ||
186 | You can modify weak hash tables in exactly the same way you | |
187 | would modify regular hash tables. (@pxref{Hash Tables}) | |
188 | @end deffn | |
189 | ||
190 | @deffn {Scheme Procedure} include-deprecated-features | |
a4b4fbbd JE |
191 | Return @code{#t} if deprecated features should be included in public |
192 | interfaces, or @code{#f} otherwise. | |
12eec8a8 MV |
193 | @end deffn |
194 | ||
195 | @deffn {Scheme Procedure} issue-deprecation-warning . msgs | |
196 | Output @var{msgs} to @code{(current-error-port)} when this | |
197 | is the first call to @code{issue-deprecation-warning} with | |
198 | this specific @var{msg}. Do nothing otherwise. | |
199 | The argument @var{msgs} should be a list of strings; | |
200 | they are printed in turn, each one followed by a newline. | |
201 | @end deffn | |
202 | ||
203 | @deffn {Scheme Procedure} valid-object-procedure? proc | |
204 | @deffnx {C Function} scm_valid_object_procedure_p (proc) | |
a4b4fbbd | 205 | Return @code{#t} ff @var{proc} is a procedure that can be used with @code{set-object-procedure}. It is always valid to use a closure constructed by @code{lambda}. |
12eec8a8 MV |
206 | @end deffn |
207 | ||
208 | @deffn {Scheme Procedure} %get-pre-modules-obarray | |
209 | @deffnx {C Function} scm_get_pre_modules_obarray () | |
210 | Return the obarray that is used for all new bindings before the module system is booted. The first call to @code{set-current-module} will boot the module system. | |
211 | @end deffn | |
212 | ||
213 | @deffn {Scheme Procedure} standard-interface-eval-closure module | |
214 | @deffnx {C Function} scm_standard_interface_eval_closure (module) | |
215 | Return a interface eval closure for the module @var{module}. Such a closure does not allow new bindings to be added. | |
216 | @end deffn | |
217 | ||
218 | @deffn {Scheme Procedure} env-module env | |
219 | @deffnx {C Function} scm_env_module (env) | |
220 | Return the module of @var{ENV}, a lexical environment. | |
221 | @end deffn | |
222 | ||
223 | @deffn {Scheme Procedure} single-active-thread? | |
224 | implemented by the C function "scm_single_thread_p" | |
225 | @end deffn | |
226 | ||
227 | @deffn {Scheme Procedure} set-debug-cell-accesses! flag | |
228 | @deffnx {C Function} scm_set_debug_cell_accesses_x (flag) | |
229 | This function is used to turn on checking for a debug version of GUILE. This version does not support this functionality | |
230 | ||
231 | @end deffn | |
232 | ||
233 | @deffn {Scheme Procedure} standard-eval-closure module | |
234 | @deffnx {C Function} scm_standard_eval_closure (module) | |
235 | Return an eval closure for the module @var{module}. | |
236 | @end deffn | |
237 | ||
238 | @deffn {Scheme Procedure} mask-signals | |
239 | @deffnx {C Function} scm_mask_signals () | |
240 | Mask signals. The returned value is not specified. | |
241 | @end deffn | |
242 | ||
243 | @deffn {Scheme Procedure} unmask-signals | |
244 | @deffnx {C Function} scm_unmask_signals () | |
245 | Unmask signals. The returned value is not specified. | |
246 | @end deffn | |
247 | ||
248 | @deffn {Scheme Procedure} noop . args | |
249 | @deffnx {C Function} scm_noop (args) | |
250 | Do nothing. When called without arguments, return @code{#f}, | |
251 | otherwise return the first argument. | |
252 | @end deffn | |
253 | ||
254 | @deffn {Scheme Procedure} system-async thunk | |
255 | @deffnx {C Function} scm_system_async (thunk) | |
256 | This function is deprecated. You can use @var{thunk} directly | |
877f06c3 | 257 | instead of explicitly creating an async object. |
12eec8a8 MV |
258 | |
259 | @end deffn | |
260 | ||
261 | @deffn {Scheme Procedure} object-address obj | |
262 | @deffnx {C Function} scm_object_address (obj) | |
263 | Return an integer that for the lifetime of @var{obj} is uniquely | |
264 | returned by this function for @var{obj} | |
265 | @end deffn | |
266 | ||
12eec8a8 MV |
267 | @deffn {Scheme Procedure} %compute-slots class |
268 | @deffnx {C Function} scm_sys_compute_slots (class) | |
269 | Return a list consisting of the names of all slots belonging to | |
679cceed | 270 | class @var{class}, i.e.@: the slots of @var{class} and of all of |
12eec8a8 MV |
271 | its superclasses. |
272 | @end deffn | |
273 | ||
274 | @deffn {Scheme Procedure} get-keyword key l default_value | |
275 | @deffnx {C Function} scm_get_keyword (key, l, default_value) | |
276 | Determine an associated value for the keyword @var{key} from | |
277 | the list @var{l}. The list @var{l} has to consist of an even | |
278 | number of elements, where, starting with the first, every | |
279 | second element is a keyword, followed by its associated value. | |
280 | If @var{l} does not hold a value for @var{key}, the value | |
281 | @var{default_value} is returned. | |
282 | @end deffn | |
283 | ||
284 | @deffn {Scheme Procedure} slot-ref-using-class class obj slot_name | |
285 | @deffnx {C Function} scm_slot_ref_using_class (class, obj, slot_name) | |
286 | ||
287 | @end deffn | |
288 | ||
289 | @deffn {Scheme Procedure} slot-set-using-class! class obj slot_name value | |
290 | @deffnx {C Function} scm_slot_set_using_class_x (class, obj, slot_name, value) | |
291 | ||
292 | @end deffn | |
293 | ||
294 | @deffn {Scheme Procedure} class-of x | |
295 | @deffnx {C Function} scm_class_of (x) | |
296 | Return the class of @var{x}. | |
297 | @end deffn | |
298 | ||
299 | @deffn {Scheme Procedure} %goops-loaded | |
300 | @deffnx {C Function} scm_sys_goops_loaded () | |
301 | Announce that GOOPS is loaded and perform initialization | |
302 | on the C level which depends on the loaded GOOPS modules. | |
303 | @end deffn | |
304 | ||
305 | @deffn {Scheme Procedure} %method-more-specific? m1 m2 targs | |
306 | @deffnx {C Function} scm_sys_method_more_specific_p (m1, m2, targs) | |
3323ec06 | 307 | Return true if method @var{m1} is more specific than @var{m2} given the argument types (classes) listed in @var{targs}. |
12eec8a8 MV |
308 | @end deffn |
309 | ||
310 | @deffn {Scheme Procedure} find-method . l | |
311 | @deffnx {C Function} scm_find_method (l) | |
312 | ||
313 | @end deffn | |
314 | ||
315 | @deffn {Scheme Procedure} primitive-generic-generic subr | |
316 | @deffnx {C Function} scm_primitive_generic_generic (subr) | |
317 | ||
318 | @end deffn | |
319 | ||
320 | @deffn {Scheme Procedure} enable-primitive-generic! . subrs | |
321 | @deffnx {C Function} scm_enable_primitive_generic_x (subrs) | |
322 | ||
323 | @end deffn | |
324 | ||
325 | @deffn {Scheme Procedure} generic-capability? proc | |
326 | @deffnx {C Function} scm_generic_capability_p (proc) | |
327 | ||
328 | @end deffn | |
329 | ||
330 | @deffn {Scheme Procedure} %invalidate-method-cache! gf | |
331 | @deffnx {C Function} scm_sys_invalidate_method_cache_x (gf) | |
332 | ||
333 | @end deffn | |
334 | ||
335 | @deffn {Scheme Procedure} %invalidate-class class | |
336 | @deffnx {C Function} scm_sys_invalidate_class (class) | |
337 | ||
338 | @end deffn | |
339 | ||
340 | @deffn {Scheme Procedure} %modify-class old new | |
341 | @deffnx {C Function} scm_sys_modify_class (old, new) | |
342 | ||
343 | @end deffn | |
344 | ||
345 | @deffn {Scheme Procedure} %modify-instance old new | |
346 | @deffnx {C Function} scm_sys_modify_instance (old, new) | |
347 | ||
348 | @end deffn | |
349 | ||
350 | @deffn {Scheme Procedure} %set-object-setter! obj setter | |
351 | @deffnx {C Function} scm_sys_set_object_setter_x (obj, setter) | |
352 | ||
353 | @end deffn | |
354 | ||
355 | @deffn {Scheme Procedure} %allocate-instance class initargs | |
356 | @deffnx {C Function} scm_sys_allocate_instance (class, initargs) | |
357 | Create a new instance of class @var{class} and initialize it | |
358 | from the arguments @var{initargs}. | |
359 | @end deffn | |
360 | ||
361 | @deffn {Scheme Procedure} slot-exists? obj slot_name | |
362 | @deffnx {C Function} scm_slot_exists_p (obj, slot_name) | |
363 | Return @code{#t} if @var{obj} has a slot named @var{slot_name}. | |
364 | @end deffn | |
365 | ||
366 | @deffn {Scheme Procedure} slot-bound? obj slot_name | |
367 | @deffnx {C Function} scm_slot_bound_p (obj, slot_name) | |
368 | Return @code{#t} if the slot named @var{slot_name} of @var{obj} | |
369 | is bound. | |
370 | @end deffn | |
371 | ||
372 | @deffn {Scheme Procedure} slot-set! obj slot_name value | |
373 | @deffnx {C Function} scm_slot_set_x (obj, slot_name, value) | |
374 | Set the slot named @var{slot_name} of @var{obj} to @var{value}. | |
375 | @end deffn | |
376 | ||
377 | @deffn {Scheme Procedure} slot-exists-using-class? class obj slot_name | |
378 | @deffnx {C Function} scm_slot_exists_using_class_p (class, obj, slot_name) | |
379 | ||
380 | @end deffn | |
381 | ||
382 | @deffn {Scheme Procedure} slot-bound-using-class? class obj slot_name | |
383 | @deffnx {C Function} scm_slot_bound_using_class_p (class, obj, slot_name) | |
384 | ||
385 | @end deffn | |
386 | ||
387 | @deffn {Scheme Procedure} %fast-slot-set! obj index value | |
388 | @deffnx {C Function} scm_sys_fast_slot_set_x (obj, index, value) | |
389 | Set the slot with index @var{index} in @var{obj} to | |
390 | @var{value}. | |
391 | @end deffn | |
392 | ||
393 | @deffn {Scheme Procedure} %fast-slot-ref obj index | |
394 | @deffnx {C Function} scm_sys_fast_slot_ref (obj, index) | |
395 | Return the slot value with index @var{index} from @var{obj}. | |
396 | @end deffn | |
397 | ||
398 | @deffn {Scheme Procedure} @@assert-bound-ref obj index | |
399 | @deffnx {C Function} scm_at_assert_bound_ref (obj, index) | |
400 | Like @code{assert-bound}, but use @var{index} for accessing | |
401 | the value from @var{obj}. | |
402 | @end deffn | |
403 | ||
404 | @deffn {Scheme Procedure} assert-bound value obj | |
405 | @deffnx {C Function} scm_assert_bound (value, obj) | |
406 | Return @var{value} if it is bound, and invoke the | |
407 | @var{slot-unbound} method of @var{obj} if it is not. | |
408 | @end deffn | |
409 | ||
410 | @deffn {Scheme Procedure} unbound? obj | |
411 | @deffnx {C Function} scm_unbound_p (obj) | |
412 | Return @code{#t} if @var{obj} is unbound. | |
413 | @end deffn | |
414 | ||
415 | @deffn {Scheme Procedure} make-unbound | |
416 | @deffnx {C Function} scm_make_unbound () | |
417 | Return the unbound value. | |
418 | @end deffn | |
419 | ||
420 | @deffn {Scheme Procedure} accessor-method-slot-definition obj | |
421 | @deffnx {C Function} scm_accessor_method_slot_definition (obj) | |
422 | Return the slot definition of the accessor @var{obj}. | |
423 | @end deffn | |
424 | ||
425 | @deffn {Scheme Procedure} method-procedure obj | |
426 | @deffnx {C Function} scm_method_procedure (obj) | |
427 | Return the procedure of the method @var{obj}. | |
428 | @end deffn | |
429 | ||
430 | @deffn {Scheme Procedure} method-specializers obj | |
431 | @deffnx {C Function} scm_method_specializers (obj) | |
432 | Return specializers of the method @var{obj}. | |
433 | @end deffn | |
434 | ||
435 | @deffn {Scheme Procedure} method-generic-function obj | |
436 | @deffnx {C Function} scm_method_generic_function (obj) | |
437 | Return the generic function for the method @var{obj}. | |
438 | @end deffn | |
439 | ||
440 | @deffn {Scheme Procedure} generic-function-methods obj | |
441 | @deffnx {C Function} scm_generic_function_methods (obj) | |
442 | Return the methods of the generic function @var{obj}. | |
443 | @end deffn | |
444 | ||
445 | @deffn {Scheme Procedure} generic-function-name obj | |
446 | @deffnx {C Function} scm_generic_function_name (obj) | |
447 | Return the name of the generic function @var{obj}. | |
448 | @end deffn | |
449 | ||
450 | @deffn {Scheme Procedure} class-environment obj | |
451 | @deffnx {C Function} scm_class_environment (obj) | |
452 | Return the environment of the class @var{obj}. | |
453 | @end deffn | |
454 | ||
455 | @deffn {Scheme Procedure} class-slots obj | |
456 | @deffnx {C Function} scm_class_slots (obj) | |
457 | Return the slot list of the class @var{obj}. | |
458 | @end deffn | |
459 | ||
460 | @deffn {Scheme Procedure} class-precedence-list obj | |
461 | @deffnx {C Function} scm_class_precedence_list (obj) | |
462 | Return the class precedence list of the class @var{obj}. | |
463 | @end deffn | |
464 | ||
465 | @deffn {Scheme Procedure} class-direct-methods obj | |
466 | @deffnx {C Function} scm_class_direct_methods (obj) | |
467 | Return the direct methods of the class @var{obj} | |
468 | @end deffn | |
469 | ||
470 | @deffn {Scheme Procedure} class-direct-subclasses obj | |
471 | @deffnx {C Function} scm_class_direct_subclasses (obj) | |
472 | Return the direct subclasses of the class @var{obj}. | |
473 | @end deffn | |
474 | ||
475 | @deffn {Scheme Procedure} class-direct-slots obj | |
476 | @deffnx {C Function} scm_class_direct_slots (obj) | |
477 | Return the direct slots of the class @var{obj}. | |
478 | @end deffn | |
479 | ||
480 | @deffn {Scheme Procedure} class-direct-supers obj | |
481 | @deffnx {C Function} scm_class_direct_supers (obj) | |
482 | Return the direct superclasses of the class @var{obj}. | |
483 | @end deffn | |
484 | ||
485 | @deffn {Scheme Procedure} class-name obj | |
486 | @deffnx {C Function} scm_class_name (obj) | |
487 | Return the class name of @var{obj}. | |
488 | @end deffn | |
489 | ||
490 | @deffn {Scheme Procedure} instance? obj | |
491 | @deffnx {C Function} scm_instance_p (obj) | |
492 | Return @code{#t} if @var{obj} is an instance. | |
493 | @end deffn | |
494 | ||
495 | @deffn {Scheme Procedure} %inherit-magic! class dsupers | |
496 | @deffnx {C Function} scm_sys_inherit_magic_x (class, dsupers) | |
497 | ||
498 | @end deffn | |
499 | ||
500 | @deffn {Scheme Procedure} %prep-layout! class | |
501 | @deffnx {C Function} scm_sys_prep_layout_x (class) | |
502 | ||
503 | @end deffn | |
504 | ||
505 | @deffn {Scheme Procedure} %initialize-object obj initargs | |
506 | @deffnx {C Function} scm_sys_initialize_object (obj, initargs) | |
507 | Initialize the object @var{obj} with the given arguments | |
508 | @var{initargs}. | |
509 | @end deffn | |
510 | ||
511 | @deffn {Scheme Procedure} make . args | |
512 | @deffnx {C Function} scm_make (args) | |
513 | Make a new object. @var{args} must contain the class and | |
514 | all necessary initialization information. | |
515 | @end deffn | |
516 | ||
517 | @deffn {Scheme Procedure} slot-ref obj slot_name | |
518 | @deffnx {C Function} scm_slot_ref (obj, slot_name) | |
519 | Return the value from @var{obj}'s slot with the name | |
520 | @var{slot_name}. | |
521 | @end deffn | |
522 | ||
523 | @deffn {Scheme Procedure} %tag-body body | |
524 | @deffnx {C Function} scm_sys_tag_body (body) | |
525 | Internal GOOPS magic---don't use this function! | |
526 | @end deffn | |
7719ef22 MV |
527 | |
528 | @deffn {Scheme Procedure} make-keyword-from-dash-symbol symbol | |
529 | @deffnx {C Function} scm_make_keyword_from_dash_symbol (symbol) | |
530 | Make a keyword object from a @var{symbol} that starts with a dash. | |
531 | @end deffn | |
532 | ||
533 | @deffn {Scheme Procedure} keyword-dash-symbol keyword | |
534 | @deffnx {C Function} scm_keyword_dash_symbol (keyword) | |
535 | Return the dash symbol for @var{keyword}. | |
536 | This is the inverse of @code{make-keyword-from-dash-symbol}. | |
537 | @end deffn | |
538 | ||
673ba2da MV |
539 | @deffn {Scheme Procedure} dimensions->uniform-array dims prot [fill] |
540 | @deffnx {Scheme Procedure} make-uniform-vector length prototype [fill] | |
541 | @deffnx {C Function} scm_dimensions_to_uniform_array (dims, prot, fill) | |
542 | Create and return a uniform array or vector of type | |
543 | corresponding to @var{prototype} with dimensions @var{dims} or | |
544 | length @var{length}. If @var{fill} is supplied, it's used to | |
545 | fill the array, otherwise @var{prototype} is used. | |
546 | @end deffn | |
547 | ||
548 | @deffn {Scheme Procedure} list->uniform-array ndim prot lst | |
549 | @deffnx {C Function} scm_list_to_uniform_array (ndim, prot, lst) | |
550 | Return a uniform array of the type indicated by prototype | |
551 | @var{prot} with elements the same as those of @var{lst}. | |
552 | Elements must be of the appropriate type, no coercions are | |
553 | done. | |
554 | ||
555 | The argument @var{ndim} determines the number of dimensions | |
556 | of the array. It is either an exact integer, giving the | |
557 | number directly, or a list of exact integers, whose length | |
558 | specifies the number of dimensions and each element is the | |
559 | lower index bound of its dimension. | |
560 | @end deffn | |
561 | ||
562 | @deffn {Scheme Procedure} array-prototype ra | |
563 | @deffnx {C Function} scm_array_prototype (ra) | |
564 | Return an object that would produce an array of the same type | |
565 | as @var{array}, if used as the @var{prototype} for | |
566 | @code{make-uniform-array}. | |
567 | @end deffn | |
568 | ||
569 | @deffn {Scheme Procedure} call-with-dynamic-root thunk handler | |
570 | @deffnx {C Function} scm_call_with_dynamic_root (thunk, handler) | |
ecb87335 | 571 | Call @var{thunk} with a new dynamic state and within a continuation barrier. The @var{handler} catches all otherwise uncaught throws and executes within the same dynamic context as @var{thunk}. |
673ba2da MV |
572 | @end deffn |
573 | ||
574 | @deffn {Scheme Procedure} dynamic-root | |
575 | @deffnx {C Function} scm_dynamic_root () | |
576 | Return an object representing the current dynamic root. | |
577 | ||
578 | These objects are only useful for comparison using @code{eq?}. | |
579 | ||
580 | @end deffn | |
581 | ||
582 | @deffn {Scheme Procedure} uniform-vector? obj | |
583 | @deffnx {C Function} scm_uniform_vector_p (obj) | |
584 | Return @code{#t} if @var{obj} is a uniform vector. | |
585 | @end deffn | |
586 | ||
587 | @deffn {Scheme Procedure} uniform-vector-ref v idx | |
588 | @deffnx {C Function} scm_uniform_vector_ref (v, idx) | |
589 | Return the element at index @var{idx} of the | |
ecb87335 | 590 | homogeneous numeric vector @var{v}. |
673ba2da MV |
591 | @end deffn |
592 | ||
593 | @deffn {Scheme Procedure} uniform-vector-set! v idx val | |
594 | @deffnx {C Function} scm_uniform_vector_set_x (v, idx, val) | |
595 | Set the element at index @var{idx} of the | |
ecb87335 | 596 | homogeneous numeric vector @var{v} to @var{val}. |
673ba2da MV |
597 | @end deffn |
598 | ||
599 | @deffn {Scheme Procedure} uniform-vector->list uvec | |
600 | @deffnx {C Function} scm_uniform_vector_to_list (uvec) | |
601 | Convert the uniform numeric vector @var{uvec} to a list. | |
602 | @end deffn | |
603 | ||
604 | @deffn {Scheme Procedure} uniform-vector-length v | |
605 | @deffnx {C Function} scm_uniform_vector_length (v) | |
606 | Return the number of elements in the uniform vector @var{v}. | |
607 | @end deffn | |
608 | ||
609 | @deffn {Scheme Procedure} make-u8vector len [fill] | |
610 | @deffnx {C Function} scm_make_u8vector (len, fill) | |
611 | Return a newly allocated uniform numeric vector which can | |
612 | hold @var{len} elements. If @var{fill} is given, it is used to | |
613 | initialize the elements, otherwise the contents of the vector | |
614 | is unspecified. | |
615 | @end deffn | |
616 | ||
617 | @deffn {Scheme Procedure} u8vector . l | |
618 | @deffnx {C Function} scm_u8vector (l) | |
619 | Return a newly allocated uniform numeric vector containing | |
620 | all argument values. | |
621 | @end deffn | |
622 | ||
623 | @deffn {Scheme Procedure} list->u8vector l | |
624 | @deffnx {C Function} scm_list_to_u8vector (l) | |
625 | Convert the list @var{l} to a numeric uniform vector. | |
626 | @end deffn | |
627 | ||
628 | @deffn {Scheme Procedure} any->u8vector obj | |
629 | @deffnx {C Function} scm_any_to_u8vector (obj) | |
630 | Convert @var{obj}, which can be a list, vector, or | |
631 | uniform vector, to a numeric uniform vector of | |
632 | type u8. | |
633 | @end deffn | |
634 | ||
635 | @deffn {Scheme Procedure} string-any-c-code char_pred s [start [end]] | |
636 | @deffnx {C Function} scm_string_any (char_pred, s, start, end) | |
637 | Check if the predicate @var{pred} is true for any character in | |
638 | the string @var{s}. | |
639 | ||
640 | Calls to @var{pred} are made from left to right across @var{s}. | |
641 | When it returns true (ie.@: non-@code{#f}), that return value | |
642 | is the return from @code{string-any}. | |
643 | ||
644 | The SRFI-13 specification requires that the call to @var{pred} | |
645 | on the last character of @var{s} (assuming that point is | |
646 | reached) be a tail call, but currently in Guile this is not the | |
647 | case. | |
648 | @end deffn | |
649 | ||
650 | @deffn {Scheme Procedure} string-every-c-code char_pred s [start [end]] | |
651 | @deffnx {C Function} scm_string_every (char_pred, s, start, end) | |
652 | Check if the predicate @var{pred} is true for every character | |
653 | in the string @var{s}. | |
654 | ||
655 | Calls to @var{pred} are made from left to right across @var{s}. | |
656 | If the predicate is true for every character then the return | |
657 | value from the last @var{pred} call is the return from | |
658 | @code{string-every}. | |
659 | ||
660 | If there are no characters in @var{s} (ie.@: @var{start} equals | |
661 | @var{end}) then the return is @code{#t}. | |
662 | ||
663 | The SRFI-13 specification requires that the call to @var{pred} | |
664 | on the last character of @var{s} (assuming that point is | |
665 | reached) be a tail call, but currently in Guile this is not the | |
666 | case. | |
667 | @end deffn | |
668 | ||
669 | @deffn {Scheme Procedure} inf? x | |
670 | @deffnx {C Function} scm_inf_p (x) | |
671 | Return @code{#t} if @var{x} is either @samp{+inf.0} | |
672 | or @samp{-inf.0}, @code{#f} otherwise. | |
673 | @end deffn | |
674 | ||
675 |