1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
(*
Title: Rebuild the basis library: IO
Copyright David C.J. Matthews 2016
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License version 2.1 as published by the Free Software Foundation.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*)
(* IO *)
(* This is much simpler if we ignore PrimIO. *)
useBasis "STREAM_IO.sml";
useBasis "IMPERATIVE_IO.sml";
signature TEXT_STREAM_IO =
sig
include STREAM_IO
where type vector = CharVector.vector
where type elem = Char.char
val inputLine : instream -> (string * instream) option
val outputSubstr : outstream * Substring.substring -> unit
end;
signature TEXT_IO =
sig
(* include IMPERATIVE_IO *)
structure StreamIO : TEXT_STREAM_IO
where type reader = TextPrimIO.reader
where type writer = TextPrimIO.writer
where type pos = TextPrimIO.pos
type vector = StreamIO.vector
type elem = StreamIO.elem
type instream
type outstream
val input : instream -> vector
val input1 : instream -> elem option
val inputN : instream * int -> vector
val inputAll : instream -> vector
val canInput : instream * int -> int option
val lookahead : instream -> elem option
val closeIn : instream -> unit
val endOfStream : instream -> bool
val output : outstream * vector -> unit
val output1 : outstream * elem -> unit
val flushOut : outstream -> unit
val closeOut : outstream -> unit
val mkInstream : StreamIO.instream -> instream
val getInstream : instream -> StreamIO.instream
val setInstream : instream * StreamIO.instream -> unit
val mkOutstream : StreamIO.outstream -> outstream
val getOutstream : outstream -> StreamIO.outstream
val setOutstream : outstream * StreamIO.outstream -> unit
val getPosOut : outstream -> StreamIO.out_pos
val setPosOut : outstream * StreamIO.out_pos -> unit
(* End of include IMPERATIVE_IO *)
val inputLine : instream -> string option
val outputSubstr : outstream * Substring.substring -> unit
val openIn : string -> instream
val openOut : string -> outstream
val openAppend : string -> outstream
val openString : string -> instream
val stdIn : instream
val stdOut : outstream
val stdErr : outstream
val print : string -> unit
val scanStream : ((Char.char, StreamIO.instream) StringCvt.reader
-> ('a, StreamIO.instream) StringCvt.reader)
-> instream -> 'a option
end;
structure TextIO: TEXT_IO =
struct
open TextIO
val canInput =
fn (s, n) => Option.map FixedInt.toLarge (canInput(s, FixedInt.fromLarge n))
val inputN =
fn (s, n) => inputN(s, FixedInt.fromLarge n)
structure StreamIO =
struct
open StreamIO
val canInput =
fn (s, n) => Option.map FixedInt.toLarge (canInput(s, FixedInt.fromLarge n))
val inputN =
fn (s, n) => inputN(s, FixedInt.fromLarge n)
end
end;
signature BIN_IO =
sig
include IMPERATIVE_IO
where type StreamIO.vector = Word8Vector.vector
where type StreamIO.elem = Word8.word
where type StreamIO.reader = BinPrimIO.reader
where type StreamIO.writer = BinPrimIO.writer
where type StreamIO.pos = BinPrimIO.pos
val openIn : string -> instream
val openOut : string -> outstream
val openAppend : string -> outstream
end;
structure BinIO: BIN_IO =
struct
open BinIO
val canInput =
fn (s, n) => Option.map FixedInt.toLarge (canInput(s, FixedInt.fromLarge n))
val inputN =
fn (s, n) => inputN(s, FixedInt.fromLarge n)
structure StreamIO =
struct
open StreamIO
val canInput =
fn (s, n) => Option.map FixedInt.toLarge (canInput(s, FixedInt.fromLarge n))
val inputN =
fn (s, n) => inputN(s, FixedInt.fromLarge n)
end
end;
|
