/[guile]/guile/guile-core/doc/maint/guile.texi
ViewVC logotype

Diff of /guile/guile-core/doc/maint/guile.texi

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.7.4.1 by ossau, Wed Nov 14 00:02:58 2001 UTC revision 1.7.4.2 by ossau, Fri Mar 15 09:23:17 2002 UTC
# Line 1  Line 1 
 @paragraphindent 0  
1    
2   acons   acons
3  @deffn primitive acons key value alist  @deffn {Scheme Procedure} acons key value alist
4  Adds a new key-value pair to @var{alist}.  A new pair is  @deffnx {C Function} scm_acons (key, value, alist)
5    Add a new key-value pair to @var{alist}.  A new pair is
6  created whose car is @var{key} and whose cdr is @var{value}, and the  created whose car is @var{key} and whose cdr is @var{value}, and the
7  pair is consed onto @var{alist}, and the new list is returned.  This  pair is consed onto @var{alist}, and the new list is returned.  This
8  function is @emph{not} destructive; @var{alist} is not modified.  function is @emph{not} destructive; @var{alist} is not modified.
9  @end deffn  @end deffn
10    
11   sloppy-assq   sloppy-assq
12  @deffn primitive sloppy-assq key alist  @deffn {Scheme Procedure} sloppy-assq key alist
13    @deffnx {C Function} scm_sloppy_assq (key, alist)
14  Behaves like @code{assq} but does not do any error checking.  Behaves like @code{assq} but does not do any error checking.
15  Recommended only for use in Guile internals.  Recommended only for use in Guile internals.
16  @end deffn  @end deffn
17    
18   sloppy-assv   sloppy-assv
19  @deffn primitive sloppy-assv key alist  @deffn {Scheme Procedure} sloppy-assv key alist
20    @deffnx {C Function} scm_sloppy_assv (key, alist)
21  Behaves like @code{assv} but does not do any error checking.  Behaves like @code{assv} but does not do any error checking.
22  Recommended only for use in Guile internals.  Recommended only for use in Guile internals.
23  @end deffn  @end deffn
24    
25   sloppy-assoc   sloppy-assoc
26  @deffn primitive sloppy-assoc key alist  @deffn {Scheme Procedure} sloppy-assoc key alist
27    @deffnx {C Function} scm_sloppy_assoc (key, alist)
28  Behaves like @code{assoc} but does not do any error checking.  Behaves like @code{assoc} but does not do any error checking.
29  Recommended only for use in Guile internals.  Recommended only for use in Guile internals.
30  @end deffn  @end deffn
31    
32   assq   assq
33  @deffn primitive assq key alist  @deffn {Scheme Procedure} assq key alist
34  @deffnx primitive assv key alist  @deffnx {Scheme Procedure} assv key alist
35  @deffnx primitive assoc key alist  @deffnx {Scheme Procedure} assoc key alist
36  Fetches the entry in @var{alist} that is associated with @var{key}.  To  @deffnx {C Function} scm_assq (key, alist)
37    Fetch the entry in @var{alist} that is associated with @var{key}.  To
38  decide whether the argument @var{key} matches a particular entry in  decide whether the argument @var{key} matches a particular entry in
39  @var{alist}, @code{assq} compares keys with @code{eq?}, @code{assv}  @var{alist}, @code{assq} compares keys with @code{eq?}, @code{assv}
40  uses @code{eqv?} and @code{assoc} uses @code{equal?}.  If @var{key}  uses @code{eqv?} and @code{assoc} uses @code{equal?}.  If @var{key}
41  cannot be found in @var{alist} (according to whichever equality  cannot be found in @var{alist} (according to whichever equality
42  predicate is in use), then @code{#f} is returned.  These functions  predicate is in use), then return @code{#f}.  These functions
43  return the entire alist entry found (i.e. both the key and the value).  return the entire alist entry found (i.e. both the key and the value).
44  @end deffn  @end deffn
45    
46   assv   assv
47  @deffn primitive assv key alist  @deffn {Scheme Procedure} assv key alist
48    @deffnx {C Function} scm_assv (key, alist)
49  Behaves like @code{assq} but uses @code{eqv?} for key comparison.  Behaves like @code{assq} but uses @code{eqv?} for key comparison.
50  @end deffn  @end deffn
51    
52   assoc   assoc
53  @deffn primitive assoc key alist  @deffn {Scheme Procedure} assoc key alist
54    @deffnx {C Function} scm_assoc (key, alist)
55  Behaves like @code{assq} but uses @code{equal?} for key comparison.  Behaves like @code{assq} but uses @code{equal?} for key comparison.
56  @end deffn  @end deffn
57    
58   assq-ref   assq-ref
59  @deffn primitive assq-ref alist key  @deffn {Scheme Procedure} assq-ref alist key
60  @deffnx primitive assv-ref alist key  @deffnx {Scheme Procedure} assv-ref alist key
61  @deffnx primitive assoc-ref alist key  @deffnx {Scheme Procedure} assoc-ref alist key
62    @deffnx {C Function} scm_assq_ref (alist, key)
63  Like @code{assq}, @code{assv} and @code{assoc}, except that only the  Like @code{assq}, @code{assv} and @code{assoc}, except that only the
64  value associated with @var{key} in @var{alist} is returned.  These  value associated with @var{key} in @var{alist} is returned.  These
65  functions are equivalent to  functions are equivalent to
# Line 66  where @var{associator} is one of @code{a Line 73  where @var{associator} is one of @code{a
73  @end deffn  @end deffn
74    
75   assv-ref   assv-ref
76  @deffn primitive assv-ref alist key  @deffn {Scheme Procedure} assv-ref alist key
77    @deffnx {C Function} scm_assv_ref (alist, key)
78  Behaves like @code{assq-ref} but uses @code{eqv?} for key comparison.  Behaves like @code{assq-ref} but uses @code{eqv?} for key comparison.
79  @end deffn  @end deffn
80    
81   assoc-ref   assoc-ref
82  @deffn primitive assoc-ref alist key  @deffn {Scheme Procedure} assoc-ref alist key
83    @deffnx {C Function} scm_assoc_ref (alist, key)
84  Behaves like @code{assq-ref} but uses @code{equal?} for key comparison.  Behaves like @code{assq-ref} but uses @code{equal?} for key comparison.
85  @end deffn  @end deffn
86    
87   assq-set!   assq-set!
88  @deffn primitive assq-set! alist key val  @deffn {Scheme Procedure} assq-set! alist key val
89  @deffnx primitive assv-set! alist key value  @deffnx {Scheme Procedure} assv-set! alist key value
90  @deffnx primitive assoc-set! alist key value  @deffnx {Scheme Procedure} assoc-set! alist key value
91    @deffnx {C Function} scm_assq_set_x (alist, key, val)
92  Reassociate @var{key} in @var{alist} with @var{value}: find any existing  Reassociate @var{key} in @var{alist} with @var{value}: find any existing
93  @var{alist} entry for @var{key} and associate it with the new  @var{alist} entry for @var{key} and associate it with the new
94  @var{value}.  If @var{alist} does not contain an entry for @var{key},  @var{value}.  If @var{alist} does not contain an entry for @var{key},
# Line 90  association list. Line 100  association list.
100  @end deffn  @end deffn
101    
102   assv-set!   assv-set!
103  @deffn primitive assv-set! alist key val  @deffn {Scheme Procedure} assv-set! alist key val
104    @deffnx {C Function} scm_assv_set_x (alist, key, val)
105  Behaves like @code{assq-set!} but uses @code{eqv?} for key comparison.  Behaves like @code{assq-set!} but uses @code{eqv?} for key comparison.
106  @end deffn  @end deffn
107    
108   assoc-set!   assoc-set!
109  @deffn primitive assoc-set! alist key val  @deffn {Scheme Procedure} assoc-set! alist key val
110    @deffnx {C Function} scm_assoc_set_x (alist, key, val)
111  Behaves like @code{assq-set!} but uses @code{equal?} for key comparison.  Behaves like @code{assq-set!} but uses @code{equal?} for key comparison.
112  @end deffn  @end deffn
113    
114   assq-remove!   assq-remove!
115  @deffn primitive assq-remove! alist key  @deffn {Scheme Procedure} assq-remove! alist key
116  @deffnx primitive assv-remove! alist key  @deffnx {Scheme Procedure} assv-remove! alist key
117  @deffnx primitive assoc-remove! alist key  @deffnx {Scheme Procedure} assoc-remove! alist key
118    @deffnx {C Function} scm_assq_remove_x (alist, key)
119  Delete the first entry in @var{alist} associated with @var{key}, and return  Delete the first entry in @var{alist} associated with @var{key}, and return
120  the resulting alist.  the resulting alist.
121  @end deffn  @end deffn
122    
123   assv-remove!   assv-remove!
124  @deffn primitive assv-remove! alist key  @deffn {Scheme Procedure} assv-remove! alist key
125    @deffnx {C Function} scm_assv_remove_x (alist, key)
126  Behaves like @code{assq-remove!} but uses @code{eqv?} for key comparison.  Behaves like @code{assq-remove!} but uses @code{eqv?} for key comparison.
127  @end deffn  @end deffn
128    
129   assoc-remove!   assoc-remove!
130  @deffn primitive assoc-remove! alist key  @deffn {Scheme Procedure} assoc-remove! alist key
131    @deffnx {C Function} scm_assoc_remove_x (alist, key)
132  Behaves like @code{assq-remove!} but uses @code{equal?} for key comparison.  Behaves like @code{assq-remove!} but uses @code{equal?} for key comparison.
133  @end deffn  @end deffn
134    
135   make-arbiter   make-arbiter
136  @deffn primitive make-arbiter name  @deffn {Scheme Procedure} make-arbiter name
137    @deffnx {C Function} scm_make_arbiter (name)
138  Return an object of type arbiter and name @var{name}. Its  Return an object of type arbiter and name @var{name}. Its
139  state is initially unlocked.  Arbiters are a way to achieve  state is initially unlocked.  Arbiters are a way to achieve
140  process synchronization.  process synchronization.
141  @end deffn  @end deffn
142    
143   try-arbiter   try-arbiter
144  @deffn primitive try-arbiter arb  @deffn {Scheme Procedure} try-arbiter arb
145    @deffnx {C Function} scm_try_arbiter (arb)
146  Return @code{#t} and lock the arbiter @var{arb} if the arbiter  Return @code{#t} and lock the arbiter @var{arb} if the arbiter
147  was unlocked. Otherwise, return @code{#f}.  was unlocked. Otherwise, return @code{#f}.
148  @end deffn  @end deffn
149    
150   release-arbiter   release-arbiter
151  @deffn primitive release-arbiter arb  @deffn {Scheme Procedure} release-arbiter arb
152    @deffnx {C Function} scm_release_arbiter (arb)
153  Return @code{#t} and unlock the arbiter @var{arb} if the  Return @code{#t} and unlock the arbiter @var{arb} if the
154  arbiter was locked. Otherwise, return @code{#f}.  arbiter was locked. Otherwise, return @code{#f}.
155  @end deffn  @end deffn
156    
157   async   async
158  @deffn primitive async thunk  @deffn {Scheme Procedure} async thunk
159    @deffnx {C Function} scm_async (thunk)
160  Create a new async for the procedure @var{thunk}.  Create a new async for the procedure @var{thunk}.
161  @end deffn  @end deffn
162    
163   system-async   system-async
164  @deffn primitive system-async thunk  @deffn {Scheme Procedure} system-async thunk
165    @deffnx {C Function} scm_system_async (thunk)
166  Create a new async for the procedure @var{thunk}.  Also  Create a new async for the procedure @var{thunk}.  Also
167  add it to the system's list of active async objects.  add it to the system's list of active async objects.
168  @end deffn  @end deffn
169    
170   async-mark   async-mark
171  @deffn primitive async-mark a  @deffn {Scheme Procedure} async-mark a
172    @deffnx {C Function} scm_async_mark (a)
173  Mark the async @var{a} for future execution.  Mark the async @var{a} for future execution.
174  @end deffn  @end deffn
175    
176   system-async-mark   system-async-mark
177  @deffn primitive system-async-mark a  @deffn {Scheme Procedure} system-async-mark a
178    @deffnx {C Function} scm_system_async_mark (a)
179  Mark the async @var{a} for future execution.  Mark the async @var{a} for future execution.
180  @end deffn  @end deffn
181    
182   run-asyncs   run-asyncs
183  @deffn primitive run-asyncs list_of_a  @deffn {Scheme Procedure} run-asyncs list_of_a
184    @deffnx {C Function} scm_run_asyncs (list_of_a)
185  Execute all thunks from the asyncs of the list @var{list_of_a}.  Execute all thunks from the asyncs of the list @var{list_of_a}.
186  @end deffn  @end deffn
187    
188   noop   noop
189  @deffn primitive noop . args  @deffn {Scheme Procedure} noop . args
190    @deffnx {C Function} scm_noop (args)
191  Do nothing.  When called without arguments, return @code{#f},  Do nothing.  When called without arguments, return @code{#f},
192  otherwise return the first argument.  otherwise return the first argument.
193  @end deffn  @end deffn
194    
195   unmask-signals   unmask-signals
196  @deffn primitive unmask-signals  @deffn {Scheme Procedure} unmask-signals
197    @deffnx {C Function} scm_unmask_signals ()
198  Unmask signals. The returned value is not specified.  Unmask signals. The returned value is not specified.
199  @end deffn  @end deffn
200    
201   mask-signals   mask-signals
202  @deffn primitive mask-signals  @deffn {Scheme Procedure} mask-signals
203    @deffnx {C Function} scm_mask_signals ()
204  Mask signals. The returned value is not specified.  Mask signals. The returned value is not specified.
205  @end deffn  @end deffn
206    
207   display-error   display-error
208  @deffn primitive display-error stack port subr message args rest  @deffn {Scheme Procedure} display-error stack port subr message args rest
209    @deffnx {C Function} scm_display_error (stack, port, subr, message, args, rest)
210  Display an error message to the output port @var{port}.  Display an error message to the output port @var{port}.
211  @var{stack} is the saved stack for the error, @var{subr} is  @var{stack} is the saved stack for the error, @var{subr} is
212  the name of the procedure in which the error occured and  the name of the procedure in which the error occurred and
213  @var{message} is the actual error message, which may contain  @var{message} is the actual error message, which may contain
214  formatting instructions. These will format the arguments in  formatting instructions. These will format the arguments in
215  the list @var{args} accordingly.  @var{rest} is currently  the list @var{args} accordingly.  @var{rest} is currently
# Line 190  ignored. Line 217  ignored.
217  @end deffn  @end deffn
218    
219   display-application   display-application
220  @deffn primitive display-application frame [port [indent]]  @deffn {Scheme Procedure} display-application frame [port [indent]]
221    @deffnx {C Function} scm_display_application (frame, port, indent)
222  Display a procedure application @var{frame} to the output port  Display a procedure application @var{frame} to the output port
223  @var{port}. @var{indent} specifies the indentation of the  @var{port}. @var{indent} specifies the indentation of the
224  output.  output.
225  @end deffn  @end deffn
226    
227   display-backtrace   display-backtrace
228  @deffn primitive display-backtrace stack port [first [depth]]  @deffn {Scheme Procedure} display-backtrace stack port [first [depth]]
229    @deffnx {C Function} scm_display_backtrace (stack, port, first, depth)
230  Display a backtrace to the output port @var{port}. @var{stack}  Display a backtrace to the output port @var{port}. @var{stack}
231  is the stack to take the backtrace from, @var{first} specifies  is the stack to take the backtrace from, @var{first} specifies
232  where in the stack to start and @var{depth} how much frames  where in the stack to start and @var{depth} how much frames
# Line 206  which means that default values will be Line 235  which means that default values will be
235  @end deffn  @end deffn
236    
237   backtrace   backtrace
238  @deffn primitive backtrace  @deffn {Scheme Procedure} backtrace
239    @deffnx {C Function} scm_backtrace ()
240  Display a backtrace of the stack saved by the last error  Display a backtrace of the stack saved by the last error
241  to the current output port.  to the current output port.
242  @end deffn  @end deffn
243    
244   not   not
245  @deffn primitive not x  @deffn {Scheme Procedure} not x
246    @deffnx {C Function} scm_not (x)
247  Return @code{#t} iff @var{x} is @code{#f}, else return @code{#f}.  Return @code{#t} iff @var{x} is @code{#f}, else return @code{#f}.
248  @end deffn  @end deffn
249    
250   boolean?   boolean?
251  @deffn primitive boolean? obj  @deffn {Scheme Procedure} boolean? obj
252    @deffnx {C Function} scm_boolean_p (obj)
253  Return @code{#t} iff @var{obj} is either @code{#t} or @code{#f}.  Return @code{#t} iff @var{obj} is either @code{#t} or @code{#f}.
254  @end deffn  @end deffn
255    
256   char?   char?
257  @deffn primitive char? x  @deffn {Scheme Procedure} char? x
258    @deffnx {C Function} scm_char_p (x)
259  Return @code{#t} iff @var{x} is a character, else @code{#f}.  Return @code{#t} iff @var{x} is a character, else @code{#f}.
260  @end deffn  @end deffn
261    
262   char=?   char=?
263  @deffn primitive char=? x y  @deffn {Scheme Procedure} char=? x y
264  Return @code{#t} iff @var{x} is the same character as @var{y}, else @code{#f}.  Return @code{#t} iff @var{x} is the same character as @var{y}, else @code{#f}.
265  @end deffn  @end deffn
266    
267   char<?   char<?
268  @deffn primitive char<? x y  @deffn {Scheme Procedure} char<? x y
269  Return @code{#t} iff @var{x} is less than @var{y} in the ASCII sequence,  Return @code{#t} iff @var{x} is less than @var{y} in the ASCII sequence,
270  else @code{#f}.  else @code{#f}.
271  @end deffn  @end deffn
272    
273   char<=?   char<=?
274  @deffn primitive char<=? x y  @deffn {Scheme Procedure} char<=? x y
275  Return @code{#t} iff @var{x} is less than or equal to @var{y} in the  Return @code{#t} iff @var{x} is less than or equal to @var{y} in the
276  ASCII sequence, else @code{#f}.  ASCII sequence, else @code{#f}.
277  @end deffn  @end deffn
278    
279   char>?   char>?
280  @deffn primitive char>? x y  @deffn {Scheme Procedure} char>? x y
281  Return @code{#t} iff @var{x} is greater than @var{y} in the ASCII  Return @code{#t} iff @var{x} is greater than @var{y} in the ASCII
282  sequence, else @code{#f}.  sequence, else @code{#f}.
283  @end deffn  @end deffn
284    
285   char>=?   char>=?
286  @deffn primitive char>=? x y  @deffn {Scheme Procedure} char>=? x y
287  Return @code{#t} iff @var{x} is greater than or equal to @var{y} in the  Return @code{#t} iff @var{x} is greater than or equal to @var{y} in the
288  ASCII sequence, else @code{#f}.  ASCII sequence, else @code{#f}.
289  @end deffn  @end deffn
290    
291   char-ci=?   char-ci=?
292  @deffn primitive char-ci=? x y  @deffn {Scheme Procedure} char-ci=? x y
293  Return @code{#t} iff @var{x} is the same character as @var{y} ignoring  Return @code{#t} iff @var{x} is the same character as @var{y} ignoring
294  case, else @code{#f}.  case, else @code{#f}.
295  @end deffn  @end deffn
296    
297   char-ci<?   char-ci<?
298  @deffn primitive char-ci<? x y  @deffn {Scheme Procedure} char-ci<? x y
299  Return @code{#t} iff @var{x} is less than @var{y} in the ASCII sequence  Return @code{#t} iff @var{x} is less than @var{y} in the ASCII sequence
300  ignoring case, else @code{#f}.  ignoring case, else @code{#f}.
301  @end deffn  @end deffn
302    
303   char-ci<=?   char-ci<=?
304  @deffn primitive char-ci<=? x y  @deffn {Scheme Procedure} char-ci<=? x y
305  Return @code{#t} iff @var{x} is less than or equal to @var{y} in the  Return @code{#t} iff @var{x} is less than or equal to @var{y} in the
306  ASCII sequence ignoring case, else @code{#f}.  ASCII sequence ignoring case, else @code{#f}.
307  @end deffn  @end deffn
308    
309   char-ci>?   char-ci>?
310  @deffn primitive char-ci>? x y  @deffn {Scheme Procedure} char-ci>? x y
311  Return @code{#t} iff @var{x} is greater than @var{y} in the ASCII  Return @code{#t} iff @var{x} is greater than @var{y} in the ASCII
312  sequence ignoring case, else @code{#f}.  sequence ignoring case, else @code{#f}.
313  @end deffn  @end deffn
314    
315   char-ci>=?   char-ci>=?
316  @deffn primitive char-ci>=? x y  @deffn {Scheme Procedure} char-ci>=? x y
317  Return @code{#t} iff @var{x} is greater than or equal to @var{y} in the  Return @code{#t} iff @var{x} is greater than or equal to @var{y} in the
318  ASCII sequence ignoring case, else @code{#f}.  ASCII sequence ignoring case, else @code{#f}.
319  @end deffn  @end deffn
320    
321   char-alphabetic?   char-alphabetic?
322  @deffn primitive char-alphabetic? chr  @deffn {Scheme Procedure} char-alphabetic? chr
323    @deffnx {C Function} scm_char_alphabetic_p (chr)
324  Return @code{#t} iff @var{chr} is alphabetic, else @code{#f}.  Return @code{#t} iff @var{chr} is alphabetic, else @code{#f}.
325  Alphabetic means the same thing as the isalpha C library function.  Alphabetic means the same thing as the isalpha C library function.
326  @end deffn  @end deffn
327    
328   char-numeric?   char-numeric?
329  @deffn primitive char-numeric? chr  @deffn {Scheme Procedure} char-numeric? chr
330    @deffnx {C Function} scm_char_numeric_p (chr)
331  Return @code{#t} iff @var{chr} is numeric, else @code{#f}.  Return @code{#t} iff @var{chr} is numeric, else @code{#f}.
332  Numeric means the same thing as the isdigit C library function.  Numeric means the same thing as the isdigit C library function.
333  @end deffn  @end deffn
334    
335   char-whitespace?   char-whitespace?
336  @deffn primitive char-whitespace? chr  @deffn {Scheme Procedure} char-whitespace? chr
337    @deffnx {C Function} scm_char_whitespace_p (chr)
338  Return @code{#t} iff @var{chr} is whitespace, else @code{#f}.  Return @code{#t} iff @var{chr} is whitespace, else @code{#f}.
339  Whitespace means the same thing as the isspace C library function.  Whitespace means the same thing as the isspace C library function.
340  @end deffn  @end deffn
341    
342   char-upper-case?   char-upper-case?
343  @deffn primitive char-upper-case? chr  @deffn {Scheme Procedure} char-upper-case? chr
344    @deffnx {C Function} scm_char_upper_case_p (chr)
345  Return @code{#t} iff @var{chr} is uppercase, else @code{#f}.  Return @code{#t} iff @var{chr} is uppercase, else @code{#f}.
346  Uppercase means the same thing as the isupper C library function.  Uppercase means the same thing as the isupper C library function.
347  @end deffn  @end deffn
348    
349   char-lower-case?   char-lower-case?
350  @deffn primitive char-lower-case? chr  @deffn {Scheme Procedure} char-lower-case? chr
351    @deffnx {C Function} scm_char_lower_case_p (chr)
352  Return @code{#t} iff @var{chr} is lowercase, else @code{#f}.  Return @code{#t} iff @var{chr} is lowercase, else @code{#f}.
353  Lowercase means the same thing as the islower C library function.  Lowercase means the same thing as the islower C library function.
354  @end deffn  @end deffn
355    
356   char-is-both?   char-is-both?
357  @deffn primitive char-is-both? chr  @deffn {Scheme Procedure} char-is-both? chr
358    @deffnx {C Function} scm_char_is_both_p (chr)
359  Return @code{#t} iff @var{chr} is either uppercase or lowercase, else @code{#f}.  Return @code{#t} iff @var{chr} is either uppercase or lowercase, else @code{#f}.
360  Uppercase and lowercase are as defined by the isupper and islower  Uppercase and lowercase are as defined by the isupper and islower
361  C library functions.  C library functions.
362  @end deffn  @end deffn
363    
364   char->integer   char->integer
365  @deffn primitive char->integer chr  @deffn {Scheme Procedure} char->integer chr
366    @deffnx {C Function} scm_char_to_integer (chr)
367  Return the number corresponding to ordinal position of @var{chr} in the  Return the number corresponding to ordinal position of @var{chr} in the
368  ASCII sequence.  ASCII sequence.
369  @end deffn  @end deffn
370    
371   integer->char   integer->char
372  @deffn primitive integer->char n  @deffn {Scheme Procedure} integer->char n
373    @deffnx {C Function} scm_integer_to_char (n)
374  Return the character at position @var{n} in the ASCII sequence.  Return the character at position @var{n} in the ASCII sequence.
375  @end deffn  @end deffn
376    
377   char-upcase   char-upcase
378  @deffn primitive char-upcase chr  @deffn {Scheme Procedure} char-upcase chr
379    @deffnx {C Function} scm_char_upcase (chr)
380  Return the uppercase character version of @var{chr}.  Return the uppercase character version of @var{chr}.
381  @end deffn  @end deffn
382    
383   char-downcase   char-downcase
384  @deffn primitive char-downcase chr  @deffn {Scheme Procedure} char-downcase chr
385    @deffnx {C Function} scm_char_downcase (chr)
386  Return the lowercase character version of @var{chr}.  Return the lowercase character version of @var{chr}.
387  @end deffn  @end deffn
388    
389   debug-options-interface   debug-options-interface
390  @deffn primitive debug-options-interface [setting]  @deffn {Scheme Procedure} debug-options-interface [setting]
391    @deffnx {C Function} scm_debug_options (setting)
392  Option interface for the debug options. Instead of using  Option interface for the debug options. Instead of using
393  this procedure directly, use the procedures @code{debug-enable},  this procedure directly, use the procedures @code{debug-enable},
394  @code{debug-disable}, @code{debug-set!} and @var{debug-options}.  @code{debug-disable}, @code{debug-set!} and @var{debug-options}.
395  @end deffn  @end deffn
396    
397   with-traps   with-traps
398  @deffn primitive with-traps thunk  @deffn {Scheme Procedure} with-traps thunk
399    @deffnx {C Function} scm_with_traps (thunk)
400  Call @var{thunk} with traps enabled.  Call @var{thunk} with traps enabled.
401  @end deffn  @end deffn
402    
403   memoized?   memoized?
404  @deffn primitive memoized? obj  @deffn {Scheme Procedure} memoized? obj
405    @deffnx {C Function} scm_memoized_p (obj)
406  Return @code{#t} if @var{obj} is memoized.  Return @code{#t} if @var{obj} is memoized.
407  @end deffn  @end deffn
408    
409   unmemoize   unmemoize
410  @deffn primitive unmemoize m  @deffn {Scheme Procedure} unmemoize m
411    @deffnx {C Function} scm_unmemoize (m)
412  Unmemoize the memoized expression @var{m},  Unmemoize the memoized expression @var{m},
413  @end deffn  @end deffn
414    
415   memoized-environment   memoized-environment
416  @deffn primitive memoized-environment m  @deffn {Scheme Procedure} memoized-environment m
417    @deffnx {C Function} scm_memoized_environment (m)
418  Return the environment of the memoized expression @var{m}.  Return the environment of the memoized expression @var{m}.
419  @end deffn  @end deffn
420    
421   procedure-name   procedure-name
422  @deffn primitive procedure-name proc  @deffn {Scheme Procedure} procedure-name proc
423    @deffnx {C Function} scm_procedure_name (proc)
424  Return the name of the procedure @var{proc}  Return the name of the procedure @var{proc}
425  @end deffn  @end deffn
426    
427   procedure-source   procedure-source
428  @deffn primitive procedure-source proc  @deffn {Scheme Procedure} procedure-source proc
429    @deffnx {C Function} scm_procedure_source (proc)
430  Return the source of the procedure @var{proc}.  Return the source of the procedure @var{proc}.
431  @end deffn  @end deffn
432    
433   procedure-environment   procedure-environment
434  @deffn primitive procedure-environment proc  @deffn {Scheme Procedure} procedure-environment proc
435    @deffnx {C Function} scm_procedure_environment (proc)
436  Return the environment of the procedure @var{proc}.  Return the environment of the procedure @var{proc}.
437  @end deffn  @end deffn
438    
439   local-eval   local-eval
440  @deffn primitive local-eval exp [env]  @deffn {Scheme Procedure} local-eval exp [env]
441    @deffnx {C Function} scm_local_eval (exp, env)
442  Evaluate @var{exp} in its environment.  If @var{env} is supplied,  Evaluate @var{exp} in its environment.  If @var{env} is supplied,
443  it is the environment in which to evaluate @var{exp}.  Otherwise,  it is the environment in which to evaluate @var{exp}.  Otherwise,
444  @var{exp} must be a memoized code object (in which case, its environment  @var{exp} must be a memoized code object (in which case, its environment
# Line 394  is implicit). Line 446  is implicit).
446  @end deffn  @end deffn
447    
448   debug-object?   debug-object?
449  @deffn primitive debug-object? obj  @deffn {Scheme Procedure} debug-object? obj
450    @deffnx {C Function} scm_debug_object_p (obj)
451  Return @code{#t} if @var{obj} is a debug object.  Return @code{#t} if @var{obj} is a debug object.
452  @end deffn  @end deffn
453    
454   c-registered-modules   c-registered-modules
455  @deffn primitive c-registered-modules  @deffn {Scheme Procedure} c-registered-modules
456    @deffnx {C Function} scm_registered_modules ()
457  Return a list of the object code modules that have been imported into  Return a list of the object code modules that have been imported into
458  the current Guile process.  Each element of the list is a pair whose  the current Guile process.  Each element of the list is a pair whose
459  car is the name of the module, and whose cdr is the function handle  car is the name of the module, and whose cdr is the function handle
# Line 408  has been passed to scm_register_module_x Line 462  has been passed to scm_register_module_x
462  @end deffn  @end deffn
463    
464   c-clear-registered-modules   c-clear-registered-modules
465  @deffn primitive c-clear-registered-modules  @deffn {Scheme Procedure} c-clear-registered-modules
466    @deffnx {C Function} scm_clear_registered_modules ()
467  Destroy the list of modules registered with the current Guile process.  Destroy the list of modules registered with the current Guile process.
468  The return value is unspecified.  @strong{Warning:} this function does  The return value is unspecified.  @strong{Warning:} this function does
469  not actually unlink or deallocate these modules, but only destroys the  not actually unlink or deallocate these modules, but only destroys the
# Line 417  only by module bookkeeping operations. Line 472  only by module bookkeeping operations.
472  @end deffn  @end deffn
473    
474   dynamic-link   dynamic-link
475  @deffn primitive dynamic-link filename  @deffn {Scheme Procedure} dynamic-link filename
476    @deffnx {C Function} scm_dynamic_link (filename)
477  Open the dynamic library called @var{filename}.  A library  Open the dynamic library called @var{filename}.  A library
478  handle representing the opened library is returned; this handle  handle representing the opened library is returned; this handle
479  should be used as the @var{dobj} argument to the following  should be used as the @var{dobj} argument to the following
# Line 425  functions. Line 481  functions.
481  @end deffn  @end deffn
482    
483   dynamic-object?   dynamic-object?
484  @deffn primitive dynamic-object? obj  @deffn {Scheme Procedure} dynamic-object? obj
485    @deffnx {C Function} scm_dynamic_object_p (obj)
486  Return @code{#t} if @var{obj} is a dynamic library handle, or @code{#f}  Return @code{#t} if @var{obj} is a dynamic library handle, or @code{#f}
487  otherwise.  otherwise.
488  @end deffn  @end deffn
489    
490   dynamic-unlink   dynamic-unlink
491  @deffn primitive dynamic-unlink dobj  @deffn {Scheme Procedure} dynamic-unlink dobj
492    @deffnx {C Function} scm_dynamic_unlink (dobj)
493  Unlink the indicated object file from the application.  The  Unlink the indicated object file from the application.  The
494  argument @var{dobj} must have been obtained by a call to  argument @var{dobj} must have been obtained by a call to
495  @code{dynamic-link}.  After @code{dynamic-unlink} has been  @code{dynamic-link}.  After @code{dynamic-unlink} has been
# Line 439  called on @var{dobj}, its content is no Line 497  called on @var{dobj}, its content is no
497  @end deffn  @end deffn
498    
499   dynamic-func   dynamic-func
500  @deffn primitive dynamic-func name dobj  @deffn {Scheme Procedure} dynamic-func name dobj
501    @deffnx {C Function} scm_dynamic_func (name, dobj)
502  Search the dynamic object @var{dobj} for the C function  Search the dynamic object @var{dobj} for the C function
503  indicated by the string @var{name} and return some Scheme  indicated by the string @var{name} and return some Scheme
504  handle that can later be used with @code{dynamic-call} to  handle that can later be used with @code{dynamic-call} to
# Line 452  needed or not and will add it when neces Line 511  needed or not and will add it when neces
511  @end deffn  @end deffn
512    
513   dynamic-call   dynamic-call
514  @deffn primitive dynamic-call func dobj  @deffn {Scheme Procedure} dynamic-call func dobj
515    @deffnx {C Function} scm_dynamic_call (func, dobj)
516  Call the C function indicated by @var{func} and @var{dobj}.  Call the C function indicated by @var{func} and @var{dobj}.
517  The function is passed no arguments and its return value is  The function is passed no arguments and its return value is
518  ignored.  When @var{function} is something returned by  ignored.  When @var{function} is something returned by
# Line 468  Interrupts are deferred while the C func Line 528  Interrupts are deferred while the C func
528  @end deffn  @end deffn
529    
530   dynamic-args-call   dynamic-args-call
531  @deffn primitive dynamic-args-call func dobj args  @deffn {Scheme Procedure} dynamic-args-call func dobj args
532    @deffnx {C Function} scm_dynamic_args_call (func, dobj, args)
533  Call the C function indicated by @var{func} and @var{dobj},  Call the C function indicated by @var{func} and @var{dobj},
534  just like @code{dynamic-call}, but pass it some arguments and  just like @code{dynamic-call}, but pass it some arguments and
535  return its return value.  The C function is expected to take  return its return value.  The C function is expected to take
# Line 485  converted to a Scheme number and returne Line 546  converted to a Scheme number and returne
546  @end deffn  @end deffn
547    
548   dynamic-wind   dynamic-wind
549  @deffn primitive dynamic-wind in_guard thunk out_guard  @deffn {Scheme Procedure} dynamic-wind in_guard thunk out_guard
550    @deffnx {C Function} scm_dynamic_wind (in_guard, thunk, out_guard)
551  All three arguments must be 0-argument procedures.  All three arguments must be 0-argument procedures.
552  @var{in_guard} is called, then @var{thunk}, then  @var{in_guard} is called, then @var{thunk}, then
553  @var{out_guard}.  @var{out_guard}.
# Line 537  a-cont Line 599  a-cont
599  @end deffn  @end deffn
600    
601   environment?   environment?
602  @deffn primitive environment? obj  @deffn {Scheme Procedure} environment? obj
603    @deffnx {C Function} scm_environment_p (obj)
604  Return @code{#t} if @var{obj} is an environment, or @code{#f}  Return @code{#t} if @var{obj} is an environment, or @code{#f}
605  otherwise.  otherwise.
606  @end deffn  @end deffn
607    
608   environment-bound?   environment-bound?
609  @deffn primitive environment-bound? env sym  @deffn {Scheme Procedure} environment-bound? env sym
610    @deffnx {C Function} scm_environment_bound_p (env, sym)
611  Return @code{#t} if @var{sym} is bound in @var{env}, or  Return @code{#t} if @var{sym} is bound in @var{env}, or
612  @code{#f} otherwise.  @code{#f} otherwise.
613  @end deffn  @end deffn
614    
615   environment-ref   environment-ref
616  @deffn primitive environment-ref env sym  @deffn {Scheme Procedure} environment-ref env sym
617    @deffnx {C Function} scm_environment_ref (env, sym)
618  Return the value of the location bound to @var{sym} in  Return the value of the location bound to @var{sym} in
619  @var{env}. If @var{sym} is unbound in @var{env}, signal an  @var{env}. If @var{sym} is unbound in @var{env}, signal an
620  @code{environment:unbound} error.  @code{environment:unbound} error.
621  @end deffn  @end deffn
622    
623   environment-fold   environment-fold
624  @deffn primitive environment-fold env proc init  @deffn {Scheme Procedure} environment-fold env proc init
625    @deffnx {C Function} scm_environment_fold (env, proc, init)
626  Iterate over all the bindings in @var{env}, accumulating some  Iterate over all the bindings in @var{env}, accumulating some
627  value.  value.
628  For each binding in @var{env}, apply @var{proc} to the symbol  For each binding in @var{env}, apply @var{proc} to the symbol
# Line 591  using environment-fold: Line 657  using environment-fold:
657  @end deffn  @end deffn
658    
659   environment-define   environment-define
660  @deffn primitive environment-define env sym val  @deffn {Scheme Procedure} environment-define env sym val
661    @deffnx {C Function} scm_environment_define (env, sym, val)
662  Bind @var{sym} to a new location containing @var{val} in  Bind @var{sym} to a new location containing @var{val} in
663  @var{env}. If @var{sym} is already bound to another location  @var{env}. If @var{sym} is already bound to another location
664  in @var{env} and the binding is mutable, that binding is  in @var{env} and the binding is mutable, that binding is
# Line 602  immutable, signal an @code{environment:i Line 669  immutable, signal an @code{environment:i
669  @end deffn  @end deffn
670    
671   environment-undefine   environment-undefine
672  @deffn primitive environment-undefine env sym  @deffn {Scheme Procedure} environment-undefine env sym
673    @deffnx {C Function} scm_environment_undefine (env, sym)
674  Remove any binding for @var{sym} from @var{env}. If @var{sym}  Remove any binding for @var{sym} from @var{env}. If @var{sym}
675  is unbound in @var{env}, do nothing.  The return value is  is unbound in @var{env}, do nothing.  The return value is
676  unspecified.  unspecified.
# Line 611  immutable, signal an @code{environment:i Line 679  immutable, signal an @code{environment:i
679  @end deffn  @end deffn
680    
681   environment-set!   environment-set!
682  @deffn primitive environment-set! env sym val  @deffn {Scheme Procedure} environment-set! env sym val
683    @deffnx {C Function} scm_environment_set_x (env, sym, val)
684  If @var{env} binds @var{sym} to some location, change that  If @var{env} binds @var{sym} to some location, change that
685  location's value to @var{val}.  The return value is  location's value to @var{val}.  The return value is
686  unspecified.  unspecified.
# Line 622  to an immutable location, signal an Line 691  to an immutable location, signal an
691  @end deffn  @end deffn
692    
693   environment-cell   environment-cell
694  @deffn primitive environment-cell env sym for_write  @deffn {Scheme Procedure} environment-cell env sym for_write
695    @deffnx {C Function} scm_environment_cell (env, sym, for_write)
696  Return the value cell which @var{env} binds to @var{sym}, or  Return the value cell which @var{env} binds to @var{sym}, or
697  @code{#f} if the binding does not live in a value cell.  @code{#f} if the binding does not live in a value cell.
698  The argument @var{for-write} indicates whether the caller  The argument @var{for-write} indicates whether the caller
# Line 638  re-bound to a new value cell, or becomes Line 708  re-bound to a new value cell, or becomes
708  @end deffn  @end deffn
709    
710   environment-observe   environment-observe
711  @deffn primitive environment-observe env proc  @deffn {Scheme Procedure} environment-observe env proc
712    @deffnx {C Function} scm_environment_observe (env, proc)
713  Whenever @var{env}'s bindings change, apply @var{proc} to  Whenever @var{env}'s bindings change, apply @var{proc} to
714  @var{env}.  @var{env}.
715  This function returns an object, token, which you can pass to  This function returns an object, token, which you can pass to
# Line 648  token is unspecified. Line 719  token is unspecified.
719  @end deffn  @end deffn
720    
721   environment-observe-weak   environment-observe-weak
722  @deffn primitive environment-observe-weak env proc  @deffn {Scheme Procedure} environment-observe-weak env proc
723    @deffnx {C Function} scm_environment_observe_weak (env, proc)
724  This function is the same as environment-observe, except that  This function is the same as environment-observe, except that
725  the reference @var{env} retains to @var{proc} is a weak  the reference @var{env} retains to @var{proc} is a weak
726  reference. This means that, if there are no other live,  reference. This means that, if there are no other live,
# Line 658  list of observing procedures. Line 730  list of observing procedures.
730  @end deffn  @end deffn
731    
732   environment-unobserve   environment-unobserve
733  @deffn primitive environment-unobserve token  @deffn {Scheme Procedure} environment-unobserve token
734    @deffnx {C Function} scm_environment_unobserve (token)
735  Cancel the observation request which returned the value  Cancel the observation request which returned the value
736  @var{token}.  The return value is unspecified.  @var{token}.  The return value is unspecified.
737  If a call @code{(environment-observe env proc)} returns  If a call @code{(environment-observe env proc)} returns
# Line 668  bindings change. Line 741  bindings change.
741  @end deffn  @end deffn
742    
743   make-leaf-environment   make-leaf-environment
744  @deffn primitive make-leaf-environment  @deffn {Scheme Procedure} make-leaf-environment
745    @deffnx {C Function} scm_make_leaf_environment ()
746  Create a new leaf environment, containing no bindings.  Create a new leaf environment, containing no bindings.
747  All bindings and locations created in the new environment  All bindings and locations created in the new environment
748  will be mutable.  will be mutable.
749  @end deffn  @end deffn
750    
751   leaf-environment?   leaf-environment?
752  @deffn primitive leaf-environment? object  @deffn {Scheme Procedure} leaf-environment? object
753    @deffnx {C Function} scm_leaf_environment_p (object)
754  Return @code{#t} if object is a leaf environment, or @code{#f}  Return @code{#t} if object is a leaf environment, or @code{#f}
755  otherwise.  otherwise.
756  @end deffn  @end deffn
757    
758   make-eval-environment   make-eval-environment
759  @deffn primitive make-eval-environment local imported  @deffn {Scheme Procedure} make-eval-environment local imported
760    @deffnx {C Function} scm_make_eval_environment (local, imported)
761  Return a new environment object eval whose bindings are the  Return a new environment object eval whose bindings are the
762  union of the bindings in the environments @var{local} and  union of the bindings in the environments @var{local} and
763  @var{imported}, with bindings from @var{local} taking  @var{imported}, with bindings from @var{local} taking
# Line 706  In typical use, @var{local} will be a fi Line 782  In typical use, @var{local} will be a fi
782  @end deffn  @end deffn
783    
784   eval-environment?   eval-environment?
785  @deffn primitive eval-environment? object  @deffn {Scheme Procedure} eval-environment? object
786    @deffnx {C Function} scm_eval_environment_p (object)
787  Return @code{#t} if object is an eval environment, or @code{#f}  Return @code{#t} if object is an eval environment, or @code{#f}
788  otherwise.  otherwise.
789  @end deffn  @end deffn
790    
791   eval-environment-local   eval-environment-local
792  @deffn primitive eval-environment-local env  @deffn {Scheme Procedure} eval-environment-local env
793    @deffnx {C Function} scm_eval_environment_local (env)
794  Return the local environment of eval environment @var{env}.  Return the local environment of eval environment @var{env}.
795  @end deffn  @end deffn
796    
797   eval-environment-set-local!   eval-environment-set-local!
798  @deffn primitive eval-environment-set-local! env local  @deffn {Scheme Procedure} eval-environment-set-local! env local
799    @deffnx {C Function} scm_eval_environment_set_local_x (env, local)
800  Change @var{env}'s local environment to @var{local}.  Change @var{env}'s local environment to @var{local}.
801  @end deffn  @end deffn
802    
803   eval-environment-imported   eval-environment-imported
804  @deffn primitive eval-environment-imported env  @deffn {Scheme Procedure} eval-environment-imported env
805    @deffnx {C Function} scm_eval_environment_imported (env)
806  Return the imported environment of eval environment @var{env}.  Return the imported environment of eval environment @var{env}.
807  @end deffn  @end deffn
808    
809   eval-environment-set-imported!   eval-environment-set-imported!
810  @deffn primitive eval-environment-set-imported! env imported  @deffn {Scheme Procedure} eval-environment-set-imported! env imported
811    @deffnx {C Function} scm_eval_environment_set_imported_x (env, imported)
812  Change @var{env}'s imported environment to @var{imported}.  Change @var{env}'s imported environment to @var{imported}.
813  @end deffn  @end deffn
814    
815   make-import-environment   make-import-environment
816  @deffn primitive make-import-environment imports conflict_proc  @deffn {Scheme Procedure} make-import-environment imports conflict_proc
817    @deffnx {C Function} scm_make_import_environment (imports, conflict_proc)
818  Return a new environment @var{imp} whose bindings are the union  Return a new environment @var{imp} whose bindings are the union
819  of the bindings from the environments in @var{imports};  of the bindings from the environments in @var{imports};
820  @var{imports} must be a list of environments. That is,  @var{imports} must be a list of environments. That is,
# Line 761  if one of its imported environments chan Line 843  if one of its imported environments chan
843  @end deffn  @end deffn
844    
845   import-environment?   import-environment?
846  @deffn primitive import-environment? object  @deffn {Scheme Procedure} import-environment? object
847    @deffnx {C Function} scm_import_environment_p (object)
848  Return @code{#t} if object is an import environment, or  Return @code{#t} if object is an import environment, or
849  @code{#f} otherwise.  @code{#f} otherwise.
850  @end deffn  @end deffn
851    
852   import-environment-imports   import-environment-imports
853  @deffn primitive import-environment-imports env  @deffn {Scheme Procedure} import-environment-imports env
854    @deffnx {C Function} scm_import_environment_imports (env)
855  Return the list of environments imported by the import  Return the list of environments imported by the import
856  environment @var{env}.  environment @var{env}.
857  @end deffn  @end deffn
858    
859   import-environment-set-imports!   import-environment-set-imports!
860  @deffn primitive import-environment-set-imports! env imports  @deffn {Scheme Procedure} import-environment-set-imports! env imports
861    @deffnx {C Function} scm_import_environment_set_imports_x (env, imports)
862  Change @var{env}'s list of imported environments to  Change @var{env}'s list of imported environments to
863  @var{imports}, and check for conflicts.  @var{imports}, and check for conflicts.
864  @end deffn  @end deffn
865    
866   make-export-environment   make-export-environment
867  @deffn primitive make-export-environment private signature  @deffn {Scheme Procedure} make-export-environment private signature
868    @deffnx {C Function} scm_make_export_environment (private, signature)
869  Return a new environment @var{exp} containing only those  Return a new environment @var{exp} containing only those
870  bindings in private whose symbols are present in  bindings in private whose symbols are present in
871  @var{signature}. The @var{private} argument must be an  @var{signature}. The @var{private} argument must be an
# Line 827  if the bindings in private change. Line 913  if the bindings in private change.
913  @end deffn  @end deffn
914    
915   export-environment?   export-environment?
916  @deffn primitive export-environment? object  @deffn {Scheme Procedure} export-environment? object
917    @deffnx {C Function} scm_export_environment_p (object)
918  Return @code{#t} if object is an export environment, or  Return @code{#t} if object is an export environment, or
919  @code{#f} otherwise.  @code{#f} otherwise.
920  @end deffn  @end deffn
921    
922   export-environment-private   export-environment-private
923  @deffn primitive export-environment-private env  @deffn {Scheme Procedure} export-environment-private env
924    @deffnx {C Function} scm_export_environment_private (env)
925  Return the private environment of export environment @var{env}.  Return the private environment of export environment @var{env}.
926  @end deffn  @end deffn
927    
928   export-environment-set-private!   export-environment-set-private!
929  @deffn primitive export-environment-set-private! env private  @deffn {Scheme Procedure} export-environment-set-private! env private
930    @deffnx {C Function} scm_export_environment_set_private_x (env, private)
931  Change the private environment of export environment @var{env}.  Change the private environment of export environment @var{env}.
932  @end deffn  @end deffn
933    
934   export-environment-signature   export-environment-signature
935  @deffn primitive export-environment-signature env  @deffn {Scheme Procedure} export-environment-signature env
936    @deffnx {C Function} scm_export_environment_signature (env)
937  Return the signature of export environment @var{env}.  Return the signature of export environment @var{env}.
938  @end deffn  @end deffn
939    
940   export-environment-set-signature!   export-environment-set-signature!
941  @deffn primitive export-environment-set-signature! env signature  @deffn {Scheme Procedure} export-environment-set-signature! env signature
942    @deffnx {C Function} scm_export_environment_set_signature_x (env, signature)
943  Change the signature of export environment @var{env}.  Change the signature of export environment @var{env}.
944  @end deffn  @end deffn
945    
946   eq?   eq?
947  @deffn primitive eq? x y  @deffn {Scheme Procedure} eq? x y
948  Return @code{#t} iff @var{x} references the same object as @var{y}.  Return @code{#t} iff @var{x} references the same object as @var{y}.
949  @code{eq?} is similar to @code{eqv?} except that in some cases it is  @code{eq?} is similar to @code{eqv?} except that in some cases it is
950  capable of discerning distinctions finer than those detectable by  capable of discerning distinctions finer than those detectable by
# Line 861  capable of discerning distinctions finer Line 952  capable of discerning distinctions finer
952  @end deffn  @end deffn
953    
954   eqv?   eqv?
955  @deffn primitive eqv? x y  @deffn {Scheme Procedure} eqv? x y
956  The @code{eqv?} procedure defines a useful equivalence relation on objects.  The @code{eqv?} procedure defines a useful equivalence relation on objects.
957  Briefly, it returns @code{#t} if @var{x} and @var{y} should normally be  Briefly, it returns @code{#t} if @var{x} and @var{y} should normally be
958  regarded as the same object.  This relation is left slightly open to  regarded as the same object.  This relation is left slightly open to
# Line 870  and inexact numbers. Line 961  and inexact numbers.
961  @end deffn  @end deffn
962    
963   equal?   equal?
964  @deffn primitive equal? x y  @deffn {Scheme Procedure} equal? x y
965  Return @code{#t} iff @var{x} and @var{y} are recursively @code{eqv?} equivalent.  Return @code{#t} iff @var{x} and @var{y} are recursively @code{eqv?} equivalent.
966  @code{equal?} recursively compares the contents of pairs,  @code{equal?} recursively compares the contents of pairs,
967  vectors, and strings, applying @code{eqv?} on other objects such as  vectors, and strings, applying @code{eqv?} on other objects such as
# Line 880  terminate if its arguments are circular Line 971  terminate if its arguments are circular
971  @end deffn  @end deffn
972    
973   scm-error   scm-error
974  @deffn primitive scm-error key subr message args data  @deffn {Scheme Procedure} scm-error key subr message args data
975    @deffnx {C Function} scm_error_scm (key, subr, message, args, data)
976  Raise an error with key @var{key}.  @var{subr} can be a string  Raise an error with key @var{key}.  @var{subr} can be a string
977  naming the procedure associated with the error, or @code{#f}.  naming the procedure associated with the error, or @code{#f}.
978  @var{message} is the error message string, possibly containing  @var{message} is the error message string, possibly containing
# Line 897  it will usually be @code{#f}. Line 989  it will usually be @code{#f}.
989  @end deffn  @end deffn
990    
991   strerror   strerror
992  @deffn primitive strerror err  @deffn {Scheme Procedure} strerror err
993    @deffnx {C Function} scm_strerror (err)
994  Return the Unix error message corresponding to @var{err}, which  Return the Unix error message corresponding to @var{err}, which
995  must be an integer value.  must be an integer value.
996  @end deffn  @end deffn
997    
998   apply:nconc2last   apply:nconc2last
999  @deffn primitive apply:nconc2last lst  @deffn {Scheme Procedure} apply:nconc2last lst
1000    @deffnx {C Function} scm_nconc2last (lst)
1001  Given a list (@var{arg1} @dots{} @var{args}), this function  Given a list (@var{arg1} @dots{} @var{args}), this function
1002  conses the @var{arg1} @dots{} arguments onto the front of  conses the @var{arg1} @dots{} arguments onto the front of
1003  @var{args}, and returns the resulting list. Note that  @var{args}, and returns the resulting list. Note that
# Line 914  destroys its argument, so use with care. Line 1008  destroys its argument, so use with care.
1008  @end deffn  @end deffn
1009    
1010   force   force
1011  @deffn primitive force x  @deffn {Scheme Procedure} force x
1012    @deffnx {C Function} scm_force (x)
1013  If the promise @var{x} has not been computed yet, compute and  If the promise @var{x} has not been computed yet, compute and
1014  return @var{x}, otherwise just return the previously computed  return @var{x}, otherwise just return the previously computed
1015  value.  value.
1016  @end deffn  @end deffn
1017    
1018   promise?   promise?
1019  @deffn primitive promise? obj  @deffn {Scheme Procedure} promise? obj
1020    @deffnx {C Function} scm_promise_p (obj)
1021  Return true if @var{obj} is a promise, i.e. a delayed computation  Return true if @var{obj} is a promise, i.e. a delayed computation
1022  (@pxref{Delayed evaluation,,,r5rs.info,The Revised^5 Report on Scheme}).  (@pxref{Delayed evaluation,,,r5rs.info,The Revised^5 Report on Scheme}).
1023  @end deffn  @end deffn
1024    
1025   cons-source   cons-source
1026  @deffn primitive cons-source xorig x y  @deffn {Scheme Procedure} cons-source xorig x y
1027    @deffnx {C Function} scm_cons_source (xorig, x, y)
1028  Create and return a new pair whose car and cdr are @var{x} and @var{y}.  Create and return a new pair whose car and cdr are @var{x} and @var{y}.
1029  Any source properties associated with @var{xorig} are also associated  Any source properties associated with @var{xorig} are also associated
1030  with the new pair.  with the new pair.
1031  @end deffn  @end deffn
1032    
1033   copy-tree   copy-tree
1034  @deffn primitive copy-tree obj  @deffn {Scheme Procedure} copy-tree obj
1035    @deffnx {C Function} scm_copy_tree (obj)
1036  Recursively copy the data tree that is bound to @var{obj}, and return a  Recursively copy the data tree that is bound to @var{obj}, and return a
1037  pointer to the new data structure.  @code{copy-tree} recurses down the  pointer to the new data structure.  @code{copy-tree} recurses down the
1038  contents of both pairs and vectors (since both cons cells and vector  contents of both pairs and vectors (since both cons cells and vector
# Line 943  any other object. Line 1041  any other object.
1041  @end deffn  @end deffn
1042    
1043   primitive-eval   primitive-eval
1044  @deffn primitive primitive-eval exp  @deffn {Scheme Procedure} primitive-eval exp
1045    @deffnx {C Function} scm_primitive_eval (exp)
1046  Evaluate @var{exp} in the top-level environment specified by  Evaluate @var{exp} in the top-level environment specified by
1047  the current module.  the current module.
1048  @end deffn  @end deffn
1049    
1050   eval   eval
1051  @deffn primitive eval exp module  @deffn {Scheme Procedure} eval exp module
1052    @deffnx {C Function} scm_eval (exp, module)
1053  Evaluate @var{exp}, a list representing a Scheme expression,  Evaluate @var{exp}, a list representing a Scheme expression,
1054  in the top-level environment specified by @var{module}.  in the top-level environment specified by @var{module}.
1055  While @var{exp} is evaluated (using @var{primitive-eval}),  While @var{exp} is evaluated (using @code{primitive-eval}),
1056  @var{module} is made the current module.  The current module  @var{module} is made the current module.  The current module
1057  is reset to its previous value when @var{eval} returns.  is reset to its previous value when @var{eval} returns.
1058  @end deffn  @end deffn
1059    
1060   eval2   eval2
1061  @deffn primitive eval2 obj env_thunk  @deffn {Scheme Procedure} eval2 obj env_thunk
1062    @deffnx {C Function} scm_eval2 (obj, env_thunk)
1063  Evaluate @var{exp}, a Scheme expression, in the environment  Evaluate @var{exp}, a Scheme expression, in the environment
1064  designated by @var{lookup}, a symbol-lookup function.  designated by @var{lookup}, a symbol-lookup function.
1065  Do not use this version of eval, it does not play well  Do not use this version of eval, it does not play well
# Line 967  with the module system.  Use @code{eval} Line 1068  with the module system.  Use @code{eval}
1068  @end deffn  @end deffn
1069    
1070   eval-options-interface   eval-options-interface
1071  @deffn primitive eval-options-interface [setting]  @deffn {Scheme Procedure} eval-options-interface [setting]
1072    @deffnx {C Function} scm_eval_options_interface (setting)
1073  Option interface for the evaluation options. Instead of using  Option interface for the evaluation options. Instead of using
1074  this procedure directly, use the procedures @code{eval-enable},  this procedure directly, use the procedures @code{eval-enable},
1075  @code{eval-disable}, @code{eval-set!} and @var{eval-options}.  @code{eval-disable}, @code{eval-set!} and @code{eval-options}.
1076  @end deffn  @end deffn
1077    
1078   evaluator-traps-interface   evaluator-traps-interface
1079  @deffn primitive evaluator-traps-interface [setting]  @deffn {Scheme Procedure} evaluator-traps-interface [setting]
1080    @deffnx {C Function} scm_evaluator_traps (setting)
1081  Option interface for the evaluator trap options.  Option interface for the evaluator trap options.
1082  @end deffn  @end deffn
1083    
1084   defined?   defined?
1085  @deffn primitive defined? sym [env]  @deffn {Scheme Procedure} defined? sym [env]
1086    @deffnx {C Function} scm_definedp (sym, env)
1087  Return @code{#t} if @var{sym} is defined in the lexical environment @var{env}.  When @var{env} is not specified, look in the top-level environment as defined by the current module.  Return @code{#t} if @var{sym} is defined in the lexical environment @var{env}.  When @var{env} is not specified, look in the top-level environment as defined by the current module.
1088  @end deffn  @end deffn
1089    
1090   map-in-order   map-in-order
1091  @deffn primitive map-in-order  @deffn {Scheme Procedure} map-in-order
1092  implemented by the C function "scm_map"  implemented by the C function "scm_map"
1093  @end deffn  @end deffn
1094    
1095   load-extension   load-extension
1096  @deffn primitive load-extension lib init  @deffn {Scheme Procedure} load-extension lib init
1097    @deffnx {C Function} scm_load_extension (lib, init)
1098  Load and initialize the extension designated by LIB and INIT.  Load and initialize the extension designated by LIB and INIT.
1099  When there is no pre-registered function for LIB/INIT, this is  When there is no pre-registered function for LIB/INIT, this is
1100  equivalent to  equivalent to
# Line 1027  well.  For example, Line 1132  well.  For example,
1132  @end deffn  @end deffn
1133    
1134   program-arguments   program-arguments
1135  @deffn primitive program-arguments  @deffn {Scheme Procedure} program-arguments
1136  @deffnx procedure command-line  @deffnx {Scheme Procedure} command-line
1137    @deffnx {C Function} scm_program_arguments ()
1138  Return the list of command line arguments passed to Guile, as a list of  Return the list of command line arguments passed to Guile, as a list of
1139  strings.  The list includes the invoked program name, which is usually  strings.  The list includes the invoked program name, which is usually
1140  @code{"guile"}, but excludes switches and parameters for command line  @code{"guile"}, but excludes switches and parameters for command line
# Line 1036  options like @code{-e} and @code{-l}. Line 1142  options like @code{-e} and @code{-l}.
1142  @end deffn  @end deffn
1143    
1144   make-fluid   make-fluid
1145  @deffn primitive make-fluid  @deffn {Scheme Procedure} make-fluid
1146    @deffnx {C Function} scm_make_fluid ()
1147  Return a newly created fluid.  Return a newly created fluid.
1148  Fluids are objects of a certain type (a smob) that can hold one SCM  Fluids are objects of a certain type (a smob) that can hold one SCM
1149  value per dynamic root.  That is, modifications to this value are  value per dynamic root.  That is, modifications to this value are
# Line 1047  in its own dynamic root, you can use flu Line 1154  in its own dynamic root, you can use flu
1154  @end deffn  @end deffn
1155    
1156   fluid?   fluid?
1157  @deffn primitive fluid? obj  @deffn {Scheme Procedure} fluid? obj
1158    @deffnx {C Function} scm_fluid_p (obj)
1159  Return @code{#t} iff @var{obj} is a fluid; otherwise, return  Return @code{#t} iff @var{obj} is a fluid; otherwise, return
1160  @code{#f}.  @code{#f}.
1161  @end deffn  @end deffn
1162    
1163   fluid-ref   fluid-ref
1164  @deffn primitive fluid-ref fluid  @deffn {Scheme Procedure} fluid-ref fluid
1165    @deffnx {C Function} scm_fluid_ref (fluid)
1166  Return the value associated with @var{fluid} in the current  Return the value associated with @var{fluid} in the current
1167  dynamic root.  If @var{fluid} has not been set, then return  dynamic root.  If @var{fluid} has not been set, then return
1168  @code{#f}.  @code{#f}.
1169  @end deffn  @end deffn
1170    
1171   fluid-set!   fluid-set!
1172  @deffn primitive fluid-set! fluid value  @deffn {Scheme Procedure} fluid-set! fluid value
1173    @deffnx {C Function} scm_fluid_set_x (fluid, value)
1174  Set the value associated with @var{fluid} in the current dynamic root.  Set the value associated with @var{fluid} in the current dynamic root.
1175  @end deffn  @end deffn
1176    
1177   with-fluids*   with-fluids*
1178  @deffn primitive with-fluids* fluids values thunk  @deffn {Scheme Procedure} with-fluids* fluids values thunk
1179    @deffnx {C Function} scm_with_fluids (fluids, values, thunk)
1180  Set @var{fluids} to @var{values} temporary, and call @var{thunk}.  Set @var{fluids} to @var{values} temporary, and call @var{thunk}.
1181  @var{fluids} must be a list of fluids and @var{values} must be the same  @var{fluids} must be a list of fluids and @var{values} must be the same
1182  number of their values to be applied.  Each substitution is done  number of their values to be applied.  Each substitution is done
# Line 1073  one after another.  @var{thunk} must be Line 1184  one after another.  @var{thunk} must be
1184  @end deffn  @end deffn
1185    
1186   setvbuf   setvbuf
1187  @deffn primitive setvbuf port mode [size]  @deffn {Scheme Procedure} setvbuf port mode [size]
1188    @deffnx {C Function} scm_setvbuf (port, mode, size)
1189  Set the buffering mode for @var{port}.  @var{mode} can be:  Set the buffering mode for @var{port}.  @var{mode} can be:
1190  @table @code  @table @code
1191  @item _IONBF  @item _IONBF
# Line 1087  If @var{size} is omitted, a default size Line 1199  If @var{size} is omitted, a default size
1199  @end deffn  @end deffn
1200    
1201   file-port?   file-port?
1202  @deffn primitive file-port? obj  @deffn {Scheme Procedure} file-port? obj
1203    @deffnx {C Function} scm_file_port_p (obj)
1204  Determine whether @var{obj} is a port that is related to a file.  Determine whether @var{obj} is a port that is related to a file.
1205  @end deffn  @end deffn
1206    
1207   open-file   open-file
1208  @deffn primitive open-file filename mode  @deffn {Scheme Procedure} open-file filename mode
1209    @deffnx {C Function} scm_open_file (filename, mode)
1210  Open the file whose name is @var{filename}, and return a port  Open the file whose name is @var{filename}, and return a port
1211  representing that file.  The attributes of the port are  representing that file.  The attributes of the port are
1212  determined by the @var{mode} string.  The way in which this is  determined by the @var{mode} string.  The way in which this is
# Line 1133  requested, @code{open-file} throws an ex Line 1247  requested, @code{open-file} throws an ex
1247  @end deffn  @end deffn
1248    
1249   gc-stats   gc-stats
1250  @deffn primitive gc-stats  @deffn {Scheme Procedure} gc-stats
1251    @deffnx {C Function} scm_gc_stats ()
1252  Return an association list of statistics about Guile's current  Return an association list of statistics about Guile's current
1253  use of storage.  use of storage.
1254  @end deffn  @end deffn
1255    
1256   object-address   object-address
1257  @deffn primitive object-address obj  @deffn {Scheme Procedure} object-address obj
1258    @deffnx {C Function} scm_object_address (obj)
1259  Return an integer that for the lifetime of @var{obj} is uniquely  Return an integer that for the lifetime of @var{obj} is uniquely
1260  returned by this function for @var{obj}  returned by this function for @var{obj}
1261  @end deffn  @end deffn
1262    
1263   gc   gc
1264  @deffn primitive gc  @deffn {Scheme Procedure} gc
1265    @deffnx {C Function} scm_gc ()
1266  Scans all of SCM objects and reclaims for further use those that are  Scans all of SCM objects and reclaims for further use those that are
1267  no longer accessible.  no longer accessible.
1268  @end deffn  @end deffn
1269    
1270   %compute-slots   %compute-slots
1271  @deffn primitive %compute-slots class  @deffn {Scheme Procedure} %compute-slots class
1272    @deffnx {C Function} scm_sys_compute_slots (class)
1273  Return a list consisting of the names of all slots belonging to  Return a list consisting of the names of all slots belonging to
1274  class @var{class}, i. e. the slots of @var{class} and of all of  class @var{class}, i. e. the slots of @var{class} and of all of
1275  its superclasses.  its superclasses.
1276  @end deffn  @end deffn
1277    
1278   get-keyword   get-keyword
1279  @deffn primitive get-keyword key l default_value  @deffn {Scheme Procedure} get-keyword key l default_value
1280    @deffnx {C Function} scm_get_keyword (key, l, default_value)
1281  Determine an associated value for the keyword @var{key} from  Determine an associated value for the keyword @var{key} from
1282  the list @var{l}.  The list @var{l} has to consist of an even  the list @var{l}.  The list @var{l} has to consist of an even
1283  number of elements, where, starting with the first, every  number of elements, where, starting with the first, every
# Line 1168  If @var{l} does not hold a value for @va Line 1287  If @var{l} does not hold a value for @va
1287  @end deffn  @end deffn
1288    
1289   %initialize-object   %initialize-object
1290  @deffn primitive %initialize-object obj initargs  @deffn {Scheme Procedure} %initialize-object obj initargs
1291    @deffnx {C Function} scm_sys_initialize_object (obj, initargs)
1292  Initialize the object @var{obj} with the given arguments  Initialize the object @var{obj} with the given arguments
1293  @var{initargs}.  @var{initargs}.
1294  @end deffn  @end deffn
1295    
1296   %prep-layout!   %prep-layout!
1297  @deffn primitive %prep-layout! class  @deffn {Scheme Procedure} %prep-layout! class
1298    @deffnx {C Function} scm_sys_prep_layout_x (class)
1299    
1300  @end deffn  @end deffn
1301    
1302   %inherit-magic!   %inherit-magic!
1303  @deffn primitive %inherit-magic! class dsupers  @deffn {Scheme Procedure} %inherit-magic! class dsupers
1304    @deffnx {C Function} scm_sys_inherit_magic_x (class, dsupers)
1305    
1306  @end deffn  @end deffn
1307    
1308   instance?   instance?
1309  @deffn primitive instance? obj  @deffn {Scheme Procedure} instance? obj
1310    @deffnx {C Function} scm_instance_p (obj)
1311  Return @code{#t} if @var{obj} is an instance.  Return @code{#t} if @var{obj} is an instance.
1312  @end deffn  @end deffn
1313    
1314   class-name   class-name
1315  @deffn primitive class-name obj  @deffn {Scheme Procedure} class-name obj
1316    @deffnx {C Function} scm_class_name (obj)
1317  Return the class name of @var{obj}.  Return the class name of @var{obj}.
1318  @end deffn  @end deffn
1319    
1320   class-direct-supers   class-direct-supers
1321  @deffn primitive class-direct-supers obj  @deffn {Scheme Procedure} class-direct-supers obj
1322    @deffnx {C Function} scm_class_direct_supers (obj)
1323  Return the direct superclasses of the class @var{obj}.  Return the direct superclasses of the class @var{obj}.
1324  @end deffn  @end deffn
1325    
1326   class-direct-slots   class-direct-slots
1327  @deffn primitive class-direct-slots obj  @deffn {Scheme Procedure} class-direct-slots obj
1328    @deffnx {C Function} scm_class_direct_slots (obj)
1329  Return the direct slots of the class @var{obj}.  Return the direct slots of the class @var{obj}.
1330  @end deffn  @end deffn
1331    
1332   class-direct-subclasses   class-direct-subclasses
1333  @deffn primitive class-direct-subclasses obj  @deffn {Scheme Procedure} class-direct-subclasses obj
1334    @deffnx {C Function} scm_class_direct_subclasses (obj)
1335  Return the direct subclasses of the class @var{obj}.  Return the direct subclasses of the class @var{obj}.
1336  @end deffn  @end deffn
1337    
1338   class-direct-methods   class-direct-methods
1339  @deffn primitive class-direct-methods obj  @deffn {Scheme Procedure} class-direct-methods obj
1340    @deffnx {C Function} scm_class_direct_methods (obj)
1341  Return the direct methods of the class @var{obj}  Return the direct methods of the class @var{obj}
1342  @end deffn  @end deffn
1343    
1344   class-precedence-list   class-precedence-list
1345  @deffn primitive class-precedence-list obj  @deffn {Scheme Procedure} class-precedence-list obj
1346    @deffnx {C Function} scm_class_precedence_list (obj)
1347  Return the class precedence list of the class @var{obj}.  Return the class precedence list of the class @var{obj}.
1348  @end deffn  @end deffn
1349    
1350   class-slots   class-slots
1351  @deffn primitive class-slots obj  @deffn {Scheme Procedure} class-slots obj
1352    @deffnx {C Function} scm_class_slots (obj)
1353  Return the slot list of the class @var{obj}.  Return the slot list of the class @var{obj}.
1354  @end deffn  @end deffn
1355    
1356   class-environment   class-environment
1357  @deffn primitive class-environment obj  @deffn {Scheme Procedure} class-environment obj
1358    @deffnx {C Function} scm_class_environment (obj)
1359  Return the environment of the class @var{obj}.  Return the environment of the class @var{obj}.
1360  @end deffn  @end deffn
1361    
1362   generic-function-name   generic-function-name
1363  @deffn primitive generic-function-name obj  @deffn {Scheme Procedure} generic-function-name obj
1364    @deffnx {C Function} scm_generic_function_name (obj)
1365  Return the name of the generic function @var{obj}.  Return the name of the generic function @var{obj}.
1366  @end deffn  @end deffn
1367    
1368   generic-function-methods   generic-function-methods
1369  @deffn primitive generic-function-methods obj  @deffn {Scheme Procedure} generic-function-methods obj
1370    @deffnx {C Function} scm_generic_function_methods (obj)
1371  Return the methods of the generic function @var{obj}.  Return the methods of the generic function @var{obj}.
1372  @end deffn  @end deffn
1373    
1374   method-generic-function   method-generic-function
1375  @deffn primitive method-generic-function obj  @deffn {Scheme Procedure} method-generic-function obj
1376  Return the generic function fot the method @var{obj}.  @deffnx {C Function} scm_method_generic_function (obj)
1377    Return the generic function for the method @var{obj}.
1378  @end deffn  @end deffn
1379    
1380   method-specializers   method-specializers
1381  @deffn primitive method-specializers obj  @deffn {Scheme Procedure} method-specializers obj
1382    @deffnx {C Function} scm_method_specializers (obj)
1383  Return specializers of the method @var{obj}.  Return specializers of the method @var{obj}.
1384  @end deffn  @end deffn
1385    
1386   method-procedure   method-procedure
1387  @deffn primitive method-procedure obj  @deffn {Scheme Procedure} method-procedure obj
1388    @deffnx {C Function} scm_method_procedure (obj)
1389  Return the procedure of the method @var{obj}.  Return the procedure of the method @var{obj}.
1390  @end deffn  @end deffn
1391    
1392   accessor-method-slot-definition   accessor-method-slot-definition
1393  @deffn primitive accessor-method-slot-definition obj  @deffn {Scheme Procedure} accessor-method-slot-definition obj
1394    @deffnx {C Function} scm_accessor_method_slot_definition (obj)
1395  Return the slot definition of the accessor @var{obj}.  Return the slot definition of the accessor @var{obj}.
1396  @end deffn  @end deffn
1397    
1398   %tag-body   %tag-body
1399  @deffn primitive %tag-body body  @deffn {Scheme Procedure} %tag-body body
1400    @deffnx {C Function} scm_sys_tag_body (body)
1401  Internal GOOPS magic---don't use this function!  Internal GOOPS magic---don't use this function!
1402  @end deffn  @end deffn
1403    
1404   make-unbound   make-unbound
1405  @deffn primitive make-unbound  @deffn {Scheme Procedure} make-unbound
1406    @deffnx {C Function} scm_make_unbound ()
1407  Return the unbound value.  Return the unbound value.
1408  @end deffn  @end deffn
1409    
1410   unbound?   unbound?
1411  @deffn primitive unbound? obj  @deffn {Scheme Procedure} unbound? obj
1412    @deffnx {C Function} scm_unbound_p (obj)
1413  Return @code{#t} if @var{obj} is unbound.  Return @code{#t} if @var{obj} is unbound.
1414  @end deffn  @end deffn
1415    
1416   assert-bound   assert-bound
1417  @deffn primitive assert-bound value obj  @deffn {Scheme Procedure} assert-bound value obj
1418    @deffnx {C Function} scm_assert_bound (value, obj)
1419  Return @var{value} if it is bound, and invoke the  Return @var{value} if it is bound, and invoke the
1420  @var{slot-unbound} method of @var{obj} if it is not.  @var{slot-unbound} method of @var{obj} if it is not.
1421  @end deffn  @end deffn
1422    
1423   @@assert-bound-ref   @@assert-bound-ref
1424  @deffn primitive @@assert-bound-ref obj index  @deffn {Scheme Procedure} @@assert-bound-ref obj index
1425    @deffnx {C Function} scm_at_assert_bound_ref (obj, index)
1426  Like @code{assert-bound}, but use @var{index} for accessing  Like @code{assert-bound}, but use @var{index} for accessing
1427  the value from @var{obj}.  the value from @var{obj}.
1428  @end deffn  @end deffn
1429    
1430   %fast-slot-ref   %fast-slot-ref
1431  @deffn primitive %fast-slot-ref obj index  @deffn {Scheme Procedure} %fast-slot-ref obj index
1432    @deffnx {C Function} scm_sys_fast_slot_ref (obj, index)
1433  Return the slot value with index @var{index} from @var{obj}.  Return the slot value with index @var{index} from @var{obj}.
1434  @end deffn  @end deffn
1435    
1436   %fast-slot-set!   %fast-slot-set!
1437  @deffn primitive %fast-slot-set! obj index value  @deffn {Scheme Procedure} %fast-slot-set! obj index value
1438    @deffnx {C Function} scm_sys_fast_slot_set_x (obj, index, value)
1439  Set the slot with index @var{index} in @var{obj} to  Set the slot with index @var{index} in @var{obj} to
1440  @var{value}.  @var{value}.
1441  @end deffn  @end deffn
1442    
1443   slot-ref-using-class   slot-ref-using-class
1444  @deffn primitive slot-ref-using-class class obj slot_name  @deffn {Scheme Procedure} slot-ref-using-class class obj slot_name
1445    @deffnx {C Function} scm_slot_ref_using_class (class, obj, slot_name)
1446    
1447  @end deffn  @end deffn
1448    
1449   slot-set-using-class!   slot-set-using-class!
1450  @deffn primitive slot-set-using-class! class obj slot_name value  @deffn {Scheme Procedure} slot-set-using-class! class obj slot_name value
1451    @deffnx {C Function} scm_slot_set_using_class_x (class, obj, slot_name, value)
1452    
1453  @end deffn  @end deffn
1454    
1455   slot-bound-using-class?   slot-bound-using-class?
1456  @deffn primitive slot-bound-using-class? class obj slot_name  @deffn {Scheme Procedure} slot-bound-using-class? class obj slot_name
1457    @deffnx {C Function} scm_slot_bound_using_class_p (class, obj, slot_name)
1458    
1459  @end deffn  @end deffn
1460    
1461   slot-exists-using-class?   slot-exists-using-class?
1462  @deffn primitive slot-exists-using-class? class obj slot_name  @deffn {Scheme Procedure} slot-exists-using-class? class obj slot_name
1463    @deffnx {C Function} scm_slot_exists_using_class_p (class, obj, slot_name)
1464    
1465  @end deffn  @end deffn
1466    
1467   slot-ref   slot-ref
1468  @deffn primitive slot-ref obj slot_name  @deffn {Scheme Procedure} slot-ref obj slot_name
1469    @deffnx {C Function} scm_slot_ref (obj, slot_name)
1470  Return the value from @var{obj}'s slot with the name  Return the value from @var{obj}'s slot with the name
1471  @var{slot_name}.  @var{slot_name}.
1472  @end deffn  @end deffn
1473    
1474   slot-set!   slot-set!
1475  @deffn primitive slot-set! obj slot_name value  @deffn {Scheme Procedure} slot-set! obj slot_name value
1476    @deffnx {C Function} scm_slot_set_x (obj, slot_name, value)
1477  Set the slot named @var{slot_name} of @var{obj} to @var{value}.  Set the slot named @var{slot_name} of @var{obj} to @var{value}.
1478  @end deffn  @end deffn
1479    
1480   slot-bound?   slot-bound?
1481  @deffn primitive slot-bound? obj slot_name  @deffn {Scheme Procedure} slot-bound? obj slot_name
1482    @deffnx {C Function} scm_slot_bound_p (obj, slot_name)
1483  Return @code{#t} if the slot named @var{slot_name} of @var{obj}  Return @code{#t} if the slot named @var{slot_name} of @var{obj}
1484  is bound.  is bound.
1485  @end deffn  @end deffn
1486    
1487   slot-exists?   slot-exists?
1488  @deffn primitive slot-exists? obj slot_name  @deffn {Scheme Procedure} slot-exists? obj slot_name
1489    @deffnx {C Function} scm_slots_exists_p (obj, slot_name)
1490  Return @code{#t} if @var{obj} has a slot named @var{slot_name}.  Return @code{#t} if @var{obj} has a slot named @var{slot_name}.
1491  @end deffn  @end deffn
1492    
1493   %allocate-instance   %allocate-instance
1494  @deffn primitive %allocate-instance class initargs  @deffn {Scheme Procedure} %allocate-instance class initargs
1495    @deffnx {C Function} scm_sys_allocate_instance (class, initargs)
1496  Create a new instance of class @var{class} and initialize it  Create a new instance of class @var{class} and initialize it
1497  from the arguments @var{initargs}.  from the arguments @var{initargs}.
1498  @end deffn  @end deffn
1499    
1500   %set-object-setter!   %set-object-setter!
1501  @deffn primitive %set-object-setter! obj setter  @deffn {Scheme Procedure} %set-object-setter! obj setter
1502    @deffnx {C Function} scm_sys_set_object_setter_x (obj, setter)
1503    
1504  @end deffn  @end deffn
1505    
1506   %modify-instance   %modify-instance
1507  @deffn primitive %modify-instance old new  @deffn {Scheme Procedure} %modify-instance old new
1508    @deffnx {C Function} scm_sys_modify_instance (old, new)
1509    
1510  @end deffn  @end deffn
1511    
1512   %modify-class   %modify-class
1513  @deffn primitive %modify-class old new  @deffn {Scheme Procedure} %modify-class old new
1514    @deffnx {C Function} scm_sys_modify_class (old, new)
1515    
1516  @end deffn  @end deffn
1517    
1518   %invalidate-class   %invalidate-class
1519  @deffn primitive %invalidate-class class  @deffn {Scheme Procedure} %invalidate-class class
1520    @deffnx {C Function} scm_sys_invalidate_class (class)
1521    
1522  @end deffn  @end deffn
1523    
1524   %invalidate-method-cache!   %invalidate-method-cache!
1525  @deffn primitive %invalidate-method-cache! gf  @deffn {Scheme Procedure} %invalidate-method-cache! gf
1526    @deffnx {C Function} scm_sys_invalidate_method_cache_x (gf)
1527    
1528  @end deffn  @end deffn
1529    
1530   generic-capability?   generic-capability?
1531  @deffn primitive generic-capability? proc  @deffn {Scheme Procedure} generic-capability? proc
1532    @deffnx {C Function} scm_generic_capability_p (proc)
1533    
1534  @end deffn  @end deffn
1535    
1536   enable-primitive-generic!   enable-primitive-generic!
1537  @deffn primitive enable-primitive-generic! . subrs  @deffn {Scheme Procedure} enable-primitive-generic! . subrs
1538    @deffnx {C Function} scm_enable_primitive_generic_x (subrs)
1539    
1540  @end deffn  @end deffn
1541    
1542   primitive-generic-generic   primitive-generic-generic
1543  @deffn primitive primitive-generic-generic subr  @deffn {Scheme Procedure} primitive-generic-generic subr
1544    @deffnx {C Function} scm_primitive_generic_generic (subr)
1545    
1546  @end deffn  @end deffn
1547    
1548   make   make
1549  @deffn primitive make . args  @deffn {Scheme Procedure} make . args
1550    @deffnx {C Function} scm_make (args)
1551  Make a new object.  @var{args} must contain the class and  Make a new object.  @var{args} must contain the class and
1552  all necessary initialization information.  all necessary initialization information.
1553  @end deffn  @end deffn
1554    
1555   find-method   find-method
1556  @deffn primitive find-method . l  @deffn {Scheme Procedure} find-method . l
1557    @deffnx {C Function} scm_find_method (l)
1558    
1559  @end deffn  @end deffn
1560    
1561   %method-more-specific?   %method-more-specific?
1562  @deffn primitive %method-more-specific? m1 m2 targs  @deffn {Scheme Procedure} %method-more-specific? m1 m2 targs
1563    @deffnx {C Function} scm_sys_method_more_specific_p (m1, m2, targs)
1564    
1565  @end deffn  @end deffn
1566    
1567   %goops-loaded   %goops-loaded
1568  @deffn primitive %goops-loaded  @deffn {Scheme Procedure} %goops-loaded
1569    @deffnx {C Function} scm_sys_goops_loaded ()
1570  Announce that GOOPS is loaded and perform initialization  Announce that GOOPS is loaded and perform initialization
1571  on the C level which depends on the loaded GOOPS modules.  on the C level which depends on the loaded GOOPS modules.
1572  @end deffn  @end deffn
1573    
1574   make-guardian   make-guardian
1575  @deffn primitive make-guardian [greedy_p]  @deffn {Scheme Procedure} make-guardian [greedy_p]
1576    @deffnx {C Function} scm_make_guardian (greedy_p)
1577  Create a new guardian.  Create a new guardian.
1578  A guardian protects a set of objects from garbage collection,  A guardian protects a set of objects from garbage collection,
1579  allowing a program to apply cleanup or other actions.  allowing a program to apply cleanup or other actions.
# Line 1436  paper still (mostly) accurately describe Line 1602  paper still (mostly) accurately describe
1602  @end deffn  @end deffn
1603    
1604   guardian-destroyed?   guardian-destroyed?
1605  @deffn primitive guardian-destroyed? guardian  @deffn {Scheme Procedure} guardian-destroyed? guardian
1606    @deffnx {C Function} scm_guardian_destroyed_p (guardian)
1607  Return @code{#t} if @var{guardian} has been destroyed, otherwise @code{#f}.  Return @code{#t} if @var{guardian} has been destroyed, otherwise @code{#f}.
1608  @end deffn  @end deffn
1609    
1610   guardian-greedy?   guardian-greedy?
1611  @deffn primitive guardian-greedy? guardian  @deffn {Scheme Procedure} guardian-greedy? guardian
1612    @deffnx {C Function} scm_guardian_greedy_p (guardian)
1613  Return @code{#t} if @var{guardian} is a greedy guardian, otherwise @code{#f}.  Return @code{#t} if @var{guardian} is a greedy guardian, otherwise @code{#f}.
1614  @end deffn  @end deffn
1615    
1616   destroy-guardian!   destroy-guardian!
1617  @deffn primitive destroy-guardian! guardian  @deffn {Scheme Procedure} destroy-guardian! guardian
1618    @deffnx {C Function} scm_destroy_guardian_x (guardian)
1619  Destroys @var{guardian}, by making it impossible to put any more  Destroys @var{guardian}, by making it impossible to put any more
1620  objects in it or get any objects from it.  It also unguards any  objects in it or get any objects from it.  It also unguards any
1621  objects guarded by @var{guardian}.  objects guarded by @var{guardian}.
1622  @end deffn  @end deffn
1623    
1624   hashq   hashq
1625  @deffn primitive hashq key size  @deffn {Scheme Procedure} hashq key size
1626    @deffnx {C Function} scm_hashq (key, size)
1627  Determine a hash value for @var{key} that is suitable for  Determine a hash value for @var{key} that is suitable for
1628  lookups in a hashtable of size @var{size}, where @code{eq?} is  lookups in a hashtable of size @var{size}, where @code{eq?} is
1629  used as the equality predicate.  The function returns an  used as the equality predicate.  The function returns an
# Line 1467  different values, since @code{foo} will Line 1637  different values, since @code{foo} will
1637  @end deffn  @end deffn
1638    
1639   hashv   hashv
1640  @deffn primitive hashv key size  @deffn {Scheme Procedure} hashv key size
1641    @deffnx {C Function} scm_hashv (key, size)
1642  Determine a hash value for @var{key} that is suitable for  Determine a hash value for @var{key} that is suitable for
1643  lookups in a hashtable of size @var{size}, where @code{eqv?} is  lookups in a hashtable of size @var{size}, where @code{eqv?} is
1644  used as the equality predicate.  The function returns an  used as the equality predicate.  The function returns an
# Line 1481  different values, since @code{foo} will Line 1652  different values, since @code{foo} will
1652  @end deffn  @end deffn
1653    
1654   hash   hash
1655  @deffn primitive hash key size  @deffn {Scheme Procedure} hash key size
1656    @deffnx {C Function} scm_hash (key, size)
1657  Determine a hash value for @var{key} that is suitable for  Determine a hash value for @var{key} that is suitable for
1658  lookups in a hashtable of size @var{size}, where @code{equal?}  lookups in a hashtable of size @var{size}, where @code{equal?}
1659  is used as the equality predicate.  The function returns an  is used as the equality predicate.  The function returns an
# Line 1489  integer in the range 0 to @var{size} - 1 Line 1661  integer in the range 0 to @var{size} - 1
1661  @end deffn  @end deffn
1662    
1663   hashq-get-handle   hashq-get-handle
1664  @deffn primitive hashq-get-handle table key  @deffn {Scheme Procedure} hashq-get-handle table key
1665    @deffnx {C Function} scm_hashq_get_handle (table, key)
1666  This procedure returns the @code{(key . value)} pair from the  This procedure returns the @code{(key . value)} pair from the
1667  hash table @var{table}.  If @var{table} does not hold an  hash table @var{table}.  If @var{table} does not hold an
1668  associated value for @var{key}, @code{#f} is returned.  associated value for @var{key}, @code{#f} is returned.
# Line 1497  Uses @code{eq?} for equality testing. Line 1670  Uses @code{eq?} for equality testing.
1670  @end deffn  @end deffn
1671    
1672   hashq-create-handle!   hashq-create-handle!
1673  @deffn primitive hashq-create-handle! table key init  @deffn {Scheme Procedure} hashq-create-handle! table key init
1674    @deffnx {C Function} scm_hashq_create_handle_x (table, key, init)
1675  This function looks up @var{key} in @var{table} and returns its handle.  This function looks up @var{key} in @var{table} and returns its handle.
1676  If @var{key} is not already present, a new handle is created which  If @var{key} is not already present, a new handle is created which
1677  associates @var{key} with @var{init}.  associates @var{key} with @var{init}.
1678  @end deffn  @end deffn
1679    
1680   hashq-ref   hashq-ref
1681  @deffn primitive hashq-ref table key [dflt]  @deffn {Scheme Procedure} hashq-ref table key [dflt]
1682    @deffnx {C Function} scm_hashq_ref (table, key, dflt)
1683  Look up @var{key} in the hash table @var{table}, and return the  Look up @var{key} in the hash table @var{table}, and return the
1684  value (if any) associated with it.  If @var{key} is not found,  value (if any) associated with it.  If @var{key} is not found,
1685  return @var{default} (or @code{#f} if no @var{default} argument  return @var{default} (or @code{#f} if no @var{default} argument
# Line 1512  is supplied).  Uses @code{eq?} for equal Line 1687  is supplied).  Uses @code{eq?} for equal
1687  @end deffn  @end deffn
1688    
1689   hashq-set!   hashq-set!
1690  @deffn primitive hashq-set! table key val  @deffn {Scheme Procedure} hashq-set! table key val
1691    @deffnx {C Function} scm_hashq_set_x (table, key, val)
1692  Find the entry in @var{table} associated with @var{key}, and  Find the entry in @var{table} associated with @var{key}, and
1693  store @var{value} there. Uses @code{eq?} for equality testing.  store @var{value} there. Uses @code{eq?} for equality testing.
1694  @end deffn  @end deffn
1695    
1696   hashq-remove!   hashq-remove!
1697  @deffn primitive hashq-remove! table key  @deffn {Scheme Procedure} hashq-remove! table key
1698    @deffnx {C Function} scm_hashq_remove_x (table, key)
1699  Remove @var{key} (and any value associated with it) from  Remove @var{key} (and any value associated with it) from
1700  @var{table}.  Uses @code{eq?} for equality tests.  @var{table}.  Uses @code{eq?} for equality tests.
1701  @end deffn  @end deffn
1702    
1703   hashv-get-handle   hashv-get-handle
1704  @deffn primitive hashv-get-handle table key  @deffn {Scheme Procedure} hashv-get-handle table key
1705    @deffnx {C Function} scm_hashv_get_handle (table, key)
1706  This procedure returns the @code{(key . value)} pair from the  This procedure returns the @code{(key . value)} pair from the
1707  hash table @var{table}.  If @var{table} does not hold an  hash table @var{table}.  If @var{table} does not hold an
1708  associated value for @var{key}, @code{#f} is returned.  associated value for @var{key}, @code{#f} is returned.
# Line 1532  Uses @code{eqv?} for equality testing. Line 1710  Uses @code{eqv?} for equality testing.
1710  @end deffn  @end deffn
1711    
1712   hashv-create-handle!   hashv-create-handle!
1713  @deffn primitive hashv-create-handle! table key init  @deffn {Scheme Procedure} hashv-create-handle! table key init
1714    @deffnx {C Function} scm_hashv_create_handle_x (table, key, init)
1715  This function looks up @var{key} in @var{table} and returns its handle.  This function looks up @var{key} in @var{table} and returns its handle.
1716  If @var{key} is not already present, a new handle is created which  If @var{key} is not already present, a new handle is created which
1717  associates @var{key} with @var{init}.  associates @var{key} with @var{init}.
1718  @end deffn  @end deffn
1719    
1720   hashv-ref   hashv-ref
1721  @deffn primitive hashv-ref table key [dflt]  @deffn {Scheme Procedure} hashv-ref table key [dflt]
1722    @deffnx {C Function} scm_hashv_ref (table, key, dflt)
1723  Look up @var{key} in the hash table @var{table}, and return the  Look up @var{key} in the hash table @var{table}, and return the
1724  value (if any) associated with it.  If @var{key} is not found,  value (if any) associated with it.  If @var{key} is not found,
1725  return @var{default} (or @code{#f} if no @var{default} argument  return @var{default} (or @code{#f} if no @var{default} argument
# Line 1547  is supplied).  Uses @code{eqv?} for equa Line 1727  is supplied).  Uses @code{eqv?} for equa
1727  @end deffn  @end deffn
1728    
1729   hashv-set!   hashv-set!
1730  @deffn primitive hashv-set! table key val  @deffn {Scheme Procedure} hashv-set! table key val
1731    @deffnx {C Function} scm_hashv_set_x (table, key, val)
1732  Find the entry in @var{table} associated with @var{key}, and  Find the entry in @var{table} associated with @var{key}, and
1733  store @var{value} there. Uses @code{eqv?} for equality testing.  store @var{value} there. Uses @code{eqv?} for equality testing.
1734  @end deffn  @end deffn
1735    
1736   hashv-remove!   hashv-remove!
1737  @deffn primitive hashv-remove! table key  @deffn {Scheme Procedure} hashv-remove! table key
1738    @deffnx {C Function} scm_hashv_remove_x (table, key)
1739  Remove @var{key} (and any value associated with it) from  Remove @var{key} (and any value associated with it) from
1740  @var{table}.  Uses @code{eqv?} for equality tests.  @var{table}.  Uses @code{eqv?} for equality tests.
1741  @end deffn  @end deffn
1742    
1743   hash-get-handle   hash-get-handle
1744  @deffn primitive hash-get-handle table key  @deffn {Scheme Procedure} hash-get-handle table key
1745    @deffnx {C Function} scm_hash_get_handle (table, key)
1746  This procedure returns the @code{(key . value)} pair from the  This procedure returns the @code{(key . value)} pair from the
1747  hash table @var{table}.  If @var{table} does not hold an  hash table @var{table}.  If @var{table} does not hold an
1748  associated value for @var{key}, @code{#f} is returned.  associated value for @var{key}, @code{#f} is returned.
# Line 1567  Uses @code{equal?} for equality testing. Line 1750  Uses @code{equal?} for equality testing.
1750  @end deffn  @end deffn
1751    
1752   hash-create-handle!   hash-create-handle!
1753  @deffn primitive hash-create-handle! table key init  @deffn {Scheme Procedure} hash-create-handle! table key init
1754    @deffnx {C Function} scm_hash_create_handle_x (table, key, init)
1755  This function looks up @var{key} in @var{table} and returns its handle.  This function looks up @var{key} in @var{table} and returns its handle.
1756  If @var{key} is not already present, a new handle is created which  If @var{key} is not already present, a new handle is created which
1757  associates @var{key} with @var{init}.  associates @var{key} with @var{init}.
1758  @end deffn  @end deffn
1759    
1760   hash-ref   hash-ref
1761  @deffn primitive hash-ref table key [dflt]  @deffn {Scheme Procedure} hash-ref table key [dflt]
1762    @deffnx {C Function} scm_hash_ref (table, key, dflt)
1763  Look up @var{key} in the hash table @var{table}, and return the  Look up @var{key} in the hash table @var{table}, and return the
1764  value (if any) associated with it.  If @var{key} is not found,  value (if any) associated with it.  If @var{key} is not found,
1765  return @var{default} (or @code{#f} if no @var{default} argument  return @var{default} (or @code{#f} if no @var{default} argument
# Line 1582  is supplied).  Uses @code{equal?} for eq Line 1767  is supplied).  Uses @code{equal?} for eq
1767  @end deffn  @end deffn
1768    
1769   hash-set!   hash-set!
1770  @deffn primitive hash-set! table key val  @deffn {Scheme Procedure} hash-set! table key val
1771    @deffnx {C Function} scm_hash_set_x (table, key, val)
1772  Find the entry in @var{table} associated with @var{key}, and  Find the entry in @var{table} associated with @var{key}, and
1773  store @var{value} there. Uses @code{equal?} for equality  store @var{value} there. Uses @code{equal?} for equality
1774  testing.  testing.
1775  @end deffn  @end deffn
1776    
1777   hash-remove!   hash-remove!
1778  @deffn primitive hash-remove! table key  @deffn {Scheme Procedure} hash-remove! table key
1779    @deffnx {C Function} scm_hash_remove_x (table, key)
1780  Remove @var{key} (and any value associated with it) from  Remove @var{key} (and any value associated with it) from
1781  @var{table}.  Uses @code{equal?} for equality tests.  @var{table}.  Uses @code{equal?} for equality tests.
1782  @end deffn  @end deffn
1783    
1784   hashx-get-handle   hashx-get-handle
1785  @deffn primitive hashx-get-handle hash assoc table key  @deffn {Scheme Procedure} hashx-get-handle hash assoc table key
1786    @deffnx {C Function} scm_hashx_get_handle (hash, assoc, table, key)
1787  This behaves the same way as the corresponding  This behaves the same way as the corresponding
1788  @code{-get-handle} function, but uses @var{hash} as a hash  @code{-get-handle} function, but uses @var{hash} as a hash
1789  function and @var{assoc} to compare keys.  @code{hash} must be  function and @var{assoc} to compare keys.  @code{hash} must be
# Line 1605  table size.  @code{assoc} must be an ass Line 1793  table size.  @code{assoc} must be an ass
1793  @end deffn  @end deffn
1794    
1795   hashx-create-handle!   hashx-create-handle!
1796  @deffn primitive hashx-create-handle! hash assoc table key init  @deffn {Scheme Procedure} hashx-create-handle! hash assoc table key init
1797    @deffnx {C Function} scm_hashx_create_handle_x (hash, assoc, table, key, init)
1798  This behaves the same way as the corresponding  This behaves the same way as the corresponding
1799  @code{-create-handle} function, but uses @var{hash} as a hash  @code{-create-handle} function, but uses @var{hash} as a hash
1800  function and @var{assoc} to compare keys.  @code{hash} must be  function and @var{assoc} to compare keys.  @code{hash} must be
# Line 1615  table size.  @code{assoc} must be an ass Line 1804  table size.  @code{assoc} must be an ass
1804  @end deffn  @end deffn
1805    
1806   hashx-ref   hashx-ref
1807  @deffn primitive hashx-ref hash assoc table key [dflt]  @deffn {Scheme Procedure} hashx-ref hash assoc table key [dflt]
1808    @deffnx {C Function} scm_hashx_ref (hash, assoc, table, key, dflt)
1809  This behaves the same way as the corresponding @code{ref}  This behaves the same way as the corresponding @code{ref}
1810  function, but uses @var{hash} as a hash function and  function, but uses @var{hash} as a hash function and
1811  @var{assoc} to compare keys.  @code{hash} must be a function  @var{assoc} to compare keys.  @code{hash} must be a function
# Line 1628  equivalent to @code{hashx-ref hashq assq Line 1818  equivalent to @code{hashx-ref hashq assq
1818  @end deffn  @end deffn
1819    
1820   hashx-set!   hashx-set!
1821  @deffn primitive hashx-set! hash assoc table key val  @deffn {Scheme Procedure} hashx-set! hash assoc table key val
1822    @deffnx {C Function} scm_hashx_set_x (hash, assoc, table, key, val)
1823  This behaves the same way as the corresponding @code{set!}  This behaves the same way as the corresponding @code{set!}
1824  function, but uses @var{hash} as a hash function and  function, but uses @var{hash} as a hash function and
1825  @var{assoc} to compare keys.  @code{hash} must be a function  @var{assoc} to compare keys.  @code{hash} must be a function
# Line 1641  equivalent to @code{hashx-set!  hashq as Line 1832  equivalent to @code{hashx-set!  hashq as
1832  @end deffn  @end deffn
1833    
1834   hash-fold   hash-fold
1835  @deffn primitive hash-fold proc init table  @deffn {Scheme Procedure} hash-fold proc init table
1836    @deffnx {C Function} scm_hash_fold (proc, init, table)
1837  An iterator over hash-table elements.  An iterator over hash-table elements.
1838  Accumulates and returns a result by applying PROC successively.  Accumulates and returns a result by applying PROC successively.
1839  The arguments to PROC are "(key value prior-result)" where key  The arguments to PROC are "(key value prior-result)" where key
# Line 1653  table into an a-list of key-value pairs. Line 1845  table into an a-list of key-value pairs.
1845  @end deffn  @end deffn
1846    
1847   make-hook   make-hook
1848  @deffn primitive make-hook [n_args]  @deffn {Scheme Procedure} make-hook [n_args]
1849    @deffnx {C Function} scm_make_hook (n_args)
1850  Create a hook for storing procedure of arity @var{n_args}.  Create a hook for storing procedure of arity @var{n_args}.
1851  @var{n_args} defaults to zero.  The returned value is a hook  @var{n_args} defaults to zero.  The returned value is a hook
1852  object to be used with the other hook procedures.  object to be used with the other hook procedures.
1853  @end deffn  @end deffn
1854    
1855   hook?   hook?
1856  @deffn primitive hook? x  @deffn {Scheme Procedure} hook? x
1857    @deffnx {C Function} scm_hook_p (x)
1858  Return @code{#t} if @var{x} is a hook, @code{#f} otherwise.  Return @code{#t} if @var{x} is a hook, @code{#f} otherwise.
1859  @end deffn  @end deffn
1860    
1861   hook-empty?   hook-empty?
1862  @deffn primitive hook-empty? hook  @deffn {Scheme Procedure} hook-empty? hook
1863    @deffnx {C Function} scm_hook_empty_p (hook)
1864  Return @code{#t} if @var{hook} is an empty hook, @code{#f}  Return @code{#t} if @var{hook} is an empty hook, @code{#f}
1865  otherwise.  otherwise.
1866  @end deffn  @end deffn
1867    
1868   add-hook!   add-hook!
1869  @deffn primitive add-hook! hook proc [append_p]  @deffn {Scheme Procedure} add-hook! hook proc [append_p]
1870    @deffnx {C Function} scm_add_hook_x (hook, proc, append_p)
1871  Add the procedure @var{proc} to the hook @var{hook}. The  Add the procedure @var{proc} to the hook @var{hook}. The
1872  procedure is added to the end if @var{append_p} is true,  procedure is added to the end if @var{append_p} is true,
1873  otherwise it is added to the front.  The return value of this  otherwise it is added to the front.  The return value of this
# Line 1679  procedure is not specified. Line 1875  procedure is not specified.
1875  @end deffn  @end deffn
1876    
1877   remove-hook!   remove-hook!
1878  @deffn primitive remove-hook! hook proc  @deffn {Scheme Procedure} remove-hook! hook proc
1879    @deffnx {C Function} scm_remove_hook_x (hook, proc)
1880  Remove the procedure @var{proc} from the hook @var{hook}.  The  Remove the procedure @var{proc} from the hook @var{hook}.  The
1881  return value of this procedure is not specified.  return value of this procedure is not specified.
1882  @end deffn  @end deffn
1883    
1884   reset-hook!   reset-hook!
1885  @deffn primitive reset-hook! hook  @deffn {Scheme Procedure} reset-hook! hook
1886    @deffnx {C Function} scm_reset_hook_x (hook)
1887  Remove all procedures from the hook @var{hook}.  The return  Remove all procedures from the hook @var{hook}.  The return
1888  value of this procedure is not specified.  value of this procedure is not specified.
1889  @end deffn  @end deffn
1890    
1891   run-hook   run-hook
1892  @deffn primitive run-hook hook . args  @deffn {Scheme Procedure} run-hook hook . args
1893    @deffnx {C Function} scm_run_hook (hook, args)
1894  Apply all procedures from the hook @var{hook} to the arguments  Apply all procedures from the hook @var{hook} to the arguments
1895  @var{args}.  The order of the procedure application is first to  @var{args}.  The order of the procedure application is first to
1896  last.  The return value of this procedure is not specified.  last.  The return value of this procedure is not specified.
1897  @end deffn  @end deffn
1898    
1899   hook->list   hook->list
1900  @deffn primitive hook->list hook  @deffn {Scheme Procedure} hook->list hook
1901    @deffnx {C Function} scm_hook_to_list (hook)
1902  Convert the procedure list of @var{hook} to a list.  Convert the procedure list of @var{hook} to a list.
1903  @end deffn  @end deffn
1904    
1905   ftell   ftell
1906  @deffn primitive ftell fd_port  @deffn {Scheme Procedure} ftell fd_port
1907    @deffnx {C Function} scm_ftell (fd_port)
1908  Return an integer representing the current position of  Return an integer representing the current position of
1909  @var{fd/port}, measured from the beginning.  Equivalent to:  @var{fd/port}, measured from the beginning.  Equivalent to:
1910    
# Line 1713  Return an integer representing the curre Line 1914  Return an integer representing the curre
1914  @end deffn  @end deffn
1915    
1916   redirect-port   redirect-port
1917  @deffn primitive redirect-port old new  @deffn {Scheme Procedure} redirect-port old new
1918    @deffnx {C Function} scm_redirect_port (old, new)
1919  This procedure takes two ports and duplicates the underlying file  This procedure takes two ports and duplicates the underlying file
1920  descriptor from @var{old-port} into @var{new-port}.  The  descriptor from @var{old-port} into @var{new-port}.  The
1921  current file descriptor in @var{new-port} will be closed.  current file descriptor in @var{new-port} will be closed.
# Line 1730  revealed counts. Line 1932  revealed counts.
1932  @end deffn  @end deffn
1933    
1934   dup->fdes   dup->fdes
1935  @deffn primitive dup->fdes fd_or_port [fd]  @deffn {Scheme Procedure} dup->fdes fd_or_port [fd]
1936    @deffnx {C Function} scm_dup_to_fdes (fd_or_port, fd)
1937  Return a new integer file descriptor referring to the open file  Return a new integer file descriptor referring to the open file
1938  designated by @var{fd_or_port}, which must be either an open  designated by @var{fd_or_port}, which must be either an open
1939  file port or a file descriptor.  file port or a file descriptor.
1940  @end deffn  @end deffn
1941    
1942   dup2   dup2
1943  @deffn primitive dup2 oldfd newfd  @deffn {Scheme Procedure} dup2 oldfd newfd
1944    @deffnx {C Function} scm_dup2 (oldfd, newfd)
1945  A simple wrapper for the @code{dup2} system call.  A simple wrapper for the @code{dup2} system call.
1946  Copies the file descriptor @var{oldfd} to descriptor  Copies the file descriptor @var{oldfd} to descriptor
1947  number @var{newfd}, replacing the previous meaning  number @var{newfd}, replacing the previous meaning
# Line 1749  The return value is unspecified. Line 1953  The return value is unspecified.
1953  @end deffn  @end deffn
1954    
1955   fileno   fileno
1956  @deffn primitive fileno port  @deffn {Scheme Procedure} fileno port
1957    @deffnx {C Function} scm_fileno (port)
1958  Return the integer file descriptor underlying @var{port}.  Does  Return the integer file descriptor underlying @var{port}.  Does
1959  not change its revealed count.  not change its revealed count.
1960  @end deffn  @end deffn
1961    
1962   isatty?   isatty?
1963  @deffn primitive isatty? port  @deffn {Scheme Procedure} isatty? port
1964    @deffnx {C Function} scm_isatty_p (port)
1965  Return @code{#t} if @var{port} is using a serial non--file  Return @code{#t} if @var{port} is using a serial non--file
1966  device, otherwise @code{#f}.  device, otherwise @code{#f}.
1967  @end deffn  @end deffn
1968    
1969   fdopen   fdopen
1970  @deffn primitive fdopen fdes modes  @deffn {Scheme Procedure} fdopen fdes modes
1971    @deffnx {C Function} scm_fdopen (fdes, modes)
1972  Return a new port based on the file descriptor @var{fdes}.  Return a new port based on the file descriptor @var{fdes}.
1973  Modes are given by the string @var{modes}.  The revealed count  Modes are given by the string @var{modes}.  The revealed count
1974  of the port is initialized to zero.  The modes string is the  of the port is initialized to zero.  The modes string is the
# Line 1769  same as that accepted by @ref{File Ports Line 1976  same as that accepted by @ref{File Ports
1976  @end deffn  @end deffn
1977    
1978   primitive-move->fdes   primitive-move->fdes
1979  @deffn primitive primitive-move->fdes port fd  @deffn {Scheme Procedure} primitive-move->fdes port fd
1980    @deffnx {C Function} scm_primitive_move_to_fdes (port, fd)
1981  Moves the underlying file descriptor for @var{port} to the integer  Moves the underlying file descriptor for @var{port} to the integer
1982  value @var{fdes} without changing the revealed count of @var{port}.  value @var{fdes} without changing the revealed count of @var{port}.
1983  Any other ports already using this descriptor will be automatically  Any other ports already using this descriptor will be automatically
# Line 1779  required value or @code{#t} if it was mo Line 1987  required value or @code{#t} if it was mo
1987  @end deffn  @end deffn
1988    
1989   fdes->ports   fdes->ports
1990  @deffn primitive fdes->ports fd  @deffn {Scheme Procedure} fdes->ports fd
1991    @deffnx {C Function} scm_fdes_to_ports (fd)
1992  Return a list of existing ports which have @var{fdes} as an  Return a list of existing ports which have @var{fdes} as an
1993  underlying file descriptor, without changing their revealed  underlying file descriptor, without changing their revealed
1994  counts.  counts.
1995  @end deffn  @end deffn
1996    
1997   make-keyword-from-dash-symbol   make-keyword-from-dash-symbol
1998  @deffn primitive make-keyword-from-dash-symbol symbol  @deffn {Scheme Procedure} make-keyword-from-dash-symbol symbol
1999    @deffnx {C Function} scm_make_keyword_from_dash_symbol (symbol)
2000  Make a keyword object from a @var{symbol} that starts with a dash.  Make a keyword object from a @var{symbol} that starts with a dash.
2001  @end deffn  @end deffn
2002    
2003   keyword?   keyword?
2004  @deffn primitive keyword? obj  @deffn {Scheme Procedure} keyword? obj
2005    @deffnx {C Function} scm_keyword_p (obj)
2006  Return @code{#t} if the argument @var{obj} is a keyword, else  Return @code{#t} if the argument @var{obj} is a keyword, else
2007  @code{#f}.  @code{#f}.
2008  @end deffn  @end deffn
2009    
2010   keyword-dash-symbol   keyword-dash-symbol
2011  @deffn primitive keyword-dash-symbol keyword  @deffn {Scheme Procedure} keyword-dash-symbol keyword
2012    @deffnx {C Function} scm_keyword_dash_symbol (keyword)
2013  Return the dash symbol for @var{keyword}.  Return the dash symbol for @var{keyword}.
2014  This is the inverse of @code{make-keyword-from-dash-symbol}.  This is the inverse of @code{make-keyword-from-dash-symbol}.
2015  @end deffn  @end deffn
2016    
2017   nil-cons   nil-cons
2018  @deffn primitive nil-cons x y  @deffn {Scheme Procedure} nil-cons x y
2019    @deffnx {C Function} scm_nil_cons (x, y)
2020  Create a new cons cell with @var{x} as the car and @var{y} as  Create a new cons cell with @var{x} as the car and @var{y} as
2021  the cdr, but convert @var{y} to Scheme's end-of-list if it is  the cdr, but convert @var{y} to Scheme's end-of-list if it is
2022  a LISP nil.  a LISP nil.
2023  @end deffn  @end deffn
2024    
2025   nil-car   nil-car
2026  @deffn primitive nil-car x  @deffn {Scheme Procedure} nil-car x
2027    @deffnx {C Function} scm_nil_car (x)
2028  Return the car of @var{x}, but convert it to LISP nil if it  Return the car of @var{x}, but convert it to LISP nil if it
2029  is Scheme's end-of-list.  is Scheme's end-of-list.
2030  @end deffn  @end deffn
2031    
2032   nil-cdr   nil-cdr
2033  @deffn primitive nil-cdr x  @deffn {Scheme Procedure} nil-cdr x
2034    @deffnx {C Function} scm_nil_cdr (x)
2035  Return the cdr of @var{x}, but convert it to LISP nil if it  Return the cdr of @var{x}, but convert it to LISP nil if it
2036  is Scheme's end-of-list.  is Scheme's end-of-list.
2037  @end deffn  @end deffn
2038    
2039   null   null
2040  @deffn primitive null x  @deffn {Scheme Procedure} null x
2041    @deffnx {C Function} scm_null (x)
2042  Return LISP's @code{t} if @var{x} is nil in the LISP sense,  Return LISP's @code{t} if @var{x} is nil in the LISP sense,
2043  return LISP's nil otherwise.  return LISP's nil otherwise.
2044  @end deffn  @end deffn
2045    
2046   nil-eq   nil-eq
2047  @deffn primitive nil-eq x y  @deffn {Scheme Procedure} nil-eq x y
2048  Compare @var{x} and @var{y} and return LISP's t if they are  Compare @var{x} and @var{y} and return LISP's t if they are
2049  @code{eq?}, return LISP's nil otherwise.  @code{eq?}, return LISP's nil otherwise.
2050  @end deffn  @end deffn
2051    
2052   list   list
2053  @deffn primitive list . objs  @deffn {Scheme Procedure} list . objs
2054    @deffnx {C Function} scm_list (objs)
2055  Return a list containing @var{objs}, the arguments to  Return a list containing @var{objs}, the arguments to
2056  @code{list}.  @code{list}.
2057  @end deffn  @end deffn
2058    
2059   list*   list*
2060  @deffn primitive list*  @deffn {Scheme Procedure} list*
2061  implemented by the C function "scm_cons_star"  implemented by the C function "scm_cons_star"
2062  @end deffn  @end deffn
2063    
2064   cons*   cons*
2065  @deffn primitive cons* arg . rest  @deffn {Scheme Procedure} cons* arg . rest
2066    @deffnx {C Function} scm_cons_star (arg, rest)
2067  Like @code{list}, but the last arg provides the tail of the  Like @code{list}, but the last arg provides the tail of the
2068  constructed list, returning @code{(cons @var{arg1} (cons  constructed list, returning @code{(cons @var{arg1} (cons
2069  @var{arg2} (cons @dots{} @var{argn})))}.  Requires at least one  @var{arg2} (cons @dots{} @var{argn})))}.  Requires at least one
# Line 1855  Schemes and in Common LISP. Line 2073  Schemes and in Common LISP.
2073  @end deffn  @end deffn
2074    
2075   null?   null?
2076  @deffn primitive null? x  @deffn {Scheme Procedure} null? x
2077    @deffnx {C Function} scm_null_p (x)
2078  Return @code{#t} iff @var{x} is the empty list, else @code{#f}.  Return @code{#t} iff @var{x} is the empty list, else @code{#f}.
2079  @end deffn  @end deffn
2080    
2081   list?   list?
2082  @deffn primitive list? x  @deffn {Scheme Procedure} list? x
2083    @deffnx {C Function} scm_list_p (x)
2084  Return @code{#t} iff @var{x} is a proper list, else @code{#f}.  Return @code{#t} iff @var{x} is a proper list, else @code{#f}.
2085  @end deffn  @end deffn
2086    
2087   length   length
2088  @deffn primitive length lst  @deffn {Scheme Procedure} length lst
2089    @deffnx {C Function} scm_length (lst)
2090  Return the number of elements in list @var{lst}.  Return the number of elements in list @var{lst}.
2091  @end deffn  @end deffn
2092    
2093   append   append
2094  @deffn primitive append . args  @deffn {Scheme Procedure} append . args
2095    @deffnx {C Function} scm_append (args)
2096  Return a list consisting of the elements the lists passed as  Return a list consisting of the elements the lists passed as
2097  arguments.  arguments.
2098  @lisp  @lisp
# Line 1889  if the last argument is not a proper lis Line 2111  if the last argument is not a proper lis
2111  @end deffn  @end deffn
2112    
2113   append!   append!
2114  @deffn primitive append! . lists  @deffn {Scheme Procedure} append! . lists
2115    @deffnx {C Function} scm_append_x (lists)
2116  A destructive version of @code{append} (@pxref{Pairs and  A destructive version of @code{append} (@pxref{Pairs and
2117  Lists,,,r5rs, The Revised^5 Report on Scheme}).  The cdr field  Lists,,,r5rs, The Revised^5 Report on Scheme}).  The cdr field
2118  of each list's final pair is changed to point to the head of  of each list's final pair is changed to point to the head of
# Line 1898  the mutated list. Line 2121  the mutated list.
2121  @end deffn  @end deffn
2122    
2123   last-pair   last-pair
2124  @deffn primitive last-pair lst  @deffn {Scheme Procedure} last-pair lst
2125    @deffnx {C Function} scm_last_pair (lst)
2126  Return a pointer to the last pair in @var{lst}, signalling an error if  Return a pointer to the last pair in @var{lst}, signalling an error if
2127  @var{lst} is circular.  @var{lst} is circular.
2128  @end deffn  @end deffn
2129    
2130   reverse   reverse
2131  @deffn primitive reverse lst  @deffn {Scheme Procedure} reverse lst
2132    @deffnx {C Function} scm_reverse (lst)
2133  Return a new list that contains the elements of @var{lst} but  Return a new list that contains the elements of @var{lst} but
2134  in reverse order.  in reverse order.
2135  @end deffn  @end deffn
2136    
2137   reverse!   reverse!
2138  @deffn primitive reverse! lst [new_tail]  @deffn {Scheme Procedure} reverse! lst [new_tail]
2139    @deffnx {C Function} scm_reverse_x (lst, new_tail)
2140  A destructive version of @code{reverse} (@pxref{Pairs and Lists,,,r5rs,  A destructive version of @code{reverse} (@pxref{Pairs and Lists,,,r5rs,
2141  The Revised^5 Report on Scheme}).  The cdr of each cell in @var{lst} is  The Revised^5 Report on Scheme}).  The cdr of each cell in @var{lst} is
2142  modified to point to the previous list element.  Return a pointer to the  modified to point to the previous list element.  Return a pointer to the
# Line 1925  of the modified list is not lost, it is Line 2151  of the modified list is not lost, it is
2151  @end deffn  @end deffn
2152    
2153   list-ref   list-ref
2154  @deffn primitive list-ref list k  @deffn {Scheme Procedure} list-ref list k
2155    @deffnx {C Function} scm_list_ref (list, k)
2156  Return the @var{k}th element from @var{list}.  Return the @var{k}th element from @var{list}.
2157  @end deffn  @end deffn
2158    
2159   list-set!   list-set!
2160  @deffn primitive list-set! list k val  @deffn {Scheme Procedure} list-set! list k val
2161    @deffnx {C Function} scm_list_set_x (list, k, val)
2162  Set the @var{k}th element of @var{list} to @var{val}.  Set the @var{k}th element of @var{list} to @var{val}.
2163  @end deffn  @end deffn
2164    
2165   list-cdr-ref   list-cdr-ref
2166  @deffn primitive list-cdr-ref  @deffn {Scheme Procedure} list-cdr-ref
2167  implemented by the C function "scm_list_tail"  implemented by the C function "scm_list_tail"
2168  @end deffn  @end deffn
2169    
2170   list-tail   list-tail
2171  @deffn primitive list-tail lst k  @deffn {Scheme Procedure} list-tail lst k
2172  @deffnx primitive list-cdr-ref lst k  @deffnx {Scheme Procedure} list-cdr-ref lst k
2173    @deffnx {C Function} scm_list_tail (lst, k)
2174  Return the "tail" of @var{lst} beginning with its @var{k}th element.  Return the "tail" of @var{lst} beginning with its @var{k}th element.
2175  The first element of the list is considered to be element 0.  The first element of the list is considered to be element 0.
2176    
# Line 1951  or returning the results of cdring @var{ Line 2180  or returning the results of cdring @var{
2180  @end deffn  @end deffn
2181    
2182   list-cdr-set!   list-cdr-set!
2183  @deffn primitive list-cdr-set! list k val  @deffn {Scheme Procedure} list-cdr-set! list k val
2184    @deffnx {C Function} scm_list_cdr_set_x (list, k, val)
2185  Set the @var{k}th cdr of @var{list} to @var{val}.  Set the @var{k}th cdr of @var{list} to @var{val}.
2186  @end deffn  @end deffn
2187    
2188   list-head   list-head
2189  @deffn primitive list-head lst k  @deffn {Scheme Procedure} list-head lst k
2190    @deffnx {C Function} scm_list_head (lst, k)
2191  Copy the first @var{k} elements from @var{lst} into a new list, and  Copy the first @var{k} elements from @var{lst} into a new list, and
2192  return it.  return it.
2193  @end deffn  @end deffn
2194    
2195   list-copy   list-copy
2196  @deffn primitive list-copy lst  @deffn {Scheme Procedure} list-copy lst
2197    @deffnx {C Function} scm_list_copy (lst)
2198  Return a (newly-created) copy of @var{lst}.  Return a (newly-created) copy of @var{lst}.
2199  @end deffn  @end deffn
2200    
2201   sloppy-memq   sloppy-memq
2202  @deffn primitive sloppy-memq x lst  @deffn {Scheme Procedure} sloppy-memq x lst
2203    @deffnx {C Function} scm_sloppy_memq (x, lst)
2204  This procedure behaves like @code{memq}, but does no type or error checking.  This procedure behaves like @code{memq}, but does no type or error checking.
2205  Its use is recommended only in writing Guile internals,  Its use is recommended only in writing Guile internals,
2206  not for high-level Scheme programs.  not for high-level Scheme programs.
2207  @end deffn  @end deffn
2208    
2209   sloppy-memv   sloppy-memv
2210  @deffn primitive sloppy-memv x lst  @deffn {Scheme Procedure} sloppy-memv x lst
2211    @deffnx {C Function} scm_sloppy_memv (x, lst)
2212  This procedure behaves like @code{memv}, but does no type or error checking.  This procedure behaves like @code{memv}, but does no type or error checking.
2213  Its use is recommended only in writing Guile internals,  Its use is recommended only in writing Guile internals,
2214  not for high-level Scheme programs.  not for high-level Scheme programs.
2215  @end deffn  @end deffn
2216    
2217   sloppy-member   sloppy-member
2218  @deffn primitive sloppy-member x lst  @deffn {Scheme Procedure} sloppy-member x lst
2219    @deffnx {C Function} scm_sloppy_member (x, lst)
2220  This procedure behaves like @code{member}, but does no type or error checking.  This procedure behaves like @code{member}, but does no type or error checking.
2221  Its use is recommended only in writing Guile internals,  Its use is recommended only in writing Guile internals,
2222  not for high-level Scheme programs.  not for high-level Scheme programs.
2223  @end deffn  @end deffn
2224    
2225   memq   memq
2226  @deffn primitive memq x lst  @deffn {Scheme Procedure} memq x lst
2227    @deffnx {C Function} scm_memq (x, lst)
2228  Return the first sublist of @var{lst} whose car is @code{eq?}  Return the first sublist of @var{lst} whose car is @code{eq?}
2229  to @var{x} where the sublists of @var{lst} are the non-empty  to @var{x} where the sublists of @var{lst} are the non-empty
2230  lists returned by @code{(list-tail @var{lst} @var{k})} for  lists returned by @code{(list-tail @var{lst} @var{k})} for
# Line 1998  returned. Line 2234  returned.
2234  @end deffn  @end deffn
2235    
2236   memv   memv
2237  @deffn primitive memv x lst  @deffn {Scheme Procedure} memv x lst
2238    @deffnx {C Function} scm_memv (x, lst)
2239  Return the first sublist of @var{lst} whose car is @code{eqv?}  Return the first sublist of @var{lst} whose car is @code{eqv?}
2240  to @var{x} where the sublists of @var{lst} are the non-empty  to @var{x} where the sublists of @var{lst} are the non-empty
2241  lists returned by @code{(list-tail @var{lst} @var{k})} for  lists returned by @code{(list-tail @var{lst} @var{k})} for
# Line 2008  returned. Line 2245  returned.
2245  @end deffn  @end deffn
2246    
2247   member   member
2248  @deffn primitive member x lst  @deffn {Scheme Procedure} member x lst
2249    @deffnx {C Function} scm_member (x, lst)
2250  Return the first sublist of @var{lst} whose car is  Return the first sublist of @var{lst} whose car is
2251  @code{equal?} to @var{x} where the sublists of @var{lst} are  @code{equal?} to @var{x} where the sublists of @var{lst} are
2252  the non-empty lists returned by @code{(list-tail @var{lst}  the non-empty lists returned by @code{(list-tail @var{lst}
# Line 2018  empty list) is returned. Line 2256  empty list) is returned.
2256  @end deffn  @end deffn
2257    
2258   delq!   delq!
2259  @deffn primitive delq! item lst  @deffn {Scheme Procedure} delq! item lst
2260  @deffnx primitive delv! item lst  @deffnx {Scheme Procedure} delv! item lst
2261  @deffnx primitive delete! item lst  @deffnx {Scheme Procedure} delete! item lst
2262    @deffnx {C Function} scm_delq_x (item, lst)
2263  These procedures are destructive versions of @code{delq}, @code{delv}  These procedures are destructive versions of @code{delq}, @code{delv}
2264  and @code{delete}: they modify the pointers in the existing @var{lst}  and @code{delete}: they modify the pointers in the existing @var{lst}
2265  rather than creating a new list.  Caveat evaluator: Like other  rather than creating a new list.  Caveat evaluator: Like other
# Line 2030  destructive list functions, these functi Line 2269  destructive list functions, these functi
2269  @end deffn  @end deffn
2270    
2271   delv!   delv!
2272  @deffn primitive delv! item lst  @deffn {Scheme Procedure} delv! item lst
2273    @deffnx {C Function} scm_delv_x (item, lst)
2274  Destructively remove all elements from @var{lst} that are  Destructively remove all elements from @var{lst} that are
2275  @code{eqv?} to @var{item}.  @code{eqv?} to @var{item}.
2276  @end deffn  @end deffn
2277    
2278   delete!   delete!
2279  @deffn primitive delete! item lst  @deffn {Scheme Procedure} delete! item lst
2280    @deffnx {C Function} scm_delete_x (item, lst)
2281  Destructively remove all elements from @var{lst} that are  Destructively remove all elements from @var{lst} that are
2282  @code{equal?} to @var{item}.  @code{equal?} to @var{item}.
2283  @end deffn  @end deffn
2284    
2285   delq   delq
2286  @deffn primitive delq item lst  @deffn {Scheme Procedure} delq item lst
2287    @deffnx {C Function} scm_delq (item, lst)
2288  Return a newly-created copy of @var{lst} with elements  Return a newly-created copy of @var{lst} with elements
2289  @code{eq?} to @var{item} removed.  This procedure mirrors  @code{eq?} to @var{item} removed.  This procedure mirrors
2290  @code{memq}: @code{delq} compares elements of @var{lst} against  @code{memq}: @code{delq} compares elements of @var{lst} against
# Line 2050  Return a newly-created copy of @var{lst} Line 2292  Return a newly-created copy of @var{lst}
2292  @end deffn  @end deffn
2293    
2294   delv   delv
2295  @deffn primitive delv item lst  @deffn {Scheme Procedure} delv item lst
2296    @deffnx {C Function} scm_delv (item, lst)
2297  Return a newly-created copy of @var{lst} with elements  Return a newly-created copy of @var{lst} with elements
2298  @code{eqv?}  to @var{item} removed.  This procedure mirrors  @code{eqv?}  to @var{item} removed.  This procedure mirrors
2299  @code{memv}: @code{delv} compares elements of @var{lst} against  @code{memv}: @code{delv} compares elements of @var{lst} against
# Line 2058  Return a newly-created copy of @var{lst} Line 2301  Return a newly-created copy of @var{lst}
2301  @end deffn  @end deffn
2302    
2303   delete   delete
2304  @deffn primitive delete item lst  @deffn {Scheme Procedure} delete item lst
2305    @deffnx {C Function} scm_delete (item, lst)
2306  Return a newly-created copy of @var{lst} with elements  Return a newly-created copy of @var{lst} with elements
2307  @code{equal?}  to @var{item} removed.  This procedure mirrors  @code{equal?}  to @var{item} removed.  This procedure mirrors
2308  @code{member}: @code{delete} compares elements of @var{lst}  @code{member}: @code{delete} compares elements of @var{lst}
# Line 2066  against @var{item} with @code{equal?}. Line 2310  against @var{item} with @code{equal?}.
2310  @end deffn  @end deffn
2311    
2312   delq1!   delq1!
2313  @deffn primitive delq1! item lst  @deffn {Scheme Procedure} delq1! item lst
2314    @deffnx {C Function} scm_delq1_x (item, lst)
2315  Like @code{delq!}, but only deletes the first occurrence of  Like @code{delq!}, but only deletes the first occurrence of
2316  @var{item} from @var{lst}.  Tests for equality using  @var{item} from @var{lst}.  Tests for equality using
2317  @code{eq?}.  See also @code{delv1!} and @code{delete1!}.  @code{eq?}.  See also @code{delv1!} and @code{delete1!}.
2318  @end deffn  @end deffn
2319    
2320   delv1!   delv1!
2321  @deffn primitive delv1! item lst  @deffn {Scheme Procedure} delv1! item lst
2322    @deffnx {C Function} scm_delv1_x (item, lst)
2323  Like @code{delv!}, but only deletes the first occurrence of  Like @code{delv!}, but only deletes the first occurrence of
2324  @var{item} from @var{lst}.  Tests for equality using  @var{item} from @var{lst}.  Tests for equality using
2325  @code{eqv?}.  See also @code{delq1!} and @code{delete1!}.  @code{eqv?}.  See also @code{delq1!} and @code{delete1!}.
2326  @end deffn  @end deffn
2327    
2328   delete1!   delete1!
2329  @deffn primitive delete1! item lst  @deffn {Scheme Procedure} delete1! item lst
2330    @deffnx {C Function} scm_delete1_x (item, lst)
2331  Like @code{delete!}, but only deletes the first occurrence of  Like @code{delete!}, but only deletes the first occurrence of
2332  @var{item} from @var{lst}.  Tests for equality using  @var{item} from @var{lst}.  Tests for equality using
2333  @code{equal?}.  See also @code{delq1!} and @code{delv1!}.  @code{equal?}.  See also @code{delq1!} and @code{delv1!}.
2334  @end deffn  @end deffn
2335    
2336   primitive-load   primitive-load
2337  @deffn primitive primitive-load filename  @deffn {Scheme Procedure} primitive-load filename
2338    @deffnx {C Function} scm_primitive_load (filename)
2339  Load the file named @var{filename} and evaluate its contents in  Load the file named @var{filename} and evaluate its contents in
2340  the top-level environment. The load paths are not searched;  the top-level environment. The load paths are not searched;
2341  @var{filename} must either be a full pathname or be a pathname  @var{filename} must either be a full pathname or be a pathname
# Line 2098  documentation for @code{%load-hook} late Line 2346  documentation for @code{%load-hook} late
2346  @end deffn  @end deffn
2347    
2348   %package-data-dir   %package-data-dir
2349  @deffn primitive %package-data-dir  @deffn {Scheme Procedure} %package-data-dir
2350    @deffnx {C Function} scm_sys_package_data_dir ()
2351  Return the name of the directory where Scheme packages, modules and  Return the name of the directory where Scheme packages, modules and
2352  libraries are kept.  On most Unix systems, this will be  libraries are kept.  On most Unix systems, this will be
2353  @samp{/usr/local/share/guile}.  @samp{/usr/local/share/guile}.
2354  @end deffn  @end deffn
2355    
2356   %library-dir   %library-dir
2357  @deffn primitive %library-dir  @deffn {Scheme Procedure} %library-dir
2358    @deffnx {C Function} scm_sys_library_dir ()
2359  Return the directory where the Guile Scheme library files are installed.  Return the directory where the Guile Scheme library files are installed.
2360  E.g., may return "/usr/share/guile/1.3.5".  E.g., may return "/usr/share/guile/1.3.5".
2361  @end deffn  @end deffn
2362    
2363   %site-dir   %site-dir
2364  @deffn primitive %site-dir  @deffn {Scheme Procedure} %site-dir
2365    @deffnx {C Function} scm_sys_site_dir ()
2366  Return the directory where the Guile site files are installed.  Return the directory where the Guile site files are installed.
2367  E.g., may return "/usr/share/guile/site".  E.g., may return "/usr/share/guile/site".
2368  @end deffn  @end deffn
2369    
2370   parse-path   parse-path
2371  @deffn primitive parse-path path [tail]  @deffn {Scheme Procedure} parse-path path [tail]
2372    @deffnx {C Function} scm_parse_path (path, tail)
2373  Parse @var{path}, which is expected to be a colon-separated  Parse @var{path}, which is expected to be a colon-separated
2374  string, into a list and return the resulting list with  string, into a list and return the resulting list with
2375  @var{tail} appended. If @var{path} is @code{#f}, @var{tail}  @var{tail} appended. If @var{path} is @code{#f}, @var{tail}
# Line 2125  is returned. Line 2377  is returned.
2377  @end deffn  @end deffn
2378    
2379   search-path   search-path
2380  @deffn primitive search-path path filename [extensions]  @deffn {Scheme Procedure} search-path path filename [extensions]
2381    @deffnx {C Function} scm_search_path (path, filename, extensions)
2382  Search @var{path} for a directory containing a file named  Search @var{path} for a directory containing a file named
2383  @var{filename}. The file must be readable, and not a directory.  @var{filename}. The file must be readable, and not a directory.
2384  If we find one, return its full filename; otherwise, return  If we find one, return its full filename; otherwise, return
# Line 2136  concatenated with each @var{extension}. Line 2389  concatenated with each @var{extension}.
2389  @end deffn  @end deffn
2390    
2391   %search-load-path   %search-load-path
2392  @deffn primitive %search-load-path filename  @deffn {Scheme Procedure} %search-load-path filename
2393    @deffnx {C Function} scm_sys_search_load_path (filename)
2394  Search @var{%load-path} for the file named @var{filename},  Search @var{%load-path} for the file named @var{filename},
2395  which must be readable by the current user.  If @var{filename}  which must be readable by the current user.  If @var{filename}
2396  is found in the list of paths to search or is an absolute  is found in the list of paths to search or is an absolute
# Line 2147  will try each extension automatically. Line 2401  will try each extension automatically.
2401  @end deffn  @end deffn
2402    
2403   primitive-load-path   primitive-load-path
2404  @deffn primitive primitive-load-path filename  @deffn {Scheme Procedure} primitive-load-path filename
2405    @deffnx {C Function} scm_primitive_load_path (filename)
2406  Search @var{%load-path} for the file named @var{filename} and  Search @var{%load-path} for the file named @var{filename} and
2407  load it into the top-level environment.  If @var{filename} is a  load it into the top-level environment.  If @var{filename} is a
2408  relative pathname and is not found in the list of search paths,  relative pathname and is not found in the list of search paths,
# Line 2155  an error is signalled. Line 2410  an error is signalled.
2410  @end deffn  @end deffn
2411    
2412   read-and-eval!   read-and-eval!
2413  @deffn primitive read-and-eval! [port]  @deffn {Scheme Procedure} read-and-eval! [port]
2414    @deffnx {C Function} scm_read_and_eval_x (port)
2415  Read a form from @var{port} (standard input by default), and evaluate it  Read a form from @var{port} (standard input by default), and evaluate it
2416  (memoizing it in the process) in the top-level environment.  If no data  (memoizing it in the process) in the top-level environment.  If no data
2417  is left to be read from @var{port}, an @code{end-of-file} error is  is left to be read from @var{port}, an @code{end-of-file} error is
# Line 2163  signalled. Line 2419  signalled.
2419  @end deffn  @end deffn
2420    
2421   procedure->syntax   procedure->syntax
2422  @deffn primitive procedure->syntax code  @deffn {Scheme Procedure} procedure->syntax code
2423    @deffnx {C Function} scm_makacro (code)
2424  Return a @dfn{macro} which, when a symbol defined to this value  Return a @dfn{macro} which, when a symbol defined to this value
2425  appears as the first symbol in an expression, returns the  appears as the first symbol in an expression, returns the
2426  result of applying @var{code} to the expression and the  result of applying @var{code} to the expression and the
# Line 2171  environment. Line 2428  environment.
2428  @end deffn  @end deffn
2429    
2430   procedure->macro   procedure->macro
2431  @deffn primitive procedure->macro code  @deffn {Scheme Procedure} procedure->macro code
2432    @deffnx {C Function} scm_makmacro (code)
2433  Return a @dfn{macro} which, when a symbol defined to this value  Return a @dfn{macro} which, when a symbol defined to this value
2434  appears as the first symbol in an expression, evaluates the  appears as the first symbol in an expression, evaluates the
2435  result of applying @var{code} to the expression and the  result of applying @var{code} to the expression and the
2436  environment.  The value returned from @var{code} which has been  environment.  For example:
 passed to @code{procedure->memoizing-macro} replaces the form  
 passed to @var{code}.  For example:  
2437    
2438  @lisp  @lisp
2439  (define trace  (define trace
# Line 2189  passed to @var{code}.  For example: Line 2445  passed to @var{code}.  For example:
2445  @end deffn  @end deffn
2446    
2447   procedure->memoizing-macro   procedure->memoizing-macro
2448  @deffn primitive procedure->memoizing-macro code  @deffn {Scheme Procedure} procedure->memoizing-macro code
2449    @deffnx {C Function} scm_makmmacro (code)
2450  Return a @dfn{macro} which, when a symbol defined to this value  Return a @dfn{macro} which, when a symbol defined to this value
2451  appears as the first symbol in an expression, evaluates the  appears as the first symbol in an expression, evaluates the
2452  result of applying @var{proc} to the expression and the  result of applying @var{code} to the expression and the
2453  environment.  The value returned from @var{proc} which has been  environment.
 passed to @code{procedure->memoizing-macro} replaces the form  
 passed to @var{proc}.  For example:  
   
 @lisp  
 (define trace  
   (procedure->macro  
    (lambda (x env) `(set! ,(cadr x) (tracef ,(cadr x) ',(cadr x))))))  
2454    
2455  (trace @i{foo}) @equiv{} (set! @i{foo} (tracef @i{foo} '@i{foo})).  @code{procedure->memoizing-macro} is the same as
2456  @end lisp  @code{procedure->macro}, except that the expression returned by
2457    @var{code} replaces the original macro expression in the memoized
2458    form of the containing code.
2459  @end deffn  @end deffn
2460    
2461   macro?   macro?
2462  @deffn primitive macro? obj  @deffn {Scheme Procedure} macro? obj
2463    @deffnx {C Function} scm_macro_p (obj)
2464  Return @code{#t} if @var{obj} is a regular macro, a memoizing macro or a  Return @code{#t} if @var{obj} is a regular macro, a memoizing macro or a
2465  syntax transformer.  syntax transformer.
2466  @end deffn  @end deffn
2467    
2468   macro-type   macro-type
2469  @deffn primitive macro-type m  @deffn {Scheme Procedure} macro-type m
2470    @deffnx {C Function} scm_macro_type (m)
2471  Return one of the symbols @code{syntax}, @code{macro} or  Return one of the symbols @code{syntax}, @code{macro} or
2472  @code{macro!}, depending on whether @var{m} is a syntax  @code{macro!}, depending on whether @var{m} is a syntax
2473  tranformer, a regular macro, or a memoizing macro,  transformer, a regular macro, or a memoizing macro,
2474  respectively.  If @var{m} is not a macro, @code{#f} is  respectively.  If @var{m} is not a macro, @code{#f} is
2475  returned.  returned.
2476  @end deffn  @end deffn
2477    
2478   macro-name   macro-name
2479  @deffn primitive macro-name m  @deffn {Scheme Procedure} macro-name m
2480    @deffnx {C Function} scm_macro_name (m)
2481  Return the name of the macro @var{m}.  Return the name of the macro @var{m}.
2482  @end deffn  @end deffn
2483    
2484   macro-transformer   macro-transformer
2485  @deffn primitive macro-transformer m  @deffn {Scheme Procedure} macro-transformer m
2486    @deffnx {C Function} scm_macro_transformer (m)
2487  Return the transformer of the macro @var{m}.  Return the transformer of the macro @var{m}.
2488  @end deffn  @end deffn
2489    
2490   current-module   current-module
2491  @deffn primitive current-module  @deffn {Scheme Procedure} current-module
2492    @deffnx {C Function} scm_current_module ()
2493  Return the current module.  Return the current module.
2494  @end deffn  @end deffn
2495    
2496   set-current-module   set-current-module
2497  @deffn primitive set-current-module module  @deffn {Scheme Procedure} set-current-module module
2498    @deffnx {C Function} scm_set_current_module (module)
2499  Set the current module to @var{module} and return  Set the current module to @var{module} and return
2500  the previous current module.  the previous current module.
2501  @end deffn  @end deffn
2502    
2503   interaction-environment   interaction-environment
2504  @deffn primitive interaction-environment  @deffn {Scheme Procedure} interaction-environment
2505    @deffnx {C Function} scm_interaction_environment ()
2506  Return a specifier for the environment that contains  Return a specifier for the environment that contains
2507  implementation--defined bindings, typically a superset of those  implementation--defined bindings, typically a superset of those
2508  listed in the report.  The intent is that this procedure will  listed in the report.  The intent is that this procedure will
# Line 2252  evaluate expressions dynamically typed b Line 2511  evaluate expressions dynamically typed b
2511  @end deffn  @end deffn
2512    
2513   env-module   env-module
2514  @deffn primitive env-module env  @deffn {Scheme Procedure} env-module env
2515    @deffnx {C Function} scm_env_module (env)
2516  Return the module of @var{ENV}, a lexical environment.  Return the module of @var{ENV}, a lexical environment.
2517  @end deffn  @end deffn
2518    
2519   standard-eval-closure   standard-eval-closure
2520  @deffn primitive standard-eval-closure module  @deffn {Scheme Procedure} standard-eval-closure module
2521    @deffnx {C Function} scm_standard_eval_closure (module)
2522  Return an eval closure for the module @var{module}.  Return an eval closure for the module @var{module}.
2523  @end deffn  @end deffn
2524    
2525   standard-interface-eval-closure   standard-interface-eval-closure
2526  @deffn primitive standard-interface-eval-closure module  @deffn {Scheme Procedure} standard-interface-eval-closure module
2527    @deffnx {C Function} scm_standard_interface_eval_closure (module)
2528  Return a interface eval closure for the module @var{module}. Such a closure does not allow new bindings to be added.  Return a interface eval closure for the module @var{module}. Such a closure does not allow new bindings to be added.
2529  @end deffn  @end deffn
2530    
2531   %get-pre-modules-obarray   %get-pre-modules-obarray
2532  @deffn primitive %get-pre-modules-obarray  @deffn {Scheme Procedure} %get-pre-modules-obarray
2533    @deffnx {C Function} scm_get_pre_modules_obarray ()
2534  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.  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.
2535  @end deffn  @end deffn
2536    
2537   exact?   exact?
2538  @deffn primitive exact? x  @deffn {Scheme Procedure} exact? x
2539    @deffnx {C Function} scm_exact_p (x)
2540  Return @code{#t} if @var{x} is an exact number, @code{#f}  Return @code{#t} if @var{x} is an exact number, @code{#f}
2541  otherwise.  otherwise.
2542  @end deffn  @end deffn
2543    
2544   odd?   odd?
2545  @deffn primitive odd? n  @deffn {Scheme Procedure} odd? n
2546    @deffnx {C Function} scm_odd_p (n)
2547  Return @code{#t} if @var{n} is an odd number, @code{#f}  Return @code{#t} if @var{n} is an odd number, @code{#f}
2548  otherwise.  otherwise.
2549  @end deffn  @end deffn
2550    
2551   even?   even?
2552  @deffn primitive even? n  @deffn {Scheme Procedure} even? n
2553    @deffnx {C Function} scm_even_p (n)
2554  Return @code{#t} if @var{n} is an even number, @code{#f}  Return @code{#t} if @var{n} is an even number, @code{#f}
2555  otherwise.  otherwise.
2556  @end deffn  @end deffn
2557    
2558   logand   logand
2559  @deffn primitive logand n1 n2  @deffn {Scheme Procedure} logand n1 n2
2560  Return the bitwise AND of the integer arguments.  Return the bitwise AND of the integer arguments.
2561    
2562  @lisp  @lisp
# Line 2301  Return the bitwise AND of the integer ar Line 2567  Return the bitwise AND of the integer ar
2567  @end deffn  @end deffn
2568    
2569   logior   logior
2570  @deffn primitive logior n1 n2  @deffn {Scheme Procedure} logior n1 n2
2571  Return the bitwise OR of the integer arguments.  Return the bitwise OR of the integer arguments.
2572    
2573  @lisp  @lisp
# Line 2312  Return the bitwise OR of the integer arg Line 2578  Return the bitwise OR of the integer arg
2578  @end deffn  @end deffn
2579    
2580   logxor   logxor
2581  @deffn primitive logxor n1 n2  @deffn {Scheme Procedure} logxor n1 n2
2582  Return the bitwise XOR of the integer arguments.  A bit is  Return the bitwise XOR of the integer arguments.  A bit is
2583  set in the result if it is set in an odd number of arguments.  set in the result if it is set in an odd number of arguments.
2584  @lisp  @lisp
# Line 2324  set in the result if it is set in an odd Line 2590  set in the result if it is set in an odd
2590  @end deffn  @end deffn
2591    
2592   logtest   logtest
2593  @deffn primitive logtest j k  @deffn {Scheme Procedure} logtest j k
2594    @deffnx {C Function} scm_logtest (j, k)
2595  @lisp  @lisp
2596  (logtest j k) @equiv{} (not (zero? (logand j k)))  (logtest j k) @equiv{} (not (zero? (logand j k)))
2597    
# Line 2334  set in the result if it is set in an odd Line 2601  set in the result if it is set in an odd
2601  @end deffn  @end deffn
2602    
2603   logbit?   logbit?
2604  @deffn primitive logbit? index j  @deffn {Scheme Procedure} logbit? index j
2605    @deffnx {C Function} scm_logbit_p (index, j)
2606  @lisp  @lisp
2607  (logbit? index j) @equiv{} (logtest (integer-expt 2 index) j)  (logbit? index j) @equiv{} (logtest (integer-expt 2 index) j)
2608    
# Line 2347  set in the result if it is set in an odd Line 2615  set in the result if it is set in an odd
2615  @end deffn  @end deffn
2616    
2617   lognot   lognot
2618  @deffn primitive lognot n  @deffn {Scheme Procedure} lognot n
2619    @deffnx {C Function} scm_lognot (n)
2620  Return the integer which is the 2s-complement of the integer  Return the integer which is the 2s-complement of the integer
2621  argument.  argument.
2622    
# Line 2360  argument. Line 2629  argument.
2629  @end deffn  @end deffn
2630    
2631   integer-expt   integer-expt
2632  @deffn primitive integer-expt n k  @deffn {Scheme Procedure} integer-expt n k
2633    @deffnx {C Function} scm_integer_expt (n, k)
2634  Return @var{n} raised to the non-negative integer exponent  Return @var{n} raised to the non-negative integer exponent
2635  @var{k}.  @var{k}.
2636    
# Line 2373  Return @var{n} raised to the non-negativ Line 2643  Return @var{n} raised to the non-negativ
2643  @end deffn  @end deffn
2644    
2645   ash   ash
2646  @deffn primitive ash n cnt  @deffn {Scheme Procedure} ash n cnt
2647    @deffnx {C Function} scm_ash (n, cnt)
2648  The function ash performs an arithmetic shift left by @var{cnt}  The function ash performs an arithmetic shift left by @var{cnt}
2649  bits (or shift right, if @var{cnt} is negative).  'Arithmetic'  bits (or shift right, if @var{cnt} is negative).  'Arithmetic'
2650  means, that the function does not guarantee to keep the bit  means, that the function does not guarantee to keep the bit
# Line 2392  Formally, the function returns an intege Line 2663  Formally, the function returns an intege
2663  @end deffn  @end deffn
2664    
2665   bit-extract   bit-extract
2666  @deffn primitive bit-extract n start end  @deffn {Scheme Procedure} bit-extract n start end
2667    @deffnx {C Function} scm_bit_extract (n, start, end)
2668  Return the integer composed of the @var{start} (inclusive)  Return the integer composed of the @var{start} (inclusive)
2669  through @var{end} (exclusive) bits of @var{n}.  The  through @var{end} (exclusive) bits of @var{n}.  The
2670  @var{start}th bit becomes the 0-th bit in the result.  @var{start}th bit becomes the 0-th bit in the result.
# Line 2406  through @var{end} (exclusive) bits of @v Line 2678  through @var{end} (exclusive) bits of @v
2678  @end deffn  @end deffn
2679    
2680   logcount   logcount
2681  @deffn primitive logcount n  @deffn {Scheme Procedure} logcount n
2682    @deffnx {C Function} scm_logcount (n)
2683  Return the number of bits in integer @var{n}.  If integer is  Return the number of bits in integer @var{n}.  If integer is
2684  positive, the 1-bits in its binary representation are counted.  positive, the 1-bits in its binary representation are counted.
2685  If negative, the 0-bits in its two's-complement binary  If negative, the 0-bits in its two's-complement binary
# Line 2423  representation are counted.  If 0, 0 is Line 2696  representation are counted.  If 0, 0 is
2696  @end deffn  @end deffn
2697    
2698   integer-length   integer-length
2699  @deffn primitive integer-length n  @deffn {Scheme Procedure} integer-length n
2700  Return the number of bits neccessary to represent @var{n}.  @deffnx {C Function} scm_integer_length (n)
2701    Return the number of bits necessary to represent @var{n}.
2702    
2703  @lisp  @lisp
2704  (integer-length #b10101010)  (integer-length #b10101010)
# Line 2437  Return the number of bits neccessary to Line 2711  Return the number of bits neccessary to
2711  @end deffn  @end deffn
2712    
2713   number->string   number->string
2714  @deffn primitive number->string n [radix]  @deffn {Scheme Procedure} number->string n [radix]
2715    @deffnx {C Function} scm_number_to_string (n, radix)
2716  Return a string holding the external representation of the  Return a string holding the external representation of the
2717  number @var{n} in the given @var{radix}.  If @var{n} is  number @var{n} in the given @var{radix}.  If @var{n} is
2718  inexact, a radix of 10 will be used.  inexact, a radix of 10 will be used.
2719  @end deffn  @end deffn
2720    
2721   string->number   string->number
2722  @deffn primitive string->number string [radix]  @deffn {Scheme Procedure} string->number string [radix]
2723    @deffnx {C Function} scm_string_to_number (string, radix)
2724  Return a number of the maximally precise representation  Return a number of the maximally precise representation
2725  expressed by the given @var{string}. @var{radix} must be an  expressed by the given @var{string}. @var{radix} must be an
2726  exact integer, either 2, 8, 10, or 16. If supplied, @var{radix}  exact integer, either 2, 8, 10, or 16. If supplied, @var{radix}
# Line 2456  syntactically valid notation for a numbe Line 2732  syntactically valid notation for a numbe
2732  @end deffn  @end deffn
2733    
2734   number?   number?
2735  @deffn primitive number?  @deffn {Scheme Procedure} number?
2736  implemented by the C function "scm_number_p"  implemented by the C function "scm_number_p"
2737  @end deffn  @end deffn
2738    
2739   complex?   complex?
2740  @deffn primitive complex? x  @deffn {Scheme Procedure} complex? x
2741    @deffnx {C Function} scm_number_p (x)
2742  Return @code{#t} if @var{x} is a complex number, @code{#f}  Return @code{#t} if @var{x} is a complex number, @code{#f}
2743  else.  Note that the sets of real, rational and integer  otherwise.  Note that the sets of real, rational and integer
2744  values form subsets of the set of complex numbers, i. e. the  values form subsets of the set of complex numbers, i. e. the
2745  predicate will also be fulfilled if @var{x} is a real,  predicate will also be fulfilled if @var{x} is a real,
2746  rational or integer number.  rational or integer number.
2747  @end deffn  @end deffn
2748    
2749   real?   real?
2750  @deffn primitive real?  @deffn {Scheme Procedure} real?
2751  implemented by the C function "scm_real_p"  implemented by the C function "scm_real_p"
2752  @end deffn  @end deffn
2753    
2754   rational?   rational?
2755  @deffn primitive rational? x  @deffn {Scheme Procedure} rational? x
2756    @deffnx {C Function} scm_real_p (x)
2757  Return @code{#t} if @var{x} is a rational number, @code{#f}  Return @code{#t} if @var{x} is a rational number, @code{#f}
2758  else.  Note that the set of integer values forms a subset of  otherwise.  Note that the set of integer values forms a subset of
2759  the set of rational numbers, i. e. the predicate will also be  the set of rational numbers, i. e. the predicate will also be
2760  fulfilled if @var{x} is an integer number.  Real numbers  fulfilled if @var{x} is an integer number.  Real numbers
2761  will also satisfy this predicate, because of their limited  will also satisfy this predicate, because of their limited
# Line 2485  precision. Line 2763  precision.
2763  @end deffn  @end deffn
2764    
2765   integer?   integer?
2766  @deffn primitive integer? x  @deffn {Scheme Procedure} integer? x
2767    @deffnx {C Function} scm_integer_p (x)
2768  Return @code{#t} if @var{x} is an integer number, @code{#f}  Return @code{#t} if @var{x} is an integer number, @code{#f}
2769  else.  else.
2770  @end deffn  @end deffn
2771    
2772   inexact?   inexact?
2773  @deffn primitive inexact? x  @deffn {Scheme Procedure} inexact? x
2774    @deffnx {C Function} scm_inexact_p (x)
2775  Return @code{#t} if @var{x} is an inexact number, @code{#f}  Return @code{#t} if @var{x} is an inexact number, @code{#f}
2776  else.  else.
2777  @end deffn  @end deffn
2778    
2779   $expt   $expt
2780  @deffn primitive $expt x y  @deffn {Scheme Procedure} $expt x y
2781    @deffnx {C Function} scm_sys_expt (x, y)
2782  Return @var{x} raised to the power of @var{y}. This  Return @var{x} raised to the power of @var{y}. This
2783  procedure does not accept complex arguments.  procedure does not accept complex arguments.
2784  @end deffn  @end deffn
2785    
2786   $atan2   $atan2
2787  @deffn primitive $atan2 x y  @deffn {Scheme Procedure} $atan2 x y
2788    @deffnx {C Function} scm_sys_atan2 (x, y)
2789  Return the arc tangent of the two arguments @var{x} and  Return the arc tangent of the two arguments @var{x} and
2790  @var{y}. This is similar to calculating the arc tangent of  @var{y}. This is similar to calculating the arc tangent of
2791  @var{x} / @var{y}, except that the signs of both arguments  @var{x} / @var{y}, except that the signs of both arguments
# Line 2512  procedure does not accept complex argume Line 2794  procedure does not accept complex argume
2794  @end deffn  @end deffn
2795    
2796   make-rectangular   make-rectangular
2797  @deffn primitive make-rectangular real imaginary  @deffn {Scheme Procedure} make-rectangular real imaginary
2798    @deffnx {C Function} scm_make_rectangular (real, imaginary)
2799  Return a complex number constructed of the given @var{real} and  Return a complex number constructed of the given @var{real} and
2800  @var{imaginary} parts.  @var{imaginary} parts.
2801  @end deffn  @end deffn
2802    
2803   make-polar   make-polar
2804  @deffn primitive make-polar x y  @deffn {Scheme Procedure} make-polar x y
2805    @deffnx {C Function} scm_make_polar (x, y)
2806  Return the complex number @var{x} * e^(i * @var{y}).  Return the complex number @var{x} * e^(i * @var{y}).
2807  @end deffn  @end deffn
2808    
2809   inexact->exact   inexact->exact
2810  @deffn primitive inexact->exact z  @deffn {Scheme Procedure} inexact->exact z
2811    @deffnx {C Function} scm_inexact_to_exact (z)
2812  Return an exact number that is numerically closest to @var{z}.  Return an exact number that is numerically closest to @var{z}.
2813  @end deffn  @end deffn
2814    
2815   class-of   class-of
2816  @deffn primitive class-of x  @deffn {Scheme Procedure} class-of x
2817    @deffnx {C Function} scm_class_of (x)
2818  Return the class of @var{x}.  Return the class of @var{x}.
2819  @end deffn  @end deffn
2820    
2821   entity?   entity?
2822  @deffn primitive entity? obj  @deffn {Scheme Procedure} entity? obj
2823    @deffnx {C Function} scm_entity_p (obj)
2824  Return @code{#t} if @var{obj} is an entity.  Return @code{#t} if @var{obj} is an entity.
2825  @end deffn  @end deffn
2826    
2827   operator?   operator?
2828  @deffn primitive operator? obj  @deffn {Scheme Procedure} operator? obj
2829    @deffnx {C Function} scm_operator_p (obj)
2830  Return @code{#t} if @var{obj} is an operator.  Return @code{#t} if @var{obj} is an operator.
2831  @end deffn  @end deffn
2832    
2833   valid-object-procedure?   valid-object-procedure?
2834  @deffn primitive valid-object-procedure? proc  @deffn {Scheme Procedure} valid-object-procedure? proc
2835    @deffnx {C Function} scm_valid_object_procedure_p (proc)
2836  Return @code{#t} iff @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}.  Return @code{#t} iff @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}.
2837  @end deffn  @end deffn
2838    
2839   set-object-procedure!   set-object-procedure!
2840  @deffn primitive set-object-procedure! obj proc  @deffn {Scheme Procedure} set-object-procedure! obj proc
2841    @deffnx {C Function} scm_set_object_procedure_x (obj, proc)
2842  Set the object procedure of @var{obj} to @var{proc}.  Set the object procedure of @var{obj} to @var{proc}.
2843  @var{obj} must be either an entity or an operator.  @var{obj} must be either an entity or an operator.
2844  @end deffn  @end deffn
2845    
2846   make-class-object   make-class-object
2847  @deffn primitive make-class-object metaclass layout  @deffn {Scheme Procedure} make-class-object metaclass layout
2848    @deffnx {C Function} scm_make_class_object (metaclass, layout)
2849  Create a new class object of class @var{metaclass}, with the  Create a new class object of class @var{metaclass}, with the
2850  slot layout specified by @var{layout}.  slot layout specified by @var{layout}.
2851  @end deffn  @end deffn
2852    
2853   make-subclass-object   make-subclass-object
2854  @deffn primitive make-subclass-object class layout  @deffn {Scheme Procedure} make-subclass-object class layout
2855    @deffnx {C Function} scm_make_subclass_object (class, layout)
2856  Create a subclass object of @var{class}, with the slot layout  Create a subclass object of @var{class}, with the slot layout
2857  specified by @var{layout}.  specified by @var{layout}.
2858  @end deffn  @end deffn
2859    
2860   object-properties   object-properties
2861  @deffn primitive object-properties obj  @deffn {Scheme Procedure} object-properties obj
2862  @deffnx primitive procedure-properties obj  @deffnx {Scheme Procedure} procedure-properties obj
2863    @deffnx {C Function} scm_object_properties (obj)
2864  Return @var{obj}'s property list.  Return @var{obj}'s property list.
2865  @end deffn  @end deffn
2866    
2867   set-object-properties!   set-object-properties!
2868  @deffn primitive set-object-properties! obj alist  @deffn {Scheme Procedure} set-object-properties! obj alist
2869  @deffnx primitive set-procedure-properties! obj alist  @deffnx {Scheme Procedure} set-procedure-properties! obj alist
2870    @deffnx {C Function} scm_set_object_properties_x (obj, alist)
2871  Set @var{obj}'s property list to @var{alist}.  Set @var{obj}'s property list to @var{alist}.
2872  @end deffn  @end deffn
2873    
2874   object-property   object-property
2875  @deffn primitive object-property obj key  @deffn {Scheme Procedure} object-property obj key
2876  @deffnx primitive procedure-property obj key  @deffnx {Scheme Procedure} procedure-property obj key
2877    @deffnx {C Function} scm_object_property (obj, key)
2878  Return the property of @var{obj} with name @var{key}.  Return the property of @var{obj} with name @var{key}.
2879  @end deffn  @end deffn
2880    
2881   set-object-property!   set-object-property!
2882  @deffn primitive set-object-property! obj key value  @deffn {Scheme Procedure} set-object-property! obj key value
2883  @deffnx primitive set-procedure-property! obj key value  @deffnx {Scheme Procedure} set-procedure-property! obj key value
2884    @deffnx {C Function} scm_set_object_property_x (obj, key, value)
2885  In @var{obj}'s property list, set the property named @var{key}  In @var{obj}'s property list, set the property named @var{key}
2886  to @var{value}.  to @var{value}.
2887  @end deffn  @end deffn
2888    
2889   cons   cons
2890  @deffn primitive cons x y  @deffn {Scheme Procedure} cons x y
2891    @deffnx {C Function} scm_cons (x, y)
2892  Return a newly allocated pair whose car is @var{x} and whose  Return a newly allocated pair whose car is @var{x} and whose
2893  cdr is @var{y}.  The pair is guaranteed to be different (in the  cdr is @var{y}.  The pair is guaranteed to be different (in the
2894  sense of @code{eq?}) from every previously existing object.  sense of @code{eq?}) from every previously existing object.
2895  @end deffn  @end deffn
2896    
2897   pair?   pair?
2898  @deffn primitive pair? x  @deffn {Scheme Procedure} pair? x
2899    @deffnx {C Function} scm_pair_p (x)
2900  Return @code{#t} if @var{x} is a pair; otherwise return  Return @code{#t} if @var{x} is a pair; otherwise return
2901  @code{#f}.  @code{#f}.
2902  @end deffn  @end deffn
2903    
2904   set-car!   set-car!
2905  @deffn primitive set-car! pair value  @deffn {Scheme Procedure} set-car! pair value
2906    @deffnx {C Function} scm_set_car_x (pair, value)
2907  Stores @var{value} in the car field of @var{pair}.  The value returned  Stores @var{value} in the car field of @var{pair}.  The value returned
2908  by @code{set-car!} is unspecified.  by @code{set-car!} is unspecified.
2909  @end deffn  @end deffn
2910    
2911   set-cdr!   set-cdr!
2912  @deffn primitive set-cdr! pair value  @deffn {Scheme Procedure} set-cdr! pair value
2913    @deffnx {C Function} scm_set_cdr_x (pair, value)
2914  Stores @var{value} in the cdr field of @var{pair}.  The value returned  Stores @var{value} in the cdr field of @var{pair}.  The value returned
2915  by @code{set-cdr!} is unspecified.  by @code{set-cdr!} is unspecified.
2916  @end deffn  @end deffn
2917    
2918   char-ready?   char-ready?
2919  @deffn primitive char-ready? [port]  @deffn {Scheme Procedure} char-ready? [port]
2920    @deffnx {C Function} scm_char_ready_p (port)
2921  Return @code{#t} if a character is ready on input @var{port}  Return @code{#t} if a character is ready on input @var{port}
2922  and return @code{#f} otherwise.  If @code{char-ready?} returns  and return @code{#f} otherwise.  If @code{char-ready?} returns
2923  @code{#t} then the next @code{read-char} operation on  @code{#t} then the next @code{read-char} operation on
# Line 2633  interactive port that has no ready chara Line 2934  interactive port that has no ready chara
2934  @end deffn  @end deffn
2935    
2936   drain-input   drain-input
2937  @deffn primitive drain-input port  @deffn {Scheme Procedure} drain-input port
2938    @deffnx {C Function} scm_drain_input (port)
2939  This procedure clears a port's input buffers, similar  This procedure clears a port's input buffers, similar
2940  to the way that force-output clears the output buffer.  The  to the way that force-output clears the output buffer.  The
2941  contents of the buffers are returned as a single string, e.g.,  contents of the buffers are returned as a single string, e.g.,
# Line 2651  for further input. Line 2953  for further input.
2953  @end deffn  @end deffn
2954    
2955   current-input-port   current-input-port
2956  @deffn primitive current-input-port  @deffn {Scheme Procedure} current-input-port
2957    @deffnx {C Function} scm_current_input_port ()
2958  Return the current input port.  This is the default port used  Return the current input port.  This is the default port used
2959  by many input procedures.  Initially, @code{current-input-port}  by many input procedures.  Initially, @code{current-input-port}
2960  returns the @dfn{standard input} in Unix and C terminology.  returns the @dfn{standard input} in Unix and C terminology.
2961  @end deffn  @end deffn
2962    
2963   current-output-port   current-output-port
2964  @deffn primitive current-output-port  @deffn {Scheme Procedure} current-output-port
2965    @deffnx {C Function} scm_current_output_port ()
2966  Return the current output port.  This is the default port used  Return the current output port.  This is the default port used
2967  by many output procedures.  Initially,  by many output procedures.  Initially,
2968  @code{current-output-port} returns the @dfn{standard output} in  @code{current-output-port} returns the @dfn{standard output} in
# Line 2666  Unix and C terminology. Line 2970  Unix and C terminology.
2970  @end deffn  @end deffn
2971    
2972   current-error-port   current-error-port
2973  @deffn primitive current-error-port  @deffn {Scheme Procedure} current-error-port
2974    @deffnx {C Function} scm_current_error_port ()
2975  Return the port to which errors and warnings should be sent (the  Return the port to which errors and warnings should be sent (the
2976  @dfn{standard error} in Unix and C terminology).  @dfn{standard error} in Unix and C terminology).
2977  @end deffn  @end deffn
2978    
2979   current-load-port   current-load-port
2980  @deffn primitive current-load-port  @deffn {Scheme Procedure} current-load-port
2981    @deffnx {C Function} scm_current_load_port ()
2982  Return the current-load-port.  Return the current-load-port.
2983  The load port is used internally by @code{primitive-load}.  The load port is used internally by @code{primitive-load}.
2984  @end deffn  @end deffn
2985    
2986   set-current-input-port   set-current-input-port
2987  @deffn primitive set-current-input-port port  @deffn {Scheme Procedure} set-current-input-port port
2988  @deffnx primitive set-current-output-port port  @deffnx {Scheme Procedure} set-current-output-port port
2989  @deffnx primitive set-current-error-port port  @deffnx {Scheme Procedure} set-current-error-port port
2990    @deffnx {C Function} scm_set_current_input_port (port)
2991  Change the ports returned by @code{current-input-port},  Change the ports returned by @code{current-input-port},
2992  @code{current-output-port} and @code{current-error-port}, respectively,  @code{current-output-port} and @code{current-error-port}, respectively,
2993  so that they use the supplied @var{port} for input or output.  so that they use the supplied @var{port} for input or output.
2994  @end deffn  @end deffn
2995    
2996   set-current-output-port   set-current-output-port
2997  @deffn primitive set-current-output-port port  @deffn {Scheme Procedure} set-current-output-port port
2998    @deffnx {C Function} scm_set_current_output_port (port)
2999  Set the current default output port to @var{port}.  Set the current default output port to @var{port}.
3000  @end deffn  @end deffn
3001    
3002   set-current-error-port   set-current-error-port
3003  @deffn primitive set-current-error-port port  @deffn {Scheme Procedure} set-current-error-port port
3004    @deffnx {C Function} scm_set_current_error_port (port)
3005  Set the current default error port to @var{port}.  Set the current default error port to @var{port}.
3006  @end deffn  @end deffn
3007    
3008   port-revealed   port-revealed
3009  @deffn primitive port-revealed port  @deffn {Scheme Procedure} port-revealed port
3010    @deffnx {C Function} scm_port_revealed (port)
3011  Return the revealed count for @var{port}.  Return the revealed count for @var{port}.
3012  @end deffn  @end deffn
3013    
3014   set-port-revealed!   set-port-revealed!
3015  @deffn primitive set-port-revealed! port rcount  @deffn {Scheme Procedure} set-port-revealed! port rcount
3016    @deffnx {C Function} scm_set_port_revealed_x (port, rcount)
3017  Sets the revealed count for a port to a given value.  Sets the revealed count for a port to a given value.
3018  The return value is unspecified.  The return value is unspecified.
3019  @end deffn  @end deffn
3020    
3021   port-mode   port-mode
3022  @deffn primitive port-mode port  @deffn {Scheme Procedure} port-mode port
3023    @deffnx {C Function} scm_port_mode (port)
3024  Return the port modes associated with the open port @var{port}.  Return the port modes associated with the open port @var{port}.
3025  These will not necessarily be identical to the modes used when  These will not necessarily be identical to the modes used when
3026  the port was opened, since modes such as "append" which are  the port was opened, since modes such as "append" which are
# Line 2716  used only during port creation are not r Line 3028  used only during port creation are not r
3028  @end deffn  @end deffn
3029    
3030   close-port   close-port
3031  @deffn primitive close-port port  @deffn {Scheme Procedure} close-port port
3032    @deffnx {C Function} scm_close_port (port)
3033  Close the specified port object.  Return @code{#t} if it  Close the specified port object.  Return @code{#t} if it
3034  successfully closes a port or @code{#f} if it was already  successfully closes a port or @code{#f} if it was already
3035  closed.  An exception may be raised if an error occurs, for  closed.  An exception may be raised if an error occurs, for
# Line 2726  descriptors. Line 3039  descriptors.
3039  @end deffn  @end deffn
3040    
3041   close-input-port   close-input-port
3042  @deffn primitive close-input-port port  @deffn {Scheme Procedure} close-input-port port
3043    @deffnx {C Function} scm_close_input_port (port)
3044  Close the specified input port object.  The routine has no effect if  Close the specified input port object.  The routine has no effect if
3045  the file has already been closed.  An exception may be raised if an  the file has already been closed.  An exception may be raised if an
3046  error occurs.  The value returned is unspecified.  error occurs.  The value returned is unspecified.
# Line 2736  which can close file descriptors. Line 3050  which can close file descriptors.
3050  @end deffn  @end deffn
3051    
3052   close-output-port   close-output-port
3053  @deffn primitive close-output-port port  @deffn {Scheme Procedure} close-output-port port
3054    @deffnx {C Function} scm_close_output_port (port)
3055  Close the specified output port object.  The routine has no effect if  Close the specified output port object.  The routine has no effect if
3056  the file has already been closed.  An exception may be raised if an  the file has already been closed.  An exception may be raised if an
3057  error occurs.  The value returned is unspecified.  error occurs.  The value returned is unspecified.
# Line 2746  which can close file descriptors. Line 3061  which can close file descriptors.
3061  @end deffn  @end deffn
3062    
3063   port-for-each   port-for-each
3064  @deffn primitive port-for-each proc  @deffn {Scheme Procedure} port-for-each proc
3065    @deffnx {C Function} scm_port_for_each (proc)
3066  Apply @var{proc} to each port in the Guile port table  Apply @var{proc} to each port in the Guile port table
3067  in turn.  The return value is unspecified.  More specifically,  in turn.  The return value is unspecified.  More specifically,
3068  @var{proc} is applied exactly once to every port that exists  @var{proc} is applied exactly once to every port that exists
# Line 2756  have no effect as far as @var{port-for-e Line 3072  have no effect as far as @var{port-for-e
3072  @end deffn  @end deffn
3073    
3074   close-all-ports-except   close-all-ports-except
3075  @deffn primitive close-all-ports-except . ports  @deffn {Scheme Procedure} close-all-ports-except . ports
3076    @deffnx {C Function} scm_close_all_ports_except (ports)
3077  [DEPRECATED] Close all open file ports used by the interpreter  [DEPRECATED] Close all open file ports used by the interpreter
3078  except for those supplied as arguments.  This procedure  except for those supplied as arguments.  This procedure
3079  was intended to be used before an exec call to close file descriptors  was intended to be used before an exec call to close file descriptors
3080  which are not needed in the new process.  However it has the  which are not needed in the new process.  However it has the
3081  undesirable side-effect of flushing buffes, so it's deprecated.  undesirable side effect of flushing buffers, so it's deprecated.
3082  Use port-for-each instead.  Use port-for-each instead.
3083  @end deffn  @end deffn
3084    
3085   input-port?   input-port?
3086  @deffn primitive input-port? x  @deffn {Scheme Procedure} input-port? x
3087    @deffnx {C Function} scm_input_port_p (x)
3088  Return @code{#t} if @var{x} is an input port, otherwise return  Return @code{#t} if @var{x} is an input port, otherwise return
3089  @code{#f}.  Any object satisfying this predicate also satisfies  @code{#f}.  Any object satisfying this predicate also satisfies
3090  @code{port?}.  @code{port?}.
3091  @end deffn  @end deffn
3092    
3093   output-port?   output-port?
3094  @deffn primitive output-port? x  @deffn {Scheme Procedure} output-port? x
3095    @deffnx {C Function} scm_output_port_p (x)
3096  Return @code{#t} if @var{x} is an output port, otherwise return  Return @code{#t} if @var{x} is an output port, otherwise return
3097  @code{#f}.  Any object satisfying this predicate also satisfies  @code{#f}.  Any object satisfying this predicate also satisfies
3098  @code{port?}.  @code{port?}.
3099  @end deffn  @end deffn
3100    
3101   port?   port?
3102  @deffn primitive port? x  @deffn {Scheme Procedure} port? x
3103    @deffnx {C Function} scm_port_p (x)
3104  Return a boolean indicating whether @var{x} is a port.  Return a boolean indicating whether @var{x} is a port.
3105  Equivalent to @code{(or (input-port? @var{x}) (output-port?  Equivalent to @code{(or (input-port? @var{x}) (output-port?
3106  @var{x}))}.  @var{x}))}.
3107  @end deffn  @end deffn
3108    
3109   port-closed?   port-closed?
3110  @deffn primitive port-closed? port  @deffn {Scheme Procedure} port-closed? port
3111    @deffnx {C Function} scm_port_closed_p (port)
3112  Return @code{#t} if @var{port} is closed or @code{#f} if it is  Return @code{#t} if @var{port} is closed or @code{#f} if it is
3113  open.  open.
3114  @end deffn  @end deffn
3115    
3116   eof-object?   eof-object?
3117  @deffn primitive eof-object? x  @deffn {Scheme Procedure} eof-object? x
3118    @deffnx {C Function} scm_eof_object_p (x)
3119  Return @code{#t} if @var{x} is an end-of-file object; otherwise  Return @code{#t} if @var{x} is an end-of-file object; otherwise
3120  return @code{#f}.  return @code{#f}.
3121  @end deffn  @end deffn
3122    
3123   force-output   force-output
3124  @deffn primitive force-output [port]  @deffn {Scheme Procedure} force-output [port]
3125    @deffnx {C Function} scm_force_output (port)
3126  Flush the specified output port, or the current output port if @var{port}  Flush the specified output port, or the current output port if @var{port}
3127  is omitted.  The current output buffer contents are passed to the  is omitted.  The current output buffer contents are passed to the
3128  underlying port implementation (e.g., in the case of fports, the  underlying port implementation (e.g., in the case of fports, the
# Line 2810  The return value is unspecified. Line 3133  The return value is unspecified.
3133  @end deffn  @end deffn
3134    
3135   flush-all-ports   flush-all-ports
3136  @deffn primitive flush-all-ports  @deffn {Scheme Procedure} flush-all-ports
3137    @deffnx {C Function} scm_flush_all_ports ()
3138  Equivalent to calling @code{force-output} on  Equivalent to calling @code{force-output} on
3139  all open output ports.  The return value is unspecified.  all open output ports.  The return value is unspecified.
3140  @end deffn  @end deffn
3141    
3142   read-char   read-char
3143  @deffn primitive read-char [port]  @deffn {Scheme Procedure} read-char [port]
3144    @deffnx {C Function} scm_read_char (port)
3145  Return the next character available from @var{port}, updating  Return the next character available from @var{port}, updating
3146  @var{port} to point to the following character.  If no more  @var{port} to point to the following character.  If no more
3147  characters are available, the end-of-file object is returned.  characters are available, the end-of-file object is returned.
3148  @end deffn  @end deffn
3149    
3150   peek-char   peek-char
3151  @deffn primitive peek-char [port]  @deffn {Scheme Procedure} peek-char [port]
3152    @deffnx {C Function} scm_peek_char (port)
3153  Return the next character available from @var{port},  Return the next character available from @var{port},
3154  @emph{without} updating @var{port} to point to the following  @emph{without} updating @var{port} to point to the following
3155  character.  If no more characters are available, the  character.  If no more characters are available, the
# Line 2839  to @code{read-char} would have hung.} Line 3165  to @code{read-char} would have hung.}
3165  @end deffn  @end deffn
3166    
3167   unread-char   unread-char
3168  @deffn primitive unread-char cobj [port]  @deffn {Scheme Procedure} unread-char cobj [port]
3169    @deffnx {C Function} scm_unread_char (cobj, port)
3170  Place @var{char} in @var{port} so that it will be read by the  Place @var{char} in @var{port} so that it will be read by the
3171  next read operation.  If called multiple times, the unread characters  next read operation.  If called multiple times, the unread characters
3172  will be read again in last-in first-out order.  If @var{port} is  will be read again in last-in first-out order.  If @var{port} is
# Line 2847  not supplied, the current input port is Line 3174  not supplied, the current input port is
3174  @end deffn  @end deffn
3175    
3176   unread-string   unread-string
3177  @deffn primitive unread-string str port  @deffn {Scheme Procedure} unread-string str port
3178    @deffnx {C Function} scm_unread_string (str, port)
3179  Place the string @var{str} in @var{port} so that its characters will be  Place the string @var{str} in @var{port} so that its characters will be
3180  read in subsequent read operations.  If called multiple times, the  read in subsequent read operations.  If called multiple times, the
3181  unread characters will be read again in last-in first-out order.  If  unread characters will be read again in last-in first-out order.  If
# Line 2855  unread characters will be read again in Line 3183  unread characters will be read again in
3183  @end deffn  @end deffn
3184    
3185   seek   seek
3186  @deffn primitive seek fd_port offset whence  @deffn {Scheme Procedure} seek fd_port offset whence
3187    @deffnx {C Function} scm_seek (fd_port, offset, whence)
3188  Sets the current position of @var{fd/port} to the integer  Sets the current position of @var{fd/port} to the integer
3189  @var{offset}, which is interpreted according to the value of  @var{offset}, which is interpreted according to the value of
3190  @var{whence}.  @var{whence}.
# Line 2882  that the current position of a port can Line 3211  that the current position of a port can
3211  @end deffn  @end deffn
3212    
3213   truncate-file   truncate-file
3214  @deffn primitive truncate-file object [length]  @deffn {Scheme Procedure} truncate-file object [length]
3215    @deffnx {C Function} scm_truncate_file (object, length)
3216  Truncates the object referred to by @var{object} to at most  Truncates the object referred to by @var{object} to at most
3217  @var{length} bytes.  @var{object} can be a string containing a  @var{length} bytes.  @var{object} can be a string containing a
3218  file name or an integer file descriptor or a port.  file name or an integer file descriptor or a port.
# Line 2892  position.  The return value is unspecifi Line 3222  position.  The return value is unspecifi
3222  @end deffn  @end deffn
3223    
3224   port-line   port-line
3225  @deffn primitive port-line port  @deffn {Scheme Procedure} port-line port
3226    @deffnx {C Function} scm_port_line (port)
3227  Return the current line number for @var{port}.  Return the current line number for @var{port}.
3228  @end deffn  @end deffn
3229    
3230   set-port-line!   set-port-line!
3231  @deffn primitive set-port-line! port line  @deffn {Scheme Procedure} set-port-line! port line
3232    @deffnx {C Function} scm_set_port_line_x (port, line)
3233  Set the current line number for @var{port} to @var{line}.  Set the current line number for @var{port} to @var{line}.
3234  @end deffn  @end deffn
3235    
3236   port-column   port-column
3237  @deffn primitive port-column port  @deffn {Scheme Procedure} port-column port
3238  @deffnx primitive port-line port  @deffnx {Scheme Procedure} port-line port
3239    @deffnx {C Function} scm_port_column (port)
3240  Return the current column number or line number of @var{port},  Return the current column number or line number of @var{port},
3241  using the current input port if none is specified.  If the number is  using the current input port if none is specified.  If the number is
3242  unknown, the result is #f.  Otherwise, the result is a 0-origin integer  unknown, the result is #f.  Otherwise, the result is a 0-origin integer
# Line 2915  what non-programmers will find most natu Line 3248  what non-programmers will find most natu
3248  @end deffn  @end deffn
3249    
3250   set-port-column!   set-port-column!
3251  @deffn primitive set-port-column! port column  @deffn {Scheme Procedure} set-port-column! port column
3252  @deffnx primitive set-port-line! port line  @deffnx {Scheme Procedure} set-port-line! port line
3253    @deffnx {C Function} scm_set_port_column_x (port, column)
3254  Set the current column or line number of @var{port}, using the  Set the current column or line number of @var{port}, using the
3255  current input port if none is specified.  current input port if none is specified.
3256  @end deffn  @end deffn
3257    
3258   port-filename   port-filename
3259  @deffn primitive port-filename port  @deffn {Scheme Procedure} port-filename port
3260    @deffnx {C Function} scm_port_filename (port)
3261  Return the filename associated with @var{port}.  This function returns  Return the filename associated with @var{port}.  This function returns
3262  the strings "standard input", "standard output" and "standard error"  the strings "standard input", "standard output" and "standard error"
3263  when called on the current input, output and error ports respectively.  when called on the current input, output and error ports respectively.
3264  @end deffn  @end deffn
3265    
3266   set-port-filename!   set-port-filename!
3267  @deffn primitive set-port-filename! port filename  @deffn {Scheme Procedure} set-port-filename! port filename
3268    @deffnx {C Function} scm_set_port_filename_x (port, filename)
3269  Change the filename associated with @var{port}, using the current input  Change the filename associated with @var{port}, using the current input
3270  port if none is specified.  Note that this does not change the port's  port if none is specified.  Note that this does not change the port's
3271  source of data, but only the value that is returned by  source of data, but only the value that is returned by
# Line 2937  source of data, but only the value that Line 3273  source of data, but only the value that
3273  @end deffn  @end deffn
3274    
3275   %make-void-port   %make-void-port
3276  @deffn primitive %make-void-port mode  @deffn {Scheme Procedure} %make-void-port mode
3277    @deffnx {C Function} scm_sys_make_void_port (mode)
3278  Create and return a new void port.  A void port acts like  Create and return a new void port.  A void port acts like
3279  /dev/null.  The @var{mode} argument  @file{/dev/null}.  The @var{mode} argument
3280  specifies the input/output modes for this port: see the  specifies the input/output modes for this port: see the
3281  documentation for @code{open-file} in @ref{File Ports}.  documentation for @code{open-file} in @ref{File Ports}.
3282  @end deffn  @end deffn
3283    
3284   print-options-interface   print-options-interface
3285  @deffn primitive print-options-interface [setting]  @deffn {Scheme Procedure} print-options-interface [setting]
3286    @deffnx {C Function} scm_print_options (setting)
3287  Option interface for the print options. Instead of using  Option interface for the print options. Instead of using
3288  this procedure directly, use the procedures  this procedure directly, use the procedures
3289  @code{print-enable}, @code{print-disable}, @code{print-set!}  @code{print-enable}, @code{print-disable}, @code{print-set!}
# Line 2953  and @code{print-options}. Line 3291  and @code{print-options}.
3291  @end deffn  @end deffn
3292    
3293   simple-format   simple-format
3294  @deffn primitive simple-format destination message . args  @deffn {Scheme Procedure} simple-format destination message . args
3295    @deffnx {C Function} scm_simple_format (destination, message, args)
3296  Write @var{message} to @var{destination}, defaulting to  Write @var{message} to @var{destination}, defaulting to
3297  the current output port.  the current output port.
3298  @var{message} can contain @code{~A} (was @code{%s}) and  @var{message} can contain @code{~A} (was @code{%s}) and
# Line 2968  containing the formatted text. Does not Line 3307  containing the formatted text. Does not
3307  @end deffn  @end deffn
3308    
3309   newline   newline
3310  @deffn primitive newline [port]  @deffn {Scheme Procedure} newline [port]
3311    @deffnx {C Function} scm_newline (port)
3312  Send a newline to @var{port}.  Send a newline to @var{port}.
3313  @end deffn  @end deffn
3314    
3315   write-char   write-char
3316  @deffn primitive write-char chr [port]  @deffn {Scheme Procedure} write-char chr [port]
3317    @deffnx {C Function} scm_write_char (chr, port)
3318  Send character @var{chr} to @var{port}.  Send character @var{chr} to @var{port}.
3319  @end deffn  @end deffn
3320    
3321   port-with-print-state   port-with-print-state
3322  @deffn primitive port-with-print-state port pstate  @deffn {Scheme Procedure} port-with-print-state port pstate
3323    @deffnx {C Function} scm_port_with_print_state (port, pstate)
3324  Create a new port which behaves like @var{port}, but with an  Create a new port which behaves like @var{port}, but with an
3325  included print state @var{pstate}.  included print state @var{pstate}.
3326  @end deffn  @end deffn
3327    
3328   get-print-state   get-print-state
3329  @deffn primitive get-print-state port  @deffn {Scheme Procedure} get-print-state port
3330    @deffnx {C Function} scm_get_print_state (port)
3331  Return the print state of the port @var{port}. If @var{port}  Return the print state of the port @var{port}. If @var{port}
3332  has no associated print state, @code{#f} is returned.  has no associated print state, @code{#f} is returned.
3333  @end deffn  @end deffn
3334    
3335   procedure-properties   procedure-properties
3336  @deffn primitive procedure-properties proc  @deffn {Scheme Procedure} procedure-properties proc
3337    @deffnx {C Function} scm_procedure_properties (proc)
3338  Return @var{obj}'s property list.  Return @var{obj}'s property list.
3339  @end deffn  @end deffn
3340    
3341   set-procedure-properties!   set-procedure-properties!
3342  @deffn primitive set-procedure-properties! proc new_val  @deffn {Scheme Procedure} set-procedure-properties! proc new_val
3343    @deffnx {C Function} scm_set_procedure_properties_x (proc, new_val)
3344  Set @var{obj}'s property list to @var{alist}.  Set @var{obj}'s property list to @var{alist}.
3345  @end deffn  @end deffn
3346    
3347   procedure-property   procedure-property
3348  @deffn primitive procedure-property p k  @deffn {Scheme Procedure} procedure-property p k
3349    @deffnx {C Function} scm_procedure_property (p, k)
3350  Return the property of @var{obj} with name @var{key}.  Return the property of @var{obj} with name @var{key}.
3351  @end deffn  @end deffn
3352    
3353   set-procedure-property!   set-procedure-property!
3354  @deffn primitive set-procedure-property! p k v  @deffn {Scheme Procedure} set-procedure-property! p k v
3355    @deffnx {C Function} scm_set_procedure_property_x (p, k, v)
3356  In @var{obj}'s property list, set the property named @var{key} to  In @var{obj}'s property list, set the property named @var{key} to
3357  @var{value}.  @var{value}.
3358  @end deffn  @end deffn
3359    
3360   procedure?   procedure?
3361  @deffn primitive procedure? obj  @deffn {Scheme Procedure} procedure? obj
3362    @deffnx {C Function} scm_procedure_p (obj)
3363  Return @code{#t} if @var{obj} is a procedure.  Return @code{#t} if @var{obj} is a procedure.
3364  @end deffn  @end deffn
3365    
3366   closure?   closure?
3367  @deffn primitive closure? obj  @deffn {Scheme Procedure} closure? obj
3368    @deffnx {C Function} scm_closure_p (obj)
3369  Return @code{#t} if @var{obj} is a closure.  Return @code{#t} if @var{obj} is a closure.
3370  @end deffn  @end deffn
3371    
3372   thunk?   thunk?
3373  @deffn primitive thunk? obj  @deffn {Scheme Procedure} thunk? obj
3374    @deffnx {C Function} scm_thunk_p (obj)
3375  Return @code{#t} if @var{obj} is a thunk.  Return @code{#t} if @var{obj} is a thunk.
3376  @end deffn  @end deffn
3377    
3378   procedure-documentation   procedure-documentation
3379  @deffn primitive procedure-documentation proc  @deffn {Scheme Procedure} procedure-documentation proc
3380    @deffnx {C Function} scm_procedure_documentation (proc)
3381  Return the documentation string associated with @code{proc}.  By  Return the documentation string associated with @code{proc}.  By
3382  convention, if a procedure contains more than one expression and the  convention, if a procedure contains more than one expression and the
3383  first expression is a string constant, that string is assumed to contain  first expression is a string constant, that string is assumed to contain
# Line 3034  documentation for that procedure. Line 3385  documentation for that procedure.
3385  @end deffn  @end deffn
3386    
3387   procedure-with-setter?   procedure-with-setter?
3388  @deffn primitive procedure-with-setter? obj  @deffn {Scheme Procedure} procedure-with-setter? obj
3389    @deffnx {C Function} scm_procedure_with_setter_p (obj)
3390  Return @code{#t} if @var{obj} is a procedure with an  Return @code{#t} if @var{obj} is a procedure with an
3391  associated setter procedure.  associated setter procedure.
3392  @end deffn  @end deffn
3393    
3394   make-procedure-with-setter   make-procedure-with-setter
3395  @deffn primitive make-procedure-with-setter procedure setter  @deffn {Scheme Procedure} make-procedure-with-setter procedure setter
3396    @deffnx {C Function} scm_make_procedure_with_setter (procedure, setter)
3397  Create a new procedure which behaves like @var{procedure}, but  Create a new procedure which behaves like @var{procedure}, but
3398  with the associated setter @var{setter}.  with the associated setter @var{setter}.
3399  @end deffn  @end deffn
3400    
3401   procedure   procedure
3402  @deffn primitive procedure proc  @deffn {Scheme Procedure} procedure proc
3403    @deffnx {C Function} scm_procedure (proc)
3404  Return the procedure of @var{proc}, which must be either a  Return the procedure of @var{proc}, which must be either a
3405  procedure with setter, or an operator struct.  procedure with setter, or an operator struct.
3406  @end deffn  @end deffn
3407    
3408   primitive-make-property   primitive-make-property
3409  @deffn primitive primitive-make-property not_found_proc  @deffn {Scheme Procedure} primitive-make-property not_found_proc
3410    @deffnx {C Function} scm_primitive_make_property (not_found_proc)
3411  Create a @dfn{property token} that can be used with  Create a @dfn{property token} that can be used with
3412  @code{primitive-property-ref} and @code{primitive-property-set!}.  @code{primitive-property-ref} and @code{primitive-property-set!}.
3413  See @code{primitive-property-ref} for the significance of  See @code{primitive-property-ref} for the significance of
# Line 3060  See @code{primitive-property-ref} for th Line 3415  See @code{primitive-property-ref} for th
3415  @end deffn  @end deffn
3416    
3417   primitive-property-ref   primitive-property-ref
3418  @deffn primitive primitive-property-ref prop obj  @deffn {Scheme Procedure} primitive-property-ref prop obj
3419    @deffnx {C Function} scm_primitive_property_ref (prop, obj)
3420  Return the property @var{prop} of @var{obj}.  When no value  Return the property @var{prop} of @var{obj}.  When no value
3421  has yet been associated with @var{prop} and @var{obj}, call  has yet been associated with @var{prop} and @var{obj}, call
3422  @var{not-found-proc} instead (see @code{primitive-make-property})  @var{not-found-proc} instead (see @code{primitive-make-property})
# Line 3071  default value of @var{prop}. Line 3427  default value of @var{prop}.
3427  @end deffn  @end deffn
3428    
3429   primitive-property-set!   primitive-property-set!
3430  @deffn primitive primitive-property-set! prop obj val  @deffn {Scheme Procedure} primitive-property-set! prop obj val
3431    @deffnx {C Function} scm_primitive_property_set_x (prop, obj, val)
3432  Associate @var{code} with @var{prop} and @var{obj}.  Associate @var{code} with @var{prop} and @var{obj}.
3433  @end deffn  @end deffn
3434    
3435   primitive-property-del!   primitive-property-del!
3436  @deffn primitive primitive-property-del! prop obj  @deffn {Scheme Procedure} primitive-property-del! prop obj
3437    @deffnx {C Function} scm_primitive_property_del_x (prop, obj)
3438  Remove any value associated with @var{prop} and @var{obj}.  Remove any value associated with @var{prop} and @var{obj}.
3439  @end deffn  @end deffn
3440    
3441   random   random
3442  @deffn primitive random n [state]  @deffn {Scheme Procedure} random n [state]
3443    @deffnx {C Function} scm_random (n, state)
3444  Return a number in [0,N).  Return a number in [0,N).
3445    
3446  Accepts a positive integer or real n and returns a  Accepts a positive integer or real n and returns a
# Line 3097  as a side effect of the random operation Line 3456  as a side effect of the random operation
3456  @end deffn  @end deffn
3457    
3458   copy-random-state   copy-random-state
3459  @deffn primitive copy-random-state [state]  @deffn {Scheme Procedure} copy-random-state [state]
3460    @deffnx {C Function} scm_copy_random_state (state)
3461  Return a copy of the random state @var{state}.  Return a copy of the random state @var{state}.
3462  @end deffn  @end deffn
3463    
3464   seed->random-state   seed->random-state
3465  @deffn primitive seed->random-state seed  @deffn {Scheme Procedure} seed->random-state seed
3466    @deffnx {C Function} scm_seed_to_random_state (seed)
3467  Return a new random state using @var{seed}.  Return a new random state using @var{seed}.
3468  @end deffn  @end deffn
3469    
3470   random:uniform   random:uniform
3471  @deffn primitive random:uniform [state]  @deffn {Scheme Procedure} random:uniform [state]
3472    @deffnx {C Function} scm_random_uniform (state)
3473  Return a uniformly distributed inexact real random number in  Return a uniformly distributed inexact real random number in
3474  [0,1).  [0,1).
3475  @end deffn  @end deffn
3476    
3477   random:normal   random:normal
3478  @deffn primitive random:normal [state]  @deffn {Scheme Procedure} random:normal [state]
3479    @deffnx {C Function} scm_random_normal (state)
3480  Return an inexact real in a normal distribution.  The  Return an inexact real in a normal distribution.  The
3481  distribution used has mean 0 and standard deviation 1.  For a  distribution used has mean 0 and standard deviation 1.  For a
3482  normal distribution with mean m and standard deviation d use  normal distribution with mean m and standard deviation d use
# Line 3121  normal distribution with mean m and stan Line 3484  normal distribution with mean m and stan
3484  @end deffn  @end deffn
3485    
3486   random:solid-sphere!   random:solid-sphere!
3487  @deffn primitive random:solid-sphere! v [state]  @deffn {Scheme Procedure} random:solid-sphere! v [state]
3488    @deffnx {C Function} scm_random_solid_sphere_x (v, state)
3489  Fills vect with inexact real random numbers  Fills vect with inexact real random numbers
3490  the sum of whose squares is less than 1.0.  the sum of whose squares is less than 1.0.
3491  Thinking of vect as coordinates in space of  Thinking of vect as coordinates in space of
# Line 3131  The sum of the squares of the numbers is Line 3495  The sum of the squares of the numbers is
3495  @end deffn  @end deffn
3496    
3497   random:hollow-sphere!   random:hollow-sphere!
3498  @deffn primitive random:hollow-sphere! v [state]  @deffn {Scheme Procedure} random:hollow-sphere! v [state]
3499    @deffnx {C Function} scm_random_hollow_sphere_x (v, state)
3500  Fills vect with inexact real random numbers  Fills vect with inexact real random numbers
3501  the sum of whose squares is equal to 1.0.  the sum of whose squares is equal to 1.0.
3502  Thinking of vect as coordinates in space of  Thinking of vect as coordinates in space of
# Line 3141  unit n-sphere. Line 3506  unit n-sphere.
3506  @end deffn  @end deffn
3507    
3508   random:normal-vector!   random:normal-vector!
3509  @deffn primitive random:normal-vector! v [state]  @deffn {Scheme Procedure} random:normal-vector! v [state]
3510    @deffnx {C Function} scm_random_normal_vector_x (v, state)
3511  Fills vect with inexact real random numbers that are  Fills vect with inexact real random numbers that are
3512  independent and standard normally distributed  independent and standard normally distributed
3513  (i.e., with mean 0 and variance 1).  (i.e., with mean 0 and variance 1).
3514  @end deffn  @end deffn
3515    
3516   random:exp   random:exp
3517  @deffn primitive random:exp [state]  @deffn {Scheme Procedure} random:exp [state]
3518    @deffnx {C Function} scm_random_exp (state)
3519  Return an inexact real in an exponential distribution with mean  Return an inexact real in an exponential distribution with mean
3520  1.  For an exponential distribution with mean u use (* u  1.  For an exponential distribution with mean u use (* u
3521  (random:exp)).  (random:exp)).
3522  @end deffn  @end deffn
3523    
3524   %read-delimited!   %read-delimited!
3525  @deffn primitive %read-delimited! delims str gobble [port [start [end]]]  @deffn {Scheme Procedure} %read-delimited! delims str gobble [port [start [end]]]
3526    @deffnx {C Function} scm_read_delimited_x (delims, str, gobble, port, start, end)
3527  Read characters from @var{port} into @var{str} until one of the  Read characters from @var{port} into @var{str} until one of the
3528  characters in the @var{delims} string is encountered.  If  characters in the @var{delims} string is encountered.  If
3529  @var{gobble} is true, discard the delimiter character;  @var{gobble} is true, discard the delimiter character;
# Line 3174  a delimiter, this value is @code{#f}. Line 3542  a delimiter, this value is @code{#f}.
3542  @end deffn  @end deffn
3543    
3544   %read-line   %read-line
3545  @deffn primitive %read-line [port]  @deffn {Scheme Procedure} %read-line [port]
3546    @deffnx {C Function} scm_read_line (port)
3547  Read a newline-terminated line from @var{port}, allocating storage as  Read a newline-terminated line from @var{port}, allocating storage as
3548  necessary.  The newline terminator (if any) is removed from the string,  necessary.  The newline terminator (if any) is removed from the string,
3549  and a pair consisting of the line and its delimiter is returned.  The  and a pair consisting of the line and its delimiter is returned.  The
# Line 3184  delimiter may be either a newline or the Line 3553  delimiter may be either a newline or the
3553  @end deffn  @end deffn
3554    
3555   write-line   write-line
3556  @deffn primitive write-line obj [port]  @deffn {Scheme Procedure} write-line obj [port]
3557    @deffnx {C Function} scm_write_line (obj, port)
3558  Display @var{obj} and a newline character to @var{port}.  If  Display @var{obj} and a newline character to @var{port}.  If
3559  @var{port} is not specified, @code{(current-output-port)} is  @var{port} is not specified, @code{(current-output-port)} is
3560  used.  This function is equivalent to:  used.  This function is equivalent to:
# Line 3195  used.  This function is equivalent to: Line 3565  used.  This function is equivalent to:
3565  @end deffn  @end deffn
3566    
3567   read-options-interface   read-options-interface
3568  @deffn primitive read-options-interface [setting]  @deffn {Scheme Procedure} read-options-interface [setting]
3569    @deffnx {C Function} scm_read_options (setting)
3570  Option interface for the read options. Instead of using  Option interface for the read options. Instead of using
3571  this procedure directly, use the procedures @code{read-enable},  this procedure directly, use the procedures @code{read-enable},
3572  @code{read-disable}, @code{read-set!} and @var{read-options}.  @code{read-disable}, @code{read-set!} and @code{read-options}.
3573  @end deffn  @end deffn
3574    
3575   read   read
3576  @deffn primitive read [port]  @deffn {Scheme Procedure} read [port]
3577    @deffnx {C Function} scm_read (port)
3578  Read an s-expression from the input port @var{port}, or from  Read an s-expression from the input port @var{port}, or from
3579  the current input port if @var{port} is not specified.  the current input port if @var{port} is not specified.
3580  Any whitespace before the next token is discarded.  Any whitespace before the next token is discarded.
3581  @end deffn  @end deffn
3582    
3583   read-hash-extend   read-hash-extend
3584  @deffn primitive read-hash-extend chr proc  @deffn {Scheme Procedure} read-hash-extend chr proc
3585    @deffnx {C Function} scm_read_hash_extend (chr, proc)
3586  Install the procedure @var{proc} for reading expressions  Install the procedure @var{proc} for reading expressions
3587  starting with the character sequence @code{#} and @var{chr}.  starting with the character sequence @code{#} and @var{chr}.
3588  @var{proc} will be called with two arguments:  the character  @var{proc} will be called with two arguments:  the character
# Line 3218  returned will be the return value of @co Line 3591  returned will be the return value of @co
3591  @end deffn  @end deffn
3592    
3593   call-with-dynamic-root   call-with-dynamic-root
3594  @deffn primitive call-with-dynamic-root thunk handler  @deffn {Scheme Procedure} call-with-dynamic-root thunk handler
3595    @deffnx {C Function} scm_call_with_dynamic_root (thunk, handler)
3596  Evaluate @code{(thunk)} in a new dynamic context, returning its value.  Evaluate @code{(thunk)} in a new dynamic context, returning its value.
3597    
3598  If an error occurs during evaluation, apply @var{handler} to the  If an error occurs during evaluation, apply @var{handler} to the
# Line 3264  be under a new dynamic root.) Line 3638  be under a new dynamic root.)
3638  @end deffn  @end deffn
3639    
3640   dynamic-root   dynamic-root
3641  @deffn primitive dynamic-root  @deffn {Scheme Procedure} dynamic-root
3642    @deffnx {C Function} scm_dynamic_root ()
3643  Return an object representing the current dynamic root.  Return an object representing the current dynamic root.
3644    
3645  These objects are only useful for comparison using @code{eq?}.  These objects are only useful for comparison using @code{eq?}.
# Line 3273  in no way depend on this. Line 3648  in no way depend on this.
3648  @end deffn  @end deffn
3649    
3650   read-string!/partial   read-string!/partial
3651  @deffn primitive read-string!/partial str [port_or_fdes [start [end]]]  @deffn {Scheme Procedure} read-string!/partial str [port_or_fdes [start [end]]]
3652    @deffnx {C Function} scm_read_string_x_partial (str, port_or_fdes, start, end)
3653  Read characters from a port or file descriptor into a  Read characters from a port or file descriptor into a
3654  string @var{str}.  A port must have an underlying file  string @var{str}.  A port must have an underlying file
3655  descriptor --- a so-called fport.  This procedure is  descriptor --- a so-called fport.  This procedure is
# Line 3314  end-of-file check. Line 3690  end-of-file check.
3690  @end deffn  @end deffn
3691    
3692   write-string/partial   write-string/partial
3693  @deffn primitive write-string/partial str [port_or_fdes [start [end]]]  @deffn {Scheme Procedure} write-string/partial str [port_or_fdes [start [end]]]
3694    @deffnx {C Function} scm_write_string_partial (str, port_or_fdes, start, end)
3695  Write characters from a string @var{str} to a port or file  Write characters from a string @var{str} to a port or file
3696  descriptor.  A port must have an underlying file descriptor  descriptor.  A port must have an underlying file descriptor
3697  --- a so-called fport.  This procedure is  --- a so-called fport.  This procedure is
# Line 3359  return 0 immediately if the request size Line 3736  return 0 immediately if the request size
3736  @end deffn  @end deffn
3737    
3738   sigaction   sigaction
3739  @deffn primitive sigaction signum [handler [flags]]  @deffn {Scheme Procedure} sigaction signum [handler [flags]]
3740    @deffnx {C Function} scm_sigaction (signum, handler, flags)
3741  Install or report the signal handler for a specified signal.  Install or report the signal handler for a specified signal.
3742    
3743  @var{signum} is the signal number, which can be specified using the value  @var{signum} is the signal number, which can be specified using the value
# Line 3389  structures. Line 3767  structures.
3767  @end deffn  @end deffn
3768    
3769   restore-signals   restore-signals
3770  @deffn primitive restore-signals  @deffn {Scheme Procedure} restore-signals
3771    @deffnx {C Function} scm_restore_signals ()
3772  Return all signal handlers to the values they had before any call to  Return all signal handlers to the values they had before any call to
3773  @code{sigaction} was made.  The return value is unspecified.  @code{sigaction} was made.  The return value is unspecified.
3774  @end deffn  @end deffn
3775    
3776   alarm   alarm
3777  @deffn primitive alarm i  @deffn {Scheme Procedure} alarm i
3778    @deffnx {C Function} scm_alarm (i)
3779  Set a timer to raise a @code{SIGALRM} signal after the specified  Set a timer to raise a @code{SIGALRM} signal after the specified
3780  number of seconds (an integer).  It's advisable to install a signal  number of seconds (an integer).  It's advisable to install a signal
3781  handler for  handler for
# Line 3408  no previous alarm, the return value is z Line 3788  no previous alarm, the return value is z
3788  @end deffn  @end deffn
3789    
3790   setitimer   setitimer
3791  @deffn primitive setitimer which_timer interval_seconds interval_microseconds value_seconds value_microseconds  @deffn {Scheme Procedure} setitimer which_timer interval_seconds interval_microseconds value_seconds value_microseconds
3792    @deffnx {C Function} scm_setitimer (which_timer, interval_seconds, interval_microseconds, value_seconds, value_microseconds)
3793  Set the timer specified by @var{which_timer} according to the given  Set the timer specified by @var{which_timer} according to the given
3794  @var{interval_seconds}, @var{interval_microseconds},  @var{interval_seconds}, @var{interval_microseconds},
3795  @var{value_seconds}, and @var{value_microseconds} values.  @var{value_seconds}, and @var{value_microseconds} values.
# Line 3427  the seconds and microseconds of the time Line 3808  the seconds and microseconds of the time
3808  @end deffn  @end deffn
3809    
3810   getitimer   getitimer
3811  @deffn primitive getitimer which_timer  @deffn {Scheme Procedure} getitimer which_timer
3812    @deffnx {C Function} scm_getitimer (which_timer)
3813  Return information about the timer specified by @var{which_timer}  Return information about the timer specified by @var{which_timer}
3814  Errors are handled as described in the guile info pages under ``POSIX  Errors are handled as described in the guile info pages under ``POSIX
3815  Interface Conventions''.  Interface Conventions''.
# Line 3442  the seconds and microseconds of the time Line 3824  the seconds and microseconds of the time
3824  @end deffn  @end deffn
3825    
3826   pause   pause
3827  @deffn primitive pause  @deffn {Scheme Procedure} pause
3828    @deffnx {C Function} scm_pause ()
3829  Pause the current process (thread?) until a signal arrives whose  Pause the current process (thread?) until a signal arrives whose
3830  action is to either terminate the current process or invoke a  action is to either terminate the current process or invoke a
3831  handler procedure.  The return value is unspecified.  handler procedure.  The return value is unspecified.
3832  @end deffn  @end deffn
3833    
3834   sleep   sleep
3835  @deffn primitive sleep i  @deffn {Scheme Procedure} sleep i
3836    @deffnx {C Function} scm_sleep (i)
3837  Wait for the given number of seconds (an integer) or until a signal  Wait for the given number of seconds (an integer) or until a signal
3838  arrives.  The return value is zero if the time elapses or the number  arrives.  The return value is zero if the time elapses or the number
3839  of seconds remaining otherwise.  of seconds remaining otherwise.
3840  @end deffn  @end deffn
3841    
3842   usleep   usleep
3843  @deffn primitive usleep i  @deffn {Scheme Procedure} usleep i
3844    @deffnx {C Function} scm_usleep (i)
3845  Sleep for I microseconds.  @code{usleep} is not available on  Sleep for I microseconds.  @code{usleep} is not available on
3846  all platforms.  all platforms.
3847  @end deffn  @end deffn
3848    
3849   raise   raise
3850  @deffn primitive raise sig  @deffn {Scheme Procedure} raise sig
3851    @deffnx {C Function} scm_raise (sig)
3852  Sends a specified signal @var{sig} to the current process, where  Sends a specified signal @var{sig} to the current process, where
3853  @var{sig} is as described for the kill procedure.  @var{sig} is as described for the kill procedure.
3854  @end deffn  @end deffn
3855    
3856   system   system
3857  @deffn primitive system [cmd]  @deffn {Scheme Procedure} system [cmd]
3858    @deffnx {C Function} scm_system (cmd)
3859  Execute @var{cmd} using the operating system's "command  Execute @var{cmd} using the operating system's "command
3860  processor".  Under Unix this is usually the default shell  processor".  Under Unix this is usually the default shell
3861  @code{sh}.  The value returned is @var{cmd}'s exit status as  @code{sh}.  The value returned is @var{cmd}'s exit status as
# Line 3480  indicating whether the command processor Line 3867  indicating whether the command processor
3867  @end deffn  @end deffn
3868    
3869   getenv   getenv
3870  @deffn primitive getenv nam  @deffn {Scheme Procedure} getenv nam
3871    @deffnx {C Function} scm_getenv (nam)
3872  Looks up the string @var{name} in the current environment.  The return  Looks up the string @var{name} in the current environment.  The return
3873  value is @code{#f} unless a string of the form @code{NAME=VALUE} is  value is @code{#f} unless a string of the form @code{NAME=VALUE} is
3874  found, in which case the string @code{VALUE} is returned.  found, in which case the string @code{VALUE} is returned.
3875  @end deffn  @end deffn
3876    
3877   primitive-exit   primitive-exit
3878  @deffn primitive primitive-exit [status]  @deffn {Scheme Procedure} primitive-exit [status]
3879    @deffnx {C Function} scm_primitive_exit (status)
3880  Terminate the current process without unwinding the Scheme stack.  Terminate the current process without unwinding the Scheme stack.
3881  This is would typically be useful after a fork.  The exit status  This is would typically be useful after a fork.  The exit status
3882  is @var{status} if supplied, otherwise zero.  is @var{status} if supplied, otherwise zero.
3883  @end deffn  @end deffn
3884    
3885   restricted-vector-sort!   restricted-vector-sort!
3886  @deffn primitive restricted-vector-sort! vec less startpos endpos  @deffn {Scheme Procedure} restricted-vector-sort! vec less startpos endpos
3887    @deffnx {C Function} scm_restricted_vector_sort_x (vec, less, startpos, endpos)
3888  Sort the vector @var{vec}, using @var{less} for comparing  Sort the vector @var{vec}, using @var{less} for comparing
3889  the vector elements.  @var{startpos} and @var{endpos} delimit  the vector elements.  @var{startpos} and @var{endpos} delimit
3890  the range of the vector which gets sorted.  The return value  the range of the vector which gets sorted.  The return value
# Line 3502  is not specified. Line 3892  is not specified.
3892  @end deffn  @end deffn
3893    
3894   sorted?   sorted?
3895  @deffn primitive sorted? items less  @deffn {Scheme Procedure} sorted? items less
3896    @deffnx {C Function} scm_sorted_p (items, less)
3897  Return @code{#t} iff @var{items} is a list or a vector such that  Return @code{#t} iff @var{items} is a list or a vector such that
3898  for all 1 <= i <= m, the predicate @var{less} returns true when  for all 1 <= i <= m, the predicate @var{less} returns true when
3899  applied to all elements i - 1 and i  applied to all elements i - 1 and i
3900  @end deffn  @end deffn
3901    
3902   merge   merge
3903  @deffn primitive merge alist blist less  @deffn {Scheme Procedure} merge alist blist less
3904  Takes two lists @var{alist} and @var{blist} such that  @deffnx {C Function} scm_merge (alist, blist, less)
3905    Take two lists @var{alist} and @var{blist} such that
3906  @code{(sorted? alist less?)} and @code{(sorted? blist less?)} and  @code{(sorted? alist less?)} and @code{(sorted? blist less?)} and
3907  returns a new list in which the elements of @var{alist} and  returns a new list in which the elements of @var{alist} and
3908  @var{blist} have been stably interleaved so that  @var{blist} have been stably interleaved so that
# Line 3519  Note:  this does _not_ accept vectors. Line 3911  Note:  this does _not_ accept vectors.
3911  @end deffn  @end deffn
3912    
3913   merge!   merge!
3914  @deffn primitive merge! alist blist less  @deffn {Scheme Procedure} merge! alist blist less
3915    @deffnx {C Function} scm_merge_x (alist, blist, less)
3916  Takes two lists @var{alist} and @var{blist} such that  Takes two lists @var{alist} and @var{blist} such that
3917  @code{(sorted? alist less?)} and @code{(sorted? blist less?)} and  @code{(sorted? alist less?)} and @code{(sorted? blist less?)} and
3918  returns a new list in which the elements of @var{alist} and  returns a new list in which the elements of @var{alist} and
# Line 3530  Note:  this does _not_ accept vectors. Line 3923  Note:  this does _not_ accept vectors.
3923  @end deffn  @end deffn
3924    
3925   sort!   sort!
3926  @deffn primitive sort! items less  @deffn {Scheme Procedure} sort! items less
3927    @deffnx {C Function} scm_sort_x (items, less)
3928  Sort the sequence @var{items}, which may be a list or a  Sort the sequence @var{items}, which may be a list or a
3929  vector.  @var{less} is used for comparing the sequence  vector.  @var{less} is used for comparing the sequence
3930  elements.  The sorting is destructive, that means that the  elements.  The sorting is destructive, that means that the
# Line 3539  This is not a stable sort. Line 3933  This is not a stable sort.
3933  @end deffn  @end deffn
3934    
3935   sort   sort
3936  @deffn primitive sort items less  @deffn {Scheme Procedure} sort items less
3937    @deffnx {C Function} scm_sort (items, less)
3938  Sort the sequence @var{items}, which may be a list or a  Sort the sequence @var{items}, which may be a list or a
3939  vector.  @var{less} is used for comparing the sequence  vector.  @var{less} is used for comparing the sequence
3940  elements.  This is not a stable sort.  elements.  This is not a stable sort.
3941  @end deffn  @end deffn
3942    
3943   stable-sort!   stable-sort!
3944  @deffn primitive stable-sort! items less  @deffn {Scheme Procedure} stable-sort! items less
3945    @deffnx {C Function} scm_stable_sort_x (items, less)
3946  Sort the sequence @var{items}, which may be a list or a  Sort the sequence @var{items}, which may be a list or a
3947  vector. @var{less} is used for comparing the sequence elements.  vector. @var{less} is used for comparing the sequence elements.
3948  The sorting is destructive, that means that the input sequence  The sorting is destructive, that means that the input sequence
# Line 3555  This is a stable sort. Line 3951  This is a stable sort.
3951  @end deffn  @end deffn
3952    
3953   stable-sort   stable-sort
3954  @deffn primitive stable-sort items less  @deffn {Scheme Procedure} stable-sort items less
3955    @deffnx {C Function} scm_stable_sort (items, less)
3956  Sort the sequence @var{items}, which may be a list or a  Sort the sequence @var{items}, which may be a list or a
3957  vector. @var{less} is used for comparing the sequence elements.  vector. @var{less} is used for comparing the sequence elements.
3958  This is a stable sort.  This is a stable sort.
3959  @end deffn  @end deffn
3960    
3961   sort-list!   sort-list!
3962  @deffn primitive sort-list! items less  @deffn {Scheme Procedure} sort-list! items less
3963    @deffnx {C Function} scm_sort_list_x (items, less)
3964  Sort the list @var{items}, using @var{less} for comparing the  Sort the list @var{items}, using @var{less} for comparing the
3965  list elements. The sorting is destructive, that means that the  list elements. The sorting is destructive, that means that the
3966  input list is modified to produce the sorted result.  input list is modified to produce the sorted result.
# Line 3570  This is a stable sort. Line 3968  This is a stable sort.
3968  @end deffn  @end deffn
3969    
3970   sort-list   sort-list
3971  @deffn primitive sort-list items less  @deffn {Scheme Procedure} sort-list items less
3972    @deffnx {C Function} scm_sort_list (items, less)
3973  Sort the list @var{items}, using @var{less} for comparing the  Sort the list @var{items}, using @var{less} for comparing the
3974  list elements. This is a stable sort.  list elements. This is a stable sort.
3975  @end deffn  @end deffn
3976    
3977   source-properties   source-properties
3978  @deffn primitive source-properties obj  @deffn {Scheme Procedure} source-properties obj
3979    @deffnx {C Function} scm_source_properties (obj)
3980  Return the source property association list of @var{obj}.  Return the source property association list of @var{obj}.
3981  @end deffn  @end deffn
3982    
3983   set-source-properties!   set-source-properties!
3984  @deffn primitive set-source-properties! obj plist  @deffn {Scheme Procedure} set-source-properties! obj plist
3985    @deffnx {C Function} scm_set_source_properties_x (obj, plist)
3986  Install the association list @var{plist} as the source property  Install the association list @var{plist} as the source property
3987  list for @var{obj}.  list for @var{obj}.
3988  @end deffn  @end deffn
3989    
3990   source-property   source-property
3991  @deffn primitive source-property obj key  @deffn {Scheme Procedure} source-property obj key
3992    @deffnx {C Function} scm_source_property (obj, key)
3993  Return the source property specified by @var{key} from  Return the source property specified by @var{key} from
3994  @var{obj}'s source property list.  @var{obj}'s source property list.
3995  @end deffn  @end deffn
3996    
3997   set-source-property!   set-source-property!
3998  @deffn primitive set-source-property! obj key datum  @deffn {Scheme Procedure} set-source-property! obj key datum
3999    @deffnx {C Function} scm_set_source_property_x (obj, key, datum)
4000  Set the source property of object @var{obj}, which is specified by  Set the source property of object @var{obj}, which is specified by
4001  @var{key} to @var{datum}.  Normally, the key will be a symbol.  @var{key} to @var{datum}.  Normally, the key will be a symbol.
4002  @end deffn  @end deffn
4003    
4004   stack?   stack?
4005  @deffn primitive stack? obj  @deffn {Scheme Procedure} stack? obj
4006    @deffnx {C Function} scm_stack_p (obj)
4007  Return @code{#t} if @var{obj} is a calling stack.  Return @code{#t} if @var{obj} is a calling stack.
4008  @end deffn  @end deffn
4009    
4010   make-stack   make-stack
4011  @deffn primitive make-stack obj . args  @deffn {Scheme Procedure} make-stack obj . args
4012    @deffnx {C Function} scm_make_stack (obj, args)
4013  Create a new stack. If @var{obj} is @code{#t}, the current  Create a new stack. If @var{obj} is @code{#t}, the current
4014  evaluation stack is used for creating the stack frames,  evaluation stack is used for creating the stack frames,
4015  otherwise the frames are taken from @var{obj} (which must be  otherwise the frames are taken from @var{obj} (which must be
# Line 3614  resulting stack will be narrowed. Line 4019  resulting stack will be narrowed.
4019  @end deffn  @end deffn
4020    
4021   stack-id   stack-id
4022  @deffn primitive stack-id stack  @deffn {Scheme Procedure} stack-id stack
4023    @deffnx {C Function} scm_stack_id (stack)
4024  Return the identifier given to @var{stack} by @code{start-stack}.  Return the identifier given to @var{stack} by @code{start-stack}.
4025  @end deffn  @end deffn
4026    
4027   stack-ref   stack-ref
4028  @deffn primitive stack-ref stack index  @deffn {Scheme Procedure} stack-ref stack index
4029    @deffnx {C Function} scm_stack_ref (stack, index)
4030  Return the @var{index}'th frame from @var{stack}.  Return the @var{index}'th frame from @var{stack}.
4031  @end deffn  @end deffn
4032    
4033   stack-length   stack-length
4034  @deffn primitive stack-length stack  @deffn {Scheme Procedure} stack-length stack
4035    @deffnx {C Function} scm_stack_length (stack)
4036  Return the length of @var{stack}.  Return the length of @var{stack}.
4037  @end deffn  @end deffn
4038    
4039   frame?   frame?
4040  @deffn primitive frame? obj  @deffn {Scheme Procedure} frame? obj
4041    @deffnx {C Function} scm_frame_p (obj)
4042  Return @code{#t} if @var{obj} is a stack frame.  Return @code{#t} if @var{obj} is a stack frame.
4043  @end deffn  @end deffn
4044    
4045   last-stack-frame   last-stack-frame
4046  @deffn primitive last-stack-frame obj  @deffn {Scheme Procedure} last-stack-frame obj
4047    @deffnx {C Function} scm_last_stack_frame (obj)
4048  Return a stack which consists of a single frame, which is the  Return a stack which consists of a single frame, which is the
4049  last stack frame for @var{obj}. @var{obj} must be either a  last stack frame for @var{obj}. @var{obj} must be either a
4050  debug object or a continuation.  debug object or a continuation.
4051  @end deffn  @end deffn
4052    
4053   frame-number   frame-number
4054  @deffn primitive frame-number frame  @deffn {Scheme Procedure} frame-number frame
4055    @deffnx {C Function} scm_frame_number (frame)
4056  Return the frame number of @var{frame}.  Return the frame number of @var{frame}.
4057  @end deffn  @end deffn
4058    
4059   frame-source   frame-source
4060  @deffn primitive frame-source frame  @deffn {Scheme Procedure} frame-source frame
4061    @deffnx {C Function} scm_frame_source (frame)
4062  Return the source of @var{frame}.  Return the source of @var{frame}.
4063  @end deffn  @end deffn
4064    
4065   frame-procedure   frame-procedure
4066  @deffn primitive frame-procedure frame  @deffn {Scheme Procedure} frame-procedure frame
4067    @deffnx {C Function} scm_frame_procedure (frame)
4068  Return the procedure for @var{frame}, or @code{#f} if no  Return the procedure for @var{frame}, or @code{#f} if no
4069  procedure is associated with @var{frame}.  procedure is associated with @var{frame}.
4070  @end deffn  @end deffn
4071    
4072   frame-arguments   frame-arguments
4073  @deffn primitive frame-arguments frame  @deffn {Scheme Procedure} frame-arguments frame
4074    @deffnx {C Function} scm_frame_arguments (frame)
4075  Return the arguments of @var{frame}.  Return the arguments of @var{frame}.
4076  @end deffn  @end deffn
4077    
4078   frame-previous   frame-previous
4079  @deffn primitive frame-previous frame  @deffn {Scheme Procedure} frame-previous frame
4080    @deffnx {C Function} scm_frame_previous (frame)
4081  Return the previous frame of @var{frame}, or @code{#f} if  Return the previous frame of @var{frame}, or @code{#f} if
4082  @var{frame} is the first frame in its stack.  @var{frame} is the first frame in its stack.
4083  @end deffn  @end deffn
4084    
4085   frame-next   frame-next
4086  @deffn primitive frame-next frame  @deffn {Scheme Procedure} frame-next frame
4087    @deffnx {C Function} scm_frame_next (frame)
4088  Return the next frame of @var{frame}, or @code{#f} if  Return the next frame of @var{frame}, or @code{#f} if
4089  @var{frame} is the last frame in its stack.  @var{frame} is the last frame in its stack.
4090  @end deffn  @end deffn
4091    
4092   frame-real?   frame-real?
4093  @deffn primitive frame-real? frame  @deffn {Scheme Procedure} frame-real? frame
4094    @deffnx {C Function} scm_frame_real_p (frame)
4095  Return @code{#t} if @var{frame} is a real frame.  Return @code{#t} if @var{frame} is a real frame.
4096  @end deffn  @end deffn
4097    
4098   frame-procedure?   frame-procedure?
4099  @deffn primitive frame-procedure? frame  @deffn {Scheme Procedure} frame-procedure? frame
4100    @deffnx {C Function} scm_frame_procedure_p (frame)
4101  Return @code{#t} if a procedure is associated with @var{frame}.  Return @code{#t} if a procedure is associated with @var{frame}.
4102  @end deffn  @end deffn
4103    
4104   frame-evaluating-args?   frame-evaluating-args?
4105  @deffn primitive frame-evaluating-args? frame  @deffn {Scheme Procedure} frame-evaluating-args? frame
4106    @deffnx {C Function} scm_frame_evaluating_args_p (frame)
4107  Return @code{#t} if @var{frame} contains evaluated arguments.  Return @code{#t} if @var{frame} contains evaluated arguments.
4108  @end deffn  @end deffn
4109    
4110   frame-overflow?   frame-overflow?
4111  @deffn primitive frame-overflow? frame  @deffn {Scheme Procedure} frame-overflow? frame
4112    @deffnx {C Function} scm_frame_overflow_p (frame)
4113  Return @code{#t} if @var{frame} is an overflow frame.  Return @code{#t} if @var{frame} is an overflow frame.
4114  @end deffn  @end deffn
4115    
4116   get-internal-real-time   get-internal-real-time
4117  @deffn primitive get-internal-real-time  @deffn {Scheme Procedure} get-internal-real-time
4118    @deffnx {C Function} scm_get_internal_real_time ()
4119  Return the number of time units since the interpreter was  Return the number of time units since the interpreter was
4120  started.  started.
4121  @end deffn  @end deffn
4122    
4123   times   times
4124  @deffn primitive times  @deffn {Scheme Procedure} times
4125    @deffnx {C Function} scm_times ()
4126  Return an object with information about real and processor  Return an object with information about real and processor
4127  time.  The following procedures accept such an object as an  time.  The following procedures accept such an object as an
4128  argument and return a selected component:  argument and return a selected component:
# Line 3725  terminated child processes. Line 4147  terminated child processes.
4147  @end deffn  @end deffn
4148    
4149   get-internal-run-time   get-internal-run-time
4150  @deffn primitive get-internal-run-time  @deffn {Scheme Procedure} get-internal-run-time
4151    @deffnx {C Function} scm_get_internal_run_time ()
4152  Return the number of time units of processor time used by the  Return the number of time units of processor time used by the
4153  interpreter.  Both @emph{system} and @emph{user} time are  interpreter.  Both @emph{system} and @emph{user} time are
4154  included but subprocesses are not.  included but subprocesses are not.
4155  @end deffn  @end deffn
4156    
4157   current-time   current-time
4158  @deffn primitive current-time  @deffn {Scheme Procedure} current-time
4159    @deffnx {C Function} scm_current_time ()
4160  Return the number of seconds since 1970-01-01 00:00:00 UTC,  Return the number of seconds since 1970-01-01 00:00:00 UTC,
4161  excluding leap seconds.  excluding leap seconds.
4162  @end deffn  @end deffn
4163    
4164   gettimeofday   gettimeofday
4165  @deffn primitive gettimeofday  @deffn {Scheme Procedure} gettimeofday
4166    @deffnx {C Function} scm_gettimeofday ()
4167  Return a pair containing the number of seconds and microseconds  Return a pair containing the number of seconds and microseconds
4168  since 1970-01-01 00:00:00 UTC, excluding leap seconds.  Note:  since 1970-01-01 00:00:00 UTC, excluding leap seconds.  Note:
4169  whether true microsecond resolution is available depends on the  whether true microsecond resolution is available depends on the
# Line 3746  operating system. Line 4171  operating system.
4171  @end deffn  @end deffn
4172    
4173   localtime   localtime
4174  @deffn primitive localtime time [zone]  @deffn {Scheme Procedure} localtime time [zone]
4175    @deffnx {C Function} scm_localtime (time, zone)
4176  Return an object representing the broken down components of  Return an object representing the broken down components of
4177  @var{time}, an integer like the one returned by  @var{time}, an integer like the one returned by
4178  @code{current-time}.  The time zone for the calculation is  @code{current-time}.  The time zone for the calculation is
# Line 3755  optionally specified by @var{zone} (a st Line 4181  optionally specified by @var{zone} (a st
4181  @end deffn  @end deffn
4182    
4183   gmtime   gmtime
4184  @deffn primitive gmtime time  @deffn {Scheme Procedure} gmtime time
4185    @deffnx {C Function} scm_gmtime (time)
4186  Return an object representing the broken down components of  Return an object representing the broken down components of
4187  @var{time}, an integer like the one returned by  @var{time}, an integer like the one returned by
4188  @code{current-time}.  The values are calculated for UTC.  @code{current-time}.  The values are calculated for UTC.
4189  @end deffn  @end deffn
4190    
4191   mktime   mktime
4192  @deffn primitive mktime sbd_time [zone]  @deffn {Scheme Procedure} mktime sbd_time [zone]
4193    @deffnx {C Function} scm_mktime (sbd_time, zone)
4194  @var{bd-time} is an object representing broken down time and @code{zone}  @var{bd-time} is an object representing broken down time and @code{zone}
4195  is an optional time zone specifier (otherwise the TZ environment variable  is an optional time zone specifier (otherwise the TZ environment variable
4196  or the system default is used).  or the system default is used).
# Line 3774  as @var{bd-time} but with normalized val Line 4202  as @var{bd-time} but with normalized val
4202  @end deffn  @end deffn
4203    
4204   tzset   tzset
4205  @deffn primitive tzset  @deffn {Scheme Procedure} tzset
4206    @deffnx {C Function} scm_tzset ()
4207  Initialize the timezone from the TZ environment variable  Initialize the timezone from the TZ environment variable
4208  or the system default.  It's not usually necessary to call this procedure  or the system default.  It's not usually necessary to call this procedure
4209  since it's done automatically by other procedures that depend on the  since it's done automatically by other procedures that depend on the
# Line 3782  timezone. Line 4211  timezone.
4211  @end deffn  @end deffn
4212    
4213   strftime   strftime
4214  @deffn primitive strftime format stime  @deffn {Scheme Procedure} strftime format stime
4215    @deffnx {C Function} scm_strftime (format, stime)
4216  Formats a time specification @var{time} using @var{template}.  @var{time}  Formats a time specification @var{time} using @var{template}.  @var{time}
4217  is an object with time components in the form returned by @code{localtime}  is an object with time components in the form returned by @code{localtime}
4218  or @code{gmtime}.  @var{template} is a string which can include formatting  or @code{gmtime}.  @var{template} is a string which can include formatting
# Line 3793  is the formatted string. Line 4223  is the formatted string.
4223  @end deffn  @end deffn
4224    
4225   strptime   strptime
4226  @deffn primitive strptime format string  @deffn {Scheme Procedure} strptime format string
4227    @deffnx {C Function} scm_strptime (format, string)
4228  Performs the reverse action to @code{strftime}, parsing  Performs the reverse action to @code{strftime}, parsing
4229  @var{string} according to the specification supplied in  @var{string} according to the specification supplied in
4230  @var{template}.  The interpretation of month and day names is  @var{template}.  The interpretation of month and day names is
# Line 3807  which were used for the conversion. Line 4238  which were used for the conversion.
4238  @end deffn  @end deffn
4239    
4240   string?   string?
4241  @deffn primitive string? obj  @deffn {Scheme Procedure} string? obj
4242  Return @code{#t} iff @var{obj} is a string, else returns  @deffnx {C Function} scm_string_p (obj)
4243  @code{#f}.  Return @code{#t} if @var{obj} is a string, else @code{#f}.
4244  @end deffn  @end deffn
4245    
4246   read-only-string?   read-only-string?
4247  @deffn primitive read-only-string? obj  @deffn {Scheme Procedure} read-only-string? obj
4248    @deffnx {C Function} scm_read_only_string_p (obj)
4249  Return @code{#t} if @var{obj} is either a string or a symbol,  Return @code{#t} if @var{obj} is either a string or a symbol,
4250  otherwise return @code{#f}.  otherwise return @code{#f}.
4251  @end deffn  @end deffn
4252    
4253   list->string   list->string
4254  @deffn primitive list->string  @deffn {Scheme Procedure} list->string
4255  implemented by the C function "scm_string"  implemented by the C function "scm_string"
4256  @end deffn  @end deffn
4257    
4258   string   string
4259  @deffn primitive string . chrs  @deffn {Scheme Procedure} string . chrs
4260  @deffnx primitive list->string chrs  @deffnx {Scheme Procedure} list->string chrs
4261    @deffnx {C Function} scm_string (chrs)
4262  Return a newly allocated string composed of the arguments,  Return a newly allocated string composed of the arguments,
4263  @var{chrs}.  @var{chrs}.
4264  @end deffn  @end deffn
4265    
4266   make-string   make-string
4267  @deffn primitive make-string k [chr]  @deffn {Scheme Procedure} make-string k [chr]
4268    @deffnx {C Function} scm_make_string (k, chr)
4269  Return a newly allocated string of  Return a newly allocated string of
4270  length @var{k}.  If @var{chr} is given, then all elements of  length @var{k}.  If @var{chr} is given, then all elements of
4271  the string are initialized to @var{chr}, otherwise the contents  the string are initialized to @var{chr}, otherwise the contents
# Line 3839  of the @var{string} are unspecified. Line 4273  of the @var{string} are unspecified.
4273  @end deffn  @end deffn
4274    
4275   string-length   string-length
4276  @deffn primitive string-length string  @deffn {Scheme Procedure} string-length string
4277    @deffnx {C Function} scm_string_length (string)
4278  Return the number of characters in @var{string}.  Return the number of characters in @var{string}.
4279  @end deffn  @end deffn
4280    
4281   string-ref   string-ref
4282  @deffn primitive string-ref str k  @deffn {Scheme Procedure} string-ref str k
4283    @deffnx {C Function} scm_string_ref (str, k)
4284  Return character @var{k} of @var{str} using zero-origin  Return character @var{k} of @var{str} using zero-origin
4285  indexing. @var{k} must be a valid index of @var{str}.  indexing. @var{k} must be a valid index of @var{str}.
4286  @end deffn  @end deffn
4287    
4288   string-set!   string-set!
4289  @deffn primitive string-set! str k chr  @deffn {Scheme Procedure} string-set! str k chr
4290    @deffnx {C Function} scm_string_set_x (str, k, chr)
4291  Store @var{chr} in element @var{k} of @var{str} and return  Store @var{chr} in element @var{k} of @var{str} and return
4292  an unspecified value. @var{k} must be a valid index of  an unspecified value. @var{k} must be a valid index of
4293  @var{str}.  @var{str}.
4294  @end deffn  @end deffn
4295    
4296   substring   substring
4297  @deffn primitive substring str start [end]  @deffn {Scheme Procedure} substring str start [end]
4298    @deffnx {C Function} scm_substring (str, start, end)
4299  Return a newly allocated string formed from the characters  Return a newly allocated string formed from the characters
4300  of @var{str} beginning with index @var{start} (inclusive) and  of @var{str} beginning with index @var{start} (inclusive) and
4301  ending with index @var{end} (exclusive).  ending with index @var{end} (exclusive).
# Line 3868  exact integers satisfying: Line 4306  exact integers satisfying:
4306  @end deffn  @end deffn
4307    
4308   string-append   string-append
4309  @deffn primitive string-append . args  @deffn {Scheme Procedure} string-append . args
4310    @deffnx {C Function} scm_string_append (args)
4311  Return a newly allocated string whose characters form the  Return a newly allocated string whose characters form the
4312  concatenation of the given strings, @var{args}.  concatenation of the given strings, @var{args}.
4313  @end deffn  @end deffn
4314    
4315   make-shared-substring   make-shared-substring
4316  @deffn primitive make-shared-substring str [start [end]]  @deffn {Scheme Procedure} make-shared-substring str [start [end]]
4317    @deffnx {C Function} scm_make_shared_substring (str, start, end)
4318  Return a shared substring of @var{str}.  The arguments are the  Return a shared substring of @var{str}.  The arguments are the
4319  same as for the @code{substring} function: the shared substring  same as for the @code{substring} function: the shared substring
4320  returned includes all of the text from @var{str} between  returned includes all of the text from @var{str} between
# Line 3885  occupies the same storage space as @var{ Line 4325  occupies the same storage space as @var{
4325  @end deffn  @end deffn
4326    
4327   string-index   string-index
4328  @deffn primitive string-index str chr [frm [to]]  @deffn {Scheme Procedure} string-index str chr [frm [to]]
4329    @deffnx {C Function} scm_string_index (str, chr, frm, to)
4330  Return the index of the first occurrence of @var{chr} in  Return the index of the first occurrence of @var{chr} in
4331  @var{str}.  The optional integer arguments @var{frm} and  @var{str}.  The optional integer arguments @var{frm} and
4332  @var{to} limit the search to a portion of the string.  This  @var{to} limit the search to a portion of the string.  This
# Line 3905  procedure essentially implements the @co Line 4346  procedure essentially implements the @co
4346  @end deffn  @end deffn
4347    
4348   string-rindex   string-rindex
4349  @deffn primitive string-rindex str chr [frm [to]]  @deffn {Scheme Procedure} string-rindex str chr [frm [to]]
4350    @deffnx {C Function} scm_string_rindex (str, chr, frm, to)
4351  Like @code{string-index}, but search from the right of the  Like @code{string-index}, but search from the right of the
4352  string rather than from the left.  This procedure essentially  string rather than from the left.  This procedure essentially
4353  implements the @code{rindex} or @code{strrchr} functions from  implements the @code{rindex} or @code{strrchr} functions from
# Line 3924  the C library. Line 4366  the C library.
4366  @end deffn  @end deffn
4367    
4368   substring-move-left!   substring-move-left!
4369  @deffn primitive substring-move-left!  @deffn {Scheme Procedure} substring-move-left!
4370  implemented by the C function "scm_substring_move_x"  implemented by the C function "scm_substring_move_x"
4371  @end deffn  @end deffn
4372    
4373   substring-move-right!   substring-move-right!
4374  @deffn primitive substring-move-right!  @deffn {Scheme Procedure} substring-move-right!
4375  implemented by the C function "scm_substring_move_x"  implemented by the C function "scm_substring_move_x"
4376  @end deffn  @end deffn
4377    
4378   substring-move!   substring-move!
4379  @deffn primitive substring-move! str1 start1 end1 str2 start2  @deffn {Scheme Procedure} substring-move! str1 start1 end1 str2 start2
4380  @deffnx primitive substring-move-left! str1 start1 end1 str2 start2  @deffnx {C Function} scm_substring_move_x (str1, start1, end1, str2, start2)
 @deffnx primitive substring-move-right! str1 start1 end1 str2 start2  
4381  Copy the substring of @var{str1} bounded by @var{start1} and @var{end1}  Copy the substring of @var{str1} bounded by @var{start1} and @var{end1}
4382  into @var{str2} beginning at position @var{start2}.  into @var{str2} beginning at position @var{start2}.
4383  @code{substring-move-right!} begins copying from the rightmost character  @var{str1} and @var{str2} can be the same string.
 and moves left, and @code{substring-move-left!} copies from the leftmost  
 character moving right.  
   
 It is useful to have two functions that copy in different directions so  
 that substrings can be copied back and forth within a single string.  If  
 you wish to copy text from the left-hand side of a string to the  
 right-hand side of the same string, and the source and destination  
 overlap, you must be careful to copy the rightmost characters of the  
 text first, to avoid clobbering your data.  Hence, when @var{str1} and  
 @var{str2} are the same string, you should use  
 @code{substring-move-right!} when moving text from left to right, and  
 @code{substring-move-left!}  otherwise.  If @code{str1} and @samp{str2}  
 are different strings, it does not matter which function you use.  
4384  @end deffn  @end deffn
4385    
4386   substring-fill!   substring-fill!
4387  @deffn primitive substring-fill! str start end fill  @deffn {Scheme Procedure} substring-fill! str start end fill
4388    @deffnx {C Function} scm_substring_fill_x (str, start, end, fill)
4389  Change every character in @var{str} between @var{start} and  Change every character in @var{str} between @var{start} and
4390  @var{end} to @var{fill}.  @var{end} to @var{fill}.
4391    
# Line 3969  y Line 4398  y
4398  @end deffn  @end deffn
4399    
4400   string-null?   string-null?
4401  @deffn primitive string-null? str  @deffn {Scheme Procedure} string-null? str
4402    @deffnx {C Function} scm_string_null_p (str)
4403  Return @code{#t} if @var{str}'s length is zero, and  Return @code{#t} if @var{str}'s length is zero, and
4404  @code{#f} otherwise.  @code{#f} otherwise.
4405  @lisp  @lisp
# Line 3980  y                    @result{} "foo" Line 4410  y                    @result{} "foo"
4410  @end deffn  @end deffn
4411    
4412   string->list   string->list
4413  @deffn primitive string->list str  @deffn {Scheme Procedure} string->list str
4414    @deffnx {C Function} scm_string_to_list (str)
4415  Return a newly allocated list of the characters that make up  Return a newly allocated list of the characters that make up
4416  the given string @var{str}. @code{string->list} and  the given string @var{str}. @code{string->list} and
4417  @code{list->string} are inverses as far as @samp{equal?} is  @code{list->string} are inverses as far as @samp{equal?} is
# Line 3988  concerned. Line 4419  concerned.
4419  @end deffn  @end deffn
4420    
4421   string-copy   string-copy
4422  @deffn primitive string-copy str  @deffn {Scheme Procedure} string-copy str
4423    @deffnx {C Function} scm_string_copy (str)
4424  Return a newly allocated copy of the given @var{string}.  Return a newly allocated copy of the given @var{string}.
4425  @end deffn  @end deffn
4426    
4427   string-fill!   string-fill!
4428  @deffn primitive string-fill! str chr  @deffn {Scheme Procedure} string-fill! str chr
4429    @deffnx {C Function} scm_string_fill_x (str, chr)
4430  Store @var{char} in every element of the given @var{string} and  Store @var{char} in every element of the given @var{string} and
4431  return an unspecified value.  return an unspecified value.
4432  @end deffn  @end deffn
4433    
4434   string-upcase!   string-upcase!
4435  @deffn primitive string-upcase! str  @deffn {Scheme Procedure} string-upcase! str
4436    @deffnx {C Function} scm_string_upcase_x (str)
4437  Destructively upcase every character in @var{str} and return  Destructively upcase every character in @var{str} and return
4438  @var{str}.  @var{str}.
4439  @lisp  @lisp
# Line 4010  y                  @result{} "ARRDEFG" Line 4444  y                  @result{} "ARRDEFG"
4444  @end deffn  @end deffn
4445    
4446   string-upcase   string-upcase
4447  @deffn primitive string-upcase str  @deffn {Scheme Procedure} string-upcase str
4448    @deffnx {C Function} scm_string_upcase (str)
4449  Return a freshly allocated string containing the characters of  Return a freshly allocated string containing the characters of
4450  @var{str} in upper case.  @var{str} in upper case.
4451  @end deffn  @end deffn
4452    
4453   string-downcase!   string-downcase!
4454  @deffn primitive string-downcase! str  @deffn {Scheme Procedure} string-downcase! str
4455    @deffnx {C Function} scm_string_downcase_x (str)
4456  Destructively downcase every character in @var{str} and return  Destructively downcase every character in @var{str} and return
4457  @var{str}.  @var{str}.
4458  @lisp  @lisp
# Line 4027  y                     @result{} "arrdefg Line 4463  y                     @result{} "arrdefg
4463  @end deffn  @end deffn
4464    
4465   string-downcase   string-downcase
4466  @deffn primitive string-downcase str  @deffn {Scheme Procedure} string-downcase str
4467    @deffnx {C Function} scm_string_downcase (str)
4468  Return a freshly allocation string containing the characters in  Return a freshly allocation string containing the characters in
4469  @var{str} in lower case.  @var{str} in lower case.
4470  @end deffn  @end deffn
4471    
4472   string-capitalize!   string-capitalize!
4473  @deffn primitive string-capitalize! str  @deffn {Scheme Procedure} string-capitalize! str
4474    @deffnx {C Function} scm_string_capitalize_x (str)
4475  Upcase the first character of every word in @var{str}  Upcase the first character of every word in @var{str}
4476  destructively and return @var{str}.  destructively and return @var{str}.
4477    
# Line 4045  y                      @result{} "Hello Line 4483  y                      @result{} "Hello
4483  @end deffn  @end deffn
4484    
4485   string-capitalize   string-capitalize
4486  @deffn primitive string-capitalize str  @deffn {Scheme Procedure} string-capitalize str
4487    @deffnx {C Function} scm_string_capitalize (str)
4488  Return a freshly allocated string with the characters in  Return a freshly allocated string with the characters in
4489  @var{str}, where the first character of every word is  @var{str}, where the first character of every word is
4490  capitalized.  capitalized.
4491  @end deffn  @end deffn
4492    
4493   string-split   string-split
4494  @deffn primitive string-split str chr  @deffn {Scheme Procedure} string-split str chr
4495    @deffnx {C Function} scm_string_split (str, chr)
4496  Split the string @var{str} into the a list of the substrings delimited  Split the string @var{str} into the a list of the substrings delimited
4497  by appearances of the character @var{chr}.  Note that an empty substring  by appearances of the character @var{chr}.  Note that an empty substring
4498  between separator characters will result in an empty string in the  between separator characters will result in an empty string in the
4499  result list.  result list.
4500    
4501  @lisp  @lisp
4502  (string-split "root:x:0:0:root:/root:/bin/bash" #:)  (string-split "root:x:0:0:root:/root:/bin/bash" #\:)
4503  @result{}  @result{}
4504  ("root" "x" "0" "0" "root" "/root" "/bin/bash")  ("root" "x" "0" "0" "root" "/root" "/bin/bash")
4505    
4506  (string-split "::" #:)  (string-split "::" #\:)
4507  @result{}  @result{}
4508  ("" "" "")  ("" "" "")
4509    
4510  (string-split "" #:)  (string-split "" #\:)
4511  @result{}  @result{}
4512  ("")  ("")
4513  @end lisp  @end lisp
4514  @end deffn  @end deffn
4515    
4516   string-ci->symbol   string-ci->symbol
4517  @deffn primitive string-ci->symbol str  @deffn {Scheme Procedure} string-ci->symbol str
4518    @deffnx {C Function} scm_string_ci_to_symbol (str)
4519  Return the symbol whose name is @var{str}.  @var{str} is  Return the symbol whose name is @var{str}.  @var{str} is
4520  converted to lowercase before the conversion is done, if Guile  converted to lowercase before the conversion is done, if Guile
4521  is currently reading symbols case--insensitively.  is currently reading symbols case-insensitively.
4522  @end deffn  @end deffn
4523    
4524   string=?   string=?
4525  @deffn primitive string=? s1 s2  @deffn {Scheme Procedure} string=? s1 s2
4526  Lexicographic equality predicate; return @code{#t} if the two  Lexicographic equality predicate; return @code{#t} if the two
4527  strings are the same length and contain the same characters in  strings are the same length and contain the same characters in
4528  the same positions, otherwise return @code{#f}.  the same positions, otherwise return @code{#f}.
# Line 4093  characters. Line 4534  characters.
4534  @end deffn  @end deffn
4535    
4536   string-ci=?   string-ci=?
4537  @deffn primitive string-ci=? s1 s2  @deffn {Scheme Procedure} string-ci=? s1 s2
4538  Case-insensitive string equality predicate; return @code{#t} if  Case-insensitive string equality predicate; return @code{#t} if
4539  the two strings are the same length and their component  the two strings are the same length and their component
4540  characters match (ignoring case) at each position; otherwise  characters match (ignoring case) at each position; otherwise
# Line 4101  return @code{#f}. Line 4542  return @code{#f}.
4542  @end deffn  @end deffn
4543    
4544   string<?   string<?
4545  @deffn primitive string<? s1 s2  @deffn {Scheme Procedure} string<? s1 s2
4546  Lexicographic ordering predicate; return @code{#t} if @var{s1}  Lexicographic ordering predicate; return @code{#t} if @var{s1}
4547  is lexicographically less than @var{s2}.  is lexicographically less than @var{s2}.
4548  @end deffn  @end deffn
4549    
4550   string<=?   string<=?
4551  @deffn primitive string<=? s1 s2  @deffn {Scheme Procedure} string<=? s1 s2
4552  Lexicographic ordering predicate; return @code{#t} if @var{s1}  Lexicographic ordering predicate; return @code{#t} if @var{s1}
4553  is lexicographically less than or equal to @var{s2}.  is lexicographically less than or equal to @var{s2}.
4554  @end deffn  @end deffn
4555    
4556   string>?   string>?
4557  @deffn primitive string>? s1 s2  @deffn {Scheme Procedure} string>? s1 s2
4558  Lexicographic ordering predicate; return @code{#t} if @var{s1}  Lexicographic ordering predicate; return @code{#t} if @var{s1}
4559  is lexicographically greater than @var{s2}.  is lexicographically greater than @var{s2}.
4560  @end deffn  @end deffn
4561    
4562   string>=?   string>=?
4563  @deffn primitive string>=? s1 s2  @deffn {Scheme Procedure} string>=? s1 s2
4564  Lexicographic ordering predicate; return @code{#t} if @var{s1}  Lexicographic ordering predicate; return @code{#t} if @var{s1}
4565  is lexicographically greater than or equal to @var{s2}.  is lexicographically greater than or equal to @var{s2}.
4566  @end deffn  @end deffn
4567    
4568   string-ci<?   string-ci<?
4569  @deffn primitive string-ci<? s1 s2  @deffn {Scheme Procedure} string-ci<? s1 s2
4570  Case insensitive lexicographic ordering predicate; return  Case insensitive lexicographic ordering predicate; return
4571  @code{#t} if @var{s1} is lexicographically less than @var{s2}  @code{#t} if @var{s1} is lexicographically less than @var{s2}
4572  regardless of case.  regardless of case.
4573  @end deffn  @end deffn
4574    
4575   string-ci<=?   string-ci<=?
4576  @deffn primitive string-ci<=? s1 s2  @deffn {Scheme Procedure} string-ci<=? s1 s2
4577  Case insensitive lexicographic ordering predicate; return  Case insensitive lexicographic ordering predicate; return
4578  @code{#t} if @var{s1} is lexicographically less than or equal  @code{#t} if @var{s1} is lexicographically less than or equal
4579  to @var{s2} regardless of case.  to @var{s2} regardless of case.
4580  @end deffn  @end deffn
4581    
4582   string-ci>?   string-ci>?
4583  @deffn primitive string-ci>? s1 s2  @deffn {Scheme Procedure} string-ci>? s1 s2
4584  Case insensitive lexicographic ordering predicate; return  Case insensitive lexicographic ordering predicate; return
4585  @code{#t} if @var{s1} is lexicographically greater than  @code{#t} if @var{s1} is lexicographically greater than
4586  @var{s2} regardless of case.  @var{s2} regardless of case.
4587  @end deffn  @end deffn
4588    
4589   string-ci>=?   string-ci>=?
4590  @deffn primitive string-ci>=? s1 s2  @deffn {Scheme Procedure} string-ci>=? s1 s2
4591  Case insensitive lexicographic ordering predicate; return  Case insensitive lexicographic ordering predicate; return
4592  @code{#t} if @var{s1} is lexicographically greater than or  @code{#t} if @var{s1} is lexicographically greater than or
4593  equal to @var{s2} regardless of case.  equal to @var{s2} regardless of case.
4594  @end deffn  @end deffn
4595    
4596   object->string   object->string
4597  @deffn primitive object->string obj [printer]  @deffn {Scheme Procedure} object->string obj [printer]
4598    @deffnx {C Function} scm_object_to_string (obj, printer)
4599  Return a Scheme string obtained by printing @var{obj}.  Return a Scheme string obtained by printing @var{obj}.
4600  Printing function can be specified by the optional second  Printing function can be specified by the optional second
4601  argument @var{printer} (default: @code{write}).  argument @var{printer} (default: @code{write}).
4602  @end deffn  @end deffn
4603    
4604   call-with-output-string   call-with-output-string
4605  @deffn primitive call-with-output-string proc  @deffn {Scheme Procedure} call-with-output-string proc
4606    @deffnx {C Function} scm_call_with_output_string (proc)
4607  Calls the one-argument procedure @var{proc} with a newly created output  Calls the one-argument procedure @var{proc} with a newly created output
4608  port.  When the function returns, the string composed of the characters  port.  When the function returns, the string composed of the characters
4609  written into the port is returned.  written into the port is returned.
4610  @end deffn  @end deffn
4611    
4612   call-with-input-string   call-with-input-string
4613  @deffn primitive call-with-input-string string proc  @deffn {Scheme Procedure} call-with-input-string string proc
4614    @deffnx {C Function} scm_call_with_input_string (string, proc)
4615  Calls the one-argument procedure @var{proc} with a newly  Calls the one-argument procedure @var{proc} with a newly
4616  created input port from which @var{string}'s contents may be  created input port from which @var{string}'s contents may be
4617  read.  The value yielded by the @var{proc} is returned.  read.  The value yielded by the @var{proc} is returned.
4618  @end deffn  @end deffn
4619    
4620   open-input-string   open-input-string
4621  @deffn primitive open-input-string str  @deffn {Scheme Procedure} open-input-string str
4622    @deffnx {C Function} scm_open_input_string (str)
4623  Take a string and return an input port that delivers characters  Take a string and return an input port that delivers characters
4624  from the string. The port can be closed by  from the string. The port can be closed by
4625  @code{close-input-port}, though its storage will be reclaimed  @code{close-input-port}, though its storage will be reclaimed
# Line 4182  by the garbage collector if it becomes i Line 4627  by the garbage collector if it becomes i
4627  @end deffn  @end deffn
4628    
4629   open-output-string   open-output-string
4630  @deffn primitive open-output-string  @deffn {Scheme Procedure} open-output-string
4631    @deffnx {C Function} scm_open_output_string ()
4632  Return an output port that will accumulate characters for  Return an output port that will accumulate characters for
4633  retrieval by @code{get-output-string}. The port can be closed  retrieval by @code{get-output-string}. The port can be closed
4634  by the procedure @code{close-output-port}, though its storage  by the procedure @code{close-output-port}, though its storage
# Line 4191  inaccessible. Line 4637  inaccessible.
4637  @end deffn  @end deffn
4638    
4639   get-output-string   get-output-string
4640  @deffn primitive get-output-string port  @deffn {Scheme Procedure} get-output-string port
4641    @deffnx {C Function} scm_get_output_string (port)
4642  Given an output port created by @code{open-output-string},  Given an output port created by @code{open-output-string},
4643  return a string consisting of the characters that have been  return a string consisting of the characters that have been
4644  output to the port so far.  output to the port so far.
4645  @end deffn  @end deffn
4646    
4647   eval-string   eval-string
4648  @deffn primitive eval-string string  @deffn {Scheme Procedure} eval-string string
4649    @deffnx {C Function} scm_eval_string (string)
4650  Evaluate @var{string} as the text representation of a Scheme  Evaluate @var{string} as the text representation of a Scheme
4651  form or forms, and return whatever value they produce.  form or forms, and return whatever value they produce.
4652  Evaluation takes place in the environment returned by the  Evaluation takes place in the environment returned by the
# Line 4206  procedure @code{interaction-environment} Line 4654  procedure @code{interaction-environment}
4654  @end deffn  @end deffn
4655    
4656   make-struct-layout   make-struct-layout
4657  @deffn primitive make-struct-layout fields  @deffn {Scheme Procedure} make-struct-layout fields
4658    @deffnx {C Function} scm_make_struct_layout (fields)
4659  Return a new structure layout object.  Return a new structure layout object.
4660    
4661  @var{fields} must be a string made up of pairs of characters  @var{fields} must be a string made up of pairs of characters
# Line 4220  indicate that the field is a tail-array. Line 4669  indicate that the field is a tail-array.
4669  @end deffn  @end deffn
4670    
4671   struct?   struct?
4672  @deffn primitive struct? x  @deffn {Scheme Procedure} struct? x
4673    @deffnx {C Function} scm_struct_p (x)
4674  Return @code{#t} iff @var{obj} is a structure object, else  Return @code{#t} iff @var{obj} is a structure object, else
4675  @code{#f}.  @code{#f}.
4676  @end deffn  @end deffn
4677    
4678   struct-vtable?   struct-vtable?
4679  @deffn primitive struct-vtable? x  @deffn {Scheme Procedure} struct-vtable? x
4680    @deffnx {C Function} scm_struct_vtable_p (x)
4681  Return @code{#t} iff obj is a vtable structure.  Return @code{#t} iff obj is a vtable structure.
4682  @end deffn  @end deffn
4683    
4684   make-struct   make-struct
4685  @deffn primitive make-struct vtable tail_array_size . init  @deffn {Scheme Procedure} make-struct vtable tail_array_size . init
4686    @deffnx {C Function} scm_make_struct (vtable, tail_array_size, init)
4687  Create a new structure.  Create a new structure.
4688    
4689  @var{type} must be a vtable structure (@pxref{Vtables}).  @var{type} must be a vtable structure (@pxref{Vtables}).
# Line 4260  For more information, see the documentat Line 4712  For more information, see the documentat
4712  @end deffn  @end deffn
4713    
4714   make-vtable-vtable   make-vtable-vtable
4715  @deffn primitive make-vtable-vtable user_fields tail_array_size . init  @deffn {Scheme Procedure} make-vtable-vtable user_fields tail_array_size . init
4716    @deffnx {C Function} scm_make_vtable_vtable (user_fields, tail_array_size, init)
4717  Return a new, self-describing vtable structure.  Return a new, self-describing vtable structure.
4718    
4719  @var{user-fields} is a string describing user defined fields of the  @var{user-fields} is a string describing user defined fields of the
# Line 4320  ball @result{} #<a green ball owned by N Line 4773  ball @result{} #<a green ball owned by N
4773  @end deffn  @end deffn
4774    
4775   struct-ref   struct-ref
4776  @deffn primitive struct-ref handle pos  @deffn {Scheme Procedure} struct-ref handle pos
4777  @deffnx primitive struct-set! struct n value  @deffnx {Scheme Procedure} struct-set! struct n value
4778    @deffnx {C Function} scm_struct_ref (handle, pos)
4779  Access (or modify) the @var{n}th field of @var{struct}.  Access (or modify) the @var{n}th field of @var{struct}.
4780    
4781  If the field is of type 'p', then it can be set to an arbitrary value.  If the field is of type 'p', then it can be set to an arbitrary value.
# Line 4331  integer value small enough to fit in one Line 4785  integer value small enough to fit in one
4785  @end deffn  @end deffn
4786    
4787   struct-set!   struct-set!
4788  @deffn primitive struct-set! handle pos val  @deffn {Scheme Procedure} struct-set! handle pos val
4789    @deffnx {C Function} scm_struct_set_x (handle, pos, val)
4790  Set the slot of the structure @var{handle} with index @var{pos}  Set the slot of the structure @var{handle} with index @var{pos}
4791  to @var{val}.  Signal an error if the slot can not be written  to @var{val}.  Signal an error if the slot can not be written
4792  to.  to.
4793  @end deffn  @end deffn
4794    
4795   struct-vtable   struct-vtable
4796  @deffn primitive struct-vtable handle  @deffn {Scheme Procedure} struct-vtable handle
4797    @deffnx {C Function} scm_struct_vtable (handle)
4798  Return the vtable structure that describes the type of @var{struct}.  Return the vtable structure that describes the type of @var{struct}.
4799  @end deffn  @end deffn
4800    
4801   struct-vtable-tag   struct-vtable-tag
4802  @deffn primitive struct-vtable-tag handle  @deffn {Scheme Procedure} struct-vtable-tag handle
4803    @deffnx {C Function} scm_struct_vtable_tag (handle)
4804  Return the vtable tag of the structure @var{handle}.  Return the vtable tag of the structure @var{handle}.
4805  @end deffn  @end deffn
4806    
4807   struct-vtable-name   struct-vtable-name
4808  @deffn primitive struct-vtable-name vtable  @deffn {Scheme Procedure} struct-vtable-name vtable
4809    @deffnx {C Function} scm_struct_vtable_name (vtable)
4810  Return the name of the vtable @var{vtable}.  Return the name of the vtable @var{vtable}.
4811  @end deffn  @end deffn
4812    
4813   set-struct-vtable-name!   set-struct-vtable-name!
4814  @deffn primitive set-struct-vtable-name! vtable name  @deffn {Scheme Procedure} set-struct-vtable-name! vtable name
4815    @deffnx {C Function} scm_set_struct_vtable_name_x (vtable, name)
4816  Set the name of the vtable @var{vtable} to @var{name}.  Set the name of the vtable @var{vtable} to @var{name}.
4817  @end deffn  @end deffn
4818    
4819   symbol?   symbol?
4820  @deffn primitive symbol? obj  @deffn {Scheme Procedure} symbol? obj
4821    @deffnx {C Function} scm_symbol_p (obj)
4822  Return @code{#t} if @var{obj} is a symbol, otherwise return  Return @code{#t} if @var{obj} is a symbol, otherwise return
4823  @code{#f}.  @code{#f}.
4824  @end deffn  @end deffn
4825    
4826   symbol->string   symbol->string
4827  @deffn primitive symbol->string s  @deffn {Scheme Procedure} symbol->string s
4828    @deffnx {C Function} scm_symbol_to_string (s)
4829  Return the name of @var{symbol} as a string.  If the symbol was  Return the name of @var{symbol} as a string.  If the symbol was
4830  part of an object returned as the value of a literal expression  part of an object returned as the value of a literal expression
4831  (section @pxref{Literal expressions,,,r5rs, The Revised^5  (section @pxref{Literal expressions,,,r5rs, The Revised^5
# Line 4391  standard case is lower case: Line 4852  standard case is lower case:
4852  @end deffn  @end deffn
4853    
4854   string->symbol   string->symbol
4855  @deffn primitive string->symbol string  @deffn {Scheme Procedure} string->symbol string
4856    @deffnx {C Function} scm_string_to_symbol (string)
4857  Return the symbol whose name is @var{string}. This procedure  Return the symbol whose name is @var{string}. This procedure
4858  can create symbols with names containing special characters or  can create symbols with names containing special characters or
4859  letters in the non-standard case, but it is usually a bad idea  letters in the non-standard case, but it is usually a bad idea
# Line 4415  standard case is lower case: Line 4877  standard case is lower case:
4877  @end deffn  @end deffn
4878    
4879   gensym   gensym
4880  @deffn primitive gensym [prefix]  @deffn {Scheme Procedure} gensym [prefix]
4881    @deffnx {C Function} scm_gensym (prefix)
4882  Create a new symbol with a name constructed from a prefix and  Create a new symbol with a name constructed from a prefix and
4883  a counter value. The string @var{prefix} can be specified as  a counter value. The string @var{prefix} can be specified as
4884  an optional argument. Default prefix is @code{g}.  The counter  an optional argument. Default prefix is @code{ g}.  The counter
4885  is increased by 1 at each call. There is no provision for  is increased by 1 at each call. There is no provision for
4886  resetting the counter.  resetting the counter.
4887  @end deffn  @end deffn
4888    
4889   symbol-hash   symbol-hash
4890  @deffn primitive symbol-hash symbol  @deffn {Scheme Procedure} symbol-hash symbol
4891    @deffnx {C Function} scm_symbol_hash (symbol)
4892  Return a hash value for @var{symbol}.  Return a hash value for @var{symbol}.
4893  @end deffn  @end deffn
4894    
4895   symbol-fref   symbol-fref
4896  @deffn primitive symbol-fref s  @deffn {Scheme Procedure} symbol-fref s
4897    @deffnx {C Function} scm_symbol_fref (s)
4898  Return the contents of @var{symbol}'s @dfn{function slot}.  Return the contents of @var{symbol}'s @dfn{function slot}.
4899  @end deffn  @end deffn
4900    
4901   symbol-pref   symbol-pref
4902  @deffn primitive symbol-pref s  @deffn {Scheme Procedure} symbol-pref s
4903    @deffnx {C Function} scm_symbol_pref (s)
4904  Return the @dfn{property list} currently associated with @var{symbol}.  Return the @dfn{property list} currently associated with @var{symbol}.
4905  @end deffn  @end deffn
4906    
4907   symbol-fset!   symbol-fset!
4908  @deffn primitive symbol-fset! s val  @deffn {Scheme Procedure} symbol-fset! s val
4909    @deffnx {C Function} scm_symbol_fset_x (s, val)
4910  Change the binding of @var{symbol}'s function slot.  Change the binding of @var{symbol}'s function slot.
4911  @end deffn  @end deffn
4912    
4913   symbol-pset!   symbol-pset!
4914  @deffn primitive symbol-pset! s val  @deffn {Scheme Procedure} symbol-pset! s val
4915    @deffnx {C Function} scm_symbol_pset_x (s, val)
4916  Change the binding of @var{symbol}'s property slot.  Change the binding of @var{symbol}'s property slot.
4917  @end deffn  @end deffn
4918    
4919   catch   catch
4920  @deffn primitive catch key thunk handler  @deffn {Scheme Procedure} catch key thunk handler
4921    @deffnx {C Function} scm_catch (key, thunk, handler)
4922  Invoke @var{thunk} in the dynamic context of @var{handler} for  Invoke @var{thunk} in the dynamic context of @var{handler} for
4923  exceptions matching @var{key}.  If thunk throws to the symbol  exceptions matching @var{key}.  If thunk throws to the symbol
4924  @var{key}, then @var{handler} is invoked this way:  @var{key}, then @var{handler} is invoked this way:
# Line 4471  match this call to @code{catch}. Line 4940  match this call to @code{catch}.
4940  @end deffn  @end deffn
4941    
4942   lazy-catch   lazy-catch
4943  @deffn primitive lazy-catch key thunk handler  @deffn {Scheme Procedure} lazy-catch key thunk handler
4944    @deffnx {C Function} scm_lazy_catch (key, thunk, handler)
4945  This behaves exactly like @code{catch}, except that it does  This behaves exactly like @code{catch}, except that it does
4946  not unwind the stack before invoking @var{handler}.  not unwind the stack before invoking @var{handler}.
4947  The @var{handler} procedure is not allowed to return:  The @var{handler} procedure is not allowed to return:
# Line 4479  it must throw to another catch, or other Line 4949  it must throw to another catch, or other
4949  @end deffn  @end deffn
4950    
4951   throw   throw
4952  @deffn primitive throw key . args  @deffn {Scheme Procedure} throw key . args
4953    @deffnx {C Function} scm_throw (key, args)
4954  Invoke the catch form matching @var{key}, passing @var{args} to the  Invoke the catch form matching @var{key}, passing @var{args} to the
4955  @var{handler}.    @var{handler}.  
4956    
# Line 4490  If there is no handler at all, Guile pri Line 4961  If there is no handler at all, Guile pri
4961  @end deffn  @end deffn
4962    
4963   values   values
4964  @deffn primitive values . args  @deffn {Scheme Procedure} values . args
4965    @deffnx {C Function} scm_values (args)
4966  Delivers all of its arguments to its continuation.  Except for  Delivers all of its arguments to its continuation.  Except for
4967  continuations created by the @code{call-with-values} procedure,  continuations created by the @code{call-with-values} procedure,
4968  all continuations take exactly one value.  The effect of  all continuations take exactly one value.  The effect of
# Line 4499  were not created by @code{call-with-valu Line 4971  were not created by @code{call-with-valu
4971  @end deffn  @end deffn
4972    
4973   make-variable   make-variable
4974  @deffn primitive make-variable init  @deffn {Scheme Procedure} make-variable init
4975    @deffnx {C Function} scm_make_variable (init)
4976  Return a variable initialized to value @var{init}.  Return a variable initialized to value @var{init}.
4977  @end deffn  @end deffn
4978    
4979   make-undefined-variable   make-undefined-variable
4980  @deffn primitive make-undefined-variable  @deffn {Scheme Procedure} make-undefined-variable
4981    @deffnx {C Function} scm_make_undefined_variable ()
4982  Return a variable that is initially unbound.  Return a variable that is initially unbound.
4983  @end deffn  @end deffn
4984    
4985   variable?   variable?
4986  @deffn primitive variable? obj  @deffn {Scheme Procedure} variable? obj
4987    @deffnx {C Function} scm_variable_p (obj)
4988  Return @code{#t} iff @var{obj} is a variable object, else  Return @code{#t} iff @var{obj} is a variable object, else
4989  return @code{#f}.  return @code{#f}.
4990  @end deffn  @end deffn
4991    
4992   variable-ref   variable-ref
4993  @deffn primitive variable-ref var  @deffn {Scheme Procedure} variable-ref var
4994    @deffnx {C Function} scm_variable_ref (var)
4995  Dereference @var{var} and return its value.  Dereference @var{var} and return its value.
4996  @var{var} must be a variable object; see @code{make-variable}  @var{var} must be a variable object; see @code{make-variable}
4997  and @code{make-undefined-variable}.  and @code{make-undefined-variable}.
4998  @end deffn  @end deffn
4999    
5000   variable-set!   variable-set!
5001  @deffn primitive variable-set! var val  @deffn {Scheme Procedure} variable-set! var val
5002    @deffnx {C Function} scm_variable_set_x (var, val)
5003  Set the value of the variable @var{var} to @var{val}.  Set the value of the variable @var{var} to @var{val}.
5004  @var{var} must be a variable object, @var{val} can be any  @var{var} must be a variable object, @var{val} can be any
5005  value. Return an unspecified value.  value. Return an unspecified value.
5006  @end deffn  @end deffn
5007    
5008   variable-bound?   variable-bound?
5009  @deffn primitive variable-bound? var  @deffn {Scheme Procedure} variable-bound? var
5010    @deffnx {C Function} scm_variable_bound_p (var)
5011  Return @code{#t} iff @var{var} is bound to a value.  Return @code{#t} iff @var{var} is bound to a value.
5012  Throws an error if @var{var} is not a variable object.  Throws an error if @var{var} is not a variable object.
5013  @end deffn  @end deffn
5014    
5015   variable-set-name-hint!   variable-set-name-hint!
5016  @deffn primitive variable-set-name-hint! var hint  @deffn {Scheme Procedure} variable-set-name-hint! var hint
5017    @deffnx {C Function} scm_variable_set_name_hint (var, hint)
5018  Do not use this function.  Do not use this function.
5019  @end deffn  @end deffn
5020    
5021   builtin-variable   builtin-variable
5022  @deffn primitive builtin-variable name  @deffn {Scheme Procedure} builtin-variable name
5023    @deffnx {C Function} scm_builtin_variable (name)
5024  Return the built-in variable with the name @var{name}.  Return the built-in variable with the name @var{name}.
5025  @var{name} must be a symbol (not a string).  @var{name} must be a symbol (not a string).
5026  Then use @code{variable-ref} to access its value.  Then use @code{variable-ref} to access its value.
5027  @end deffn  @end deffn
5028    
5029   vector?   vector?
5030  @deffn primitive vector? obj  @deffn {Scheme Procedure} vector? obj
5031    @deffnx {C Function} scm_vector_p (obj)
5032  Return @code{#t} if @var{obj} is a vector, otherwise return  Return @code{#t} if @var{obj} is a vector, otherwise return
5033  @code{#f}.  @code{#f}.
5034  @end deffn  @end deffn
5035    
5036   list->vector   list->vector
5037  @deffn primitive list->vector  @deffn {Scheme Procedure} list->vector
5038  implemented by the C function "scm_vector"  implemented by the C function "scm_vector"
5039  @end deffn  @end deffn
5040    
5041   vector   vector
5042  @deffn primitive vector . l  @deffn {Scheme Procedure} vector . l
5043  @deffnx primitive list->vector l  @deffnx {Scheme Procedure} list->vector l
5044    @deffnx {C Function} scm_vector (l)
5045  Return a newly allocated vector whose elements contain the  Return a newly allocated vector whose elements contain the
5046  given arguments.  Analogous to @code{list}.  given arguments.  Analogous to @code{list}.
5047    
# Line 4569  given arguments.  Analogous to @code{lis Line 5051  given arguments.  Analogous to @code{lis
5051  @end deffn  @end deffn
5052    
5053   make-vector   make-vector
5054  @deffn primitive make-vector k [fill]  @deffn {Scheme Procedure} make-vector k [fill]
5055    @deffnx {C Function} scm_make_vector (k, fill)
5056  Return a newly allocated vector of @var{k} elements.  If a  Return a newly allocated vector of @var{k} elements.  If a
5057  second argument is given, then each element is initialized to  second argument is given, then each element is initialized to
5058  @var{fill}.  Otherwise the initial contents of each element is  @var{fill}.  Otherwise the initial contents of each element is
# Line 4577  unspecified. Line 5060  unspecified.
5060  @end deffn  @end deffn
5061    
5062   vector->list   vector->list
5063  @deffn primitive vector->list v  @deffn {Scheme Procedure} vector->list v
5064    @deffnx {C Function} scm_vector_to_list (v)
5065  Return a newly allocated list of the objects contained in the  Return a newly allocated list of the objects contained in the
5066  elements of @var{vector}.  elements of @var{vector}.
5067    
# Line 4588  elements of @var{vector}. Line 5072  elements of @var{vector}.
5072  @end deffn  @end deffn
5073    
5074   vector-fill!   vector-fill!
5075  @deffn primitive vector-fill! v fill  @deffn {Scheme Procedure} vector-fill! v fill
5076    @deffnx {C Function} scm_vector_fill_x (v, fill)
5077  Store @var{fill} in every element of @var{vector}.  The value  Store @var{fill} in every element of @var{vector}.  The value
5078  returned by @code{vector-fill!} is unspecified.  returned by @code{vector-fill!} is unspecified.
5079  @end deffn  @end deffn
5080    
5081   vector-move-left!   vector-move-left!
5082  @deffn primitive vector-move-left! vec1 start1 end1 vec2 start2  @deffn {Scheme Procedure} vector-move-left! vec1 start1 end1 vec2 start2
5083  Vector version of @code{substring-move-left!}.  @deffnx {C Function} scm_vector_move_left_x (vec1, start1, end1, vec2, start2)
5084    Copy elements from @var{vec1}, positions @var{start1} to @var{end1},
5085    to @var{vec2} starting at position @var{start2}.  @var{start1} and
5086    @var{start2} are inclusive indices; @var{end1} is exclusive.
5087    
5088    @code{vector-move-left!} copies elements in leftmost order.
5089    Therefore, in the case where @var{vec1} and @var{vec2} refer to the
5090    same vector, @code{vector-move-left!} is usually appropriate when
5091    @var{start1} is greater than @var{start2}.
5092  @end deffn  @end deffn
5093    
5094   vector-move-right!   vector-move-right!
5095  @deffn primitive vector-move-right! vec1 start1 end1 vec2 start2  @deffn {Scheme Procedure} vector-move-right! vec1 start1 end1 vec2 start2
5096  Vector version of @code{substring-move-right!}.  @deffnx {C Function} scm_vector_move_right_x (vec1, start1, end1, vec2, start2)
5097    Copy elements from @var{vec1}, positions @var{start1} to @var{end1},
5098    to @var{vec2} starting at position @var{start2}.  @var{start1} and
5099    @var{start2} are inclusive indices; @var{end1} is exclusive.
5100    
5101    @code{vector-move-right!} copies elements in rightmost order.
5102    Therefore, in the case where @var{vec1} and @var{vec2} refer to the
5103    same vector, @code{vector-move-right!} is usually appropriate when
5104    @var{start1} is less than @var{start2}.
5105  @end deffn  @end deffn
5106    
5107   major-version   major-version
5108  @deffn primitive major-version  @deffn {Scheme Procedure} major-version
5109    @deffnx {C Function} scm_major_version ()
5110  Return a string containing Guile's major version number.  Return a string containing Guile's major version number.
5111  E.g., the 1 in "1.6.5".  E.g., the 1 in "1.6.5".
5112  @end deffn  @end deffn
5113    
5114   minor-version   minor-version
5115  @deffn primitive minor-version  @deffn {Scheme Procedure} minor-version
5116    @deffnx {C Function} scm_minor_version ()
5117  Return a string containing Guile's minor version number.  Return a string containing Guile's minor version number.
5118  E.g., the 6 in "1.6.5".  E.g., the 6 in "1.6.5".
5119  @end deffn  @end deffn
5120    
5121   micro-version   micro-version
5122  @deffn primitive micro-version  @deffn {Scheme Procedure} micro-version
5123    @deffnx {C Function} scm_micro_version ()
5124  Return a string containing Guile's micro version number.  Return a string containing Guile's micro version number.
5125  E.g., the 5 in "1.6.5".  E.g., the 5 in "1.6.5".
5126  @end deffn  @end deffn
5127    
5128   version   version
5129  @deffn primitive version  @deffn {Scheme Procedure} version
5130  @deffnx primitive major-version  @deffnx {Scheme Procedure} major-version
5131  @deffnx primitive minor-version  @deffnx {Scheme Procedure} minor-version
5132  @deffnx primitive micro-version  @deffnx {Scheme Procedure} micro-version
5133    @deffnx {C Function} scm_version ()
5134  Return a string describing Guile's version number, or its major, minor  Return a string describing Guile's version number, or its major, minor
5135  or micro version number, respectively.  or micro version number, respectively.
5136    
# Line 4638  or micro version number, respectively. Line 5143  or micro version number, respectively.
5143  @end deffn  @end deffn
5144    
5145   make-soft-port   make-soft-port
5146  @deffn primitive make-soft-port pv modes  @deffn {Scheme Procedure} make-soft-port pv modes
5147    @deffnx {C Function} scm_make_soft_port (pv, modes)
5148  Return a port capable of receiving or delivering characters as  Return a port capable of receiving or delivering characters as
5149  specified by the @var{modes} string (@pxref{File Ports,  specified by the @var{modes} string (@pxref{File Ports,
5150  open-file}).  @var{pv} must be a vector of length 5.  Its  open-file}).  @var{pv} must be a vector of length 5.  Its
# Line 4683  For example: Line 5189  For example:
5189  @end deffn  @end deffn
5190    
5191   make-weak-vector   make-weak-vector
5192  @deffn primitive make-weak-vector size [fill]  @deffn {Scheme Procedure} make-weak-vector size [fill]
5193    @deffnx {C Function} scm_make_weak_vector (size, fill)
5194  Return a weak vector with @var{size} elements. If the optional  Return a weak vector with @var{size} elements. If the optional
5195  argument @var{fill} is given, all entries in the vector will be  argument @var{fill} is given, all entries in the vector will be
5196  set to @var{fill}. The default value for @var{fill} is the  set to @var{fill}. The default value for @var{fill} is the
# Line 4691  empty list. Line 5198  empty list.
5198  @end deffn  @end deffn
5199    
5200   list->weak-vector   list->weak-vector
5201  @deffn primitive list->weak-vector  @deffn {Scheme Procedure} list->weak-vector
5202  implemented by the C function "scm_weak_vector"  implemented by the C function "scm_weak_vector"
5203  @end deffn  @end deffn
5204    
5205   weak-vector   weak-vector
5206  @deffn primitive weak-vector . l  @deffn {Scheme Procedure} weak-vector . l
5207  @deffnx primitive list->weak-vector l  @deffnx {Scheme Procedure} list->weak-vector l
5208    @deffnx {C Function} scm_weak_vector (l)
5209  Construct a weak vector from a list: @code{weak-vector} uses  Construct a weak vector from a list: @code{weak-vector} uses
5210  the list of its arguments while @code{list->weak-vector} uses  the list of its arguments while @code{list->weak-vector} uses
5211  its only argument @var{l} (a list) to construct a weak vector  its only argument @var{l} (a list) to construct a weak vector
# Line 4705  the same way @code{list->vector} would. Line 5213  the same way @code{list->vector} would.
5213  @end deffn  @end deffn
5214    
5215   weak-vector?   weak-vector?
5216  @deffn primitive weak-vector? obj  @deffn {Scheme Procedure} weak-vector? obj
5217    @deffnx {C Function} scm_weak_vector_p (obj)
5218  Return @code{#t} if @var{obj} is a weak vector. Note that all  Return @code{#t} if @var{obj} is a weak vector. Note that all
5219  weak hashes are also weak vectors.  weak hashes are also weak vectors.
5220  @end deffn  @end deffn
5221    
5222   make-weak-key-hash-table   make-weak-key-hash-table
5223  @deffn primitive make-weak-key-hash-table size  @deffn {Scheme Procedure} make-weak-key-hash-table size
5224  @deffnx primitive make-weak-value-hash-table size  @deffnx {Scheme Procedure} make-weak-value-hash-table size
5225  @deffnx primitive make-doubly-weak-hash-table size  @deffnx {Scheme Procedure} make-doubly-weak-hash-table size
5226    @deffnx {C Function} scm_make_weak_key_hash_table (size)
5227  Return a weak hash table with @var{size} buckets. As with any  Return a weak hash table with @var{size} buckets. As with any
5228  hash table, choosing a good size for the table requires some  hash table, choosing a good size for the table requires some
5229  caution.  caution.
# Line 4723  would modify regular hash tables. (@pxre Line 5233  would modify regular hash tables. (@pxre
5233  @end deffn  @end deffn
5234    
5235   make-weak-value-hash-table   make-weak-value-hash-table
5236  @deffn primitive make-weak-value-hash-table size  @deffn {Scheme Procedure} make-weak-value-hash-table size
5237    @deffnx {C Function} scm_make_weak_value_hash_table (size)
5238  Return a hash table with weak values with @var{size} buckets.  Return a hash table with weak values with @var{size} buckets.
5239  (@pxref{Hash Tables})  (@pxref{Hash Tables})
5240  @end deffn  @end deffn
5241    
5242   make-doubly-weak-hash-table   make-doubly-weak-hash-table
5243  @deffn primitive make-doubly-weak-hash-table size  @deffn {Scheme Procedure} make-doubly-weak-hash-table size
5244    @deffnx {C Function} scm_make_doubly_weak_hash_table (size)
5245  Return a hash table with weak keys and values with @var{size}  Return a hash table with weak keys and values with @var{size}
5246  buckets.  (@pxref{Hash Tables})  buckets.  (@pxref{Hash Tables})
5247  @end deffn  @end deffn
5248    
5249   weak-key-hash-table?   weak-key-hash-table?
5250  @deffn primitive weak-key-hash-table? obj  @deffn {Scheme Procedure} weak-key-hash-table? obj
5251  @deffnx primitive weak-value-hash-table? obj  @deffnx {Scheme Procedure} weak-value-hash-table? obj
5252  @deffnx primitive doubly-weak-hash-table? obj  @deffnx {Scheme Procedure} doubly-weak-hash-table? obj
5253    @deffnx {C Function} scm_weak_key_hash_table_p (obj)
5254  Return @code{#t} if @var{obj} is the specified weak hash  Return @code{#t} if @var{obj} is the specified weak hash
5255  table. Note that a doubly weak hash table is neither a weak key  table. Note that a doubly weak hash table is neither a weak key
5256  nor a weak value hash table.  nor a weak value hash table.
5257  @end deffn  @end deffn
5258    
5259   weak-value-hash-table?   weak-value-hash-table?
5260  @deffn primitive weak-value-hash-table? obj  @deffn {Scheme Procedure} weak-value-hash-table? obj
5261    @deffnx {C Function} scm_weak_value_hash_table_p (obj)
5262  Return @code{#t} if @var{obj} is a weak value hash table.  Return @code{#t} if @var{obj} is a weak value hash table.
5263  @end deffn  @end deffn
5264    
5265   doubly-weak-hash-table?   doubly-weak-hash-table?
5266  @deffn primitive doubly-weak-hash-table? obj  @deffn {Scheme Procedure} doubly-weak-hash-table? obj
5267    @deffnx {C Function} scm_doubly_weak_hash_table_p (obj)
5268  Return @code{#t} if @var{obj} is a doubly weak hash table.  Return @code{#t} if @var{obj} is a doubly weak hash table.
5269  @end deffn  @end deffn
5270    
5271   string->obarray-symbol   string->obarray-symbol
5272  @deffn primitive string->obarray-symbol o s [softp]  @deffn {Scheme Procedure} string->obarray-symbol o s [softp]
5273    @deffnx {C Function} scm_string_to_obarray_symbol (o, s, softp)
5274  Intern a new symbol in @var{obarray}, a symbol table, with name  Intern a new symbol in @var{obarray}, a symbol table, with name
5275  @var{string}.  @var{string}.
5276    
# Line 4771  table; instead, simply return @code{#f}. Line 5287  table; instead, simply return @code{#f}.
5287  @end deffn  @end deffn
5288    
5289   intern-symbol   intern-symbol
5290  @deffn primitive intern-symbol o s  @deffn {Scheme Procedure} intern-symbol o s
5291    @deffnx {C Function} scm_intern_symbol (o, s)
5292  Add a new symbol to @var{obarray} with name @var{string}, bound to an  Add a new symbol to @var{obarray} with name @var{string}, bound to an
5293  unspecified initial value.  The symbol table is not modified if a symbol  unspecified initial value.  The symbol table is not modified if a symbol
5294  with this name is already present.  with this name is already present.
5295  @end deffn  @end deffn
5296    
5297   unintern-symbol   unintern-symbol
5298  @deffn primitive unintern-symbol o s  @deffn {Scheme Procedure} unintern-symbol o s
5299    @deffnx {C Function} scm_unintern_symbol (o, s)
5300  Remove the symbol with name @var{string} from @var{obarray}.  This  Remove the symbol with name @var{string} from @var{obarray}.  This
5301  function returns @code{#t} if the symbol was present and @code{#f}  function returns @code{#t} if the symbol was present and @code{#f}
5302  otherwise.  otherwise.
5303  @end deffn  @end deffn
5304    
5305   symbol-binding   symbol-binding
5306  @deffn primitive symbol-binding o s  @deffn {Scheme Procedure} symbol-binding o s
5307    @deffnx {C Function} scm_symbol_binding (o, s)
5308  Look up in @var{obarray} the symbol whose name is @var{string}, and  Look up in @var{obarray} the symbol whose name is @var{string}, and
5309  return the value to which it is bound.  If @var{obarray} is @code{#f},  return the value to which it is bound.  If @var{obarray} is @code{#f},
5310  use the global symbol table.  If @var{string} is not interned in  use the global symbol table.  If @var{string} is not interned in
# Line 4793  use the global symbol table.  If @var{st Line 5312  use the global symbol table.  If @var{st
5312  @end deffn  @end deffn
5313    
5314   symbol-interned?   symbol-interned?
5315  @deffn primitive symbol-interned? o s  @deffn {Scheme Procedure} symbol-interned? o s
5316    @deffnx {C Function} scm_symbol_interned_p (o, s)
5317  Return @code{#t} if @var{obarray} contains a symbol with name  Return @code{#t} if @var{obarray} contains a symbol with name
5318  @var{string}, and @code{#f} otherwise.  @var{string}, and @code{#f} otherwise.
5319  @end deffn  @end deffn
5320    
5321   symbol-bound?   symbol-bound?
5322  @deffn primitive symbol-bound? o s  @deffn {Scheme Procedure} symbol-bound? o s
5323    @deffnx {C Function} scm_symbol_bound_p (o, s)
5324  Return @code{#t} if @var{obarray} contains a symbol with name  Return @code{#t} if @var{obarray} contains a symbol with name
5325  @var{string} bound to a defined value.  This differs from  @var{string} bound to a defined value.  This differs from
5326  @var{symbol-interned?} in that the mere mention of a symbol  @var{symbol-interned?} in that the mere mention of a symbol
# Line 4809  value. Line 5330  value.
5330  @end deffn  @end deffn
5331    
5332   symbol-set!   symbol-set!
5333  @deffn primitive symbol-set! o s v  @deffn {Scheme Procedure} symbol-set! o s v
5334    @deffnx {C Function} scm_symbol_set_x (o, s, v)
5335  Find the symbol in @var{obarray} whose name is @var{string}, and rebind  Find the symbol in @var{obarray} whose name is @var{string}, and rebind
5336  it to @var{value}.  An error is signalled if @var{string} is not present  it to @var{value}.  An error is signalled if @var{string} is not present
5337  in @var{obarray}.  in @var{obarray}.
5338  @end deffn  @end deffn
5339    
5340   gentemp   gentemp
5341  @deffn primitive gentemp [prefix [obarray]]  @deffn {Scheme Procedure} gentemp [prefix [obarray]]
5342    @deffnx {C Function} scm_gentemp (prefix, obarray)
5343  Create a new symbol with a name unique in an obarray.  Create a new symbol with a name unique in an obarray.
5344  The name is constructed from an optional string @var{prefix}  The name is constructed from an optional string @var{prefix}
5345  and a counter value.  The default prefix is @code{t}.  The  and a counter value.  The default prefix is @code{t}.  The
# Line 4827  call.  There is no provision for resetti Line 5350  call.  There is no provision for resetti
5350  @end deffn  @end deffn
5351    
5352   regexp?   regexp?
5353  @deffn primitive regexp? obj  @deffn {Scheme Procedure} regexp? obj
5354    @deffnx {C Function} scm_regexp_p (obj)
5355  Return @code{#t} if @var{obj} is a compiled regular expression,  Return @code{#t} if @var{obj} is a compiled regular expression,
5356  or @code{#f} otherwise.  or @code{#f} otherwise.
5357  @end deffn  @end deffn
5358    
5359   make-regexp   make-regexp
5360  @deffn primitive make-regexp pat . flags  @deffn {Scheme Procedure} make-regexp pat . flags
5361    @deffnx {C Function} scm_make_regexp (pat, flags)
5362  Compile the regular expression described by @var{pat}, and  Compile the regular expression described by @var{pat}, and
5363  return the compiled regexp structure.  If @var{pat} does not  return the compiled regexp structure.  If @var{pat} does not
5364  describe a legal regular expression, @code{make-regexp} throws  describe a legal regular expression, @code{make-regexp} throws
# Line 4874  one which comes last will override the e Line 5399  one which comes last will override the e
5399  @end deffn  @end deffn
5400    
5401   regexp-exec   regexp-exec
5402  @deffn primitive regexp-exec rx str [start [flags]]  @deffn {Scheme Procedure} regexp-exec rx str [start [flags]]
5403    @deffnx {C Function} scm_regexp_exec (rx, str, start, flags)
5404  Match the compiled regular expression @var{rx} against  Match the compiled regular expression @var{rx} against
5405  @code{str}.  If the optional integer @var{start} argument is  @code{str}.  If the optional integer @var{start} argument is
5406  provided, begin matching from that position in the string.  provided, begin matching from that position in the string.
# Line 4897  considered the end of a line. Line 5423  considered the end of a line.
5423  @end deffn  @end deffn
5424    
5425   array-fill!   array-fill!
5426  @deffn primitive array-fill! ra fill  @deffn {Scheme Procedure} array-fill! ra fill
5427  Stores @var{fill} in every element of @var{array}.  The value returned  @deffnx {C Function} scm_array_fill_x (ra, fill)
5428    Store @var{fill} in every element of @var{array}.  The value returned
5429  is unspecified.  is unspecified.
5430  @end deffn  @end deffn
5431    
5432   array-copy-in-order!   array-copy-in-order!
5433  @deffn primitive array-copy-in-order!  @deffn {Scheme Procedure} array-copy-in-order!
5434  implemented by the C function "scm_array_copy_x"  implemented by the C function "scm_array_copy_x"
5435  @end deffn  @end deffn
5436    
5437   array-copy!   array-copy!
5438  @deffn primitive array-copy! src dst  @deffn {Scheme Procedure} array-copy! src dst
5439  @deffnx primitive array-copy-in-order! src dst  @deffnx {Scheme Procedure} array-copy-in-order! src dst
5440  Copies every element from vector or array @var{source} to the  @deffnx {C Function} scm_array_copy_x (src, dst)
5441    Copy every element from vector or array @var{source} to the
5442  corresponding element of @var{destination}.  @var{destination} must have  corresponding element of @var{destination}.  @var{destination} must have
5443  the same rank as @var{source}, and be at least as large in each  the same rank as @var{source}, and be at least as large in each
5444  dimension.  The order is unspecified.  dimension.  The order is unspecified.
5445  @end deffn  @end deffn
5446    
5447   array-map-in-order!   array-map-in-order!
5448  @deffn primitive array-map-in-order!  @deffn {Scheme Procedure} array-map-in-order!
5449  implemented by the C function "scm_array_map_x"  implemented by the C function "scm_array_map_x"
5450  @end deffn  @end deffn
5451    
5452   array-map!   array-map!
5453  @deffn primitive array-map! ra0 proc . lra  @deffn {Scheme Procedure} array-map! ra0 proc . lra
5454  @deffnx primitive array-map-in-order! ra0 proc . lra  @deffnx {Scheme Procedure} array-map-in-order! ra0 proc . lra
5455    @deffnx {C Function} scm_array_map_x (ra0, proc, lra)
5456  @var{array1}, @dots{} must have the same number of dimensions as  @var{array1}, @dots{} must have the same number of dimensions as
5457  @var{array0} and have a range for each index which includes the range  @var{array0} and have a range for each index which includes the range
5458  for the corresponding index in @var{array0}.  @var{proc} is applied to  for the corresponding index in @var{array0}.  @var{proc} is applied to
# Line 4933  unspecified.  The order of application i Line 5462  unspecified.  The order of application i
5462  @end deffn  @end deffn
5463    
5464   array-for-each   array-for-each
5465  @deffn primitive array-for-each proc ra0 . lra  @deffn {Scheme Procedure} array-for-each proc ra0 . lra
5466  @var{proc} is applied to each tuple of elements of @var{array0} @dots{}  @deffnx {C Function} scm_array_for_each (proc, ra0, lra)
5467    Apply @var{proc} to each tuple of elements of @var{array0} @dots{}
5468  in row-major order.  The value returned is unspecified.  in row-major order.  The value returned is unspecified.
5469  @end deffn  @end deffn
5470    
5471   array-index-map!   array-index-map!
5472  @deffn primitive array-index-map! ra proc  @deffn {Scheme Procedure} array-index-map! ra proc
5473  applies @var{proc} to the indices of each element of @var{array} in  @deffnx {C Function} scm_array_index_map_x (ra, proc)
5474    Apply @var{proc} to the indices of each element of @var{array} in
5475  turn, storing the result in the corresponding element.  The value  turn, storing the result in the corresponding element.  The value
5476  returned and the order of application are unspecified.  returned and the order of application are unspecified.
5477    
# Line 4961  Another example: Line 5492  Another example:
5492  @end deffn  @end deffn
5493    
5494   uniform-vector-length   uniform-vector-length
5495  @deffn primitive uniform-vector-length v  @deffn {Scheme Procedure} uniform-vector-length v
5496    @deffnx {C Function} scm_uniform_vector_length (v)
5497  Return the number of elements in @var{uve}.  Return the number of elements in @var{uve}.
5498  @end deffn  @end deffn
5499    
5500   array?   array?
5501  @deffn primitive array? v [prot]  @deffn {Scheme Procedure} array? v [prot]
5502    @deffnx {C Function} scm_array_p (v, prot)
5503  Return @code{#t} if the @var{obj} is an array, and @code{#f} if  Return @code{#t} if the @var{obj} is an array, and @code{#f} if
5504  not.  The @var{prototype} argument is used with uniform arrays  not.  The @var{prototype} argument is used with uniform arrays
5505  and is described elsewhere.  and is described elsewhere.
5506  @end deffn  @end deffn
5507    
5508   array-rank   array-rank
5509  @deffn primitive array-rank ra  @deffn {Scheme Procedure} array-rank ra
5510    @deffnx {C Function} scm_array_rank (ra)
5511  Return the number of dimensions of @var{obj}.  If @var{obj} is  Return the number of dimensions of @var{obj}.  If @var{obj} is
5512  not an array, @code{0} is returned.  not an array, @code{0} is returned.
5513  @end deffn  @end deffn
5514    
5515   array-dimensions   array-dimensions
5516  @deffn primitive array-dimensions ra  @deffn {Scheme Procedure} array-dimensions ra
5517    @deffnx {C Function} scm_array_dimensions (ra)
5518  @code{Array-dimensions} is similar to @code{array-shape} but replaces  @code{Array-dimensions} is similar to @code{array-shape} but replaces
5519  elements with a @code{0} minimum with one greater than the maximum. So:  elements with a @code{0} minimum with one greater than the maximum. So:
5520  @lisp  @lisp
# Line 4988  elements with a @code{0} minimum with on Line 5523  elements with a @code{0} minimum with on
5523  @end deffn  @end deffn
5524    
5525   shared-array-root   shared-array-root
5526  @deffn primitive shared-array-root ra  @deffn {Scheme Procedure} shared-array-root ra
5527    @deffnx {C Function} scm_shared_array_root (ra)
5528  Return the root vector of a shared array.  Return the root vector of a shared array.
5529  @end deffn  @end deffn
5530    
5531   shared-array-offset   shared-array-offset
5532  @deffn primitive shared-array-offset ra  @deffn {Scheme Procedure} shared-array-offset ra
5533    @deffnx {C Function} scm_shared_array_offset (ra)
5534  Return the root vector index of the first element in the array.  Return the root vector index of the first element in the array.
5535  @end deffn  @end deffn
5536    
5537   shared-array-increments   shared-array-increments
5538  @deffn primitive shared-array-increments ra  @deffn {Scheme Procedure} shared-array-increments ra
5539    @deffnx {C Function} scm_shared_array_increments (ra)
5540  For each dimension, return the distance between elements in the root vector.  For each dimension, return the distance between elements in the root vector.
5541  @end deffn  @end deffn
5542    
5543   dimensions->uniform-array   dimensions->uniform-array
5544  @deffn primitive dimensions->uniform-array dims prot [fill]  @deffn {Scheme Procedure} dimensions->uniform-array dims prot [fill]
5545  @deffnx primitive make-uniform-vector length prototype [fill]  @deffnx {Scheme Procedure} make-uniform-vector length prototype [fill]
5546    @deffnx {C Function} scm_dimensions_to_uniform_array (dims, prot, fill)
5547  Create and return a uniform array or vector of type  Create and return a uniform array or vector of type
5548  corresponding to @var{prototype} with dimensions @var{dims} or  corresponding to @var{prototype} with dimensions @var{dims} or
5549  length @var{length}.  If @var{fill} is supplied, it's used to  length @var{length}.  If @var{fill} is supplied, it's used to
# Line 5012  fill the array, otherwise @var{prototype Line 5551  fill the array, otherwise @var{prototype
5551  @end deffn  @end deffn
5552    
5553   make-shared-array   make-shared-array
5554  @deffn primitive make-shared-array oldra mapfunc . dims  @deffn {Scheme Procedure} make-shared-array oldra mapfunc . dims
5555    @deffnx {C Function} scm_make_shared_array (oldra, mapfunc, dims)
5556  @code{make-shared-array} can be used to create shared subarrays of other  @code{make-shared-array} can be used to create shared subarrays of other
5557  arrays.  The @var{mapper} is a function that translates coordinates in  arrays.  The @var{mapper} is a function that translates coordinates in
5558  the new array into coordinates in the old array.  A @var{mapper} must be  the new array into coordinates in the old array.  A @var{mapper} must be
# Line 5031  it can be otherwise arbitrary.  A simple Line 5571  it can be otherwise arbitrary.  A simple
5571  @end deffn  @end deffn
5572    
5573   transpose-array   transpose-array
5574  @deffn primitive transpose-array ra . args  @deffn {Scheme Procedure} transpose-array ra . args
5575    @deffnx {C Function} scm_transpose_array (ra, args)
5576  Return an array sharing contents with @var{array}, but with  Return an array sharing contents with @var{array}, but with
5577  dimensions arranged in a different order.  There must be one  dimensions arranged in a different order.  There must be one
5578  @var{dim} argument for each dimension of @var{array}.  @var{dim} argument for each dimension of @var{array}.
# Line 5054  have smaller rank than @var{array}. Line 5595  have smaller rank than @var{array}.
5595  @end deffn  @end deffn
5596    
5597   enclose-array   enclose-array
5598  @deffn primitive enclose-array ra . axes  @deffn {Scheme Procedure} enclose-array ra . axes
5599    @deffnx {C Function} scm_enclose_array (ra, axes)
5600  @var{dim0}, @var{dim1} @dots{} should be nonnegative integers less than  @var{dim0}, @var{dim1} @dots{} should be nonnegative integers less than
5601  the rank of @var{array}.  @var{enclose-array} returns an array  the rank of @var{array}.  @var{enclose-array} returns an array
5602  resembling an array of shared arrays.  The dimensions of each shared  resembling an array of shared arrays.  The dimensions of each shared
# Line 5079  examples: Line 5621  examples:
5621  @end deffn  @end deffn
5622    
5623   array-in-bounds?   array-in-bounds?
5624  @deffn primitive array-in-bounds? v . args  @deffn {Scheme Procedure} array-in-bounds? v . args
5625    @deffnx {C Function} scm_array_in_bounds_p (v, args)
5626  Return @code{#t} if its arguments would be acceptable to  Return @code{#t} if its arguments would be acceptable to
5627  @code{array-ref}.  @code{array-ref}.
5628  @end deffn  @end deffn
5629    
5630   array-ref   array-ref
5631  @deffn primitive array-ref  @deffn {Scheme Procedure} array-ref
5632  implemented by the C function "scm_uniform_vector_ref"  implemented by the C function "scm_uniform_vector_ref"
5633  @end deffn  @end deffn
5634    
5635   uniform-vector-ref   uniform-vector-ref
5636  @deffn primitive uniform-vector-ref v args  @deffn {Scheme Procedure} uniform-vector-ref v args
5637  @deffnx primitive array-ref v . args  @deffnx {Scheme Procedure} array-ref v . args
5638    @deffnx {C Function} scm_uniform_vector_ref (v, args)
5639  Return the element at the @code{(index1, index2)} element in  Return the element at the @code{(index1, index2)} element in
5640  @var{array}.  @var{array}.
5641  @end deffn  @end deffn
5642    
5643   uniform-array-set1!   uniform-array-set1!
5644  @deffn primitive uniform-array-set1!  @deffn {Scheme Procedure} uniform-array-set1!
5645  implemented by the C function "scm_array_set_x"  implemented by the C function "scm_array_set_x"
5646  @end deffn  @end deffn
5647    
5648   array-set!   array-set!
5649  @deffn primitive array-set! v obj . args  @deffn {Scheme Procedure} array-set! v obj . args
5650  @deffnx primitive uniform-array-set1! v obj args  @deffnx {Scheme Procedure} uniform-array-set1! v obj args
5651  Sets the element at the @code{(index1, index2)} element in @var{array} to  @deffnx {C Function} scm_array_set_x (v, obj, args)
5652    Set the element at the @code{(index1, index2)} element in @var{array} to
5653  @var{new-value}.  The value returned by array-set! is unspecified.  @var{new-value}.  The value returned by array-set! is unspecified.
5654  @end deffn  @end deffn
5655    
5656   array-contents   array-contents
5657  @deffn primitive array-contents ra [strict]  @deffn {Scheme Procedure} array-contents ra [strict]
5658  @deffnx primitive array-contents array strict  @deffnx {Scheme Procedure} array-contents array strict
5659    @deffnx {C Function} scm_array_contents (ra, strict)
5660  If @var{array} may be @dfn{unrolled} into a one dimensional shared array  If @var{array} may be @dfn{unrolled} into a one dimensional shared array
5661  without changing their order (last subscript changing fastest), then  without changing their order (last subscript changing fastest), then
5662  @code{array-contents} returns that shared array, otherwise it returns  @code{array-contents} returns that shared array, otherwise it returns
# Line 5124  memory. Line 5670  memory.
5670  @end deffn  @end deffn
5671    
5672   uniform-array-read!   uniform-array-read!
5673  @deffn primitive uniform-array-read! ra [port_or_fd [start [end]]]  @deffn {Scheme Procedure} uniform-array-read! ra [port_or_fd [start [end]]]
5674  @deffnx primitive uniform-vector-read! uve [port-or-fdes] [start] [end]  @deffnx {Scheme Procedure} uniform-vector-read! uve [port-or-fdes] [start] [end]
5675  Attempts to read all elements of @var{ura}, in lexicographic order, as  @deffnx {C Function} scm_uniform_array_read_x (ra, port_or_fd, start, end)
5676    Attempt to read all elements of @var{ura}, in lexicographic order, as
5677  binary objects from @var{port-or-fdes}.  binary objects from @var{port-or-fdes}.
5678  If an end of file is encountered during  If an end of file is encountered during
5679  uniform-array-read! the objects up to that point only are put into @var{ura}  uniform-array-read! the objects up to that point only are put into @var{ura}
# Line 5143  returned by @code{(current-input-port)}. Line 5690  returned by @code{(current-input-port)}.
5690  @end deffn  @end deffn
5691    
5692   uniform-array-write   uniform-array-write
5693  @deffn primitive uniform-array-write v [port_or_fd [start [end]]]  @deffn {Scheme Procedure} uniform-array-write v [port_or_fd [start [end]]]
5694  @deffnx primitive uniform-vector-write uve [port-or-fdes] [start] [end]  @deffnx {Scheme Procedure} uniform-vector-write uve [port-or-fdes] [start] [end]
5695    @deffnx {C Function} scm_uniform_array_write (v, port_or_fd, start, end)
5696  Writes all elements of @var{ura} as binary objects to  Writes all elements of @var{ura} as binary objects to
5697  @var{port-or-fdes}.  @var{port-or-fdes}.
5698    
# Line 5159  omitted, in which case it defaults to th Line 5707  omitted, in which case it defaults to th
5707  @end deffn  @end deffn
5708    
5709   bit-count   bit-count
5710  @deffn primitive bit-count b bitvector  @deffn {Scheme Procedure} bit-count b bitvector
5711    @deffnx {C Function} scm_bit_count (b, bitvector)
5712  Return the number of occurrences of the boolean @var{b} in  Return the number of occurrences of the boolean @var{b} in
5713  @var{bitvector}.  @var{bitvector}.
5714  @end deffn  @end deffn
5715    
5716   bit-position   bit-position
5717  @deffn primitive bit-position item v k  @deffn {Scheme Procedure} bit-position item v k
5718    @deffnx {C Function} scm_bit_position (item, v, k)
5719  Return the minimum index of an occurrence of @var{bool} in  Return the minimum index of an occurrence of @var{bool} in
5720  @var{bv} which is at least @var{k}.  If no @var{bool} occurs  @var{bv} which is at least @var{k}.  If no @var{bool} occurs
5721  within the specified range @code{#f} is returned.  within the specified range @code{#f} is returned.
5722  @end deffn  @end deffn
5723    
5724   bit-set*!   bit-set*!
5725  @deffn primitive bit-set*! v kv obj  @deffn {Scheme Procedure} bit-set*! v kv obj
5726    @deffnx {C Function} scm_bit_set_star_x (v, kv, obj)
5727  If uve is a bit-vector @var{bv} and uve must be of the same  If uve is a bit-vector @var{bv} and uve must be of the same
5728  length.  If @var{bool} is @code{#t}, uve is OR'ed into  length.  If @var{bool} is @code{#t}, uve is OR'ed into
5729  @var{bv}; If @var{bool} is @code{#f}, the inversion of uve is  @var{bv}; If @var{bool} is @code{#f}, the inversion of uve is
# Line 5185  of @var{bv} corresponding to the indexes Line 5736  of @var{bv} corresponding to the indexes
5736  @end deffn  @end deffn
5737    
5738   bit-count*   bit-count*
5739  @deffn primitive bit-count* v kv obj  @deffn {Scheme Procedure} bit-count* v kv obj
5740    @deffnx {C Function} scm_bit_count_star (v, kv, obj)
5741  Return  Return
5742  @lisp  @lisp
5743  (bit-count (bit-set*! (if bool bv (bit-invert! bv)) uve #t) #t).  (bit-count (bit-set*! (if bool bv (bit-invert! bv)) uve #t) #t).
# Line 5194  Return Line 5746  Return
5746  @end deffn  @end deffn
5747    
5748   bit-invert!   bit-invert!
5749  @deffn primitive bit-invert! v  @deffn {Scheme Procedure} bit-invert! v
5750  Modifies @var{bv} by replacing each element with its negation.  @deffnx {C Function} scm_bit_invert_x (v)
5751    Modify @var{bv} by replacing each element with its negation.
5752  @end deffn  @end deffn
5753    
5754   array->list   array->list
5755  @deffn primitive array->list v  @deffn {Scheme Procedure} array->list v
5756    @deffnx {C Function} scm_array_to_list (v)
5757  Return a list consisting of all the elements, in order, of  Return a list consisting of all the elements, in order, of
5758  @var{array}.  @var{array}.
5759  @end deffn  @end deffn
5760    
5761   list->uniform-array   list->uniform-array
5762  @deffn primitive list->uniform-array ndim prot lst  @deffn {Scheme Procedure} list->uniform-array ndim prot lst
5763  @deffnx procedure list->uniform-vector prot lst  @deffnx {Scheme Procedure} list->uniform-vector prot lst
5764    @deffnx {C Function} scm_list_to_uniform_array (ndim, prot, lst)
5765  Return a uniform array of the type indicated by prototype  Return a uniform array of the type indicated by prototype
5766  @var{prot} with elements the same as those of @var{lst}.  @var{prot} with elements the same as those of @var{lst}.
5767  Elements must be of the appropriate type, no coercions are  Elements must be of the appropriate type, no coercions are
# Line 5214  done. Line 5769  done.
5769  @end deffn  @end deffn
5770    
5771   array-prototype   array-prototype
5772  @deffn primitive array-prototype ra  @deffn {Scheme Procedure} array-prototype ra
5773    @deffnx {C Function} scm_array_prototype (ra)
5774  Return an object that would produce an array of the same type  Return an object that would produce an array of the same type
5775  as @var{array}, if used as the @var{prototype} for  as @var{array}, if used as the @var{prototype} for
5776  @code{make-uniform-array}.  @code{make-uniform-array}.
5777  @end deffn  @end deffn
5778    
5779   chown   chown
5780  @deffn primitive chown object owner group  @deffn {Scheme Procedure} chown object owner group
5781    @deffnx {C Function} scm_chown (object, owner, group)
5782  Change the ownership and group of the file referred to by @var{object} to  Change the ownership and group of the file referred to by @var{object} to
5783  the integer values @var{owner} and @var{group}.  @var{object} can be  the integer values @var{owner} and @var{group}.  @var{object} can be
5784  a string containing a file name or, if the platform  a string containing a file name or, if the platform
# Line 5237  as @code{-1}, then that ID is not change Line 5794  as @code{-1}, then that ID is not change
5794  @end deffn  @end deffn
5795    
5796   chmod   chmod
5797  @deffn primitive chmod object mode  @deffn {Scheme Procedure} chmod object mode
5798    @deffnx {C Function} scm_chmod (object, mode)
5799  Changes the permissions of the file referred to by @var{obj}.  Changes the permissions of the file referred to by @var{obj}.
5800  @var{obj} can be a string containing a file name or a port or integer file  @var{obj} can be a string containing a file name or a port or integer file
5801  descriptor which is open on a file (in which case @code{fchmod} is used  descriptor which is open on a file (in which case @code{fchmod} is used
# Line 5248  The return value is unspecified. Line 5806  The return value is unspecified.
5806  @end deffn  @end deffn
5807    
5808   umask   umask
5809  @deffn primitive umask [mode]  @deffn {Scheme Procedure} umask [mode]
5810  If @var{mode} is omitted, retuns a decimal number representing the current  @deffnx {C Function} scm_umask (mode)
5811    If @var{mode} is omitted, returns a decimal number representing the current
5812  file creation mask.  Otherwise the file creation mask is set to  file creation mask.  Otherwise the file creation mask is set to
5813  @var{mode} and the previous value is returned.  @var{mode} and the previous value is returned.
5814    
# Line 5257  E.g., @code{(umask #o022)} sets the mask Line 5816  E.g., @code{(umask #o022)} sets the mask
5816  @end deffn  @end deffn
5817    
5818   open-fdes   open-fdes
5819  @deffn primitive open-fdes path flags [mode]  @deffn {Scheme Procedure} open-fdes path flags [mode]
5820    @deffnx {C Function} scm_open_fdes (path, flags, mode)
5821  Similar to @code{open} but return a file descriptor instead of  Similar to @code{open} but return a file descriptor instead of
5822  a port.  a port.
5823  @end deffn  @end deffn
5824    
5825   open   open
5826  @deffn primitive open path flags [mode]  @deffn {Scheme Procedure} open path flags [mode]
5827    @deffnx {C Function} scm_open (path, flags, mode)
5828  Open the file named by @var{path} for reading and/or writing.  Open the file named by @var{path} for reading and/or writing.
5829  @var{flags} is an integer specifying how the file should be opened.  @var{flags} is an integer specifying how the file should be opened.
5830  @var{mode} is an integer specifying the permission bits of the file, if  @var{mode} is an integer specifying the permission bits of the file, if
# Line 5294  for additional flags. Line 5855  for additional flags.
5855  @end deffn  @end deffn
5856    
5857   close   close
5858  @deffn primitive close fd_or_port  @deffn {Scheme Procedure} close fd_or_port
5859    @deffnx {C Function} scm_close (fd_or_port)
5860  Similar to close-port (@pxref{Generic Port Operations, close-port}),  Similar to close-port (@pxref{Generic Port Operations, close-port}),
5861  but also works on file descriptors.  A side  but also works on file descriptors.  A side
5862  effect of closing a file descriptor is that any ports using that file  effect of closing a file descriptor is that any ports using that file
# Line 5303  their revealed counts set to zero. Line 5865  their revealed counts set to zero.
5865  @end deffn  @end deffn
5866    
5867   close-fdes   close-fdes
5868  @deffn primitive close-fdes fd  @deffn {Scheme Procedure} close-fdes fd
5869    @deffnx {C Function} scm_close_fdes (fd)
5870  A simple wrapper for the @code{close} system call.  A simple wrapper for the @code{close} system call.
5871  Close file descriptor @var{fd}, which must be an integer.  Close file descriptor @var{fd}, which must be an integer.
5872  Unlike close (@pxref{Ports and File Descriptors, close}),  Unlike close (@pxref{Ports and File Descriptors, close}),
# Line 5312  The return value is unspecified. Line 5875  The return value is unspecified.
5875  @end deffn  @end deffn
5876    
5877   stat   stat
5878  @deffn primitive stat object  @deffn {Scheme Procedure} stat object
5879    @deffnx {C Function} scm_stat (object)
5880  Return an object containing various information about the file  Return an object containing various information about the file
5881  determined by @var{obj}.  @var{obj} can be a string containing  determined by @var{obj}.  @var{obj} can be a string containing
5882  a file name or a port or integer file descriptor which is open  a file name or a port or integer file descriptor which is open
# Line 5372  An integer representing the access permi Line 5936  An integer representing the access permi
5936  @end deffn  @end deffn
5937    
5938   link   link
5939  @deffn primitive link oldpath newpath  @deffn {Scheme Procedure} link oldpath newpath
5940    @deffnx {C Function} scm_link (oldpath, newpath)
5941  Creates a new name @var{newpath} in the file system for the  Creates a new name @var{newpath} in the file system for the
5942  file named by @var{oldpath}.  If @var{oldpath} is a symbolic  file named by @var{oldpath}.  If @var{oldpath} is a symbolic
5943  link, the link may or may not be followed depending on the  link, the link may or may not be followed depending on the
# Line 5380  system. Line 5945  system.
5945  @end deffn  @end deffn
5946    
5947   rename-file   rename-file
5948  @deffn primitive rename-file oldname newname  @deffn {Scheme Procedure} rename-file oldname newname
5949    @deffnx {C Function} scm_rename (oldname, newname)
5950  Renames the file specified by @var{oldname} to @var{newname}.  Renames the file specified by @var{oldname} to @var{newname}.
5951  The return value is unspecified.  The return value is unspecified.
5952  @end deffn  @end deffn
5953    
5954   delete-file   delete-file
5955  @deffn primitive delete-file str  @deffn {Scheme Procedure} delete-file str
5956    @deffnx {C Function} scm_delete_file (str)
5957  Deletes (or "unlinks") the file specified by @var{path}.  Deletes (or "unlinks") the file specified by @var{path}.
5958  @end deffn  @end deffn
5959    
5960   mkdir   mkdir
5961  @deffn primitive mkdir path [mode]  @deffn {Scheme Procedure} mkdir path [mode]
5962    @deffnx {C Function} scm_mkdir (path, mode)
5963  Create a new directory named by @var{path}.  If @var{mode} is omitted  Create a new directory named by @var{path}.  If @var{mode} is omitted
5964  then the permissions of the directory file are set using the current  then the permissions of the directory file are set using the current
5965  umask.  Otherwise they are set to the decimal value specified with  umask.  Otherwise they are set to the decimal value specified with
# Line 5399  umask.  Otherwise they are set to the de Line 5967  umask.  Otherwise they are set to the de
5967  @end deffn  @end deffn
5968    
5969   rmdir   rmdir
5970  @deffn primitive rmdir path  @deffn {Scheme Procedure} rmdir path
5971    @deffnx {C Function} scm_rmdir (path)
5972  Remove the existing directory named by @var{path}.  The directory must  Remove the existing directory named by @var{path}.  The directory must
5973  be empty for this to succeed.  The return value is unspecified.  be empty for this to succeed.  The return value is unspecified.
5974  @end deffn  @end deffn
5975    
5976   directory-stream?   directory-stream?
5977  @deffn primitive directory-stream? obj  @deffn {Scheme Procedure} directory-stream? obj
5978    @deffnx {C Function} scm_directory_stream_p (obj)
5979  Return a boolean indicating whether @var{object} is a directory  Return a boolean indicating whether @var{object} is a directory
5980  stream as returned by @code{opendir}.  stream as returned by @code{opendir}.
5981  @end deffn  @end deffn
5982    
5983   opendir   opendir
5984  @deffn primitive opendir dirname  @deffn {Scheme Procedure} opendir dirname
5985    @deffnx {C Function} scm_opendir (dirname)
5986  Open the directory specified by @var{path} and return a directory  Open the directory specified by @var{path} and return a directory
5987  stream.  stream.
5988  @end deffn  @end deffn
5989    
5990   readdir   readdir
5991  @deffn primitive readdir port  @deffn {Scheme Procedure} readdir port
5992    @deffnx {C Function} scm_readdir (port)
5993  Return (as a string) the next directory entry from the directory stream  Return (as a string) the next directory entry from the directory stream
5994  @var{stream}.  If there is no remaining entry to be read then the  @var{stream}.  If there is no remaining entry to be read then the
5995  end of file object is returned.  end of file object is returned.
5996  @end deffn  @end deffn
5997    
5998   rewinddir   rewinddir
5999  @deffn primitive rewinddir port  @deffn {Scheme Procedure} rewinddir port
6000    @deffnx {C Function} scm_rewinddir (port)
6001  Reset the directory port @var{stream} so that the next call to  Reset the directory port @var{stream} so that the next call to
6002  @code{readdir} will return the first directory entry.  @code{readdir} will return the first directory entry.
6003  @end deffn  @end deffn
6004    
6005   closedir   closedir
6006  @deffn primitive closedir port  @deffn {Scheme Procedure} closedir port
6007    @deffnx {C Function} scm_closedir (port)
6008  Close the directory stream @var{stream}.  Close the directory stream @var{stream}.
6009  The return value is unspecified.  The return value is unspecified.
6010  @end deffn  @end deffn
6011    
6012   chdir   chdir
6013  @deffn primitive chdir str  @deffn {Scheme Procedure} chdir str
6014    @deffnx {C Function} scm_chdir (str)
6015  Change the current working directory to @var{path}.  Change the current working directory to @var{path}.
6016  The return value is unspecified.  The return value is unspecified.
6017  @end deffn  @end deffn
6018    
6019   getcwd   getcwd
6020  @deffn primitive getcwd  @deffn {Scheme Procedure} getcwd
6021    @deffnx {C Function} scm_getcwd ()
6022  Return the name of the current working directory.  Return the name of the current working directory.
6023  @end deffn  @end deffn
6024    
6025   select   select
6026  @deffn primitive select reads writes excepts [secs [usecs]]  @deffn {Scheme Procedure} select reads writes excepts [secs [usecs]]
6027    @deffnx {C Function} scm_select (reads, writes, excepts, secs, usecs)
6028  This procedure has a variety of uses: waiting for the ability  This procedure has a variety of uses: waiting for the ability
6029  to provide input, accept output, or the existance of  to provide input, accept output, or the existence of
6030  exceptional conditions on a collection of ports or file  exceptional conditions on a collection of ports or file
6031  descriptors, or waiting for a timeout to occur.  descriptors, or waiting for a timeout to occur.
6032  It also returns if interrupted by a signal.  It also returns if interrupted by a signal.
# Line 5480  An additional @code{select!} interface i Line 6057  An additional @code{select!} interface i
6057  @end deffn  @end deffn
6058    
6059   fcntl   fcntl
6060  @deffn primitive fcntl object cmd [value]  @deffn {Scheme Procedure} fcntl object cmd [value]
6061    @deffnx {C Function} scm_fcntl (object, cmd, value)
6062  Apply @var{command} to the specified file descriptor or the underlying  Apply @var{command} to the specified file descriptor or the underlying
6063  file descriptor of the specified port.  @var{value} is an optional  file descriptor of the specified port.  @var{value} is an optional
6064  integer argument.  integer argument.
# Line 5509  The value used to indicate the "close on Line 6087  The value used to indicate the "close on
6087  @end deffn  @end deffn
6088    
6089   fsync   fsync
6090  @deffn primitive fsync object  @deffn {Scheme Procedure} fsync object
6091    @deffnx {C Function} scm_fsync (object)
6092  Copies any unwritten data for the specified output file descriptor to disk.  Copies any unwritten data for the specified output file descriptor to disk.
6093  If @var{port/fd} is a port, its buffer is flushed before the underlying  If @var{port/fd} is a port, its buffer is flushed before the underlying
6094  file descriptor is fsync'd.  file descriptor is fsync'd.
# Line 5517  The return value is unspecified. Line 6096  The return value is unspecified.
6096  @end deffn  @end deffn
6097    
6098   symlink   symlink
6099  @deffn primitive symlink oldpath newpath  @deffn {Scheme Procedure} symlink oldpath newpath
6100    @deffnx {C Function} scm_symlink (oldpath, newpath)
6101  Create a symbolic link named @var{path-to} with the value (i.e., pointing to)  Create a symbolic link named @var{path-to} with the value (i.e., pointing to)
6102  @var{path-from}.  The return value is unspecified.  @var{path-from}.  The return value is unspecified.
6103  @end deffn  @end deffn
6104    
6105   readlink   readlink
6106  @deffn primitive readlink path  @deffn {Scheme Procedure} readlink path
6107    @deffnx {C Function} scm_readlink (path)
6108  Return the value of the symbolic link named by @var{path} (a  Return the value of the symbolic link named by @var{path} (a
6109  string), i.e., the file that the link points to.  string), i.e., the file that the link points to.
6110  @end deffn  @end deffn
6111    
6112   lstat   lstat
6113  @deffn primitive lstat str  @deffn {Scheme Procedure} lstat str
6114    @deffnx {C Function} scm_lstat (str)
6115  Similar to @code{stat}, but does not follow symbolic links, i.e.,  Similar to @code{stat}, but does not follow symbolic links, i.e.,
6116  it will return information about a symbolic link itself, not the  it will return information about a symbolic link itself, not the
6117  file it points to.  @var{path} must be a string.  file it points to.  @var{path} must be a string.
6118  @end deffn  @end deffn
6119    
6120   copy-file   copy-file
6121  @deffn primitive copy-file oldfile newfile  @deffn {Scheme Procedure} copy-file oldfile newfile
6122    @deffnx {C Function} scm_copy_file (oldfile, newfile)
6123  Copy the file specified by @var{path-from} to @var{path-to}.  Copy the file specified by @var{path-from} to @var{path-to}.
6124  The return value is unspecified.  The return value is unspecified.
6125  @end deffn  @end deffn
6126    
6127   dirname   dirname
6128  @deffn primitive dirname filename  @deffn {Scheme Procedure} dirname filename
6129    @deffnx {C Function} scm_dirname (filename)
6130  Return the directory name component of the file name  Return the directory name component of the file name
6131  @var{filename}. If @var{filename} does not contain a directory  @var{filename}. If @var{filename} does not contain a directory
6132  component, @code{.} is returned.  component, @code{.} is returned.
6133  @end deffn  @end deffn
6134    
6135   basename   basename
6136  @deffn primitive basename filename [suffix]  @deffn {Scheme Procedure} basename filename [suffix]
6137    @deffnx {C Function} scm_basename (filename, suffix)
6138  Return the base name of the file name @var{filename}. The  Return the base name of the file name @var{filename}. The
6139  base name is the file name without any directory components.  base name is the file name without any directory components.
6140  If @var{suffix} is privided, and is equal to the end of  If @var{suffix} is provided, and is equal to the end of
6141  @var{basename}, it is removed also.  @var{basename}, it is removed also.
6142  @end deffn  @end deffn
6143    
6144   pipe   pipe
6145  @deffn primitive pipe  @deffn {Scheme Procedure} pipe
6146    @deffnx {C Function} scm_pipe ()
6147  Return a newly created pipe: a pair of ports which are linked  Return a newly created pipe: a pair of ports which are linked
6148  together on the local machine.  The @emph{car} is the input  together on the local machine.  The @emph{car} is the input
6149  port and the @emph{cdr} is the output port.  Data written (and  port and the @emph{cdr} is the output port.  Data written (and
# Line 5574  from the input port. Line 6160  from the input port.
6160  @end deffn  @end deffn
6161    
6162   getgroups   getgroups
6163  @deffn primitive getgroups  @deffn {Scheme Procedure} getgroups
6164    @deffnx {C Function} scm_getgroups ()
6165  Return a vector of integers representing the current  Return a vector of integers representing the current
6166  supplimentary group IDs.  supplementary group IDs.
6167  @end deffn  @end deffn
6168    
6169   getpw   getpw
6170  @deffn primitive getpw [user]  @deffn {Scheme Procedure} getpw [user]
6171    @deffnx {C Function} scm_getpwuid (user)
6172  Look up an entry in the user database.  @var{obj} can be an integer,  Look up an entry in the user database.  @var{obj} can be an integer,
6173  a string, or omitted, giving the behaviour of getpwuid, getpwnam  a string, or omitted, giving the behaviour of getpwuid, getpwnam
6174  or getpwent respectively.  or getpwent respectively.
6175  @end deffn  @end deffn
6176    
6177   setpw   setpw
6178  @deffn primitive setpw [arg]  @deffn {Scheme Procedure} setpw [arg]
6179    @deffnx {C Function} scm_setpwent (arg)
6180  If called with a true argument, initialize or reset the password data  If called with a true argument, initialize or reset the password data
6181  stream.  Otherwise, close the stream.  The @code{setpwent} and  stream.  Otherwise, close the stream.  The @code{setpwent} and
6182  @code{endpwent} procedures are implemented on top of this.  @code{endpwent} procedures are implemented on top of this.
6183  @end deffn  @end deffn
6184    
6185   getgr   getgr
6186  @deffn primitive getgr [name]  @deffn {Scheme Procedure} getgr [name]
6187    @deffnx {C Function} scm_getgrgid (name)
6188  Look up an entry in the group database.  @var{obj} can be an integer,  Look up an entry in the group database.  @var{obj} can be an integer,
6189  a string, or omitted, giving the behaviour of getgrgid, getgrnam  a string, or omitted, giving the behaviour of getgrgid, getgrnam
6190  or getgrent respectively.  or getgrent respectively.
6191  @end deffn  @end deffn
6192    
6193   setgr   setgr
6194  @deffn primitive setgr [arg]  @deffn {Scheme Procedure} setgr [arg]
6195    @deffnx {C Function} scm_setgrent (arg)
6196  If called with a true argument, initialize or reset the group data  If called with a true argument, initialize or reset the group data
6197  stream.  Otherwise, close the stream.  The @code{setgrent} and  stream.  Otherwise, close the stream.  The @code{setgrent} and
6198  @code{endgrent} procedures are implemented on top of this.  @code{endgrent} procedures are implemented on top of this.
6199  @end deffn  @end deffn
6200    
6201   kill   kill
6202  @deffn primitive kill pid sig  @deffn {Scheme Procedure} kill pid sig
6203    @deffnx {C Function} scm_kill (pid, sig)
6204  Sends a signal to the specified process or group of processes.  Sends a signal to the specified process or group of processes.
6205    
6206  @var{pid} specifies the processes to which the signal is sent:  @var{pid} specifies the processes to which the signal is sent:
# Line 5639  Interrupt signal. Line 6231  Interrupt signal.
6231  @end deffn  @end deffn
6232    
6233   waitpid   waitpid
6234  @deffn primitive waitpid pid [options]  @deffn {Scheme Procedure} waitpid pid [options]
6235    @deffnx {C Function} scm_waitpid (pid, options)
6236  This procedure collects status information from a child process which  This procedure collects status information from a child process which
6237  has terminated or (optionally) stopped.  Normally it will  has terminated or (optionally) stopped.  Normally it will
6238  suspend the calling process until this can be done.  If more than one  suspend the calling process until this can be done.  If more than one
# Line 5684  The integer status value. Line 6277  The integer status value.
6277  @end deffn  @end deffn
6278    
6279   status:exit-val   status:exit-val
6280  @deffn primitive status:exit-val status  @deffn {Scheme Procedure} status:exit-val status
6281    @deffnx {C Function} scm_status_exit_val (status)
6282  Return the exit status value, as would be set if a process  Return the exit status value, as would be set if a process
6283  ended normally through a call to @code{exit} or @code{_exit},  ended normally through a call to @code{exit} or @code{_exit},
6284  if any, otherwise @code{#f}.  if any, otherwise @code{#f}.
6285  @end deffn  @end deffn
6286    
6287   status:term-sig   status:term-sig
6288  @deffn primitive status:term-sig status  @deffn {Scheme Procedure} status:term-sig status
6289    @deffnx {C Function} scm_status_term_sig (status)
6290  Return the signal number which terminated the process, if any,  Return the signal number which terminated the process, if any,
6291  otherwise @code{#f}.  otherwise @code{#f}.
6292  @end deffn  @end deffn
6293    
6294   status:stop-sig   status:stop-sig
6295  @deffn primitive status:stop-sig status  @deffn {Scheme Procedure} status:stop-sig status
6296    @deffnx {C Function} scm_status_stop_sig (status)
6297  Return the signal number which stopped the process, if any,  Return the signal number which stopped the process, if any,
6298  otherwise @code{#f}.  otherwise @code{#f}.
6299  @end deffn  @end deffn
6300    
6301   getppid   getppid
6302  @deffn primitive getppid  @deffn {Scheme Procedure} getppid
6303    @deffnx {C Function} scm_getppid ()
6304  Return an integer representing the process ID of the parent  Return an integer representing the process ID of the parent
6305  process.  process.
6306  @end deffn  @end deffn
6307    
6308   getuid   getuid
6309  @deffn primitive getuid  @deffn {Scheme Procedure} getuid
6310    @deffnx {C Function} scm_getuid ()
6311  Return an integer representing the current real user ID.  Return an integer representing the current real user ID.
6312  @end deffn  @end deffn
6313    
6314   getgid   getgid
6315  @deffn primitive getgid  @deffn {Scheme Procedure} getgid
6316    @deffnx {C Function} scm_getgid ()
6317  Return an integer representing the current real group ID.  Return an integer representing the current real group ID.
6318  @end deffn  @end deffn
6319    
6320   geteuid   geteuid
6321  @deffn primitive geteuid  @deffn {Scheme Procedure} geteuid
6322    @deffnx {C Function} scm_geteuid ()
6323  Return an integer representing the current effective user ID.  Return an integer representing the current effective user ID.
6324  If the system does not support effective IDs, then the real ID  If the system does not support effective IDs, then the real ID
6325  is returned.  @code{(feature? 'EIDs)} reports whether the  is returned.  @code{(feature? 'EIDs)} reports whether the
# Line 5727  system supports effective IDs. Line 6327  system supports effective IDs.
6327  @end deffn  @end deffn
6328    
6329   getegid   getegid
6330  @deffn primitive getegid  @deffn {Scheme Procedure} getegid
6331    @deffnx {C Function} scm_getegid ()
6332  Return an integer representing the current effective group ID.  Return an integer representing the current effective group ID.
6333  If the system does not support effective IDs, then the real ID  If the system does not support effective IDs, then the real ID
6334  is returned.  @code{(feature? 'EIDs)} reports whether the  is returned.  @code{(feature? 'EIDs)} reports whether the
# Line 5735  system supports effective IDs. Line 6336  system supports effective IDs.
6336  @end deffn  @end deffn
6337    
6338   setuid   setuid
6339  @deffn primitive setuid id  @deffn {Scheme Procedure} setuid id
6340    @deffnx {C Function} scm_setuid (id)
6341  Sets both the real and effective user IDs to the integer @var{id}, provided  Sets both the real and effective user IDs to the integer @var{id}, provided
6342  the process has appropriate privileges.  the process has appropriate privileges.
6343  The return value is unspecified.  The return value is unspecified.
6344  @end deffn  @end deffn
6345    
6346   setgid   setgid
6347  @deffn primitive setgid id  @deffn {Scheme Procedure} setgid id
6348    @deffnx {C Function} scm_setgid (id)
6349  Sets both the real and effective group IDs to the integer @var{id}, provided  Sets both the real and effective group IDs to the integer @var{id}, provided
6350  the process has appropriate privileges.  the process has appropriate privileges.
6351  The return value is unspecified.  The return value is unspecified.
6352  @end deffn  @end deffn
6353    
6354   seteuid   seteuid
6355  @deffn primitive seteuid id  @deffn {Scheme Procedure} seteuid id
6356    @deffnx {C Function} scm_seteuid (id)
6357  Sets the effective user ID to the integer @var{id}, provided the process  Sets the effective user ID to the integer @var{id}, provided the process
6358  has appropriate privileges.  If effective IDs are not supported, the  has appropriate privileges.  If effective IDs are not supported, the
6359  real ID is set instead -- @code{(feature? 'EIDs)} reports whether the  real ID is set instead -- @code{(feature? 'EIDs)} reports whether the
# Line 5758  The return value is unspecified. Line 6362  The return value is unspecified.
6362  @end deffn  @end deffn
6363    
6364   setegid   setegid
6365  @deffn primitive setegid id  @deffn {Scheme Procedure} setegid id
6366    @deffnx {C Function} scm_setegid (id)
6367  Sets the effective group ID to the integer @var{id}, provided the process  Sets the effective group ID to the integer @var{id}, provided the process
6368  has appropriate privileges.  If effective IDs are not supported, the  has appropriate privileges.  If effective IDs are not supported, the
6369  real ID is set instead -- @code{(feature? 'EIDs)} reports whether the  real ID is set instead -- @code{(feature? 'EIDs)} reports whether the
# Line 5767  The return value is unspecified. Line 6372  The return value is unspecified.
6372  @end deffn  @end deffn
6373    
6374   getpgrp   getpgrp
6375  @deffn primitive getpgrp  @deffn {Scheme Procedure} getpgrp
6376    @deffnx {C Function} scm_getpgrp ()
6377  Return an integer representing the current process group ID.  Return an integer representing the current process group ID.
6378  This is the POSIX definition, not BSD.  This is the POSIX definition, not BSD.
6379  @end deffn  @end deffn
6380    
6381   setpgid   setpgid
6382  @deffn primitive setpgid pid pgid  @deffn {Scheme Procedure} setpgid pid pgid
6383    @deffnx {C Function} scm_setpgid (pid, pgid)
6384  Move the process @var{pid} into the process group @var{pgid}.  @var{pid} or  Move the process @var{pid} into the process group @var{pgid}.  @var{pid} or
6385  @var{pgid} must be integers: they can be zero to indicate the ID of the  @var{pgid} must be integers: they can be zero to indicate the ID of the
6386  current process.  current process.
# Line 5782  The return value is unspecified. Line 6389  The return value is unspecified.
6389  @end deffn  @end deffn
6390    
6391   setsid   setsid
6392  @deffn primitive setsid  @deffn {Scheme Procedure} setsid
6393    @deffnx {C Function} scm_setsid ()
6394  Creates a new session.  The current process becomes the session leader  Creates a new session.  The current process becomes the session leader
6395  and is put in a new process group.  The process will be detached  and is put in a new process group.  The process will be detached
6396  from its controlling terminal if it has one.  from its controlling terminal if it has one.
# Line 5790  The return value is an integer represent Line 6398  The return value is an integer represent
6398  @end deffn  @end deffn
6399    
6400   ttyname   ttyname
6401  @deffn primitive ttyname port  @deffn {Scheme Procedure} ttyname port
6402    @deffnx {C Function} scm_ttyname (port)
6403  Return a string with the name of the serial terminal device  Return a string with the name of the serial terminal device
6404  underlying @var{port}.  underlying @var{port}.
6405  @end deffn  @end deffn
6406    
6407   ctermid   ctermid
6408  @deffn primitive ctermid  @deffn {Scheme Procedure} ctermid
6409    @deffnx {C Function} scm_ctermid ()
6410  Return a string containing the file name of the controlling  Return a string containing the file name of the controlling
6411  terminal for the current process.  terminal for the current process.
6412  @end deffn  @end deffn
6413    
6414   tcgetpgrp   tcgetpgrp
6415  @deffn primitive tcgetpgrp port  @deffn {Scheme Procedure} tcgetpgrp port
6416    @deffnx {C Function} scm_tcgetpgrp (port)
6417  Return the process group ID of the foreground process group  Return the process group ID of the foreground process group
6418  associated with the terminal open on the file descriptor  associated with the terminal open on the file descriptor
6419  underlying @var{port}.  underlying @var{port}.
# Line 5816  foreground. Line 6427  foreground.
6427  @end deffn  @end deffn
6428    
6429   tcsetpgrp   tcsetpgrp
6430  @deffn primitive tcsetpgrp port pgid  @deffn {Scheme Procedure} tcsetpgrp port pgid
6431    @deffnx {C Function} scm_tcsetpgrp (port, pgid)
6432  Set the foreground process group ID for the terminal used by the file  Set the foreground process group ID for the terminal used by the file
6433  descriptor underlying @var{port} to the integer @var{pgid}.  descriptor underlying @var{port} to the integer @var{pgid}.
6434  The calling process  The calling process
# Line 5825  controlling terminal.  The return value Line 6437  controlling terminal.  The return value
6437  @end deffn  @end deffn
6438    
6439   execl   execl
6440  @deffn primitive execl filename . args  @deffn {Scheme Procedure} execl filename . args
6441    @deffnx {C Function} scm_execl (filename, args)
6442  Executes the file named by @var{path} as a new process image.  Executes the file named by @var{path} as a new process image.
6443  The remaining arguments are supplied to the process; from a C program  The remaining arguments are supplied to the process; from a C program
6444  they are accessable as the @code{argv} argument to @code{main}.  they are accessible as the @code{argv} argument to @code{main}.
6445  Conventionally the first @var{arg} is the same as @var{path}.  Conventionally the first @var{arg} is the same as @var{path}.
6446  All arguments must be strings.    All arguments must be strings.  
6447    
# Line 5840  call, but we call it @code{execl} becaus Line 6453  call, but we call it @code{execl} becaus
6453  @end deffn  @end deffn
6454    
6455   execlp   execlp
6456  @deffn primitive execlp filename . args  @deffn {Scheme Procedure} execlp filename . args
6457    @deffnx {C Function} scm_execlp (filename, args)
6458  Similar to @code{execl}, however if  Similar to @code{execl}, however if
6459  @var{filename} does not contain a slash  @var{filename} does not contain a slash
6460  then the file to execute will be located by searching the  then the file to execute will be located by searching the
# Line 5851  call, but we call it @code{execlp} becau Line 6465  call, but we call it @code{execlp} becau
6465  @end deffn  @end deffn
6466    
6467   execle   execle
6468  @deffn primitive execle filename env . args  @deffn {Scheme Procedure} execle filename env . args
6469    @deffnx {C Function} scm_execle (filename, env, args)
6470  Similar to @code{execl}, but the environment of the new process is  Similar to @code{execl}, but the environment of the new process is
6471  specified by @var{env}, which must be a list of strings as returned by the  specified by @var{env}, which must be a list of strings as returned by the
6472  @code{environ} procedure.  @code{environ} procedure.
# Line 5861  call, but we call it @code{execle} becau Line 6476  call, but we call it @code{execle} becau
6476  @end deffn  @end deffn
6477    
6478   primitive-fork   primitive-fork
6479  @deffn primitive primitive-fork  @deffn {Scheme Procedure} primitive-fork
6480    @deffnx {C Function} scm_fork ()
6481  Creates a new "child" process by duplicating the current "parent" process.  Creates a new "child" process by duplicating the current "parent" process.
6482  In the child the return value is 0.  In the parent the return value is  In the child the return value is 0.  In the parent the return value is
6483  the integer process ID of the child.  the integer process ID of the child.
# Line 5871  with the scsh fork. Line 6487  with the scsh fork.
6487  @end deffn  @end deffn
6488    
6489   uname   uname
6490  @deffn primitive uname  @deffn {Scheme Procedure} uname
6491    @deffnx {C Function} scm_uname ()
6492  Return an object with some information about the computer  Return an object with some information about the computer
6493  system the program is running on.  system the program is running on.
6494  @end deffn  @end deffn
6495    
6496   environ   environ
6497  @deffn primitive environ [env]  @deffn {Scheme Procedure} environ [env]
6498    @deffnx {C Function} scm_environ (env)
6499  If @var{env} is omitted, return the current environment (in the  If @var{env} is omitted, return the current environment (in the
6500  Unix sense) as a list of strings.  Otherwise set the current  Unix sense) as a list of strings.  Otherwise set the current
6501  environment, which is also the default environment for child  environment, which is also the default environment for child
# Line 5888  then the return value is unspecified. Line 6506  then the return value is unspecified.
6506  @end deffn  @end deffn
6507    
6508   tmpnam   tmpnam
6509  @deffn primitive tmpnam  @deffn {Scheme Procedure} tmpnam
6510    @deffnx {C Function} scm_tmpnam ()
6511  Return a name in the file system that does not match any  Return a name in the file system that does not match any
6512  existing file.  However there is no guarantee that another  existing file.  However there is no guarantee that another
6513  process will not create the file after @code{tmpnam} is called.  process will not create the file after @code{tmpnam} is called.
# Line 5897  Care should be taken if opening the file Line 6516  Care should be taken if opening the file
6516  @end deffn  @end deffn
6517    
6518   mkstemp!   mkstemp!
6519  @deffn primitive mkstemp! tmpl  @deffn {Scheme Procedure} mkstemp! tmpl
6520    @deffnx {C Function} scm_mkstemp (tmpl)
6521  Create a new unique file in the file system and returns a new  Create a new unique file in the file system and returns a new
6522  buffered port open for reading and writing to the file.  buffered port open for reading and writing to the file.
6523  @var{tmpl} is a string specifying where the file should be  @var{tmpl} is a string specifying where the file should be
# Line 5906  place to return the name of the temporar Line 6526  place to return the name of the temporar
6526  @end deffn  @end deffn
6527    
6528   utime   utime
6529  @deffn primitive utime pathname [actime [modtime]]  @deffn {Scheme Procedure} utime pathname [actime [modtime]]
6530    @deffnx {C Function} scm_utime (pathname, actime, modtime)
6531  @code{utime} sets the access and modification times for the  @code{utime} sets the access and modification times for the
6532  file named by @var{path}.  If @var{actime} or @var{modtime} is  file named by @var{path}.  If @var{actime} or @var{modtime} is
6533  not supplied, then the current time is used.  @var{actime} and  not supplied, then the current time is used.  @var{actime} and
# Line 5920  modification time to the current time. Line 6541  modification time to the current time.
6541  @end deffn  @end deffn
6542    
6543   access?   access?
6544  @deffn primitive access? path how  @deffn {Scheme Procedure} access? path how
6545    @deffnx {C Function} scm_access (path, how)
6546  Return @code{#t} if @var{path} corresponds to an existing file  Return @code{#t} if @var{path} corresponds to an existing file
6547  and the current process has the type of access specified by  and the current process has the type of access specified by
6548  @var{how}, otherwise @code{#f}.  @var{how} should be specified  @var{how}, otherwise @code{#f}.  @var{how} should be specified
# Line 5947  test for existence of the file. Line 6569  test for existence of the file.
6569  @end deffn  @end deffn
6570    
6571   getpid   getpid
6572  @deffn primitive getpid  @deffn {Scheme Procedure} getpid
6573    @deffnx {C Function} scm_getpid ()
6574  Return an integer representing the current process ID.  Return an integer representing the current process ID.
6575  @end deffn  @end deffn
6576    
6577   putenv   putenv
6578  @deffn primitive putenv str  @deffn {Scheme Procedure} putenv str
6579    @deffnx {C Function} scm_putenv (str)
6580  Modifies the environment of the current process, which is  Modifies the environment of the current process, which is
6581  also the default environment inherited by child processes.  also the default environment inherited by child processes.
6582    
# Line 5967  The return value is unspecified. Line 6591  The return value is unspecified.
6591  @end deffn  @end deffn
6592    
6593   setlocale   setlocale
6594  @deffn primitive setlocale category [locale]  @deffn {Scheme Procedure} setlocale category [locale]
6595    @deffnx {C Function} scm_setlocale (category, locale)
6596  If @var{locale} is omitted, return the current value of the  If @var{locale} is omitted, return the current value of the
6597  specified locale category as a system-dependent string.  specified locale category as a system-dependent string.
6598  @var{category} should be specified using the values  @var{category} should be specified using the values
# Line 5976  specified locale category as a system-de Line 6601  specified locale category as a system-de
6601  Otherwise the specified locale category is set to the string  Otherwise the specified locale category is set to the string
6602  @var{locale} and the new value is returned as a  @var{locale} and the new value is returned as a
6603  system-dependent string.  If @var{locale} is an empty string,  system-dependent string.  If @var{locale} is an empty string,
6604  the locale will be set using envirionment variables.  the locale will be set using environment variables.
6605  @end deffn  @end deffn
6606    
6607   mknod   mknod
6608  @deffn primitive mknod path type perms dev  @deffn {Scheme Procedure} mknod path type perms dev
6609    @deffnx {C Function} scm_mknod (path, type, perms, dev)
6610  Creates a new special file, such as a file corresponding to a device.  Creates a new special file, such as a file corresponding to a device.
6611  @var{path} specifies the name of the file.  @var{type} should  @var{path} specifies the name of the file.  @var{type} should
6612  be one of the following symbols:  be one of the following symbols:
# Line 5999  The return value is unspecified. Line 6625  The return value is unspecified.
6625  @end deffn  @end deffn
6626    
6627   nice   nice
6628  @deffn primitive nice incr  @deffn {Scheme Procedure} nice incr
6629    @deffnx {C Function} scm_nice (incr)
6630  Increment the priority of the current process by @var{incr}.  A higher  Increment the priority of the current process by @var{incr}.  A higher
6631  priority value means that the process runs less often.  priority value means that the process runs less often.
6632  The return value is unspecified.  The return value is unspecified.
6633  @end deffn  @end deffn
6634    
6635   sync   sync
6636  @deffn primitive sync  @deffn {Scheme Procedure} sync
6637    @deffnx {C Function} scm_sync ()
6638  Flush the operating system disk buffers.  Flush the operating system disk buffers.
6639  The return value is unspecified.  The return value is unspecified.
6640  @end deffn  @end deffn
6641    
6642   crypt   crypt
6643  @deffn primitive crypt key salt  @deffn {Scheme Procedure} crypt key salt
6644    @deffnx {C Function} scm_crypt (key, salt)
6645  Encrypt @var{key} using @var{salt} as the salt value to the  Encrypt @var{key} using @var{salt} as the salt value to the
6646  crypt(3) library call.  crypt(3) library call.
6647  @end deffn  @end deffn
6648    
6649   chroot   chroot
6650  @deffn primitive chroot path  @deffn {Scheme Procedure} chroot path
6651    @deffnx {C Function} scm_chroot (path)
6652  Change the root directory to that specified in @var{path}.  Change the root directory to that specified in @var{path}.
6653  This directory will be used for path names beginning with  This directory will be used for path names beginning with
6654  @file{/}.  The root directory is inherited by all children  @file{/}.  The root directory is inherited by all children
# Line 6027  root directory. Line 6657  root directory.
6657  @end deffn  @end deffn
6658    
6659   getlogin   getlogin
6660  @deffn primitive getlogin  @deffn {Scheme Procedure} getlogin
6661    @deffnx {C Function} scm_getlogin ()
6662  Return a string containing the name of the user logged in on  Return a string containing the name of the user logged in on
6663  the controlling terminal of the process, or @code{#f} if this  the controlling terminal of the process, or @code{#f} if this
6664  information cannot be obtained.  information cannot be obtained.
6665  @end deffn  @end deffn
6666    
6667   cuserid   cuserid
6668  @deffn primitive cuserid  @deffn {Scheme Procedure} cuserid
6669    @deffnx {C Function} scm_cuserid ()
6670  Return a string containing a user name associated with the  Return a string containing a user name associated with the
6671  effective user id of the process.  Return @code{#f} if this  effective user id of the process.  Return @code{#f} if this
6672  information cannot be obtained.  information cannot be obtained.
6673  @end deffn  @end deffn
6674    
6675   getpriority   getpriority
6676  @deffn primitive getpriority which who  @deffn {Scheme Procedure} getpriority which who
6677    @deffnx {C Function} scm_getpriority (which, who)
6678  Return the scheduling priority of the process, process group  Return the scheduling priority of the process, process group
6679  or user, as indicated by @var{which} and @var{who}. @var{which}  or user, as indicated by @var{which} and @var{who}. @var{which}
6680  is one of the variables @code{PRIO_PROCESS}, @code{PRIO_PGRP}  is one of the variables @code{PRIO_PROCESS}, @code{PRIO_PGRP}
# Line 6055  specified processes. Line 6688  specified processes.
6688  @end deffn  @end deffn
6689    
6690   setpriority   setpriority
6691  @deffn primitive setpriority which who prio  @deffn {Scheme Procedure} setpriority which who prio
6692    @deffnx {C Function} scm_setpriority (which, who, prio)
6693  Set the scheduling priority of the process, process group  Set the scheduling priority of the process, process group
6694  or user, as indicated by @var{which} and @var{who}. @var{which}  or user, as indicated by @var{which} and @var{who}. @var{which}
6695  is one of the variables @code{PRIO_PROCESS}, @code{PRIO_PGRP}  is one of the variables @code{PRIO_PROCESS}, @code{PRIO_PGRP}
# Line 6072  The return value is not specified. Line 6706  The return value is not specified.
6706  @end deffn  @end deffn
6707    
6708   getpass   getpass
6709  @deffn primitive getpass prompt  @deffn {Scheme Procedure} getpass prompt
6710    @deffnx {C Function} scm_getpass (prompt)
6711  Display @var{prompt} to the standard error output and read  Display @var{prompt} to the standard error output and read
6712  a password from @file{/dev/tty}.  If this file is not  a password from @file{/dev/tty}.  If this file is not
6713  accessible, it reads from standard input.  The password may be  accessible, it reads from standard input.  The password may be
# Line 6083  characters is disabled. Line 6718  characters is disabled.
6718  @end deffn  @end deffn
6719    
6720   flock   flock
6721  @deffn primitive flock file operation  @deffn {Scheme Procedure} flock file operation
6722    @deffnx {C Function} scm_flock (file, operation)
6723  Apply or remove an advisory lock on an open file.  Apply or remove an advisory lock on an open file.
6724  @var{operation} specifies the action to be done:  @var{operation} specifies the action to be done:
6725  @table @code  @table @code
# Line 6100  Don't block when locking.  May be specif Line 6736  Don't block when locking.  May be specif
6736  it to one of the other operations.  it to one of the other operations.
6737  @end table  @end table
6738  The return value is not specified. @var{file} may be an open  The return value is not specified. @var{file} may be an open
6739  file descriptor or an open file descriptior port.  file descriptor or an open file descriptor port.
6740  @end deffn  @end deffn
6741    
6742   sethostname   sethostname
6743  @deffn primitive sethostname name  @deffn {Scheme Procedure} sethostname name
6744    @deffnx {C Function} scm_sethostname (name)
6745  Set the host name of the current processor to @var{name}. May  Set the host name of the current processor to @var{name}. May
6746  only be used by the superuser.  The return value is not  only be used by the superuser.  The return value is not
6747  specified.  specified.
6748  @end deffn  @end deffn
6749    
6750   gethostname   gethostname
6751  @deffn primitive gethostname  @deffn {Scheme Procedure} gethostname
6752    @deffnx {C Function} scm_gethostname ()
6753  Return the host name of the current processor.  Return the host name of the current processor.
6754  @end deffn  @end deffn
6755    
6756   gethost   gethost
6757  @deffn primitive gethost [host]  @deffn {Scheme Procedure} gethost [host]
6758  @deffnx procedure gethostbyname hostname  @deffnx {Scheme Procedure} gethostbyname hostname
6759  @deffnx procedure gethostbyaddr address  @deffnx {Scheme Procedure} gethostbyaddr address
6760    @deffnx {C Function} scm_gethost (host)
6761  Look up a host by name or address, returning a host object.  The  Look up a host by name or address, returning a host object.  The
6762  @code{gethost} procedure will accept either a string name or an integer  @code{gethost} procedure will accept either a string name or an integer
6763  address; if given no arguments, it behaves like @code{gethostent} (see  address; if given no arguments, it behaves like @code{gethostent} (see
# Line 6131  Unusual conditions may result in errors Line 6770  Unusual conditions may result in errors
6770  @end deffn  @end deffn
6771    
6772   getnet   getnet
6773  @deffn primitive getnet [net]  @deffn {Scheme Procedure} getnet [net]
6774  @deffnx procedure getnetbyname net-name  @deffnx {Scheme Procedure} getnetbyname net-name
6775  @deffnx procedure getnetbyaddr net-number  @deffnx {Scheme Procedure} getnetbyaddr net-number
6776    @deffnx {C Function} scm_getnet (net)
6777  Look up a network by name or net number in the network database.  The  Look up a network by name or net number in the network database.  The
6778  @var{net-name} argument must be a string, and the @var{net-number}  @var{net-name} argument must be a string, and the @var{net-number}
6779  argument must be an integer.  @code{getnet} will accept either type of  argument must be an integer.  @code{getnet} will accept either type of
# Line 6142  given. Line 6782  given.
6782  @end deffn  @end deffn
6783    
6784   getproto   getproto
6785  @deffn primitive getproto [protocol]  @deffn {Scheme Procedure} getproto [protocol]
6786  @deffnx procedure getprotobyname name  @deffnx {Scheme Procedure} getprotobyname name
6787  @deffnx procedure getprotobynumber number  @deffnx {Scheme Procedure} getprotobynumber number
6788    @deffnx {C Function} scm_getproto (protocol)
6789  Look up a network protocol by name or by number.  @code{getprotobyname}  Look up a network protocol by name or by number.  @code{getprotobyname}
6790  takes a string argument, and @code{getprotobynumber} takes an integer  takes a string argument, and @code{getprotobynumber} takes an integer
6791  argument.  @code{getproto} will accept either type, behaving like  argument.  @code{getproto} will accept either type, behaving like
# Line 6152  argument.  @code{getproto} will accept e Line 6793  argument.  @code{getproto} will accept e
6793  @end deffn  @end deffn
6794    
6795   getserv   getserv
6796  @deffn primitive getserv [name [protocol]]  @deffn {Scheme Procedure} getserv [name [protocol]]
6797  @deffnx procedure getservbyname name protocol  @deffnx {Scheme Procedure} getservbyname name protocol
6798  @deffnx procedure getservbyport port protocol  @deffnx {Scheme Procedure} getservbyport port protocol
6799    @deffnx {C Function} scm_getserv (name, protocol)
6800  Look up a network service by name or by service number, and return a  Look up a network service by name or by service number, and return a
6801  network service object.  The @var{protocol} argument specifies the name  network service object.  The @var{protocol} argument specifies the name
6802  of the desired protocol; if the protocol found in the network service  of the desired protocol; if the protocol found in the network service
# Line 6166  as its first argument; if given no argum Line 6808  as its first argument; if given no argum
6808  @end deffn  @end deffn
6809    
6810   sethost   sethost
6811  @deffn primitive sethost [stayopen]  @deffn {Scheme Procedure} sethost [stayopen]
6812    @deffnx {C Function} scm_sethost (stayopen)
6813  If @var{stayopen} is omitted, this is equivalent to @code{endhostent}.  If @var{stayopen} is omitted, this is equivalent to @code{endhostent}.
6814  Otherwise it is equivalent to @code{sethostent stayopen}.  Otherwise it is equivalent to @code{sethostent stayopen}.
6815  @end deffn  @end deffn
6816    
6817   setnet   setnet
6818  @deffn primitive setnet [stayopen]  @deffn {Scheme Procedure} setnet [stayopen]
6819    @deffnx {C Function} scm_setnet (stayopen)
6820  If @var{stayopen} is omitted, this is equivalent to @code{endnetent}.  If @var{stayopen} is omitted, this is equivalent to @code{endnetent}.
6821  Otherwise it is equivalent to @code{setnetent stayopen}.  Otherwise it is equivalent to @code{setnetent stayopen}.
6822  @end deffn  @end deffn
6823    
6824   setproto   setproto
6825  @deffn primitive setproto [stayopen]  @deffn {Scheme Procedure} setproto [stayopen]
6826    @deffnx {C Function} scm_setproto (stayopen)
6827  If @var{stayopen} is omitted, this is equivalent to @code{endprotoent}.  If @var{stayopen} is omitted, this is equivalent to @code{endprotoent}.
6828  Otherwise it is equivalent to @code{setprotoent stayopen}.  Otherwise it is equivalent to @code{setprotoent stayopen}.
6829  @end deffn  @end deffn
6830    
6831   setserv   setserv
6832  @deffn primitive setserv [stayopen]  @deffn {Scheme Procedure} setserv [stayopen]
6833    @deffnx {C Function} scm_setserv (stayopen)
6834  If @var{stayopen} is omitted, this is equivalent to @code{endservent}.  If @var{stayopen} is omitted, this is equivalent to @code{endservent}.
6835  Otherwise it is equivalent to @code{setservent stayopen}.  Otherwise it is equivalent to @code{setservent stayopen}.
6836  @end deffn  @end deffn
6837    
6838   htons   htons
6839  @deffn primitive htons value  @deffn {Scheme Procedure} htons value
6840    @deffnx {C Function} scm_htons (value)
6841  Convert a 16 bit quantity from host to network byte ordering.  Convert a 16 bit quantity from host to network byte ordering.
6842  @var{value} is packed into 2 bytes, which are then converted  @var{value} is packed into 2 bytes, which are then converted
6843  and returned as a new integer.  and returned as a new integer.
6844  @end deffn  @end deffn
6845    
6846   ntohs   ntohs
6847  @deffn primitive ntohs value  @deffn {Scheme Procedure} ntohs value
6848    @deffnx {C Function} scm_ntohs (value)
6849  Convert a 16 bit quantity from network to host byte ordering.  Convert a 16 bit quantity from network to host byte ordering.
6850  @var{value} is packed into 2 bytes, which are then converted  @var{value} is packed into 2 bytes, which are then converted
6851  and returned as a new integer.  and returned as a new integer.
6852  @end deffn  @end deffn
6853    
6854   htonl   htonl
6855  @deffn primitive htonl value  @deffn {Scheme Procedure} htonl value
6856    @deffnx {C Function} scm_htonl (value)
6857  Convert a 32 bit quantity from host to network byte ordering.  Convert a 32 bit quantity from host to network byte ordering.
6858  @var{value} is packed into 4 bytes, which are then converted  @var{value} is packed into 4 bytes, which are then converted
6859  and returned as a new integer.  and returned as a new integer.
6860  @end deffn  @end deffn
6861    
6862   ntohl   ntohl
6863  @deffn primitive ntohl value  @deffn {Scheme Procedure} ntohl value
6864    @deffnx {C Function} scm_ntohl (value)
6865  Convert a 32 bit quantity from network to host byte ordering.  Convert a 32 bit quantity from network to host byte ordering.
6866  @var{value} is packed into 4 bytes, which are then converted  @var{value} is packed into 4 bytes, which are then converted
6867  and returned as a new integer.  and returned as a new integer.
6868  @end deffn  @end deffn
6869    
6870   inet-aton   inet-aton
6871  @deffn primitive inet-aton address  @deffn {Scheme Procedure} inet-aton address
6872    @deffnx {C Function} scm_inet_aton (address)
6873  Convert an IPv4 Internet address from printable string  Convert an IPv4 Internet address from printable string
6874  (dotted decimal notation) to an integer.  E.g.,  (dotted decimal notation) to an integer.  E.g.,
6875    
# Line 6228  Convert an IPv4 Internet address from pr Line 6879  Convert an IPv4 Internet address from pr
6879  @end deffn  @end deffn
6880    
6881   inet-ntoa   inet-ntoa
6882  @deffn primitive inet-ntoa inetid  @deffn {Scheme Procedure} inet-ntoa inetid
6883    @deffnx {C Function} scm_inet_ntoa (inetid)
6884  Convert an IPv4 Internet address to a printable  Convert an IPv4 Internet address to a printable
6885  (dotted decimal notation) string.  E.g.,  (dotted decimal notation) string.  E.g.,
6886    
# Line 6238  Convert an IPv4 Internet address to a pr Line 6890  Convert an IPv4 Internet address to a pr
6890  @end deffn  @end deffn
6891    
6892   inet-netof   inet-netof
6893  @deffn primitive inet-netof address  @deffn {Scheme Procedure} inet-netof address
6894    @deffnx {C Function} scm_inet_netof (address)
6895  Return the network number part of the given IPv4  Return the network number part of the given IPv4
6896  Internet address.  E.g.,  Internet address.  E.g.,
6897    
# Line 6248  Internet address.  E.g., Line 6901  Internet address.  E.g.,
6901  @end deffn  @end deffn
6902    
6903   inet-lnaof   inet-lnaof
6904  @deffn primitive inet-lnaof address  @deffn {Scheme Procedure} inet-lnaof address
6905    @deffnx {C Function} scm_lnaof (address)
6906  Return the local-address-with-network part of the given  Return the local-address-with-network part of the given
6907  IPv4 Internet address, using the obsolete class A/B/C system.  IPv4 Internet address, using the obsolete class A/B/C system.
6908  E.g.,  E.g.,
# Line 6259  E.g., Line 6913  E.g.,
6913  @end deffn  @end deffn
6914    
6915   inet-makeaddr   inet-makeaddr
6916  @deffn primitive inet-makeaddr net lna  @deffn {Scheme Procedure} inet-makeaddr net lna
6917    @deffnx {C Function} scm_inet_makeaddr (net, lna)
6918  Make an IPv4 Internet address by combining the network number  Make an IPv4 Internet address by combining the network number
6919  @var{net} with the local-address-within-network number  @var{net} with the local-address-within-network number
6920  @var{lna}.  E.g.,  @var{lna}.  E.g.,
# Line 6270  Make an IPv4 Internet address by combini Line 6925  Make an IPv4 Internet address by combini
6925  @end deffn  @end deffn
6926    
6927   inet-pton   inet-pton
6928  @deffn primitive inet-pton family address  @deffn {Scheme Procedure} inet-pton family address
6929    @deffnx {C Function} scm_inet_pton (family, address)
6930  Convert a string containing a printable network address to  Convert a string containing a printable network address to
6931  an integer address.  Note that unlike the C version of this  an integer address.  Note that unlike the C version of this
6932  function,  function,
# Line 6284  the result is an integer with normal hos Line 6940  the result is an integer with normal hos
6940  @end deffn  @end deffn
6941    
6942   inet-ntop   inet-ntop
6943  @deffn primitive inet-ntop family address  @deffn {Scheme Procedure} inet-ntop family address
6944    @deffnx {C Function} scm_inet_ntop (family, address)
6945  Convert a network address into a printable string.  Convert a network address into a printable string.
6946  Note that unlike the C version of this function,  Note that unlike the C version of this function,
6947  the input is an integer with normal host byte ordering.  the input is an integer with normal host byte ordering.
# Line 6298  ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff Line 6955  ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff
6955  @end deffn  @end deffn
6956    
6957   socket   socket
6958  @deffn primitive socket family style proto  @deffn {Scheme Procedure} socket family style proto
6959    @deffnx {C Function} scm_socket (family, style, proto)
6960  Return a new socket port of the type specified by @var{family},  Return a new socket port of the type specified by @var{family},
6961  @var{style} and @var{proto}.  All three parameters are  @var{style} and @var{proto}.  All three parameters are
6962  integers.  Supported values for @var{family} are  integers.  Supported values for @var{family} are
# Line 6315  has been connected to another socket. Line 6973  has been connected to another socket.
6973  @end deffn  @end deffn
6974    
6975   socketpair   socketpair
6976  @deffn primitive socketpair family style proto  @deffn {Scheme Procedure} socketpair family style proto
6977    @deffnx {C Function} scm_socketpair (family, style, proto)
6978  Return a pair of connected (but unnamed) socket ports of the  Return a pair of connected (but unnamed) socket ports of the
6979  type specified by @var{family}, @var{style} and @var{proto}.  type specified by @var{family}, @var{style} and @var{proto}.
6980  Many systems support only socket pairs of the @code{AF_UNIX}  Many systems support only socket pairs of the @code{AF_UNIX}
# Line 6324  family.  Zero is likely to be the only m Line 6983  family.  Zero is likely to be the only m
6983  @end deffn  @end deffn
6984    
6985   getsockopt   getsockopt
6986  @deffn primitive getsockopt sock level optname  @deffn {Scheme Procedure} getsockopt sock level optname
6987    @deffnx {C Function} scm_getsockopt (sock, level, optname)
6988  Return the value of a particular socket option for the socket  Return the value of a particular socket option for the socket
6989  port @var{sock}.  @var{level} is an integer code for type of  port @var{sock}.  @var{level} is an integer code for type of
6990  option being requested, e.g., @code{SOL_SOCKET} for  option being requested, e.g., @code{SOL_SOCKET} for
# Line 6337  returns a pair of integers. Line 6997  returns a pair of integers.
6997  @end deffn  @end deffn
6998    
6999   setsockopt   setsockopt
7000  @deffn primitive setsockopt sock level optname value  @deffn {Scheme Procedure} setsockopt sock level optname value
7001    @deffnx {C Function} scm_setsockopt (sock, level, optname, value)
7002  Set the value of a particular socket option for the socket  Set the value of a particular socket option for the socket
7003  port @var{sock}.  @var{level} is an integer code for type of option  port @var{sock}.  @var{level} is an integer code for type of option
7004  being set, e.g., @code{SOL_SOCKET} for socket-level options.  being set, e.g., @code{SOL_SOCKET} for socket-level options.
# Line 6352  The return value is unspecified. Line 7013  The return value is unspecified.
7013  @end deffn  @end deffn
7014    
7015   shutdown   shutdown
7016  @deffn primitive shutdown sock how  @deffn {Scheme Procedure} shutdown sock how
7017    @deffnx {C Function} scm_shutdown (sock, how)
7018  Sockets can be closed simply by using @code{close-port}. The  Sockets can be closed simply by using @code{close-port}. The
7019  @code{shutdown} procedure allows reception or tranmission on a  @code{shutdown} procedure allows reception or transmission on a
7020  connection to be shut down individually, according to the parameter  connection to be shut down individually, according to the parameter
7021  @var{how}:  @var{how}:
7022    
# Line 6373  The return value is unspecified. Line 7035  The return value is unspecified.
7035  @end deffn  @end deffn
7036    
7037   connect   connect
7038  @deffn primitive connect sock fam address . args  @deffn {Scheme Procedure} connect sock fam address . args
7039    @deffnx {C Function} scm_connect (sock, fam, address, args)
7040  Initiate a connection from a socket using a specified address  Initiate a connection from a socket using a specified address
7041  family to the address  family to the address
7042  specified by @var{address} and possibly @var{args}.  specified by @var{address} and possibly @var{args}.
# Line 6398  The return value is unspecified. Line 7061  The return value is unspecified.
7061  @end deffn  @end deffn
7062    
7063   bind   bind
7064  @deffn primitive bind sock fam address . args  @deffn {Scheme Procedure} bind sock fam address . args
7065    @deffnx {C Function} scm_bind (sock, fam, address, args)
7066  Assign an address to the socket port @var{sock}.  Assign an address to the socket port @var{sock}.
7067  Generally this only needs to be done for server sockets,  Generally this only needs to be done for server sockets,
7068  so they know where to look for incoming connections.  A socket  so they know where to look for incoming connections.  A socket
# Line 6445  The return value is unspecified. Line 7109  The return value is unspecified.
7109  @end deffn  @end deffn
7110    
7111   listen   listen
7112  @deffn primitive listen sock backlog  @deffn {Scheme Procedure} listen sock backlog
7113    @deffnx {C Function} scm_listen (sock, backlog)
7114  Enable @var{sock} to accept connection  Enable @var{sock} to accept connection
7115  requests.  @var{backlog} is an integer specifying  requests.  @var{backlog} is an integer specifying
7116  the maximum length of the queue for pending connections.  the maximum length of the queue for pending connections.
# Line 6457  The return value is unspecified. Line 7122  The return value is unspecified.
7122  @end deffn  @end deffn
7123    
7124   accept   accept
7125  @deffn primitive accept sock  @deffn {Scheme Procedure} accept sock
7126    @deffnx {C Function} scm_accept (sock)
7127  Accept a connection on a bound, listening socket.  Accept a connection on a bound, listening socket.
7128  If there  If there
7129  are no pending connections in the queue, wait until  are no pending connections in the queue, wait until
# Line 6475  connection and will continue to accept n Line 7141  connection and will continue to accept n
7141  @end deffn  @end deffn
7142    
7143   getsockname   getsockname
7144  @deffn primitive getsockname sock  @deffn {Scheme Procedure} getsockname sock
7145    @deffnx {C Function} scm_getsockname (sock)
7146  Return the address of @var{sock}, in the same form as the  Return the address of @var{sock}, in the same form as the
7147  object returned by @code{accept}.  On many systems the address  object returned by @code{accept}.  On many systems the address
7148  of a socket in the @code{AF_FILE} namespace cannot be read.  of a socket in the @code{AF_FILE} namespace cannot be read.
7149  @end deffn  @end deffn
7150    
7151   getpeername   getpeername
7152  @deffn primitive getpeername sock  @deffn {Scheme Procedure} getpeername sock
7153    @deffnx {C Function} scm_getpeername (sock)
7154  Return the address that @var{sock}  Return the address that @var{sock}
7155  is connected to, in the same form as the object returned by  is connected to, in the same form as the object returned by
7156  @code{accept}.  On many systems the address of a socket in the  @code{accept}.  On many systems the address of a socket in the
# Line 6490  is connected to, in the same form as the Line 7158  is connected to, in the same form as the
7158  @end deffn  @end deffn
7159    
7160   recv!   recv!
7161  @deffn primitive recv! sock buf [flags]  @deffn {Scheme Procedure} recv! sock buf [flags]
7162    @deffnx {C Function} scm_recv (sock, buf, flags)
7163  Receive data from a socket port.  Receive data from a socket port.
7164  @var{sock} must already  @var{sock} must already
7165  be bound to the address from which data is to be received.  be bound to the address from which data is to be received.
# Line 6514  any unread buffered port data is ignored Line 7183  any unread buffered port data is ignored
7183  @end deffn  @end deffn
7184    
7185   send   send
7186  @deffn primitive send sock message [flags]  @deffn {Scheme Procedure} send sock message [flags]
7187    @deffnx {C Function} scm_send (sock, message, flags)
7188  Transmit the string @var{message} on a socket port @var{sock}.  Transmit the string @var{message} on a socket port @var{sock}.
7189  @var{sock} must already be bound to a destination address.  The  @var{sock} must already be bound to a destination address.  The
7190  value returned is the number of bytes transmitted --  value returned is the number of bytes transmitted --
# Line 6531  any unflushed buffered port data is igno Line 7201  any unflushed buffered port data is igno
7201  @end deffn  @end deffn
7202    
7203   recvfrom!   recvfrom!
7204  @deffn primitive recvfrom! sock str [flags [start [end]]]  @deffn {Scheme Procedure} recvfrom! sock str [flags [start [end]]]
7205    @deffnx {C Function} scm_recvfrom (sock, str, flags, start, end)
7206  Return data from the socket port @var{sock} and also  Return data from the socket port @var{sock} and also
7207  information about where the data was received from.  information about where the data was received from.
7208  @var{sock} must already be bound to the address from which  @var{sock} must already be bound to the address from which
# Line 6558  descriptor: any unread buffered port dat Line 7229  descriptor: any unread buffered port dat
7229  @end deffn  @end deffn
7230    
7231   sendto   sendto
7232  @deffn primitive sendto sock message fam address . args_and_flags  @deffn {Scheme Procedure} sendto sock message fam address . args_and_flags
7233    @deffnx {C Function} scm_sendto (sock, message, fam, address, args_and_flags)
7234  Transmit the string @var{message} on the socket port  Transmit the string @var{message} on the socket port
7235  @var{sock}.  The  @var{sock}.  The
7236  destination address is specified using the @var{fam},  destination address is specified using the @var{fam},
# Line 6578  Note that the data is written directly t Line 7250  Note that the data is written directly t
7250  file descriptor:  file descriptor:
7251  any unflushed buffered port data is ignored.  any unflushed buffered port data is ignored.
7252  @end deffn  @end deffn
7253    
7254     single-active-thread?
7255    @deffn {Scheme Procedure} single-active-thread?
7256    implemented by the C function "scm_single_thread_p"
7257    @end deffn
7258    
7259     yield
7260    @deffn {Scheme Procedure} yield
7261    implemented by the C function "scm_yield"
7262    @end deffn
7263    
7264     call-with-new-thread
7265    @deffn {Scheme Procedure} call-with-new-thread
7266    implemented by the C function "scm_call_with_new_thread"
7267    @end deffn
7268    
7269     join-thread
7270    @deffn {Scheme Procedure} join-thread
7271    implemented by the C function "scm_join_thread"
7272    @end deffn
7273    
7274     make-mutex
7275    @deffn {Scheme Procedure} make-mutex
7276    implemented by the C function "scm_make_mutex"
7277    @end deffn
7278    
7279     lock-mutex
7280    @deffn {Scheme Procedure} lock-mutex
7281    implemented by the C function "scm_lock_mutex"
7282    @end deffn
7283    
7284     unlock-mutex
7285    @deffn {Scheme Procedure} unlock-mutex
7286    implemented by the C function "scm_unlock_mutex"
7287    @end deffn
7288    
7289     make-condition-variable
7290    @deffn {Scheme Procedure} make-condition-variable
7291    implemented by the C function "scm_make_condition_variable"
7292    @end deffn
7293    
7294     wait-condition-variable
7295    @deffn {Scheme Procedure} wait-condition-variable
7296    implemented by the C function "scm_wait_condition_variable"
7297    @end deffn
7298    
7299     signal-condition-variable
7300    @deffn {Scheme Procedure} signal-condition-variable
7301    implemented by the C function "scm_signal_condition_variable"
7302    @end deffn

Legend:
Removed from v.1.7.4.1  
changed lines
  Added in v.1.7.4.2

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26