← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/ecl/intrepid

« back to all changes in this revision

Viewing changes to src/cmp/sysfun.lsp

  • Committer: Bazaar Package Importer
  • Author(s): Peter Van Eynde
  • Date: 2007-04-09 11:51:51 UTC
  • mfrom: (1.1.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20070409115151-ql8cr0kalzx1jmla
Tags: 0.9i-20070324-2
Upload to unstable. 

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/cmp/sysfun.lsp
97
97
;;; ALL FUNCTION DECLARATIONS AND INLINE FORMS
98
98
;;;
99
99
 
100
 
(proclaim-function si:list-nth (*) t)
101
100
(proclaim-function si:make-pure-array (*) array)
102
101
(proclaim-function si:make-vector (*) vector)
103
102
(proclaim-function aref (array *) t :no-side-effects t)
104
103
(def-inline aref :unsafe (t t t) t
105
 
 "@0;aref(#0,fix(#1)*(#0)->array.dims[1]+fix(#2))")
 
104
 "@0;ecl_aref(#0,fix(#1)*(#0)->array.dims[1]+fix(#2))")
106
105
(def-inline aref :unsafe ((array t) t t) t
107
106
 "@0;(#0)->array.self.t[fix(#1)*(#0)->array.dims[1]+fix(#2)]")
108
107
(def-inline aref :unsafe ((array bit) t t) :fixnum
109
 
 "@0;aref_bv(#0,fix(#1)*(#0)->array.dims[1]+fix(#2))")
 
108
 "@0;ecl_aref_bv(#0,fix(#1)*(#0)->array.dims[1]+fix(#2))")
110
109
(def-inline aref :unsafe ((array t) fixnum fixnum) t
111
110
 "@0;(#0)->array.self.t[#1*(#0)->array.dims[1]+#2]")
112
111
(def-inline aref :unsafe ((array bit) fixnum fixnum) :fixnum
113
 
 "@0;aref_bv(#0,(#1)*(#0)->array.dims[1]+#2)")
 
112
 "@0;ecl_aref_bv(#0,(#1)*(#0)->array.dims[1]+#2)")
114
113
(def-inline aref :unsafe ((array base-char) fixnum fixnum) :char
115
114
 "@0;(#0)->base_string.self[#1*(#0)->array.dims[1]+#2]")
116
 
(def-inline aref :unsafe ((array long-float) fixnum fixnum) :double
117
 
 "@0;(#0)->array.self.lf[#1*(#0)->array.dims[1]+#2]")
118
 
(def-inline aref :unsafe ((array short-float) fixnum fixnum) :float
 
115
(def-inline aref :unsafe ((array double-float) fixnum fixnum) :double
 
116
 "@0;(#0)->array.self.df[#1*(#0)->array.dims[1]+#2]")
 
117
(def-inline aref :unsafe ((array single-float) fixnum fixnum) :float
119
118
 "@0;(#0)->array.self.sf[#1*(#0)->array.dims[1]+#2]")
120
119
(def-inline aref :unsafe ((array fixnum) fixnum fixnum) :fixnum
121
120
 "@0;(#0)->array.self.fix[#1*(#0)->array.dims[1]+#2]")
122
 
(def-inline aref :always (t t) t "aref1(#0,fixint(#1))")
123
 
(def-inline aref :always (t fixnum) t "aref1(#0,#1)")
124
 
(def-inline aref :unsafe (t t) t "aref1(#0,fix(#1))")
125
 
(def-inline aref :unsafe (t fixnum) t "aref1(#0,#1)")
126
 
(def-inline aref :unsafe ((array bit) t) :fixnum "aref_bv(#0,fix(#1))")
127
 
(def-inline aref :unsafe ((array bit) fixnum) :fixnum "aref_bv(#0,#1)")
 
121
(def-inline aref :always (t t) t "ecl_aref1(#0,fixint(#1))")
 
122
(def-inline aref :always (t fixnum) t "ecl_aref1(#0,#1)")
 
123
(def-inline aref :unsafe (t t) t "ecl_aref1(#0,fix(#1))")
 
124
(def-inline aref :unsafe (t fixnum) t "ecl_aref1(#0,#1)")
 
125
(def-inline aref :unsafe ((array bit) t) :fixnum "ecl_aref_bv(#0,fix(#1))")
 
126
(def-inline aref :unsafe ((array bit) fixnum) :fixnum "ecl_aref_bv(#0,#1)")
128
127
(def-inline aref :unsafe ((array base-char) fixnum) t
129
128
 "CODE_CHAR((#0)->base_string.self[#1])")
130
129
#+unicode
131
130
(def-inline aref :unsafe ((array character) fixnum fixnum) t
132
131
 "@0;(#0)->string.self[#1*(#0)->array.dims[1]+#2]")
133
 
(def-inline aref :unsafe ((array long-float) fixnum) t
134
 
 "make_longfloat((#0)->array.self.lf[#1])")
135
 
(def-inline aref :unsafe ((array short-float) fixnum) t
136
 
 "make_shortfloat((#0)->array.self.sf[#1])")
 
132
(def-inline aref :unsafe ((array double-float) fixnum) t
 
133
 "ecl_make_doublefloat((#0)->array.self.df[#1])")
 
134
(def-inline aref :unsafe ((array single-float) fixnum) t
 
135
 "ecl_make_singlefloat((#0)->array.self.sf[#1])")
137
136
(def-inline aref :unsafe ((array fixnum) fixnum) t
138
137
 "MAKE_FIXNUM((#0)->array.self.fix[#1])")
139
138
(def-inline aref :unsafe ((array base-char) fixnum) :fixnum
143
142
 "CHAR_CODE((#0)->base_string.self[#1])")
144
143
(def-inline aref :unsafe ((array base-char) fixnum) :char
145
144
 "(#0)->base_string.self[#1]")
146
 
(def-inline aref :unsafe ((array long-float) fixnum) :double
147
 
 "(#0)->array.self.lf[#1]")
148
 
(def-inline aref :unsafe ((array short-float) fixnum) :float
 
145
(def-inline aref :unsafe ((array double-float) fixnum) :double
 
146
 "(#0)->array.self.df[#1]")
 
147
(def-inline aref :unsafe ((array single-float) fixnum) :float
149
148
 "(#0)->array.self.sf[#1]")
150
149
(def-inline aref :unsafe ((array fixnum) fixnum) :fixnum
151
150
 "(#0)->array.self.fix[#1]")
152
151
 
153
152
(proclaim-function si:aset (t array *) nil)
154
153
(def-inline si:aset :unsafe (t t t t) t
155
 
 "@0;aset(#1,fix(#2)*(#1)->array.dims[1]+fix(#3),#0)")
 
154
 "@0;ecl_aset(#1,fix(#2)*(#1)->array.dims[1]+fix(#3),#0)")
156
155
(def-inline si:aset :unsafe (t t fixnum fixnum) t
157
 
 "@0;aset(#1,(#2)*(#1)->array.dims[1]+(#3),#0)")
 
156
 "@0;ecl_aset(#1,(#2)*(#1)->array.dims[1]+(#3),#0)")
158
157
(def-inline si:aset :unsafe (t (array t) fixnum fixnum) t
159
158
 "@1;(#1)->array.self.t[#2*(#1)->array.dims[1]+#3]= #0")
160
159
(def-inline si:aset :unsafe (t (array bit) fixnum fixnum) :fixnum
161
 
 "@0;aset_bv(#1,(#2)*(#1)->array.dims[1]+(#3),fix(#0))")
162
 
(def-inline si:aset :unsafe (character (array base-char) fixnum fixnum) :char
 
160
 "@0;ecl_aset_bv(#1,(#2)*(#1)->array.dims[1]+(#3),fix(#0))")
 
161
(def-inline si:aset :unsafe (base-char (array base-char) fixnum fixnum) :char
163
162
 "@1;(#1)->base_string.self[#2*(#1)->array.dims[1]+#3]= #0")
164
 
(def-inline si:aset :unsafe (long-float (array long-float) fixnum fixnum)
165
 
 :double "@1;(#1)->array.self.lf[#2*(#1)->array.dims[1]+#3]= #0")
166
 
(def-inline si:aset :unsafe (short-float (array short-float) fixnum fixnum)
 
163
(def-inline si:aset :unsafe (double-float (array double-float) fixnum fixnum)
 
164
 :double "@1;(#1)->array.self.df[#2*(#1)->array.dims[1]+#3]= #0")
 
165
(def-inline si:aset :unsafe (single-float (array single-float) fixnum fixnum)
167
166
 :float "@1;(#1)->array.self.sf[#2*(#1)->array.dims[1]+#3]= #0")
168
167
(def-inline si:aset :unsafe (fixnum (array fixnum) fixnum fixnum) :fixnum
169
168
 "@1;(#1)->array.self.fix[#2*(#1)->array.dims[1]+#3]= #0")
170
169
(def-inline si:aset :unsafe (fixnum (array bit) fixnum fixnum) :fixnum
171
 
 "@0;aset_bv(#1,(#2)*(#1)->array.dims[1]+(#3),#0)")
172
 
(def-inline si:aset :always (t t t) t "aset1(#1,fixint(#2),#0)")
173
 
(def-inline si:aset :always (t t fixnum) t "aset1(#1,#2,#0)")
174
 
(def-inline si:aset :unsafe (t t t) t "aset1(#1,fix(#2),#0)")
 
170
 "@0;ecl_aset_bv(#1,(#2)*(#1)->array.dims[1]+(#3),#0)")
 
171
(def-inline si:aset :always (t t t) t "ecl_aset1(#1,fixint(#2),#0)")
 
172
(def-inline si:aset :always (t t fixnum) t "ecl_aset1(#1,#2,#0)")
 
173
(def-inline si:aset :unsafe (t t t) t "ecl_aset1(#1,fix(#2),#0)")
175
174
(def-inline si:aset :unsafe (t (array t) fixnum) t
176
175
 "(#1)->vector.self.t[#2]= #0")
177
176
(def-inline si:aset :unsafe (t (array bit) fixnum) :fixnum
178
 
 "aset_bv(#1,#2,fix(#0))")
179
 
(def-inline si:aset :unsafe (character (array base-char) fixnum) :char
 
177
 "ecl_aset_bv(#1,#2,fix(#0))")
 
178
(def-inline si:aset :unsafe (base-char (array base-char) fixnum) :char
180
179
 "(#1)->base_string.self[#2]= #0")
181
180
#+unicode
182
181
(def-inline si:aset :unsafe (character (array character) fixnum) t
183
182
 "(#1)->string.self[#2]= #0")
184
 
(def-inline si:aset :unsafe (long-float (array long-float) fixnum) :double
185
 
 "(#1)->array.self.lf[#2]= #0")
186
 
(def-inline si:aset :unsafe (short-float (array short-float) fixnum) :float
 
183
(def-inline si:aset :unsafe (double-float (array double-float) fixnum) :double
 
184
 "(#1)->array.self.df[#2]= #0")
 
185
(def-inline si:aset :unsafe (single-float (array single-float) fixnum) :float
187
186
 "(#1)->array.self.sf[#2]= #0")
188
187
(def-inline si:aset :unsafe (fixnum (array fixnum) fixnum) :fixnum
189
188
 "(#1)->array.self.fix[#2]= #0")
190
189
(def-inline si:aset :unsafe (fixnum (array bit) fixnum) :fixnum
191
 
 "aset_bv(#1,#2,#0)")
 
190
 "ecl_aset_bv(#1,#2,#0)")
192
191
 
193
192
(proclaim-function row-major-aref (array fixnum) t :no-side-effects t)
194
 
(def-inline row-major-aref :always (array fixnum) t "aref(#0,#1)")
 
193
(def-inline row-major-aref :always (array fixnum) t "ecl_aref(#0,#1)")
195
194
 
196
195
(proclaim-function si:row-major-aset (array fixnum t) t)
197
 
(def-inline si:row-major-aset :always (array fixnum t) t "aset(#0,#1,#2)")
 
196
(def-inline si:row-major-aset :always (array fixnum t) t "ecl_aset(#0,#1,#2)")
198
197
 
199
198
(proclaim-function array-element-type (array) t)
200
199
(proclaim-function array-rank (array) fixnum)
205
204
(proclaim-function adjustable-array-p (array) t :predicate t)
206
205
(proclaim-function array-displacement (array) (values t fixnum) :predicate t)
207
206
(proclaim-function svref (simple-vector fixnum) t :no-side-effects t)
208
 
(def-inline svref :always (t t) t "aref1(#0,fixint(#1))")
209
 
(def-inline svref :always (t fixnum) t "aref1(#0,#1)")
 
207
(def-inline svref :always (t t) t "ecl_aref1(#0,fixint(#1))")
 
208
(def-inline svref :always (t fixnum) t "ecl_aref1(#0,#1)")
210
209
(def-inline svref :unsafe (t t) t "(#0)->vector.self.t[fix(#1)]")
211
210
(def-inline svref :unsafe (t fixnum) t "(#0)->vector.self.t[#1]")
212
211
 
213
212
(proclaim-function si:svset (simple-vector fixnum t) t)
214
 
(def-inline si:svset :always (t t t) t "aset1(#0,fixint(#1),#2)")
215
 
(def-inline si:svset :always (t fixnum t) t "aset1(#0,#1,#2)")
 
213
(def-inline si:svset :always (t t t) t "ecl_aset1(#0,fixint(#1),#2)")
 
214
(def-inline si:svset :always (t fixnum t) t "ecl_aset1(#0,#1,#2)")
216
215
(def-inline si:svset :unsafe (t t t) t "((#0)->vector.self.t[fix(#1)]=(#2))")
217
216
(def-inline si:svset :unsafe (t fixnum t) t "(#0)->vector.self.t[#1]= #2")
218
217
 
241
240
;; file character.d
242
241
 
243
242
(proclaim-function standard-char-p (character) t :predicate t)
 
243
(def-inline standard-char-p :always (character) :bool "ecl_standard_char_p(#0)")
 
244
 
244
245
(proclaim-function graphic-char-p (character) t :predicate t)
 
246
(def-inline graphic-char-p :always (character) :bool "ecl_graphic_char_p(#0)")
 
247
 
245
248
(proclaim-function alpha-char-p (character) t :predicate t :no-side-effects t)
246
 
(def-inline alpha-char-p :always (character) :bool "isalpha(#0)")
 
249
(def-inline alpha-char-p :always (character) :bool "ecl_alpha_char_p(#0)")
247
250
 
248
251
(proclaim-function upper-case-p (character) t :predicate t :no-side-effects t)
249
 
(def-inline upper-case-p :always (character) :bool "isupper(#0)")
 
252
(def-inline upper-case-p :always (character) :bool "ecl_upper_case_p(#0)")
250
253
 
251
254
(proclaim-function lower-case-p (character) t :predicate t :no-side-effects t)
252
 
(def-inline lower-case-p :always (character) :bool "islower(#0)")
 
255
(def-inline lower-case-p :always (character) :bool "ecl_lower_case_p(#0)")
253
256
 
254
257
(proclaim-function both-case-p (character) t :predicate t :no-side-effects t)
255
 
(def-inline both-case-p :always (character) :bool "(islower(#0)||isupper(#0))")
 
258
(def-inline both-case-p :always (character) :bool "ecl_both_case_p(#0)")
256
259
 
257
260
(proclaim-function digit-char-p (character *) t :no-side-effects t)
258
261
(def-inline digit-char-p :always (character) :bool
264
267
(proclaim-function character (t) character)
265
268
(proclaim-function char= (character *) t :predicate t :no-side-effects t)
266
269
(def-inline char= :always (character character) :bool "(#0)==(#1)")
267
 
(def-inline char= :always (t t) :bool "char_code(#0)==char_code(#1)")
 
270
(def-inline char= :always (t t) :bool "ecl_char_code(#0)==ecl_char_code(#1)")
268
271
 
269
272
(proclaim-function char/= (character *) t :predicate t :no-side-effects t)
270
273
(def-inline char/= :always (character character) :bool "(#0)!=(#1)")
271
 
(def-inline char/= :always (t t) :bool "char_code(#0)!=char_code(#1)")
 
274
(def-inline char/= :always (t t) :bool "ecl_char_code(#0)!=ecl_char_code(#1)")
272
275
 
273
276
(proclaim-function char< (character *) t :predicate t :no-side-effects t)
274
277
(def-inline char< :always (character character) :bool "(#0)<(#1)")
296
299
(def-inline code-char :always (fixnum) :char "#0")
297
300
 
298
301
(proclaim-function char-upcase (character) character :no-side-effects t)
299
 
(def-inline char-upcase :always (character) :char "toupper(#0)")
 
302
(def-inline char-upcase :always (base-char) :char "toupper(#0)")
300
303
 
301
304
(proclaim-function char-downcase (character) character :no-side-effects t)
302
 
(def-inline char-downcase :always (character) :char "tolower(#0)")
 
305
(def-inline char-downcase :always (base-char) :char "tolower(#0)")
303
306
 
304
307
(proclaim-function digit-char (fixnum *) (or character null))
305
308
(proclaim-function char-int (character) fixnum :no-side-effects t)
407
410
(proclaim-function remhash (t t) t)
408
411
(proclaim-function maphash (t t) t)
409
412
(proclaim-function clrhash (t) t)
410
 
(proclaim-function hash-table-count (t) t)
 
413
(proclaim-function hash-table-count (t) si::index)
411
414
(proclaim-function sxhash (t) fixnum)
412
415
(proclaim-function si:hash-set (*) t)
413
416
 
538
541
 
539
542
(proclaim-function tree-equal (t t *) t :predicate t)
540
543
(proclaim-function endp (list) t :predicate t :no-side-effects t)
541
 
(def-inline endp :safe (t) :bool "endp(#0)")
 
544
(def-inline endp :safe (t) :bool "ecl_endp(#0)")
542
545
(def-inline endp :unsafe (t) :bool "#0==Cnil")
543
546
 
544
547
(proclaim-function list-length (list) (or nil (integer 0 *)))
545
548
(proclaim-function nth (integer list) t :no-side-effects t)
546
 
(def-inline nth :always (t t) t "nth(fixint(#0),#1)")
547
 
(def-inline nth :always (fixnum t) t "nth(#0,#1)")
548
 
(def-inline nth :unsafe (t t) t "nth(fix(#0),#1)")
549
 
(def-inline nth :unsafe (fixnum t) t "nth(#0,#1)")
 
549
(def-inline nth :always (t t) t "ecl_nth(fixint(#0),#1)")
 
550
(def-inline nth :always (fixnum t) t "ecl_nth(#0,#1)")
 
551
(def-inline nth :unsafe (t t) t "ecl_nth(fix(#0),#1)")
 
552
(def-inline nth :unsafe (fixnum t) t "ecl_nth(#0,#1)")
550
553
 
551
554
(proclaim-function first (list) t :no-side-effects t)
552
555
(def-inline first :always (cons) t "CAR(#0)")
575
578
(def-inline rest :unsafe (t) t "CDR(#0)")
576
579
 
577
580
(proclaim-function nthcdr (fixnum list) t :no-side-effects t)
578
 
(def-inline nthcdr :always (t t) t "nthcdr(fixint(#0),#1)")
579
 
(def-inline nthcdr :always (fixnum t) t "nthcdr(#0,#1)")
580
 
(def-inline nthcdr :unsafe (t t) t "nthcdr(fix(#0),#1)")
581
 
(def-inline nthcdr :unsafe (fixnum t) t "nthcdr(#0,#1)")
 
581
(def-inline nthcdr :always (t t) t "ecl_nthcdr(fixint(#0),#1)")
 
582
(def-inline nthcdr :always (fixnum t) t "ecl_nthcdr(#0,#1)")
 
583
(def-inline nthcdr :unsafe (t t) t "ecl_nthcdr(fix(#0),#1)")
 
584
(def-inline nthcdr :unsafe (fixnum t) t "ecl_nthcdr(#0,#1)")
582
585
 
583
586
(proclaim-function last (list) t)
584
587
(proclaim-function list (*) list :no-side-effects t)
591
594
 
592
595
(proclaim-function make-list (fixnum *) list)
593
596
(proclaim-function append (*) list :no-side-effects t)
594
 
(def-inline append :always (t t) t "append(#0,#1)")
 
597
(def-inline append :always (t t) t "ecl_append(#0,#1)")
595
598
 
596
599
(proclaim-function copy-list (list) list)
597
600
(proclaim-function copy-alist (list) list)
598
601
(proclaim-function copy-tree (t) t)
599
602
(proclaim-function revappend (list t) t)
600
603
(proclaim-function nconc (*) t)
601
 
(def-inline nconc :always (t t) t "nconc(#0,#1)")
 
604
(def-inline nconc :always (t t) t "ecl_nconc(#0,#1)")
602
605
 
603
606
(proclaim-function nreconc (list t) t)
604
607
(proclaim-function butlast (list *) list)
663
666
;; file num_arith.d
664
667
 
665
668
(proclaim-function + (*) t :no-side-effects t)
666
 
(def-inline + :always (t t) t "number_plus(#0,#1)")
 
669
(def-inline + :always (t t) t "ecl_plus(#0,#1)")
667
670
(def-inline + :always (fixnum-float fixnum-float) :double
668
671
 "(double)(#0)+(double)(#1)")
669
672
(def-inline + :always (fixnum-float fixnum-float) :float
671
674
(def-inline + :always (fixnum fixnum) :fixnum "(#0)+(#1)")
672
675
 
673
676
(proclaim-function - (t *) t :no-side-effects t)
674
 
(def-inline - :always (t) t "number_negate(#0)")
675
 
(def-inline - :always (t t) t "number_minus(#0,#1)")
 
677
(def-inline - :always (t) t "ecl_negate(#0)")
 
678
(def-inline - :always (t t) t "ecl_minus(#0,#1)")
676
679
(def-inline - :always (fixnum-float fixnum-float) :double
677
680
 "(double)(#0)-(double)(#1)")
678
681
(def-inline - :always (fixnum-float fixnum-float) :float
683
686
(def-inline - :always (fixnum) :fixnum "-(#0)")
684
687
 
685
688
(proclaim-function * (*) t :no-side-effects t)
686
 
(def-inline * :always (t t) t "number_times(#0,#1)")
 
689
(def-inline * :always (t t) t "ecl_times(#0,#1)")
687
690
(def-inline * :always (fixnum-float fixnum-float) :double
688
691
 "(double)(#0)*(double)(#1)")
689
692
(def-inline * :always (fixnum-float fixnum-float) :float
692
695
(def-inline * :always (fixnum fixnum) :fixnum "(#0)*(#1)")
693
696
 
694
697
(proclaim-function / (t *) t :no-side-effects t)
695
 
(def-inline / :always (t t) t "number_divide(#0,#1)")
 
698
(def-inline / :always (t t) t "ecl_divide(#0,#1)")
696
699
(def-inline / :always (fixnum-float fixnum-float) :double
697
700
 "(double)(#0)/(double)(#1)")
698
701
(def-inline / :always (fixnum-float fixnum-float) :float
700
703
(def-inline / :always (fixnum fixnum) :fixnum "(#0)/(#1)")
701
704
 
702
705
(proclaim-function 1+ (t) t :no-side-effects t)
703
 
(def-inline 1+ :always (t) t "one_plus(#0)")
 
706
(def-inline 1+ :always (t) t "ecl_one_plus(#0)")
704
707
(def-inline 1+ :always (fixnum-float) :double "(double)(#0)+1")
705
708
(def-inline 1+ :always (fixnum-float) :float "(float)(#0)+1")
706
709
(def-inline 1+ :always (fixnum) :fixnum "(#0)+1")
707
710
 
708
711
(proclaim-function 1- (t) t :no-side-effects t)
709
 
(def-inline 1- :always (t) t "one_minus(#0)")
 
712
(def-inline 1- :always (t) t "ecl_one_minus(#0)")
710
713
(def-inline 1- :always (fixnum-float) :double "(double)(#0)-1")
711
714
(def-inline 1- :always (fixnum-float) :float "(float)(#0)-1")
712
715
(def-inline 1- :always (fixnum) :fixnum "(#0)-1")
718
721
;; file num_co.d
719
722
 
720
723
(proclaim-function float (t *) t :no-side-effects t)
721
 
(def-inline float :always (t short-float) :float "number_to_double(#0)")
722
 
(def-inline float :always (t long-float) :double "number_to_double(#0)")
 
724
(def-inline float :always (t single-float) :float "ecl_to_double(#0)")
 
725
(def-inline float :always (t double-float) :double "ecl_to_double(#0)")
723
726
(def-inline float :always (fixnum-float) :double "((double)(#0))")
724
727
(def-inline float :always (fixnum-float) :float "((float)(#0))")
725
728
 
727
730
(proclaim-function denominator (t) t)
728
731
(proclaim-function floor (t *) (values t t) :no-side-effects t)
729
732
(def-inline floor :always (fixnum fixnum) :fixnum
730
 
 "@01;(#0>=0&&#1>0?(#0)/(#1):ifloor(#0,#1))")
 
733
 "@01;(#0>=0&&#1>0?(#0)/(#1):ecl_ifloor(#0,#1))")
731
734
 
732
735
(proclaim-function ceiling (t *) (values t t))
733
736
(proclaim-function truncate (t *) (values t t) :no-side-effects t)
736
739
(proclaim-function round (t *) (values t t))
737
740
(proclaim-function mod (t t) t :no-side-effects t)
738
741
(def-inline mod :always (fixnum fixnum) :fixnum
739
 
 "@01;(#0>=0&&#1>0?(#0)%(#1):imod(#0,#1))")
 
742
 "@01;(#0>=0&&#1>0?(#0)%(#1):ecl_imod(#0,#1))")
740
743
 
741
744
(proclaim-function rem (t t) t :no-side-effects t)
742
745
(def-inline rem :always (fixnum fixnum) :fixnum "(#0)%(#1)")
752
755
(proclaim-function realpart (t) t)
753
756
(proclaim-function imagpart (t) t)
754
757
(proclaim-function = (t *) t :predicate t :no-side-effects t)
755
 
(def-inline = :always (t t) :bool "number_equalp(#0,#1)")
 
758
(def-inline = :always (t t) :bool "ecl_number_equalp(#0,#1)")
756
759
(def-inline = :always (fixnum-float fixnum-float) :bool "(#0)==(#1)")
757
760
 
758
761
(proclaim-function /= (t *) t :predicate t :no-side-effects t)
759
 
(def-inline /= :always (t t) :bool "!number_equalp(#0,#1)")
 
762
(def-inline /= :always (t t) :bool "!ecl_number_equalp(#0,#1)")
760
763
(def-inline /= :always (fixnum-float fixnum-float) :bool "(#0)!=(#1)")
761
764
 
762
765
(proclaim-function < (t *) t :predicate t :no-side-effects t)
763
 
(def-inline < :always (t t) :bool "number_compare(#0,#1)<0")
 
766
(def-inline < :always (t t) :bool "ecl_number_compare(#0,#1)<0")
764
767
(def-inline < :always (fixnum-float fixnum-float) :bool "(#0)<(#1)")
765
768
 
766
769
(proclaim-function > (t *) t :predicate t :no-side-effects t)
767
 
(def-inline > :always (t t) :bool "number_compare(#0,#1)>0")
 
770
(def-inline > :always (t t) :bool "ecl_number_compare(#0,#1)>0")
768
771
(def-inline > :always (fixnum-float fixnum-float) :bool "(#0)>(#1)")
769
772
 
770
773
(proclaim-function <= (t *) t :predicate t :no-side-effects t)
771
 
(def-inline <= :always (t t) :bool "number_compare(#0,#1)<=0")
 
774
(def-inline <= :always (t t) :bool "ecl_number_compare(#0,#1)<=0")
772
775
(def-inline <= :always (fixnum-float fixnum-float) :bool "(#0)<=(#1)")
773
776
 
774
777
(proclaim-function >= (t *) t :predicate t :no-side-effects t)
775
 
(def-inline >= :always (t t) :bool "number_compare(#0,#1)>=0")
 
778
(def-inline >= :always (t t) :bool "ecl_number_compare(#0,#1)>=0")
776
779
(def-inline >= :always (fixnum-float fixnum-float) :bool "(#0)>=(#1)")
777
780
 
778
781
(proclaim-function max (t *) t :no-side-effects t)
779
 
(def-inline max :always (t t) t "@01;(number_compare(#0,#1)>=0?#0:#1)")
 
782
(def-inline max :always (t t) t "@01;(ecl_number_compare(#0,#1)>=0?#0:#1)")
780
783
(def-inline max :always (fixnum fixnum) :fixnum "@01;(#0)>=(#1)?#0:#1")
781
784
 
782
785
(proclaim-function min (t *) t :no-side-effects t)
783
 
(def-inline min :always (t t) t "@01;(number_compare(#0,#1)<=0?#0:#1)")
 
786
(def-inline min :always (t t) t "@01;(ecl_number_compare(#0,#1)<=0?#0:#1)")
784
787
(def-inline min :always (fixnum fixnum) :fixnum "@01;(#0)<=(#1)?#0:#1")
785
788
 
786
789
;; file num_log.d
848
851
(proclaim-function integer-length (t) fixnum)
849
852
(proclaim-function si:bit-array-op (*) t)
850
853
(proclaim-function zerop (t) t :predicate t :no-side-effects t)
851
 
(def-inline zerop :always (t) :bool "number_zerop(#0)")
 
854
(def-inline zerop :always (t) :bool "ecl_zerop(#0)")
852
855
(def-inline zerop :always (fixnum-float) :bool "(#0)==0")
853
856
 
854
857
(proclaim-function plusp (t) t :predicate t :no-side-effects t)
855
 
(def-inline plusp :always (t) :bool "number_plusp(#0)")
 
858
(def-inline plusp :always (t) :bool "ecl_plusp(#0)")
856
859
(def-inline plusp :always (fixnum-float) :bool "(#0)>0")
857
860
 
858
861
(proclaim-function minusp (t) t :predicate t :no-side-effects t)
859
 
(def-inline minusp :always (t) :bool "number_minusp(#0)")
 
862
(def-inline minusp :always (t) :bool "ecl_minusp(#0)")
860
863
(def-inline minusp :always (fixnum-float) :bool "(#0)<0")
861
864
 
862
865
(proclaim-function oddp (t) t :predicate t :no-side-effects t)
863
 
(def-inline oddp :always (t) :bool "number_oddp(#0)")
 
866
(def-inline oddp :always (t) :bool "ecl_oddp(#0)")
864
867
(def-inline oddp :always (fixnum fixnum) :bool "(#0) & 1")
865
868
 
866
869
(proclaim-function evenp (t) t :predicate t :no-side-effects t)
867
 
(def-inline evenp :always (t) :bool "number_evenp(#0)")
 
870
(def-inline evenp :always (t) :bool "ecl_evenp(#0)")
868
871
(def-inline evenp :always (fixnum fixnum) :bool "~(#0) & 1")
869
872
 
870
873
(proclaim-function random (t *) t)
959
962
(def-inline listp :always (t) :bool "@0;LISTP(#0)")
960
963
 
961
964
(proclaim-function numberp (t) t :predicate t :no-side-effects t)
962
 
(def-inline numberp :always (t) :bool "numberp(#0)")
 
965
(def-inline numberp :always (t) :bool "ecl_numberp(#0)")
963
966
 
964
967
(proclaim-function integerp (t) t :predicate t :no-side-effects t)
965
968
(def-inline integerp :always (t) :bool
967
970
 
968
971
(proclaim-function rationalp (t) t :predicate t)
969
972
(proclaim-function floatp (t) t :predicate t :no-side-effects t)
970
 
(def-inline floatp :always (t) :bool
971
 
 "@0;type_of(#0)==t_shortfloat||type_of(#0)==t_longfloat")
 
973
(def-inline floatp :always (t) :bool "floatp(#0)")
972
974
 
973
975
(proclaim-function complexp (t) t :predicate t)
974
976
(proclaim-function characterp (t) t :predicate t :no-side-effects t)
975
977
(def-inline characterp :always (t) :bool "CHARACTERP(#0)")
976
978
 
977
 
#+unicode #+unicode
978
979
(proclaim-function base-char-p (t) t :predicate t :no-side-effects t)
979
 
(def-inline base-char-p :always (t) :bool "BASE_CHAR_P(#0)")
 
980
(def-inline base-char-p :always (character) :bool "BASE_CHAR_P(#0)")
980
981
 
981
982
(proclaim-function stringp (t) t :predicate t :no-side-effects t)
982
 
#-unicode
983
 
(def-inline stringp :always (t) :bool "type_of(#0)==t_base_string")
984
 
#+unicode
 
983
(def-inline stringp :always (t) :bool "ecl_stringp(#0)")
 
984
 
 
985
(proclaim-function base-string-p (t) t :predicate t :no-side-effects t)
985
986
(def-inline base-string-p :always (t) :bool "type_of(#0)==t_base_string")
986
 
#+unicode
987
 
(def-inline stringp :always (t) :bool "(type_of(#0)==t_base_string||type_of(#0)==t_string)")
988
987
 
989
988
(proclaim-function bit-vector-p (t) t :predicate t :no-side-effects t)
990
989
(def-inline bit-vector-p :always (t) :bool "(type_of(#0)==t_bitvector)")
1000
999
type_of(#0)==t_string||
1001
1000
type_of(#0)==t_bitvector")
1002
1001
 
1003
 
(proclaim-function vector-push (t vector) fixnum :no-sp-change t)
 
1002
(proclaim-function vector-push (t vector) (or fixnum null) :no-sp-change t)
1004
1003
(proclaim-function vector-push-extend (t vector *) fixnum :no-sp-change t)
1005
1004
(proclaim-function simple-string-p (t) t :predicate t)
1006
1005
(proclaim-function simple-bit-vector-p (t) t :predicate t)
1016
1015
(def-inline eq :always (fixnum fixnum) :bool "(#0)==(#1)")
1017
1016
 
1018
1017
(proclaim-function eql (t t) t :predicate t :no-side-effects t)
1019
 
(def-inline eql :always (t t) :bool "eql(#0,#1)")
 
1018
(def-inline eql :always (t t) :bool "ecl_eql(#0,#1)")
1020
1019
(def-inline eql :always (character t) :bool
1021
1020
 "(CHARACTERP(#1) && (#0)==CHAR_CODE(#1))")
1022
1021
(def-inline eql :always (t character) :bool
1029
1028
(def-inline eql :always (fixnum fixnum) :bool "(#0)==(#1)")
1030
1029
 
1031
1030
(proclaim-function equal (t t) t :predicate t :no-side-effects t)
1032
 
(def-inline equal :always (t t) :bool "equal(#0,#1)")
 
1031
(def-inline equal :always (t t) :bool "ecl_equal(#0,#1)")
1033
1032
(def-inline equal :always (fixnum fixnum) :bool "(#0)==(#1)")
1034
1033
 
1035
1034
(proclaim-function equalp (t t) t :predicate t :no-side-effects t)
1036
 
(def-inline equalp :always (t t) :bool "equalp(#0,#1)")
 
1035
(def-inline equalp :always (t t) :bool "ecl_equalp(#0,#1)")
1037
1036
(def-inline equalp :always (fixnum fixnum) :bool "(#0)==(#1)")
1038
1037
 
1039
1038
(proclaim-function not (t) t :predicate t :no-side-effects t)
1055
1054
(proclaim-function peek-char (*) t)
1056
1055
(proclaim-function pprint (t *) t)
1057
1056
(proclaim-function prin1 (t *) t)
1058
 
(def-inline prin1 :always (t t) t "prin1(#0,#1)")
1059
 
(def-inline prin1 :always (t) t "prin1(#0,Cnil)")
 
1057
(def-inline prin1 :always (t t) t "ecl_prin1(#0,#1)")
 
1058
(def-inline prin1 :always (t) t "ecl_prin1(#0,Cnil)")
1060
1059
 
1061
1060
(proclaim-function princ (t *) t)
1062
 
(def-inline princ :always (t t) t "princ(#0,#1)")
1063
 
(def-inline princ :always (t) t "princ(#0,Cnil)")
 
1061
(def-inline princ :always (t t) t "ecl_princ(#0,#1)")
 
1062
(def-inline princ :always (t) t "ecl_princ(#0,Cnil)")
1064
1063
 
1065
1064
(proclaim-function print (t *) t)
1066
 
(def-inline print :always (t t) t "print(#0,#1)")
1067
 
(def-inline print :always (t) t "print(#0,Cnil)")
 
1065
(def-inline print :always (t t) t "ecl_print(#0,#1)")
 
1066
(def-inline print :always (t) t "ecl_print(#0,Cnil)")
1068
1067
 
1069
1068
(proclaim-function probe-file (t) t :predicate t)
1070
1069
(proclaim-function unread-char (t *) t)
1074
1073
(proclaim-function read-line (*) (values t t))
1075
1074
(proclaim-function read-preserving-whitespace (*) t)
1076
1075
(proclaim-function terpri (*) t :predicate t)
1077
 
(def-inline terpri :always (t) t "terpri(#0)")
1078
 
(def-inline terpri :always nil t "terpri(Cnil)")
 
1076
(def-inline terpri :always (t) t "ecl_terpri(#0)")
 
1077
(def-inline terpri :always nil t "ecl_terpri(Cnil)")
1079
1078
 
1080
1079
(proclaim-function write (t *) t)
1081
1080
(proclaim-function write-byte (fixnum stream) t)
1082
1081
(proclaim-function write-char (t *) t)
1083
 
(def-inline write-char :always (t) t "@0;(princ_char(char_code(#0),Cnil),(#0))")
 
1082
(def-inline write-char :always (t) t "@0;(ecl_princ_char(ecl_char_code(#0),Cnil),(#0))")
1084
1083
 
1085
1084
(proclaim-function write-line (t *) t)
1086
1085
(proclaim-function write-string (t *) t)
1118
1117
;; file sequence.d
1119
1118
 
1120
1119
(proclaim-function elt (sequence fixnum) t :no-side-effects t)
1121
 
(def-inline elt :always (t t) t "elt(#0,fixint(#1))")
1122
 
(def-inline elt :always (t fixnum) t "elt(#0,#1)")
1123
 
(def-inline elt :unsafe (t t) t "elt(#0,fix(#1))")
1124
 
(def-inline elt :unsafe (t fixnum) t "elt(#0,#1)")
 
1120
(def-inline elt :always (t t) t "ecl_elt(#0,fixint(#1))")
 
1121
(def-inline elt :always (t fixnum) t "ecl_elt(#0,#1)")
 
1122
(def-inline elt :unsafe (t t) t "ecl_elt(#0,fix(#1))")
 
1123
(def-inline elt :unsafe (t fixnum) t "ecl_elt(#0,#1)")
1125
1124
 
1126
1125
(proclaim-function si:elt-set (sequence fixnum t) t)
1127
 
(def-inline si:elt-set :always (t t t) t "elt_set(#0,fixint(#1),#2)")
1128
 
(def-inline si:elt-set :always (t fixnum t) t "elt_set(#0,#1,#2)")
1129
 
(def-inline si:elt-set :unsafe (t t t) t "elt_set(#0,fix(#1),#2)")
 
1126
(def-inline si:elt-set :always (t t t) t "ecl_elt_set(#0,fixint(#1),#2)")
 
1127
(def-inline si:elt-set :always (t fixnum t) t "ecl_elt_set(#0,#1,#2)")
 
1128
(def-inline si:elt-set :unsafe (t t t) t "ecl_elt_set(#0,fix(#1),#2)")
1130
1129
 
1131
1130
(proclaim-function subseq (sequence fixnum *) sequence)
1132
1131
(proclaim-function copy-seq (sequence) sequence)
1133
1132
(proclaim-function length (sequence) fixnum :no-side-effects t)
1134
1133
(def-inline length :always (t) t "cl_length(#0)")
1135
 
(def-inline length :always (t) :fixnum "length(#0)")
 
1134
(def-inline length :always (t) :fixnum "ecl_length(#0)")
1136
1135
(def-inline length :unsafe ((array t)) :fixnum "(#0)->vector.fillp")
1137
1136
(def-inline length :unsafe (string) :fixnum "(#0)->base_string.fillp")
1138
1137
 
1143
1142
 
1144
1143
(proclaim-function char (string fixnum) character :no-side-effects t)
1145
1144
(def-inline char :always (t t) t "cl_char(#0,#1)")
1146
 
(def-inline char :always (t fixnum) t "aref1(#0,#1)")
 
1145
(def-inline char :always (t fixnum) t "ecl_aref1(#0,#1)")
1147
1146
(def-inline char :unsafe (t t) t "CODE_CHAR((#0)->base_string.self[fix(#1)])")
1148
1147
(def-inline char :unsafe (t fixnum) :fixnum "(#0)->base_string.self[#1]")
1149
1148
(def-inline char :unsafe (t fixnum) :char "(#0)->base_string.self[#1]")
1150
1149
 
1151
1150
(proclaim-function si:char-set (string fixnum character) character)
1152
1151
(def-inline si:char-set :always (t t t) t "si_char_set(#0,#1,#2)")
1153
 
(def-inline si:char-set :always (t fixnum t) t "aset1(#0,#1,#2)")
 
1152
(def-inline si:char-set :always (t fixnum t) t "ecl_aset1(#0,#1,#2)")
1154
1153
(def-inline si:char-set :unsafe (t t t) t
1155
 
 "@2;((#0)->base_string.self[fix(#1)]=char_code(#2),(#2))")
 
1154
 "@2;((#0)->base_string.self[fix(#1)]=ecl_char_code(#2),(#2))")
1156
1155
(def-inline si:char-set :unsafe (t fixnum character) :char
1157
1156
 "(#0)->base_string.self[#1]= #2")
1158
1157
 
1159
1158
(proclaim-function schar (simple-string fixnum) character :no-side-effects t)
1160
 
(def-inline schar :always (t t) t "elt(#0,fixint(#1))")
1161
 
(def-inline schar :always (t fixnum) t "elt(#0,#1)")
 
1159
(def-inline schar :always (t t) t "ecl_elt(#0,fixint(#1))")
 
1160
(def-inline schar :always (t fixnum) t "ecl_elt(#0,#1)")
1162
1161
(def-inline schar :unsafe (t t) t "CODE_CHAR((#0)->base_string.self[fix(#1)])")
1163
1162
(def-inline schar :unsafe (t t) :fixnum "(#0)->base_string.self[fix(#1)]")
1164
1163
(def-inline schar :unsafe (t fixnum) :fixnum "(#0)->base_string.self[#1]")
1165
1164
(def-inline schar :unsafe (t fixnum) :char "(#0)->base_string.self[#1]")
1166
1165
 
1167
1166
(proclaim-function si:schar-set (string fixnum character) character)
1168
 
(def-inline si:schar-set :always (t t t) t "elt_set(#0,fixint(#1),#2)")
1169
 
(def-inline si:schar-set :always (t fixnum t) t "elt_set(#0,#1,#2)")
 
1167
(def-inline si:schar-set :always (t t t) t "ecl_elt_set(#0,fixint(#1),#2)")
 
1168
(def-inline si:schar-set :always (t fixnum t) t "ecl_elt_set(#0,#1,#2)")
1170
1169
(def-inline si:schar-set :unsafe (t t t) t
1171
 
 "@2;((#0)->base_string.self[fix(#1)]=char_code(#2),(#2))")
1172
 
(def-inline si:schar-set :unsafe (t fixnum character) :char
 
1170
 "@2;((#0)->base_string.self[fix(#1)]=ecl_char_code(#2),(#2))")
 
1171
(def-inline si:schar-set :unsafe (t fixnum base-char) :char
1173
1172
 "(#0)->base_string.self[#1]= #2")
1174
1173
 
1175
1174
(proclaim-function string= (string-designator string-designator *) t :predicate t :no-side-effects t)
1176
 
(def-inline string= :always (string string) :bool "string_eq(#0,#1)")
 
1175
(def-inline string= :always (string string) :bool "ecl_string_eq(#0,#1)")
1177
1176
 
1178
1177
(proclaim-function string< (string-designator string-designator *) t :predicate t)
1179
1178
(proclaim-function string> (string-designator string-designator *) t :predicate t)
1208
1207
(def-inline si:structure-name :always (structure) symbol "SNAME(#0)")
1209
1208
 
1210
1209
(proclaim-function si:structure-ref (t t fixnum) t :no-side-effects t)
1211
 
(def-inline si:structure-ref :always (t t fixnum) t "structure_ref(#0,#1,#2)")
 
1210
(def-inline si:structure-ref :always (t t fixnum) t "ecl_structure_ref(#0,#1,#2)")
1212
1211
 
1213
1212
(proclaim-function si:structure-set (t t fixnum t) t)
1214
1213
(def-inline si:structure-set :always (t t fixnum t) t
1215
 
 "structure_set(#0,#1,#2,#3)")
 
1214
 "ecl_structure_set(#0,#1,#2,#3)")
1216
1215
 
1217
1216
(proclaim-function si:structurep (t) t :predicate t)
1218
1217
(proclaim-function si:structure-subtype-p (t t) t :predicate t)
1219
 
(proclaim-function si:rplaca-nthcdr (t t t) t)
1220
 
(proclaim-function si:list-nth (t t) t :predicate t)
1221
1218
 
1222
1219
(proclaim-function si:*make-special (*) t)
1223
1220
(proclaim-function si:*make-constant (*) t)
1289
1286
(def-inline shift<< :always (fixnum fixnum) :fixnum "((#0) << (#1))")
1290
1287
 
1291
1288
(proclaim-function short-float-p (*) nil :predicate t :no-side-effects t)
 
1289
#-short-float
 
1290
(def-inline short-float-p :always (t) :bool "type_of(#0)==t_singlefloat")
 
1291
#+short-float
1292
1292
(def-inline short-float-p :always (t) :bool "type_of(#0)==t_shortfloat")
1293
1293
 
 
1294
(proclaim-function single-float-p (*) nil :predicate t :no-side-effects t)
 
1295
(def-inline single-float-p :always (t) :bool "type_of(#0)==t_singlefloat")
 
1296
 
 
1297
(proclaim-function double-float-p (*) nil :predicate t :no-side-effects t)
 
1298
(def-inline double-float-p :always (t) :bool "type_of(#0)==t_doublefloat")
 
1299
 
1294
1300
(proclaim-function long-float-p (*) nil :predicate t :no-side-effects t)
 
1301
#-long-float
 
1302
(def-inline long-float-p :always (t) :bool "type_of(#0)==t_doublefloat")
 
1303
#+long-float
1295
1304
(def-inline long-float-p :always (t) :bool "type_of(#0)==t_longfloat")
1296
1305
 
1297
1306
(proclaim-function si:fixnump (*) nil :predicate t :no-side-effects t)
1312
1321
(proclaim-function si:allocate-raw-instance (t t fixnum) t)
1313
1322
(proclaim-function si:instance-ref-safe (t fixnum) t)
1314
1323
(proclaim-function si:instance-ref (t fixnum) t :no-side-effects t)
1315
 
(def-inline si:instance-ref :always (t fixnum) t "instance_ref((#0),(#1))")
 
1324
(def-inline si:instance-ref :always (t fixnum) t "ecl_instance_ref((#0),(#1))")
1316
1325
(def-inline si:instance-ref :unsafe (standard-object fixnum) t
1317
1326
 "(#0)->instance.slots[#1]")
1318
1327
 
1319
1328
(proclaim-function si:instance-set (t fixnum t) t)
1320
1329
(def-inline si:instance-set :unsafe (t fixnum t) t
1321
 
 "instance_set((#0),(#1),(#2))")
 
1330
 "ecl_instance_set((#0),(#1),(#2))")
1322
1331
(def-inline si:instance-set :unsafe (standard-object fixnum t) t
1323
1332
 "(#0)->instance.slots[#1]=(#2)")
1324
1333
 
1336
1345
(proclaim-function si:sl-makunbound (t fixnum) t :predicate t)
1337
1346
 
1338
1347
(proclaim-function standard-instance-access (standard-object fixnum) t :no-side-effects t)
1339
 
(def-inline standard-instance-access :always (standard-object fixnum) t "instance_ref((#0),(#1))")
 
1348
(def-inline standard-instance-access :always (standard-object fixnum) t "ecl_instance_ref((#0),(#1))")
1340
1349
(def-inline standard-instance-access :unsafe (standard-object fixnum) t
1341
1350
 "(#0)->instance.slots[#1]")
1342
1351
 
1343
1352
(proclaim-function funcallable-standard-instance-access (funcallable-standard-object fixnum) t :no-side-effects t)
1344
 
(def-inline funcallable-standard-instance-access :always (funcallable-standard-object fixnum) t "instance_ref((#0),(#1))")
 
1353
(def-inline funcallable-standard-instance-access :always (funcallable-standard-object fixnum) t "ecl_instance_ref((#0),(#1))")
1345
1354
(def-inline funcallable-standard-instance-access :unsafe (funcallable-standard-object fixnum) t
1346
1355
 "(#0)->instance.slots[#1]")
1347
1356
 
1389
1398
    deposit-field
1390
1399
    ;; packlib.lsp
1391
1400
    find-all-symbols apropos apropos-list
 
1401
    find-relative-package package-parent package-children
1392
1402
    ;; predlib.lsp
1393
1403
    upgraded-array-element-type upgraded-complex-part-type typep subtypep coerce
1394
1404
    do-deftype