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/branches/primop-branch-2/src/system/smlnj/init/built-in.sml
ViewVC logotype

Annotation of /sml/branches/primop-branch-2/src/system/smlnj/init/built-in.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2061 - (view) (download)

1 : blume 573 (* 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 : macqueen 1947 (* [dbm, 6/21/06] This module is compiled in the environment PrimEnv.primEnv.
10 :     See init.cmi *)
11 :    
12 : blume 573 structure PrimTypes = struct open PrimTypes end
13 :     (* this silliness is to prevent elabstr.sml from sticking a NO_ACCESS
14 : macqueen 1947 in the wrong place [dbm: presumably this NO_ACCESS is derived from
15 :     the dummy access value (NO_ACCESS) in the hand-built PrimTypes module.]
16 :     How and why does this access value get propagated into the code. *)
17 : blume 573
18 :     local
19 :     open PrimTypes
20 :     in
21 : macqueen 1947 (* [dbm, 6/21/06] If this is elaborated in the primEnv environment, there is
22 :     already an opened PrimType, so is the above code redundnat? By experimentation,
23 :     it appears that the "local open PrimTypes in ..." is not necessary. *)
24 : blume 573
25 :     structure Assembly = Core.Assembly
26 :    
27 : blume 772 (* The following code was used to create a type-safe version of the InLine
28 :     * structure while preserving the inline property of the functions.
29 :     * Since everything in InLine is now properly typed already, the code
30 :     * should now be seen as:
31 :     * - organizing things a bit better
32 :     * - confirming the type information
33 :     * See compiler/Semant/statenv/prim.sml for the origin of the type info
34 :     * in InLine. (Blume, 1/2001) *)
35 : blume 573 structure InlineT =
36 :     struct
37 :     type 'a control_cont = 'a control_cont
38 :    
39 :     val callcc : ('a cont -> 'a) -> 'a = InLine.callcc
40 :     val throw : 'a cont -> 'a -> 'b = InLine.throw
41 :     val capture : ('a control_cont -> 'a) -> 'a = InLine.capture
42 :     val escape : 'a control_cont -> 'a -> 'b = InLine.cthrow
43 :     val isolate : ('a -> unit) -> 'a cont = InLine.isolate
44 :     val ! : 'a ref -> 'a = InLine.!
45 :     val op := : 'a ref * 'a -> unit = InLine.:=
46 :     val makeref : 'a -> 'a ref = InLine.makeref
47 :     val op = : ''a * ''a -> bool = InLine.=
48 :     val op <> : ''a * ''a -> bool = InLine.<>
49 :     val boxed : 'a -> bool = InLine.boxed
50 :     val unboxed : 'a -> bool = InLine.unboxed
51 :     val cast : 'a -> 'b = InLine.cast
52 :     val identity : 'a -> 'a = InLine.cast
53 :     val objlength : 'a -> int = InLine.objlength
54 :     val mkspecial : int * 'a -> 'b = InLine.mkspecial
55 :     val getspecial : 'a -> int = InLine.getspecial
56 :     val setspecial : ('a * int) -> unit = InLine.setspecial
57 :     val getpseudo : int -> 'a = InLine.getpseudo
58 :     val setpseudo : 'a * int -> unit = InLine.setpseudo
59 :     val gethdlr : unit -> 'a cont = InLine.gethdlr
60 :     val sethdlr : 'a cont -> unit = InLine.sethdlr
61 :     val getvar : unit -> 'a = InLine.getvar
62 :     val setvar : 'a -> unit = InLine.setvar
63 :     val compose : ('b -> 'c) * ('a -> 'b) -> ('a -> 'c) = InLine.compose
64 :     val op before : ('a * 'b) -> 'a = InLine.before
65 : blume 1183 val ignore : 'a -> unit = InLine.ignore
66 : blume 573 val gettag : 'a -> int = InLine.gettag
67 :     val setmark : 'a -> unit = InLine.setmark
68 :     val dispose : 'a -> unit = InLine.dispose
69 :     val inlnot : bool -> bool = InLine.inlnot
70 :     val recordSub : ('a * int) -> 'b = InLine.recordSub
71 :     val raw64Sub : ('a * int) -> real = InLine.raw64Sub
72 :    
73 : mblume 1615 val ptreql : 'a * 'a -> bool = InLine.ptreql
74 :    
75 : blume 573 structure Real64 =
76 :     struct
77 :     val op + : real * real -> real = InLine.f64add
78 :     val op - : real * real -> real = InLine.f64sub
79 :     val op / : real * real -> real = InLine.f64div
80 :     val op * : real * real -> real = InLine.f64mul
81 :     val op == : real * real -> bool = InLine.f64eq
82 :     val op != : real * real -> bool = InLine.f64ne
83 :     val op >= : real * real -> bool = InLine.f64ge
84 :     val op > : real * real -> bool = InLine.f64gt
85 :     val op <= : real * real -> bool = InLine.f64le
86 :     val op < : real * real -> bool = InLine.f64lt
87 :     val ~ : real -> real = InLine.f64neg
88 :     val abs : real -> real = InLine.f64abs
89 : blume 1183
90 :     val min : real * real -> real = InLine.f64min
91 :     val max : real * real -> real = InLine.f64max
92 : mblume 1381
93 :     val from_int31 : int -> real = InLine.real
94 :     val from_int32 : int32 -> real = InLine.real32
95 : blume 573 end
96 :    
97 : mblume 1347 structure IntInf =
98 :     struct
99 :     val test_int31 : intinf -> int = InLine.test_inf_31
100 :     val test_int32 : intinf -> int32 = InLine.test_inf_32
101 :     val trunc_word8 : intinf -> word8 = InLine.trunc_inf_8
102 :     val trunc_word31 : intinf -> word = InLine.trunc_inf_31
103 :     val trunc_word32 : intinf -> word32 = InLine.trunc_inf_32
104 :     val copy_word8 : word8 -> intinf = InLine.copy_8_inf
105 :     val copy_int31 : int -> intinf = InLine.copy_31_inf_i
106 :     val copy_word31 : word -> intinf = InLine.copy_31_inf_w
107 :     val copy_int32 : int32 -> intinf = InLine.copy_32_inf_i
108 :     val copy_word32 : word32 -> intinf = InLine.copy_32_inf_w
109 :     val extend_word8 : word8 -> intinf = InLine.extend_8_inf
110 :     val extend_int31 : int -> intinf = InLine.extend_31_inf_i
111 :     val extend_word31 : word -> intinf = InLine.extend_31_inf_w
112 :     val extend_int32 : int32 -> intinf = InLine.extend_32_inf_i
113 :     val extend_word32 : word32 -> intinf = InLine.extend_32_inf_w
114 :    
115 :     val toInt = test_int31
116 :     val fromInt = extend_int31
117 :     val toLarge : intinf -> intinf = InLine.identity
118 :     val fromLarge : intinf -> intinf = InLine.identity
119 :     end
120 :    
121 : blume 573 structure Word32 =
122 :     struct
123 : mblume 1347 val test_int31 : word32 -> int = InLine.test_32_31_w
124 :     val testu_int31 : word32 -> int = InLine.testu_32_31
125 :     val testu_int32 : word32 -> int32 = InLine.testu_32_32
126 :     val trunc_word31 : word32 -> word = InLine.trunc_32_31_w
127 :     val trunc_word8 : word32 -> word8 = InLine.trunc_32_8_w
128 :     val copy_word8 : word8 -> word32 = InLine.copy_8_32_w
129 :     val copy_word31 : word -> word32 = InLine.copy_31_32_w
130 :     val copyf_int32 : int32 -> word32 = InLine.copy_32_32_iw
131 :     val copyt_int32 : word32 -> int32 = InLine.copy_32_32_wi
132 :     val copy_word32 : word32 -> word32 = InLine.copy_32_32_ww
133 :     val extend_word8 : word8 -> word32 = InLine.extend_8_32_w
134 :     val extend_int31 : int -> word32 = InLine.extend_31_32_iw
135 :     val extend_word31: word -> word32 = InLine.extend_31_32_ww
136 : blume 573
137 : mblume 1347 val toLargeWord = copy_word32
138 :     val toLargeWordX = copy_word32
139 :     val fromLargeWord = copy_word32
140 : georgekuan 2061 val toLargeInt = IntInf.copy_word32
141 :     val toLargeIntX = IntInf.extend_word32
142 : mblume 1347 val fromLargeInt = IntInf.trunc_word32
143 :     val toInt = testu_int31
144 :     val toIntX = test_int31
145 :     val fromInt = extend_int31
146 :    
147 : blume 573 val orb : word32 * word32 -> word32 = InLine.w32orb
148 :     val xorb : word32 * word32 -> word32 = InLine.w32xorb
149 :     val andb : word32 * word32 -> word32 = InLine.w32andb
150 :     val op * : word32 * word32 -> word32 = InLine.w32mul
151 :     val op + : word32 * word32 -> word32 = InLine.w32add
152 :     val op - : word32 * word32 -> word32 = InLine.w32sub
153 : mblume 1683 val ~ : word32 -> word32 = InLine.w32neg
154 : blume 573 val op div : word32 * word32 -> word32 = InLine.w32div
155 : blume 1183 val op mod : word32 * word32 -> word32 = InLine.w32mod
156 : blume 573 val op > : word32 * word32 -> bool = InLine.w32gt
157 :     val op >= : word32 * word32 -> bool = InLine.w32ge
158 :     val op < : word32 * word32 -> bool = InLine.w32lt
159 :     val op <= : word32 * word32 -> bool = InLine.w32le
160 :     val rshift : word32 * word -> word32 = InLine.w32rshift
161 :     val rshiftl : word32 * word -> word32 = InLine.w32rshiftl
162 :     val lshift : word32 * word -> word32 = InLine.w32lshift
163 :     val notb : word32 -> word32 = InLine.w32notb
164 :     val chkLshift : word32 * word -> word32 = InLine.w32ChkLshift
165 :     val chkRshift : word32 * word -> word32 = InLine.w32ChkRshift
166 :     val chkRshiftl : word32 * word -> word32 = InLine.w32ChkRshiftl
167 : blume 1183
168 :     val min : word32 * word32 -> word32 = InLine.w32min
169 :     val max : word32 * word32 -> word32 = InLine.w32max
170 : blume 573 end
171 :    
172 : mblume 1682 structure Word64 =
173 :     struct
174 : mblume 1715 val extern : word64 -> word32 * word32 = InLine.w64p
175 :     val intern : word32 * word32 -> word64 = InLine.p64w
176 : mblume 1682 end
177 :    
178 : mblume 1347 structure Int32 =
179 :     struct
180 :     val test_int31 : int32 -> int = InLine.test_32_31_i
181 :     val trunc_word8 : int32 -> word8 = InLine.trunc_32_8_i
182 :     val trunc_word31 : int32 -> word = InLine.trunc_32_31_i
183 :     val copy_word8 : word8 -> int32 = InLine.copy_8_32_i
184 :     val copy_word31 : word -> int32 = InLine.copy_31_32_i
185 :     val copy_int32 : int32 -> int32 = InLine.copy_32_32_ii
186 :     val extend_word8 : word8 -> int32 = InLine.extend_8_32_i
187 :     val extend_int31 : int -> int32 = InLine.extend_31_32_ii
188 :     val extend_word31: word -> int32 = InLine.extend_31_32_wi
189 :    
190 :     val toInt = test_int31
191 :     val fromInt = extend_int31
192 :     val toLarge = IntInf.extend_int32
193 :     val fromLarge = IntInf.test_int32
194 :    
195 :     val op * : int32 * int32 -> int32 = InLine.i32mul
196 :     val op quot : int32 * int32 -> int32 = InLine.i32quot
197 :     val op rem : int32 * int32 -> int32 = InLine.i32rem
198 :     val op div : int32 * int32 -> int32 = InLine.i32div
199 :     val op mod : int32 * int32 -> int32 = InLine.i32mod
200 :     val op + : int32 * int32 -> int32 = InLine.i32add
201 :     val op - : int32 * int32 -> int32 = InLine.i32sub
202 :     val ~ : int32 -> int32 = InLine.i32neg
203 :     val andb : int32 * int32 -> int32 = InLine.i32andb
204 :     val orb : int32 * int32 -> int32 = InLine.i32orb
205 :     val xorb : int32 * int32 -> int32 = InLine.i32xorb
206 :     val rshift : int32 * int32 -> int32 = InLine.i32rshift
207 :     val lshift : int32 * int32 -> int32 = InLine.i32lshift
208 :     val op < : int32 * int32 -> bool = InLine.i32lt
209 :     val op <= : int32 * int32 -> bool = InLine.i32le
210 :     val op > : int32 * int32 -> bool = InLine.i32gt
211 :     val op >= : int32 * int32 -> bool = InLine.i32ge
212 :     val op = : int32 * int32 -> bool = InLine.i32eq
213 :     val op <> : int32 * int32 -> bool = InLine.i32ne
214 :    
215 :     val min : int32 * int32 -> int32 = InLine.i32min
216 :     val max : int32 * int32 -> int32 = InLine.i32max
217 :     val abs : int32 -> int32 = InLine.i32abs
218 :     end
219 :    
220 : blume 573 structure Word31 =
221 :     struct
222 : mblume 1347 val testu_int31 : word -> int = InLine.testu_31_31
223 :     val copyt_int31 : word -> int = InLine.copy_31_31_wi
224 :     val copyf_int31 : int -> word = InLine.copy_31_31_iw
225 : blume 573
226 : mblume 1347 val toLargeWord = Word32.copy_word31
227 :     val toLargeWordX = Word32.extend_word31
228 :     val fromLargeWord = Word32.trunc_word31
229 :     val toLargeInt = IntInf.copy_word31
230 :     val toLargeIntX = IntInf.extend_word31
231 :     val fromLargeInt = IntInf.trunc_word31
232 :     val toInt = testu_int31
233 :     val toIntX = copyt_int31
234 :     val fromInt = copyf_int31
235 :    
236 : blume 573 val orb : word * word -> word = InLine.w31orb
237 :     val xorb : word * word -> word = InLine.w31xorb
238 :     val andb : word * word -> word = InLine.w31andb
239 :     val op * : word * word -> word = InLine.w31mul
240 :     val op + : word * word -> word = InLine.w31add
241 :     val op - : word * word -> word = InLine.w31sub
242 : mblume 1683 val ~ : word -> word = InLine.w31neg
243 : blume 573 val op div : word * word -> word = InLine.w31div
244 : blume 1183 val op mod : word * word -> word = InLine.w31mod
245 : blume 573 val op > : word * word -> bool = InLine.w31gt
246 :     val op >= : word * word -> bool = InLine.w31ge
247 :     val op < : word * word -> bool = InLine.w31lt
248 :     val op <= : word * word -> bool = InLine.w31le
249 :     val rshift : word * word -> word = InLine.w31rshift
250 :     val rshiftl : word * word -> word = InLine.w31rshiftl
251 :     val lshift : word * word -> word = InLine.w31lshift
252 :     val chkLshift : word * word -> word = InLine.w31ChkLshift
253 :     val chkRshift : word * word -> word = InLine.w31ChkRshift
254 :     val chkRshiftl : word * word -> word = InLine.w31ChkRshiftl
255 :     val notb : word -> word = InLine.w31notb
256 : blume 1183
257 :     val min : word * word -> word = InLine.w31min
258 :     val max : word * word -> word = InLine.w31max
259 : blume 573 end
260 :    
261 : mblume 1347 structure Int31 =
262 :     struct
263 :     val trunc_word8 : int -> word8 = InLine.trunc_31_8
264 :     val copy_int31 : int -> int = InLine.copy_31_31_ii
265 :     val copy_word8 : word8 -> int = InLine.copy_8_31
266 :     val extend_word8 : word8 -> int = InLine.extend_8_31
267 :    
268 :     val toInt = copy_int31
269 :     val fromInt = copy_int31
270 :     val toLarge = IntInf.extend_int31
271 :     val fromLarge = IntInf.test_int31
272 :    
273 :     val op * : int * int -> int = InLine.i31mul
274 :     val op quot : int * int -> int = InLine.i31quot
275 :     val op rem : int * int -> int = InLine.i31rem
276 :     val op div : int * int -> int = InLine.i31div
277 :     val op mod : int * int -> int = InLine.i31mod
278 :     val op + : int * int -> int = InLine.i31add
279 :     val op - : int * int -> int = InLine.i31sub
280 :     val ~ : int -> int = InLine.i31neg
281 :     val andb : int * int -> int = InLine.i31andb
282 :     val orb : int * int -> int = InLine.i31orb
283 :     val xorb : int * int -> int = InLine.i31xorb
284 :     val rshift : int * int -> int = InLine.i31rshift
285 :     val lshift : int * int -> int = InLine.i31lshift
286 :     val notb : int -> int = InLine.i31notb
287 :     val op < : int * int -> bool = InLine.i31lt
288 :     val op <= : int * int -> bool = InLine.i31le
289 :     val op > : int * int -> bool = InLine.i31gt
290 :     val op >= : int * int -> bool = InLine.i31ge
291 :     val op = : int * int -> bool = InLine.i31eq
292 :     val op <> : int * int -> bool = InLine.i31ne
293 :     val ltu : int * int -> bool = InLine.i31ltu
294 :     val geu : int * int -> bool = InLine.i31geu
295 :    
296 :     val min : int * int -> int = InLine.i31min
297 :     val max : int * int -> int = InLine.i31max
298 :     val abs : int -> int = InLine.i31abs
299 :     end
300 :    
301 : mblume 1682 structure Int64 =
302 :     struct
303 : mblume 1715 val extern : int64 -> word32 * word32 = InLine.i64p
304 :     val intern : word32 * word32 -> int64 = InLine.p64i
305 : mblume 1682 end
306 :    
307 : blume 573 structure Word8 =
308 :     struct
309 :    
310 : mblume 1347 (* LargeInt is still 32 bit: *)
311 :     val toLargeWord = Word32.copy_word8
312 :     val toLargeWordX = Word32.extend_word8
313 :     val fromLargeWord = Word32.trunc_word8
314 :     val toLargeInt = IntInf.copy_word8
315 :     val toLargeIntX = IntInf.extend_word8
316 :     val fromLargeInt = IntInf.trunc_word8
317 :     val toInt = Int31.copy_word8
318 :     val toIntX = Int31.extend_word8
319 :     val fromInt = Int31.trunc_word8
320 :    
321 : blume 573 (* temporary framework, because the actual word8 operators
322 :     * are not implemented*)
323 : mblume 1683 (* WARNING! some of the following operators
324 :     * don't get the high-order bits right *)
325 :     val orb : word8 * word8 -> word8 = InLine.w31orb_8
326 :     val xorb : word8 * word8 -> word8 = InLine.w31xorb_8
327 :     val andb : word8 * word8 -> word8 = InLine.w31andb_8
328 :     val op * : word8 * word8 -> word8 = InLine.w31mul_8
329 :     val op + : word8 * word8 -> word8 = InLine.w31add_8
330 :     val op - : word8 * word8 -> word8 = InLine.w31sub_8
331 :     val ~ : word8 -> word8 = InLine.w31neg_8
332 :     val op div : word8 * word8 -> word8 = InLine.w31div_8
333 :     val op mod : word8 * word8 -> word8 = InLine.w31mod_8
334 :     val op > : word8 * word8 -> bool = InLine.w31gt_8
335 :     val op >= : word8 * word8 -> bool = InLine.w31ge_8
336 :     val op < : word8 * word8 -> bool = InLine.w31lt_8
337 :     val op <= : word8 * word8 -> bool = InLine.w31le_8
338 :     val rshift : word8 * word -> word8 = InLine.w31rshift_8
339 :     val rshiftl : word8 * word -> word8 = InLine.w31rshift_8
340 :     val lshift : word8 * word -> word8 = InLine.w31lshift_8
341 :     val notb : word8 -> word8 = InLine.w31notb_8
342 :     val chkLshift : word8 * word -> word8 = InLine.w31ChkLshift_8
343 :     val chkRshift : word8 * word -> word8 = InLine.w31ChkRshift_8
344 :     val chkRshiftl : word8 * word -> word8 = InLine.w31ChkRshiftl_8
345 :    
346 :     val min : word8 * word8 -> word8 = InLine.w31min_8
347 :     val max : word8 * word8 -> word8 = InLine.w31max_8
348 : blume 573 end
349 :    
350 :     structure Char =
351 :     struct
352 :    
353 :     val maxOrd = 255
354 :     exception Chr
355 :    
356 :     (* the following should be an inline operator *)
357 :     fun chr i = if (Int31.geu(i, Int31.+(maxOrd,1)))
358 :     then raise Chr
359 :     else ((InLine.cast i) : char)
360 :    
361 :     val ord : char -> int = InLine.cast
362 :    
363 : blume 772 val (op <) : (char * char) -> bool = InLine.i31lt_c
364 :     val (op <=) : (char * char) -> bool = InLine.i31le_c
365 :     val (op >) : (char * char) -> bool = InLine.i31gt_c
366 :     val (op >=) : (char * char) -> bool = InLine.i31ge_c
367 : blume 573 end
368 :    
369 :     structure PolyArray =
370 :     struct
371 :     val newArray0 : unit -> 'a array = InLine.newArray0
372 :     val array : int * 'a -> 'a array = InLine.mkarray
373 :     val length : 'a array -> int = InLine.length
374 :     val sub : 'a array * int -> 'a = InLine.arrSub
375 :     val chkSub : 'a array * int -> 'a = InLine.arrChkSub
376 :     val update : 'a array * int * 'a -> unit = InLine.arrUpdate
377 :     val chkUpdate : 'a array * int * 'a -> unit = InLine.arrChkUpdate
378 :     val getData : 'a array -> 'b = InLine.getSeqData
379 :     end
380 :    
381 :     structure PolyVector =
382 :     struct
383 :     val length : 'a vector -> int = InLine.length
384 :     val sub : 'a vector * int -> 'a = InLine.vecSub
385 :     val chkSub : 'a vector * int -> 'a = InLine.vecChkSub
386 :     val getData : 'a vector -> 'b = InLine.getSeqData
387 :     end
388 :    
389 :     (* The type of this ought to be float64array *)
390 :     structure Real64Array =
391 :     struct
392 :     val newArray0 : unit -> Assembly.A.real64array = InLine.newArray0
393 :     val length : Assembly.A.real64array -> int = InLine.length
394 :     val sub : Assembly.A.real64array * int -> real = InLine.f64Sub
395 :     val chkSub : Assembly.A.real64array * int -> real = InLine.f64chkSub
396 :     val update : Assembly.A.real64array * int * real -> unit = InLine.f64Update
397 :     val chkUpdate : Assembly.A.real64array * int * real -> unit = InLine.f64chkUpdate
398 :     val getData : Assembly.A.real64array -> 'b = InLine.getSeqData
399 :     end
400 :    
401 :     (** NOTE: we are currently using polymorphic vectors to implement the Real64Vector
402 :     ** structure.
403 :     **)
404 :     structure Real64Vector =
405 :     struct
406 :     val length : real vector -> int = InLine.length
407 :     val sub : real vector * int -> real = InLine.vecSub
408 :     val chkSub : real vector * int -> real = InLine.vecChkSub
409 :     val getData : real vector -> 'b = InLine.getSeqData
410 :     end
411 :    
412 :     structure Word8Array =
413 :     struct
414 :     type array = Assembly.A.word8array
415 :     val newArray0 : unit -> array = InLine.newArray0
416 :     val length : array -> int = InLine.length
417 :     (* BUG: using "ordof" for W8A.sub is dangerous, because ordof is
418 :     (technically) fetching from immutable things. A fancy optimizer might
419 :     someday be confused. *)
420 :     val sub : array * int -> word8 = InLine.ordof
421 :     val chkSub : array * int -> word8 = InLine.inlbyteof
422 :     val update : array * int * word8 -> unit = InLine.store
423 :     val chkUpdate : array * int * word8 -> unit = InLine.inlstore
424 :     val getData : array -> 'a = InLine.getSeqData
425 :     end
426 :    
427 : mblume 1393 (* preliminary version with just the type *)
428 :     structure Word8Vector :> sig
429 :     eqtype vector
430 :     val create : int -> vector
431 :     end = struct
432 :     type vector = string
433 :     val create = Assembly.A.create_s
434 :     end
435 :    
436 :     (* now the real version with all values *)
437 : blume 573 structure Word8Vector =
438 :     struct
439 : mblume 1393 open Word8Vector
440 :     val length : vector -> int = InLine.length
441 : blume 573 val sub : vector * int -> word8 = InLine.ordof
442 :     val chkSub : vector * int -> word8 = InLine.inlordof
443 :     val update : vector * int * word8 -> unit = InLine.store
444 :     val getData : vector -> 'a = InLine.getSeqData
445 :     end
446 :    
447 : mblume 1393 structure CharArray :> sig (* prelim *)
448 :     eqtype array
449 :     val newArray0 : unit -> array
450 :     val create : int -> array
451 :     end = struct
452 :     type array = Assembly.A.word8array
453 :     val newArray0 : unit -> array = InLine.newArray0
454 :     val create = Assembly.A.create_b
455 :     end
456 :    
457 :     structure CharArray = (* full *)
458 : blume 573 struct
459 : mblume 1393 open CharArray
460 : blume 573 val length : array -> int = InLine.length
461 :     val chkSub : (array * int) -> char = InLine.inlordof
462 :     val chkUpdate : (array * int * char) -> unit = InLine.inlstore
463 :     val sub : (array * int) -> char = InLine.ordof
464 :     val update : (array * int * char) -> unit = InLine.store
465 :     val getData : array -> 'a = InLine.getSeqData
466 :     end
467 :    
468 :     structure CharVector =
469 :     struct
470 :     val length : string -> int = InLine.length
471 :     val chkSub : (string * int) -> char = InLine.inlordof
472 :     val sub : (string * int) -> char = InLine.ordof
473 :     val update : (string * int * char) -> unit = InLine.store
474 :     val getData : string -> 'a = InLine.getSeqData
475 :     end
476 :    
477 :     structure DfltInt = Int31
478 :     structure DfltWord = Word31
479 :     structure DfltReal = Real64
480 :    
481 :     end (* structure InlineT *)
482 :    
483 :     end (* local *)

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