Home My Page Projects Code Snippets Project Openings SML/NJ
Summary Activity Forums Tracker Lists Tasks Docs Surveys News SCM Files

SCM Repository

[smlnj] Annotation of /sml/trunk/src/system/Init/built-in.sml
ViewVC logotype

Annotation of /sml/trunk/src/system/Init/built-in.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 430 - (view) (download)

1 : monnier 416 (* built-in.sml
2 :     *
3 :     * COPYRIGHT (c) 1995 AT&T Bell Laboratories.
4 :     *
5 :     * Interfaces to the compiler built-ins, infixes, etc.
6 :     *
7 :     *)
8 :    
9 :     structure PrimTypes = struct open PrimTypes end
10 :     (* this silliness is to prevent elabstr.sml from sticking a NO_ACCESS
11 :     in the wrong place *)
12 :    
13 : monnier 429 local
14 :     open PrimTypes
15 :     in
16 : monnier 416
17 : monnier 429 structure Assembly = Core.Assembly
18 : monnier 416
19 : monnier 429 (* create a type-safe version of the InLine structure while preserving
20 :     * the inline property of the functions.
21 :     *)
22 :     structure InlineT =
23 :     struct
24 : monnier 416 type 'a control_cont = 'a control_cont
25 :    
26 :     val callcc : ('a cont -> 'a) -> 'a = InLine.callcc
27 :     val throw : 'a cont -> 'a -> 'b = InLine.throw
28 :     val capture : ('a control_cont -> 'a) -> 'a = InLine.capture
29 :     val escape : 'a control_cont -> 'a -> 'b = InLine.cthrow
30 :     val isolate : ('a -> unit) -> 'a cont = InLine.isolate
31 :     val ! : 'a ref -> 'a = InLine.!
32 :     val op := : 'a ref * 'a -> unit = InLine.:=
33 :     val makeref : 'a -> 'a ref = InLine.makeref
34 :     val op = : ''a * ''a -> bool = InLine.=
35 :     val op <> : ''a * ''a -> bool = InLine.<>
36 :     val boxed : 'a -> bool = InLine.boxed
37 :     val unboxed : 'a -> bool = InLine.unboxed
38 :     val cast : 'a -> 'b = InLine.cast
39 :     val identity : 'a -> 'a = InLine.cast
40 :     val objlength : 'a -> int = InLine.objlength
41 :     val mkspecial : int * 'a -> 'b = InLine.mkspecial
42 :     val getspecial : 'a -> int = InLine.getspecial
43 :     val setspecial : ('a * int) -> unit = InLine.setspecial
44 :     val getpseudo : int -> 'a = InLine.getpseudo
45 :     val setpseudo : 'a * int -> unit = InLine.setpseudo
46 :     val gethdlr : unit -> 'a cont = InLine.gethdlr
47 :     val sethdlr : 'a cont -> unit = InLine.sethdlr
48 :     val getvar : unit -> 'a = InLine.getvar
49 :     val setvar : 'a -> unit = InLine.setvar
50 :     val compose : ('b -> 'c) * ('a -> 'b) -> ('a -> 'c) = InLine.compose
51 :     val op before : ('a * 'b) -> 'a = InLine.before
52 :     val gettag : 'a -> int = InLine.gettag
53 :     val setmark : 'a -> unit = InLine.setmark
54 :     val dispose : 'a -> unit = InLine.dispose
55 :     val inlnot : bool -> bool = InLine.inlnot
56 :     val real : int -> real = InLine.real
57 :     val recordSub : ('a * int) -> 'b = InLine.recordSub
58 :     val raw64Sub : ('a * int) -> real = InLine.raw64Sub
59 :    
60 :     structure Int31 =
61 :     struct
62 :     val fromInt : int -> int = InLine.copy_31_31
63 :     val toInt : int -> int = InLine.copy_31_31
64 :     val op * : int * int -> int = InLine.i31mul
65 :     val op quot : int * int -> int = InLine.i31quot
66 :     val op rem : int * int -> int = InLine.i31rem
67 :     val op + : int * int -> int = InLine.i31add
68 :     val op - : int * int -> int = InLine.i31sub
69 :     val ~ : int -> int = InLine.i31neg
70 :     val andb : int * int -> int = InLine.i31andb
71 :     val orb : int * int -> int = InLine.i31orb
72 :     val xorb : int * int -> int = InLine.i31xorb
73 :     val rshift : int * int -> int = InLine.i31rshift
74 :     val lshift : int * int -> int = InLine.i31lshift
75 :     val notb : int -> int = InLine.i31notb
76 :     val op < : int * int -> bool = InLine.i31lt
77 :     val op <= : int * int -> bool = InLine.i31le
78 :     val op > : int * int -> bool = InLine.i31gt
79 :     val op >= : int * int -> bool = InLine.i31ge
80 :     val op = : int * int -> bool = InLine.i31eq
81 :     val op <> : int * int -> bool = InLine.i31ne
82 :     val ltu : int * int -> bool = InLine.i31ltu
83 :     val geu : int * int -> bool = InLine.i31geu
84 :    
85 :     val op mod : int * int -> int = InLine.i31mod
86 :     val op div : int * int -> int = InLine.i31div
87 :     val min : int * int -> int = InLine.i31min
88 :     val max : int * int -> int = InLine.i31max
89 :     val abs : int -> int = InLine.i31abs
90 :     end
91 :    
92 :     structure Int32 =
93 :     struct
94 :     val toLarge : int32 -> int32 = InLine.copy_32_32
95 :     val fromInt : int -> int32 = InLine.extend_31_32
96 :     val toInt : int32 -> int = InLine.test_32_31
97 :     val fromLarge : int32 -> int32 = InLine.copy_32_32
98 :    
99 :     val op * : int32 * int32 -> int32 = InLine.i32mul
100 :     val op quot : int32 * int32 -> int32 = InLine.i32quot
101 :     val op + : int32 * int32 -> int32 = InLine.i32add
102 :     val op - : int32 * int32 -> int32 = InLine.i32sub
103 :     val ~ : int32 -> int32 = InLine.i32neg
104 :     val andb : int32 * int32 -> int32 = InLine.i32andb
105 :     val orb : int32 * int32 -> int32 = InLine.i32orb
106 :     val xorb : int32 * int32 -> int32 = InLine.i32xorb
107 :     val rshift : int32 * int32 -> int32 = InLine.i32rshift
108 :     val lshift : int32 * int32 -> int32 = InLine.i32lshift
109 :     val op < : int32 * int32 -> bool = InLine.i32lt
110 :     val op <= : int32 * int32 -> bool = InLine.i32le
111 :     val op > : int32 * int32 -> bool = InLine.i32gt
112 :     val op >= : int32 * int32 -> bool = InLine.i32ge
113 :     val op = : int32 * int32 -> bool = InLine.i32eq
114 :     val op <> : int32 * int32 -> bool = InLine.i32ne
115 :     end
116 :    
117 :    
118 :     structure Real64 =
119 :     struct
120 :     val op + : real * real -> real = InLine.f64add
121 :     val op - : real * real -> real = InLine.f64sub
122 :     val op / : real * real -> real = InLine.f64div
123 :     val op * : real * real -> real = InLine.f64mul
124 :     val op == : real * real -> bool = InLine.f64eq
125 :     val op != : real * real -> bool = InLine.f64ne
126 :     val op >= : real * real -> bool = InLine.f64ge
127 :     val op > : real * real -> bool = InLine.f64gt
128 :     val op <= : real * real -> bool = InLine.f64le
129 :     val op < : real * real -> bool = InLine.f64lt
130 :     val ~ : real -> real = InLine.f64neg
131 :     val abs : real -> real = InLine.f64abs
132 :     end
133 :    
134 :     structure Word32 =
135 :     struct
136 :     val toLargeInt : word32 -> int32 = InLine.testu_32_32
137 :     val toLargeIntX : word32 -> int32 = InLine.copy_32_32
138 :     val fromLargeInt : int32 -> word32 = InLine.copy_32_32
139 :     val fromInt : int -> word32 = InLine.extend_31_32
140 :     val toLargeWord : word32 -> word32 = InLine.copy_32_32
141 :     val toLargeWordX : word32 -> word32 = InLine.copy_32_32
142 :     val fromLargeWord : word32 -> word32 = InLine.copy_32_32
143 :     val toIntX : word32 -> int = InLine.test_32_31
144 :     val toInt : word32 -> int = InLine.testu_32_31
145 :    
146 :     val orb : word32 * word32 -> word32 = InLine.w32orb
147 :     val xorb : word32 * word32 -> word32 = InLine.w32xorb
148 :     val andb : word32 * word32 -> word32 = InLine.w32andb
149 :     val op * : word32 * word32 -> word32 = InLine.w32mul
150 :     val op + : word32 * word32 -> word32 = InLine.w32add
151 :     val op - : word32 * word32 -> word32 = InLine.w32sub
152 :     val op div : word32 * word32 -> word32 = InLine.w32div
153 :     val op > : word32 * word32 -> bool = InLine.w32gt
154 :     val op >= : word32 * word32 -> bool = InLine.w32ge
155 :     val op < : word32 * word32 -> bool = InLine.w32lt
156 :     val op <= : word32 * word32 -> bool = InLine.w32le
157 :     val rshift : word32 * word -> word32 = InLine.w32rshift
158 :     val rshiftl : word32 * word -> word32 = InLine.w32rshiftl
159 :     val lshift : word32 * word -> word32 = InLine.w32lshift
160 :     val notb : word32 -> word32 = InLine.w32notb
161 :     val chkLshift : word32 * word -> word32 = InLine.w32ChkLshift
162 :     val chkRshift : word32 * word -> word32 = InLine.w32ChkRshift
163 :     val chkRshiftl : word32 * word -> word32 = InLine.w32ChkRshiftl
164 :     end
165 :    
166 :     structure Word31 =
167 :     struct
168 :     val toLargeInt : word -> int32 = InLine.copy_31_32
169 :     val toLargeIntX : word -> int32 = InLine.extend_31_32
170 :     val toInt : word -> int = InLine.testu_31_31
171 :     val toLargeWord : word -> word32 = InLine.copy_31_32
172 :     val toLargeWordX : word -> word32 = InLine.extend_31_32
173 :     val fromInt : int -> word = InLine.copy_31_31
174 :     val fromLargeWord : word32 -> word = InLine.trunc_32_31
175 :     val fromLargeInt : int32 -> word = InLine.trunc_32_31
176 :     val toIntX : word -> int = InLine.copy_31_31
177 :    
178 :     val orb : word * word -> word = InLine.w31orb
179 :     val xorb : word * word -> word = InLine.w31xorb
180 :     val andb : word * word -> word = InLine.w31andb
181 :     val op * : word * word -> word = InLine.w31mul
182 :     val op + : word * word -> word = InLine.w31add
183 :     val op - : word * word -> word = InLine.w31sub
184 :     val op div : word * word -> word = InLine.w31div
185 :     val op > : word * word -> bool = InLine.w31gt
186 :     val op >= : word * word -> bool = InLine.w31ge
187 :     val op < : word * word -> bool = InLine.w31lt
188 :     val op <= : word * word -> bool = InLine.w31le
189 :     val rshift : word * word -> word = InLine.w31rshift
190 :     val rshiftl : word * word -> word = InLine.w31rshiftl
191 :     val lshift : word * word -> word = InLine.w31lshift
192 :     val chkLshift : word * word -> word = InLine.w31ChkLshift
193 :     val chkRshift : word * word -> word = InLine.w31ChkRshift
194 :     val chkRshiftl : word * word -> word = InLine.w31ChkRshiftl
195 :     val notb : word -> word = InLine.w31notb
196 :     end
197 :    
198 :     structure Word8 =
199 :     struct
200 :     val toLargeIntX : word8 -> int32 = InLine.extend_8_32
201 :     val toLargeInt : word8 -> int32 = InLine.copy_8_32
202 :     val toIntX : word8 -> int = InLine.extend_8_31
203 :     val toInt : word8 -> int = InLine.copy_8_31
204 :     val toLargeWordX : word8 -> word32 = InLine.extend_8_32
205 :     val toLargeWord : word8 -> word32 = InLine.copy_8_32
206 :     val fromLargeWord : word32 -> word8 = InLine.trunc_32_8
207 :     val fromInt : int -> word8 = InLine.trunc_31_8
208 :     val fromLargeInt : int32 -> word8 = InLine.trunc_32_8
209 :    
210 :     (* temporary framework, because the actual word8 operators
211 :     * are not implemented*)
212 :     val orb : word8 * word8 -> word8 = InLine.i31orb
213 :     val xorb : word8 * word8 -> word8 = InLine.i31xorb
214 :     val op div : word8 * word8 -> word8 = InLine.i31div
215 :     val andb : word8 * word8 -> word8 = InLine.i31andb
216 :     val op > : word8 * word8 -> bool = InLine.i31gt
217 :     val op >= : word8 * word8 -> bool = InLine.i31ge
218 :     val op < : word8 * word8 -> bool = InLine.i31lt
219 :     val op <= : word8 * word8 -> bool = InLine.i31le
220 :     val rshift : word8 * word -> word8 = InLine.i31rshift
221 :     val rshiftl : word8 * word -> word8 = InLine.i31rshift (* high bits always 0 *)
222 :     val lshift : word8 * word -> word8 = InLine.i31lshift
223 :     (* WARNING! the following operators don't get the high-order bits right *)
224 :     val notb : word8 -> word8 = InLine.i31notb
225 :     val op * : word8 * word8 -> word8 = InLine.i31mul
226 :     val op + : word8 * word8 -> word8 = InLine.i31add
227 :     val op - : word8 * word8 -> word8 = InLine.i31sub
228 :     end
229 :    
230 :     structure Char =
231 :     struct
232 :    
233 :     val maxOrd = 255
234 :     exception Chr
235 :    
236 :     (* the following should be an inline operator *)
237 :     fun chr i = if (Int31.geu(i, Int31.+(maxOrd,1)))
238 :     then raise Chr
239 :     else ((InLine.cast i) : char)
240 :    
241 :     val ord : char -> int = InLine.cast
242 :    
243 :     val (op <) : (char * char) -> bool = InLine.i31lt
244 :     val (op <=) : (char * char) -> bool = InLine.i31le
245 :     val (op >) : (char * char) -> bool = InLine.i31gt
246 :     val (op >=) : (char * char) -> bool = InLine.i31ge
247 :     end
248 :    
249 :     structure PolyArray =
250 :     struct
251 :     val newArray0 : unit -> 'a array = InLine.newArray0
252 :     val array : int * 'a -> 'a array = InLine.mkarray
253 :     val length : 'a array -> int = InLine.length
254 :     val sub : 'a array * int -> 'a = InLine.arrSub
255 :     val chkSub : 'a array * int -> 'a = InLine.arrChkSub
256 :     val update : 'a array * int * 'a -> unit = InLine.arrUpdate
257 :     val chkUpdate : 'a array * int * 'a -> unit = InLine.arrChkUpdate
258 :     val getData : 'a array -> 'b = InLine.getSeqData
259 :     end
260 :    
261 :     structure PolyVector =
262 :     struct
263 :     val length : 'a vector -> int = InLine.length
264 :     val sub : 'a vector * int -> 'a = InLine.vecSub
265 :     val chkSub : 'a vector * int -> 'a = InLine.vecChkSub
266 :     val getData : 'a vector -> 'b = InLine.getSeqData
267 :     end
268 :    
269 :     (* The type of this ought to be float64array *)
270 :     structure Real64Array =
271 :     struct
272 :     val newArray0 : unit -> Assembly.A.real64array = InLine.newArray0
273 :     val length : Assembly.A.real64array -> int = InLine.length
274 :     val sub : Assembly.A.real64array * int -> real = InLine.f64Sub
275 :     val chkSub : Assembly.A.real64array * int -> real = InLine.f64chkSub
276 :     val update : Assembly.A.real64array * int * real -> unit = InLine.f64Update
277 :     val chkUpdate : Assembly.A.real64array * int * real -> unit = InLine.f64chkUpdate
278 :     val getData : Assembly.A.real64array -> 'b = InLine.getSeqData
279 :     end
280 :    
281 :     (** NOTE: we are currently using polymorphic vectors to implement the Real64Vector
282 :     ** structure.
283 :     **)
284 :     structure Real64Vector =
285 :     struct
286 :     val length : real vector -> int = InLine.length
287 :     val sub : real vector * int -> real = InLine.vecSub
288 :     val chkSub : real vector * int -> real = InLine.vecChkSub
289 :     val getData : real vector -> 'b = InLine.getSeqData
290 :     end
291 :    
292 :     structure Word8Array =
293 :     struct
294 :     type array = Assembly.A.word8array
295 :     val newArray0 : unit -> array = InLine.newArray0
296 :     val length : array -> int = InLine.length
297 :     (* BUG: using "ordof" for W8A.sub is dangerous, because ordof is
298 :     (technically) fetching from immutable things. A fancy optimizer might
299 :     someday be confused. *)
300 :     val sub : array * int -> word8 = InLine.ordof
301 :     val chkSub : array * int -> word8 = InLine.inlbyteof
302 :     val update : array * int * word8 -> unit = InLine.store
303 :     val chkUpdate : array * int * word8 -> unit = InLine.inlstore
304 :     val getData : array -> 'a = InLine.getSeqData
305 :     end
306 :    
307 :     structure Word8Vector =
308 :     struct
309 :     local
310 :     structure V :> sig
311 :     eqtype vector
312 :     val create : int -> vector
313 :     end = struct
314 :     type vector = string
315 :     val create = Assembly.A.create_s
316 :     end
317 :     in
318 :     open V
319 :     end
320 :     val length : vector -> int = InLine.length
321 :     val sub : vector * int -> word8 = InLine.ordof
322 :     val chkSub : vector * int -> word8 = InLine.inlordof
323 :     val update : vector * int * word8 -> unit = InLine.store
324 :     val getData : vector -> 'a = InLine.getSeqData
325 :     end
326 :    
327 :     structure CharArray =
328 :     struct
329 :     local
330 :     structure A :> sig
331 :     eqtype array
332 :     val newArray0 : unit -> array
333 :     val create : int -> array
334 :     end = struct
335 :     type array = Assembly.A.word8array
336 :     val newArray0 : unit -> array = InLine.newArray0
337 :     val create = Assembly.A.create_b
338 :     end
339 :     in
340 :     open A
341 :     end
342 :     val length : array -> int = InLine.length
343 :     val chkSub : (array * int) -> char = InLine.inlordof
344 :     val chkUpdate : (array * int * char) -> unit = InLine.inlstore
345 :     val sub : (array * int) -> char = InLine.ordof
346 :     val update : (array * int * char) -> unit = InLine.store
347 :     val getData : array -> 'a = InLine.getSeqData
348 :     end
349 :    
350 :     structure CharVector =
351 :     struct
352 :     val length : string -> int = InLine.length
353 :     val chkSub : (string * int) -> char = InLine.inlordof
354 :     val sub : (string * int) -> char = InLine.ordof
355 :     val update : (string * int * char) -> unit = InLine.store
356 :     val getData : string -> 'a = InLine.getSeqData
357 :     end
358 :    
359 :     structure DfltInt = Int31
360 :     structure DfltWord = Word31
361 :     structure DfltReal = Real64
362 :    
363 : monnier 429 end (* structure InlineT *)
364 : monnier 416
365 : monnier 429 end (* local *)

root@smlnj-gforge.cs.uchicago.edu
ViewVC Help
Powered by ViewVC 1.0.0