source: project/chicken/branches/chicken-3/chicken-primitive-object-inlines.scm @ 13178

Last change on this file since 13178 was 13178, checked in by Kon Lovett, 11 years ago

defaults.make : chking of svnrev sep from svnrev fil as a target
lolevel.scm : comment fix
runtime.c : use of C defines for platform info, reflow of some comments/code due to > 100 chars long, cl -> closure (like other procs), use of macros rather than open-coded block access, added return value testing for FreeLibrary? & shl_unlaod.
library.scm : refactored make-property-condition & condition-property-accessor so ##sy# routine available, make ##sys# routines for breakpoint condition, placed 'continuation, etc, on breakpoint condition & not exn.
chicken.h : use of C defines for platform info, added comments, C_CHAR_SHIFT.
posixunix.scm, posixwin.scm : added use of Unit ports
scheduler.scm : use of library breakpoint condition routines, placed 'continuation, etc, on breakpoint condition & not exn
srfi-18.scm : renamed some -inlines (match chicken-thread-object-inlines)

File size: 18.3 KB
Line 
1;;;; chicken-primitive-object-nlines.scm
2;;;; Kon Lovett, Jan '09
3;;;; (Was chicken-sys-macros.scm)
4
5; Usage
6;
7; (include "chicken-primitive-object-inlines")
8
9;; Notes
10;
11; Provides inlines & macros for primitive procedures. Use of these procedures
12; by non-core & non-core-extensions is highly suspect. Many of these routines
13; are unsafe.
14;
15; In fact, any use is suspect ;-)
16;
17; A ##core#Inline is just what it says - literal inclusion in the compiled C
18; code of the C macro/function and the arguments taken literally, i.e. as the
19; C_word value.
20;
21; These are much faster than a lambda, but very dangerous since the arguments and
22; the return value are not converted. The C code must perform any such conversions.
23;
24; ##core#inline cannot be used with a runtime C function which is coded in the
25;CPS style.
26;
27; A ##core#primitive creates a lambda for a C function which is coded in the
28; CPS style.
29;
30; These have a stereotypical argument list which begins the 3 arguments C_word
31; c, C_word closure, and C_word k. Any actual arguments follow.
32;
33; c - number of arguments, not including 'c', but including 'closure' & 'k'
34; closure - caller
35; k - continuation
36
37
38;;; Type Predicates
39
40;; Argument is a 'C_word'
41
42
43;; Immediate
44
45(define-inline (%immediate? ?x) (##core#inline "C_immp" x))
46
47
48;; Fixnum
49
50(define-inline (%fixnum? x) (##core#inline "C_fixnump" x))
51
52
53;; Character
54
55(define-inline (%char? x) (##core#inline "C_charp" x))
56
57
58;; Boolean
59
60(define-inline (%boolean? x) (##core#inline "C_booleanp" x))
61
62
63;; EOF
64
65(define-inline (%eof-object? x) (##core#inline "C_eofp" x))
66
67
68;; Null (the end-of-list value)
69
70(define-inline (%null? x) (##core#inline "C_i_nullp" x))
71
72
73;; Undefined (void)
74
75(define-inline (%undefined? x) (##core#inline "C_undefinedp" x))
76
77
78;; Unbound (the unbound value, not 'is a symbol unbound')
79
80(define-inline (%unbound? x) (##core#inline "C_unboundvaluep" x))
81
82
83;; Block (anything not immediate)
84
85(define-inline (%block? x) (##core#inline "C_blockp" x))
86
87
88;; Vector
89
90(define-inline (%vector-type? x) (##core#inline "C_vectorp" x))
91
92
93;; Bytevector (isa vector so be careful; refers to how allocated, not what stored)
94
95(define-inline (%bytevector-type? x) (##core#inline "C_bytevectorp" x))
96
97
98;; Pair
99
100(define-inline (%pair-type? x) (##core#inline "C_pairp" x))
101
102
103;; Bucket
104
105; A bucket is used by the runtime for the symbol-table. The bucket type is not
106; "seen" by Scheme code.
107
108
109;; Structure
110
111(define-inline (%structure-type? x) (##core#inline "C_structurep" x))
112
113
114;; Symbol
115
116(define-inline (%symbol-type? x) (##core#inline "C_symbolp" x))
117
118
119;; Byteblock
120
121(define-inline (%byteblock? x) (##core#inline "C_byteblockp" x))
122
123
124;; String
125
126(define-inline (%string-type? x) (##core#inline "C_stringp" x))
127
128
129;; Flonum
130
131(define-inline (%flonum-type? x) (##core#inline "C_flonump" x))
132
133
134;; Lambda-info
135
136(define-inline (%lambda-info-type? x) (##core#inline "C_lambdainfop" x))
137
138
139;; Special
140
141(define-inline (%special? x) (##core#inline "C_specialp" x))
142
143
144;; Closure
145
146(define-inline (%closure-type? x) (##core#inline "C_closurep" x))
147
148
149;; Port
150
151(define-inline (%port-type? x) (##core#inline "C_portp" x))
152
153
154;; Simple-pointer
155
156(define-inline (%simple-pointer-type? x) (##core#inline "C_pointerp" x))
157
158
159;; Tagged-Pointer
160
161(define-inline (%tagged-pointer-type? x) (##core#inline "C_taggedpointerp" x))
162
163
164;; Swig-Pointer
165
166(define-inline (%swig-pointer-type? x) (##core#inline "C_swigpointerp" x))
167
168
169;; Any-pointer
170
171(define-inline (%any-pointer-type? x) (##core#inline "C_anypointerp" x))
172
173
174;; Locative
175
176(define-inline (%locative-type? x) (##core#inline "C_locativep" x))
177
178
179;; Forwarded (block object moved to new address, forwarding pointer)
180
181(define-inline (%forwarded? x) (##core#inline "C_forwardedp" x))
182
183
184
185;;; Values
186
187
188
189;;; Operations
190
191(define-inline (%eq? x y) (##core#inline "C_eqp" x y))
192
193; (%peek-signed-integer BLOCK INDEX)
194;
195(define-inline %peek-signed-integer (##core#primitive "C_peek_signed_integer"))
196
197; (%peek-unsigned-integer BLOCK INDEX)
198;
199(define-inline %peek-unsigned-integer (##core#primitive "C_peek_unsigned_integer"))
200
201(define-inline (%poke-integer b i n) (##core#inline "C_poke_integer" b i n))
202
203
204;; Fixnum
205
206(define-inline (%fx+ x y) (##core#inline "C_fixnum_plus" x y))
207(define-inline (%fx- x y) (##core#inline "C_fixnum_difference" x y))
208(define-inline (%fx* x y) (##core#inline "C_fixnum_times" x y))
209(define-inline (%fx= x y) (%eq? x y))
210(define-inline (%fx> x y) (##core#inline "C_fixnum_greaterp" x y))
211(define-inline (%fx< x y) (##core#inline "C_fixnum_lessp" x y))
212(define-inline (%fx>= x y) (##core#inline "C_fixnum_greater_or_equal_p" x y))
213(define-inline (%fx<= x y) (##core#inline "C_fixnum_less_or_equal_p" x y))
214(define-inline (%fxmin x y) (##core#inline "C_i_fixnum_min" x y))
215(define-inline (%fxmax x y) (##core#inline "C_i_fixnum_max" x y))
216(define-inline (%fxneg x) (##core#inline "C_fixnum_negate" x))
217(define-inline (%fxand x y) (##core#inline "C_fixnum_and" x y))
218(define-inline (%fxior x y) (##core#inline "C_fixnum_or" x y))
219(define-inline (%fxxor x y) (##core#inline "C_fixnum_xor" x y))
220(define-inline (%fxnot x) (##core#inline "C_fixnum_not" x))
221(define-inline (%fxshl x y) (##core#inline "C_fixnum_shift_left" x y))
222(define-inline (%fxshr x y) (##core#inline "C_fixnum_shift_right" x y))
223
224; These are very unsafe, no check for division-by-zero
225(define-inline (%fx/ x y) (##core#inline "C_fixnum_divide" x y))
226(define-inline (%fxmod x y) (##core#inline "C_fixnum_modulo" x y))
227
228
229;;; Block
230
231
232;; Size of object in units of sub-object.
233
234; byteblock is # of bytes, otherwise # of words.
235;
236(define-inline (%block-size x) (##core#inline "C_block_size" x))
237
238
239;; (%block-allocate size byteblock? fill aligned-8-byte-boundry?)
240;
241; Creates & returns a string when 'byteblock?', otherwise a vector.
242;
243; Size is # of bytes when 'byteblock?', otherwise # of words.
244; Fill is a character when 'byteblock?', otherwise any.
245;
246(define-inline %block-allocate (##core#primitive "C_allocate_vector"))
247
248(define-inline (%block-address x) (##core#inline_allocate ("C_block_address" 4) x))
249
250
251;; Byte access
252
253(define-inline (%make-block-byte n f a?) (%block-allocate n #t f a?))
254
255(define-inline (%block-byte-ref x i) (##core#inline "C_subbyte" x i))
256(define-inline (%block-byte-set! x i n) (##core#inline "C_setsubbyte" x i n))
257
258
259;; Word access
260
261(define-inline (%make-block-word n f a?) (%block-allocate n #f f a?))
262
263(define-inline (%block-word-ref x i) (##core#inline "C_slot" x i))
264
265(define-inline (%block-word-set! x i y) (##core#inline "C_i_setslot" x i y))
266(define-inline (%block-word-set!/immediate x i y) (##core#inline "C_i_set_i_slot" x i y))
267
268
269
270;;;
271
272
273;; Generic-byteblock
274
275; generic-byteblock isa string, flonum, or lambda-info
276;
277(define-inline (%generic-byteblock? x) (and (%block? x) (%byteblock? x)))
278
279
280;; String (byteblock)
281
282(define-inline (%make-string size fill) (%make-block-byte size fill #f))
283
284(define-inline (%string? x) (and (%block? x) (%string-type? x)))
285
286(define-inline (%string-ref s i) (##core#inline "C_subchar" s i))
287
288(define-inline (%string-set! s i c) (##core#inline "C_setsubchar" s i c))
289
290(define-inline (%string-length s) (%block-size s))
291
292;%bytevector->string - see Bytevector
293
294
295;; Flonum (byteblock)
296
297(define-inline (%flonum? x) (and (%block? x) (%flonum-type? x)))
298
299
300;; Lambda-info (byteblock)
301
302(define-inline (%lambda-info? x) (and (%block? x) (%lambda-info-type? x)))
303
304
305;; Generic-vector
306
307; generic-vector isa vector, pair, structure, symbol, or keyword
308;
309(define-inline (%generic-vector? x)
310  (and (%block? x)
311       (not (or (%special? x) (%byteblock? x)))) )
312
313
314;; Vector (wordblock)
315
316(define-inline (%make-vector size fill) (%make-word-block size fill #f))
317
318(define-inline (%vector? x) (and (%block? x) (%vector-type? x)))
319
320(define-inline (%vector-ref v i) (%block-word-ref v i))
321
322(define-inline (%vector-set! v i x) (%block-word-set! v i x))
323(define-inline (%vector-set!/immediate v i x) (%block-word-set!/immediate v i x))
324
325(define-inline (%vector-length v) (%block-size v))
326
327
328;; Bytevector (wordblock, but byte referenced)
329
330(define-inline (%make-bytevector sz)
331  (let ([bv (%make-string sz #f #t)])
332    (##core#inline "C_string_to_bytevector" bv)
333    bv ) )
334
335(define-inline (%bytevector? x) (and (%block? x) (%bytevector-type? x)))
336
337(define-inline (%bytevector-ref bv i) (%block-byte-ref bv i))
338
339(define-inline (%bytevector-set! bv i x) (%block-byte-set! bv i x))
340
341(define-inline (%bytevector-length bv) (%block-size bv))
342
343(define-inline (%bytevector=? v1 v2)
344  (let ([ln (%bytevector-length v1)])
345    (and (%eq? n %bytevector-length v2))
346         (fx=? 0 (##core#inline "C_string_compare" v1 v2 n)) ) )
347
348(define-inline (%string->bytevector s)
349  (let* ([n (%string-length s)]
350               [bv (%make-bytevector sz)] )
351    (##core#inline "C_copy_memory" bv s n) 
352    bv ) )
353
354(define-inline (%bytevector->string bv)
355  (let* ([n (%bytevector-length bv)]
356               [s (%make-string n #\space)] )
357    (##core#inline "C_copy_memory" s bv n) 
358    s ) )
359
360
361;; Blob (isa bytevector w/o accessors)
362
363(define-inline (%make-blob sz) (%make-bytevector sz))
364
365(define-inline (%blob? x) (%bytevector? x))
366
367(define-inline (%blob-size b) (%bytevector-length b))
368
369(define-inline (%blob=? b1 b2) (%bytevector=? b1 b2))
370
371(define-inline (%string->blob s) (%string->bytevector s))
372
373(define-inline (%blob->string bv) (%bytevector->string bv))
374
375
376;; Pair (wordblock)
377
378(define-inline (%pair? x) (and (%block? x) (%pair-type? x)))
379
380(define-inline (%list? x) (or (%null? x) (%pair? x)))
381
382(define-inline (%cons x y) (##core#inline_allocate ("C_a_i_cons" 3) x y) )
383
384(define-inline (%length l) (##core#inline "C_i_length" l))
385
386(define-inline (%car p) (%block-word-ref p 0))
387(define-inline (%cdr p) (%block-word-ref p 1))
388
389(define-inline (%caar p) (%car (%car p)))
390(define-inline (%cadr p) (%car (%cdr p)))
391(define-inline (%cdar p) (%cdr (%car p)))
392(define-inline (%cddr p) (%cdr (%cdr p)))
393
394(define-inline (%caaar p) (%car (%caar p)))
395(define-inline (%caadr p) (%car (%cadr p)))
396(define-inline (%cadar p) (%car (%cdar p)))
397(define-inline (%caddr p) (%car (%cddr p)))
398(define-inline (%cdaar p) (%cdr (%caar p)))
399(define-inline (%cdadr p) (%cdr (%cadr p)))
400(define-inline (%cddar p) (%cdr (%cdar p)))
401(define-inline (%cdddr p) (%cdr (%cddr p)))
402
403(define-inline (%set-car! p x) (%block-word-set! p 0 x))
404(define-inline (%set-cdr! p x) (%block-word-set! p 1 x))
405(define-inline (%set-car/immediate! p x) (%block-word-set!/immediate p 0 x))
406(define-inline (%set-cdr/immediate! p x) (%block-word-set!/immediate p 1 x))
407
408;; l0 must be a proper-list
409
410(define-inline (%list-ref l0 i0)
411  (let loop ([l l0] [i i0])
412    (cond [(null? l)
413           '() ]
414                [(%fx= 0 i)
415                 (%car l) ]
416                [else
417                 (loop (%cdr l) (%fx- i 1)) ] ) ) )
418
419; l0 cannot be null
420(define-inline (%last-pair l0)
421  (do ([l l0 (%cdr l)])
422      [(%null? (%cdr l)) l]) )
423
424(define-inline (%delq! x l0)
425  (let loop ([l l0] [pp #f])
426    (cond [(null? l)
427           l0 ]
428                [(%eq? x (%car l))
429                 (cond [pp
430                        (%set-cdr! pp (%cdr l))
431                        l0 ]
432                       [else
433                        (%cdr l) ] ) ]
434                [else
435                 (loop (%cdr l) l) ] ) ) )
436
437;; These are safe
438
439(define-inline (%memq x l) (##core#inline "C_i_memq" x l))
440(define-inline (%memv x l) (##core#inline "C_i_memv" x l))
441(define-inline (%member x l) (##core#inline "C_i_member" x l))
442
443(define-inline (%assq x l) (##core#inline "C_i_assq" x l))
444(define-inline (%assv x l) (##core#inline "C_i_assv" x l))
445(define-inline (%assoc x l) (##core#inline "C_i_assoc" x l))
446
447
448;; Structure (wordblock)
449
450;; (%make-structure tag fill)
451;;
452
453; (%make-structure TAG [SLOT ...])
454(define-inline %make-structure (##core#primitive "C_make_structure"))
455
456(define-inline (%generic-structure? x) (and (%block? x) (%structure-type? x)))
457
458(define-inline (%structure-instance? x s) (##core#inline "C_i_structurep" x s))
459
460(cond-expand
461  [hygienic-macros
462    (define-syntax %structure?
463      (syntax-rules ()
464        [(_ ?x)     (%generic-structure? ?x)]
465        [(_ ?x ?t)  (%structure-instance? ?x ?t)] ) ) ]
466  [else
467    (define-macro (%structure? ?x . ?t)
468      (if (%null? ?t)
469          `(%generic-structure? ,?x)
470          `(%structure-instance? ,?x ,(car ?t)) ) ) ] )
471
472(define-inline (%structure-ref r i) (%block-word-ref r i))
473
474(define-inline (%structure-set! r i x) (%block-word-set! r i x))
475(define-inline (%structure-set!/immediate r i x) (%block-word-set!/immediate r i x))
476
477(define-inline (%structure-length r) (%block-size r))
478
479(define-inline (%structure-tag r) (%block-word-ref r 0))
480
481
482;; Special-block (wordblock)
483
484(define-inline (%special-block? x) (and (%block? x) (%special? x)))
485
486
487;; Port (wordblock)
488
489; Port layout:
490;
491; 0       FP (special - C FILE *)
492; 1       input/output (bool)
493; 2       class (vector, see Port-class)
494; 3       name (string)
495; 4       row (fixnum)
496; 5       col (fixnum)
497; 6       EOF (bool)
498; 7       type (symbol)
499; 8       closed (bool)
500; 9       data
501; 10-15  reserved, port class specific
502
503; port is 16 slots + a block-header word
504;
505;(define-inline (%make-port n) (##core#inline_allocate ("C_a_i_port" 17)))
506
507(define-inline (%port? x) (and (%block? x) (%port-type? x)))
508
509(define-inline (%port-filep port) (%peek-unsigned-integer port 0))
510(define-inline (%port-input-mode? port) (%block-word-ref? port 1))
511(define-inline (%port-class port) (%block-word-ref? port 2))
512(define-inline (%port-name port) (%block-word-ref? port 3))
513(define-inline (%port-row port) (%block-word-ref? port 4))
514(define-inline (%port-column port) (%block-word-ref? port 5))
515(define-inline (%port-eof? port) (%block-word-ref? port 6))
516(define-inline (%port-type port) (%block-word-ref? port 7))
517(define-inline (%port-closed? port) (%block-word-ref? port 8))
518(define-inline (%port-data port) (%block-word-ref? port 9))
519
520(define-inline (%port-filep-set! port fp) (%poke-integer port 0 fp))
521(define-inline (%port-input-mode-set! port f) (%block-word-set!/immediate port 1 f))
522(define-inline (%port-class port v) (%block-word-set! port 2 v))
523(define-inline (%port-name-set! port s) (%block-word-set! port 3 s))
524(define-inline (%port-row-set! port n) (%block-word-set!/immediate port 4 n))
525(define-inline (%port-column-set! port n) (%block-word-set!/immediate port 5 n))
526(define-inline (%port-eof-set! port f) (%block-word-set!/immediate port 6 f))
527(define-inline (%port-type-set! port s) (%block-word-set! port 7 s))
528(define-inline (%port-closed-set! port f) (%block-word-set!/immediate port 8 f))
529(define-inline (%port-data-set! port port) (%block-word-set! port 9 x))
530
531; Port-class layout     
532;
533; 0       (read-char PORT) -> CHAR | EOF
534; 1       (peek-char PORT) -> CHAR | EOF
535; 2       (write-char PORT CHAR)
536; 3       (write-string PORT STRING)
537; 4       (close PORT)
538; 5       (flush-output PORT)
539; 6       (char-ready? PORT) -> BOOL
540; 7       (read-string! PORT COUNT STRING START) -> COUNT'
541; 8       (read-line PORT LIMIT) -> STRING | EOF
542
543
544;; Closure (wordblock)
545
546(define-inline (%closure? x) (and (%block? x) (%closure-type? x)))
547
548(define-inline (%closure-size c) (%block-size? c))
549
550(define-inline (%vector->closure! v a)
551  (##core#inline "C_vector_to_closure" v)
552  (##core#inline "C_update_pointer" a v) )
553
554
555;; Symbol (wordblock)
556
557(define-inline (%symbol? x) (and (%block? x) (%symbol-type? x)))
558
559(define-inline (%symbol-binding s) (%block-word-ref s 0))
560(define-inline (%symbol-string s) (%block-word-ref s 1))
561(define-inline (%symbol-bucket s) (%block-word-ref s 2))
562
563(define-inline %string->symbol-interned (##core#primitive "C_string_to_symbol"))
564
565;(define-inline (%symbol-intern! s) (%string->symbol (%symbol-string s)))
566
567(define-inline (%symbol-interned? x) (##core#inline "C_lookup_symbol" x))
568
569(define-inline (%symbol-bound? s) (##core#inline "C_boundp" s))
570
571
572;; Keyword (wordblock)
573
574(define-inline (%keyword? x)
575  (and (%symbol? x)
576       (%eq? 0 (%block-byte-ref (%symbol-string x) 0)) ) )
577
578
579;; Locative (wordblock)
580
581(define-inline (%make-locative typ obj idx weak?)
582  (##core#inline_allocate ("C_a_i_make_locative" 5) typ obj idx weak?))
583
584(define-inline (%locative? x) (and (%block? x) (%locative-type? x)))
585
586; Locative layout:
587;
588; 0     Object-address + byte-offset (address)
589; 1     Byte-offset (fixnum)
590; 2     Type (fixnum)
591;         0     vector or pair          (C_SLOT_LOCATIVE)
592;         1     string                  (C_CHAR_LOCATIVE)
593;         2     u8vector                (C_U8_LOCATIVE)
594;         3     s8vector or bytevector  (C_U8_LOCATIVE)
595;         4     u16vector                           (C_U16_LOCATIVE)
596;         5     s16vector                           (C_S16_LOCATIVE)
597;         6     u32vector                           (C_U32_LOCATIVE)
598;         7     s32vector                           (C_S32_LOCATIVE)
599;         8     f32vector                           (C_F32_LOCATIVE)
600;         9     f64vector                           (C_F64_LOCATIVE)
601; 3     Object or #f, if weak (C_word)
602
603;%locative-address - see Pointer
604(define-inline (%locative-offset lv) (%block-word-ref lv 1))
605(define-inline (%locative-type lv) (%block-word-ref lv 2))
606(define-inline (%locative-weak? lv) (not (%block-word-ref lv 3)))
607(define-inline (%locative-object lv) (%block-word-ref lv 3))
608
609
610;; Pointer (wordblock)
611
612(define-inline (%pointer? x) (and (%block? x) (%any-pointer-type? x)))
613
614; simple-pointer, tagged-pointer, swig-pointer, locative
615(define-inline (%generic-pointer? x) (or (%pointer? x) (%locative? x)))
616
617; simple-pointer, tagged-pointer, swig-pointer, locative, closure, port, symbol, keyword
618(define-inline (%pointer-like? x) (%special-block? x))
619
620; These operate on pointer-like objects
621
622(define-inline (%pointer-ref ptr) (%block-word-ref ptr 0))
623(define-inline (%pointer-set! ptr y) (%block-word-set! ptr 0 y))
624
625(define-inline (%peek-byte ptr i) (##core#inline "C_peek_byte" ptr i))
626
627(define-inline (%pointer-null? ptr) (##core#inline "C_null_pointerp" ptr))
628
629(define-inline (%pointer->address ptr)
630  ; Pack pointer address value into Chicken words; '4' is platform dependent!
631  (##core#inline_allocate ("C_block_address" 4) (%generic-pointer-ref x)) )
632
633(define-inline (%locative-address lv) (%pointer->address lv))
634
635
636;; Simple-pointer (wordblock)
637
638(define-inline %make-simple-pointer (##core#primitive "C_make_pointer"))
639
640(define-inline (%simple-pointer? x) (and (%block? x) (%simple-pointer-type? x)))
641
642(define-inline (%make-pointer-null)
643  (let ([ptr (%make-simple-pointer)])
644    (##core#inline "C_update_pointer" 0 ptr)
645    ptr ) )
646
647(define-inline (%address->pointer a)
648  (let ([ptr (%make-simple-pointer)])
649    (##core#inline "C_update_pointer" a ptr)
650    ptr ) )
651
652(define-inline (%make-pointer-block b)
653  (let ([ptr (%make-simple-pointer)])
654    (##core#inline "C_pointer_to_block" ptr b)
655    ptr ) )
656
657
658;; Tagged-pointer (wordblock)
659
660(define-inline %make-tagged-pointer (##core#primitive "C_make_tagged_pointer"))
661
662(define-inline (%tagged-pointer? x) (and (%block? x) (%tagged-pointer-type? x)))
663
664
665;; Swig-pointer (wordblock)
666
667(define-inline (%swig-pointer? x) (and (%block? x) (%swig-pointer-type? x)))
668
669
670
671;;; Values
672
673
674
675;;; Operations
676
677
678;; Random
679
680(define-inline (%random-fixnum x) (##core#inline "C_random_fixnum" x))
Note: See TracBrowser for help on using the repository browser.