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
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
|
/* __ *\
** ________ ___ / / ___ Scala API **
** / __/ __// _ | / / / _ | (c) 2003-2010, LAMP/EPFL **
** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ **
** /____/\___/_/ |_/____/_/ | | **
** |/ **
\* */
// $Id$
package scala.io
import java.io.{ FileInputStream, InputStream, PrintStream, File => JFile }
import java.net.{ URI, URL }
/** This object provides convenience methods to create an iterable
* representation of a source file.
*
* @author Burak Emir, Paul Phillips
* @version 1.0, 19/08/2004
*/
object Source {
val DefaultBufSize = 2048
/** Creates a <code>Source</code> from System.in.
*/
def stdin = fromInputStream(System.in)
/** Creates a <code>Source</code> from an Iterable.
*
* @param iterable the Iterable
* @return the <code>Source</code> instance.
*/
def fromIterable(iterable: Iterable[Char]): Source = new Source {
val iter = iterable.iterator
} withReset(() => fromIterable(iterable))
/** Creates a <code>Source</code> instance from a single character.
*
* @param c ...
* @return the create <code>Source</code> instance.
*/
def fromChar(c: Char): Source = fromIterable(Array(c))
/** creates Source from array of characters, with empty description.
*
* @param chars ...
* @return ...
*/
def fromChars(chars: Array[Char]): Source = fromIterable(chars)
/** creates Source from string, with empty description.
*
* @param s ...
* @return ...
*/
def fromString(s: String): Source = fromIterable(s)
/** Create a <code>Source</code> from array of bytes, decoding
* the bytes according to codec.
*
* @param bytes ...
* @param enc ...
* @return the created <code>Source</code> instance.
*/
def fromBytes(bytes: Array[Byte])(implicit codec: Codec = Codec.default): Source =
fromString(new String(bytes, codec.name))
/** Create a <code>Source</code> from array of bytes, assuming
* one byte per character (ISO-8859-1 encoding.)
*/
def fromRawBytes(bytes: Array[Byte]): Source = fromString(new String(bytes, Codec.ISO8859.name))
/** creates Source from file with given name, setting
* its description to filename.
*/
def fromPath(name: String)(implicit codec: Codec = Codec.default): Source = fromFile(new JFile(name))
/** creates <code>Source</code> from file with given file: URI
*/
def fromURI(uri: URI)(implicit codec: Codec = Codec.default): Source = fromFile(new JFile(uri))
/** same as fromInputStream(url.openStream())(codec)
*/
def fromURL(url: URL)(implicit codec: Codec = Codec.default): Source =
fromInputStream(url.openStream())(codec)
/** Creates Source from <code>file</code>, using given character encoding,
* setting its description to filename. Input is buffered in a buffer of
* size <code>bufferSize</code>.
*/
def fromFile(file: JFile, bufferSize: Int = DefaultBufSize)(implicit codec: Codec = Codec.default): Source = {
val inputStream = new FileInputStream(file)
fromInputStream(
inputStream,
bufferSize,
() => fromFile(file, bufferSize)(codec),
() => inputStream.close()
) withDescription ("file:" + file.getAbsolutePath)
}
/** Reads data from <code>inputStream</code> with a buffered reader,
* using encoding in implicit parameter <code>codec</code>.
*
* @param inputStream the input stream from which to read
* @param bufferSize buffer size (defaults to Source.DefaultBufSize)
* @param reset a () => Source which resets the stream (if unset, reset() will throw an Exception)
* @param codec (implicit) a scala.io.Codec specifying behavior (defaults to Codec.default)
* @return the buffered source
*/
def fromInputStream(
inputStream: InputStream,
bufferSize: Int = DefaultBufSize,
reset: () => Source = null,
close: () => Unit = null
)(implicit codec: Codec = Codec.default): Source =
{
// workaround for default arguments being unable to refer to other parameters
val resetFn = if (reset == null) () => fromInputStream(inputStream, bufferSize, reset, close) else reset
new BufferedSource(inputStream)(codec) .
withReset (resetFn) .
withClose (close)
}
}
// Coming Soon?
//
// abstract class Source2[T] extends Iterable[T] { }
//
// abstract class ByteSource() extends Source2[Byte] { }
//
// abstract class CharSource(implicit codec: Codec = Codec.default) extends Source2[Char] { }
/** The class <code>Source</code> implements an iterable representation
* of source data. Calling method <code>reset</code> returns an identical,
* resetted source, where possible.
*
* @author Burak Emir
* @version 1.0
*/
abstract class Source extends Iterator[Char]
{
/** the actual iterator */
protected val iter: Iterator[Char]
// ------ public values
/** description of this source, default empty */
var descr: String = ""
var nerrors = 0
var nwarnings = 0
/** convenience method, returns given line (not including newline)
* from Source.
*
* @param line the line index, first line is 1
* @return the character string of the specified line.
*
*/
def getLine(line: Int): String = getLines() drop (line - 1) next
class LineIterator(separator: String) extends Iterator[String] {
require(separator.length == 1 || separator.length == 2, "Line separator may be 1 or 2 characters only.")
lazy val iter: BufferedIterator[Char] = Source.this.iter.buffered
// For two character newline sequences like \r\n, we peek at
// the iterator head after seeing \r, and drop the \n if present.
val isNewline: Char => Boolean = {
val firstCh = separator(0)
if (separator.length == 1) (_ == firstCh)
else (ch: Char) => (ch == firstCh) && iter.hasNext && {
val res = iter.head == separator(1)
if (res) { iter.next } // drop the second character
res
}
}
private[this] val sb = new StringBuilder
private def getc() =
if (!iter.hasNext) false
else {
val ch = iter.next
if (isNewline(ch)) false
else {
sb append ch
true
}
}
def hasNext = iter.hasNext
def next = {
sb.clear
while (getc()) { }
sb.toString
}
}
/** returns an iterator who returns lines (NOT including newline character(s)).
* If no separator is given, the platform-specific value "line.separator" is used.
* a line ends in \r, \n, or \r\n.
*/
def getLines(separator: String = compat.Platform.EOL): Iterator[String] =
new LineIterator(separator)
/** Returns <code>true</code> if this source has more characters.
*/
def hasNext = iter.hasNext
/** Returns next character.
*/
def next: Char = positioner.next
class Positioner {
/** the last character returned by next. */
var ch: Char = _
/** position of last character returned by next */
var pos = 0
/** current line and column */
var cline = 1
var ccol = 1
/** default col increment for tabs '\t', set to 4 initially */
var tabinc = 4
def next: Char = {
ch = iter.next
pos = Position.encode(cline, ccol)
ch match {
case '\n' =>
ccol = 1
cline += 1
case '\t' =>
ccol += tabinc
case _ =>
ccol += 1
}
ch
}
}
object NoPositioner extends Positioner {
override def next: Char = iter.next
}
def ch = positioner.ch
def pos = positioner.pos
/** Reports an error message to the output stream <code>out</code>.
*
* @param pos the source position (line/column)
* @param msg the error message to report
* @param out PrintStream to use (optional: defaults to <code>Console.err</code>)
*/
def reportError(
pos: Int,
msg: String,
out: PrintStream = Console.err)
{
nerrors += 1
report(pos, msg, out)
}
private def spaces(n: Int) = List.fill(n)(' ').mkString
/**
* @param pos the source position (line/column)
* @param msg the error message to report
* @param out PrintStream to use
*/
def report(pos: Int, msg: String, out: PrintStream) {
val line = Position line pos
val col = Position column pos
out println "%s:%d:%d: %s%s%s^".format(descr, line, col, msg, getLine(line), spaces(col - 1))
}
/**
* @param pos the source position (line/column)
* @param msg the warning message to report
* @param out PrintStream to use (optional: defaults to <code>Console.out</code>)
*/
def reportWarning(
pos: Int,
msg: String,
out: PrintStream = Console.out)
{
nwarnings += 1
report(pos, "warning! " + msg, out)
}
private[this] var resetFunction: () => Source = null
private[this] var closeFunction: () => Unit = null
private[this] var positioner: Positioner = new Positioner
def withReset(f: () => Source): this.type = {
resetFunction = f
this
}
def withClose(f: () => Unit): this.type = {
closeFunction = f
this
}
def withDescription(text: String): this.type = {
descr = text
this
}
// we'd like to default to no positioning, but for now we break
// less by defaulting to status quo.
def withPositioning(on: Boolean): this.type = {
positioner = if (on) new Positioner else NoPositioner
this
}
/** The close() method closes the underlying resource. */
def close(): Unit =
if (closeFunction != null) closeFunction()
/** The reset() method creates a fresh copy of this Source. */
def reset(): Source =
if (resetFunction != null) resetFunction()
else throw new UnsupportedOperationException("Source's reset() method was not set.")
}
|