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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
|
(* Copyright (C) 1999-2007 Henry Cejtin, Matthew Fluet, Suresh
* Jagannathan, and Stephen Weeks.
* Copyright (C) 1997-2000 NEC Research Institute.
*
* MLton is released under a HPND-style license.
* See the file MLton-LICENSE for details.
*)
structure StringCvt: STRING_CVT_EXTRA =
struct
open Reader
val wordFromInt = Word.sextdFromInt
datatype radix = BIN | OCT | DEC | HEX
val radixToInt: radix -> int =
fn BIN => 2
| OCT => 8
| DEC => 10
| HEX => 16
val radixToWord: radix -> word = wordFromInt o radixToInt
datatype realfmt =
SCI of int option
| FIX of int option
| GEN of int option
| EXACT
type ('a, 'b) reader = 'b -> ('a * 'b) option
open Int
local
fun pad f (c: char) i s =
let
val n = String.size s
in
if n >= i
then s
else f (s, String.vector (i -! n, c))
end
in
val padLeft = pad (fn (s, pad) => String.^ (pad, s))
val padRight = pad String.^
end
fun splitl p f src =
let fun done chars = String.implode (rev chars)
fun loop (src, chars) =
case f src of
NONE => (done chars, src)
| SOME (c, src') =>
if p c
then loop (src', c :: chars)
else (done chars, src)
in loop (src, [])
end
fun takel p f s = #1 (splitl p f s)
fun dropl p f s = #2 (splitl p f s)
type cs = int
fun stringReader (s: string): (char, cs) reader =
fn i => if i >= String.size s
then NONE
else SOME (String.sub (s, i), i + 1)
fun 'a scanString (f: ((char, cs) reader -> ('a, cs) reader)) (s: string)
: 'a option =
case f (stringReader s) 0 of
NONE => NONE
| SOME (a, _) => SOME a
local
fun memoize (f: char -> 'a): char -> 'a =
let val a = Array.tabulate (Char.numChars, f o Char.chrUnsafe)
in fn c => Array.sub (a, Char.ord c)
end
fun range (add: int, cmin: char, cmax: char): char -> int option =
let val min = Char.ord cmin
in fn c => if Char.<= (cmin, c) andalso Char.<= (c, cmax)
then SOME (add +! Char.ord c -! min)
else NONE
end
fun 'a combine (ds: (char -> 'a option) list): char -> 'a option =
memoize
(fn c =>
let
val rec loop =
fn [] => NONE
| d :: ds =>
case d c of
NONE => loop ds
| z => z
in loop ds
end)
val bin = memoize (range (0, #"0", #"1"))
val oct = memoize (range (0, #"0", #"7"))
val dec = memoize (range (0, #"0", #"9"))
val hex = combine [range (0, #"0", #"9"),
range (10, #"a", #"f"),
range (10, #"A", #"F")]
fun isSpace c = (c = #" " orelse c = #"\t" orelse c = #"\r" orelse
c = #"\n" orelse c = #"\v" orelse c = #"\f")
in
val isSpace = memoize isSpace
fun skipWS x = dropl isSpace x
fun charToDigit (radix: radix): char -> int option =
case radix of
BIN => bin
| OCT => oct
| DEC => dec
| HEX => hex
end
fun charToWDigit radix = (Option.map wordFromInt) o (charToDigit radix)
fun digits (radix, max, accum) reader state =
let
val r = radixToInt radix
fun loop (max, accum, state) =
let fun done () = SOME (accum, state)
in if max <= 0
then done ()
else
case reader state of
NONE => done ()
| SOME (c, state) =>
case charToDigit radix c of
NONE => done ()
| SOME n => loop (max - 1, n + accum * r, state)
end
in loop (max, accum, state)
end
fun digitsPlus (radix, max) reader state =
case reader state of
NONE => NONE
| SOME (c, state) =>
case charToDigit radix c of
NONE => NONE
| SOME n => digits (radix, max -! 1, n) reader state
fun digitsExact (radix, num) reader state =
let val r = radixToInt radix
fun loop (num, accum, state) =
if num <= 0
then SOME (accum, state)
else
case reader state of
NONE => NONE
| SOME (c, state) =>
case charToDigit radix c of
NONE => NONE
| SOME n => loop (num - 1, n + accum * r, state)
in loop (num, 0, state)
end
fun digits radix reader state =
let
val r = radixToInt radix
fun loop (accum, state) =
case reader state of
NONE => SOME (accum, state)
| SOME (c, state') =>
case charToDigit radix c of
NONE => SOME (accum, state)
| SOME n => loop (n + accum * r, state')
in case reader state of
NONE => NONE
| SOME (c, state) =>
case charToDigit radix c of
NONE => NONE
| SOME n => loop (n, state)
end
fun wdigits radix reader state =
let
val op + = Word.+
val op * = Word.*
val r = radixToWord radix
fun loop (accum, state) =
case reader state of
NONE => SOME (accum, state)
| SOME (c, state') =>
case charToWDigit radix c of
NONE => SOME (accum, state)
| SOME n => loop (n + accum * r, state')
in case reader state of
NONE => NONE
| SOME (c, state) =>
case charToWDigit radix c of
NONE => NONE
| SOME n => loop (n, state)
end
fun digitToChar (n: int): char = String.sub ("0123456789ABCDEF", n)
end
|
