← Back to branch summary

~ubuntu-branches/ubuntu/vivid/golang/vivid

« back to all changes in this revision

Viewing changes to src/pkg/bufio/bufio.go

  • Committer: Package Import Robot
  • Author(s): Serge Hallyn
  • Date: 2014-11-18 15:12:26 UTC
  • mfrom: (14.2.12 vivid-proposed)
  • Revision ID: package-import@ubuntu.com-20141118151226-zug7vn93mn3dtiz3
Tags: 2:1.3.2-1ubuntu1
* Merge from Debian unstable.  Remaining changes:
  - 016-armhf-elf-header.patch: Use correct ELF header for armhf binaries.
  - Support co-installability with gccgo-go tool:
    - d/rules,golang-go.install: Rename bin/go -> bin/golang-go
    - d/golang-go.{postinst,prerm}: Install/remove /usr/bin/go using
      alternatives.
  - d/copyright: Amendments for full compiliance with copyright format.
  - d/control: Demote golang-go.tools to Suggests to support Ubuntu MIR.
  - dropped patches (now upstream):
    - d/p/issue27650045_40001_50001.diff
    - d/p/issue28050043_60001_70001.diff
    - d/p/issue54790044_100001_110001.diff

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/pkg/bufio/bufio.go
38
38
}
39
39
 
40
40
const minReadBufferSize = 16
 
41
const maxConsecutiveEmptyReads = 100
41
42
 
42
43
// NewReaderSize returns a new Reader whose buffer has at least the specified
43
44
// size. If the argument io.Reader is already a Reader with large enough
87
88
                b.r = 0
88
89
        }
89
90
 
90
 
        // Read new data.
91
 
        n, err := b.rd.Read(b.buf[b.w:])
92
 
        if n < 0 {
93
 
                panic(errNegativeRead)
94
 
        }
95
 
        b.w += n
96
 
        if err != nil {
97
 
                b.err = err
98
 
        }
 
91
        if b.w >= len(b.buf) {
 
92
                panic("bufio: tried to fill full buffer")
 
93
        }
 
94
 
 
95
        // Read new data: try a limited number of times.
 
96
        for i := maxConsecutiveEmptyReads; i > 0; i-- {
 
97
                n, err := b.rd.Read(b.buf[b.w:])
 
98
                if n < 0 {
 
99
                        panic(errNegativeRead)
 
100
                }
 
101
                b.w += n
 
102
                if err != nil {
 
103
                        b.err = err
 
104
                        return
 
105
                }
 
106
                if n > 0 {
 
107
                        return
 
108
                }
 
109
        }
 
110
        b.err = io.ErrNoProgress
99
111
}
100
112
 
101
113
func (b *Reader) readErr() error {
115
127
        if n > len(b.buf) {
116
128
                return nil, ErrBufferFull
117
129
        }
 
130
        // 0 <= n <= len(b.buf)
118
131
        for b.w-b.r < n && b.err == nil {
119
 
                b.fill()
 
132
                b.fill() // b.w-b.r < len(b.buf) => buffer is not full
120
133
        }
121
134
        m := b.w - b.r
122
135
        if m > n {
142
155
        if n == 0 {
143
156
                return 0, b.readErr()
144
157
        }
145
 
        if b.w == b.r {
 
158
        if b.r == b.w {
146
159
                if b.err != nil {
147
160
                        return 0, b.readErr()
148
161
                }
150
163
                        // Large read, empty buffer.
151
164
                        // Read directly into p to avoid copy.
152
165
                        n, b.err = b.rd.Read(p)
 
166
                        if n < 0 {
 
167
                                panic(errNegativeRead)
 
168
                        }
153
169
                        if n > 0 {
154
170
                                b.lastByte = int(p[n-1])
155
171
                                b.lastRuneSize = -1
156
172
                        }
157
173
                        return n, b.readErr()
158
174
                }
159
 
                b.fill()
 
175
                b.fill() // buffer is empty
160
176
                if b.w == b.r {
161
177
                        return 0, b.readErr()
162
178
                }
176
192
// If no byte is available, returns an error.
177
193
func (b *Reader) ReadByte() (c byte, err error) {
178
194
        b.lastRuneSize = -1
179
 
        for b.w == b.r {
 
195
        for b.r == b.w {
180
196
                if b.err != nil {
181
197
                        return 0, b.readErr()
182
198
                }
183
 
                b.fill()
 
199
                b.fill() // buffer is empty
184
200
        }
185
201
        c = b.buf[b.r]
186
202
        b.r++
190
206
 
191
207
// UnreadByte unreads the last byte.  Only the most recently read byte can be unread.
192
208
func (b *Reader) UnreadByte() error {
193
 
        b.lastRuneSize = -1
194
 
        if b.r == b.w && b.lastByte >= 0 {
 
209
        if b.lastByte < 0 || b.r == 0 && b.w > 0 {
 
210
                return ErrInvalidUnreadByte
 
211
        }
 
212
        // b.r > 0 || b.w == 0
 
213
        if b.r > 0 {
 
214
                b.r--
 
215
        } else {
 
216
                // b.r == 0 && b.w == 0
195
217
                b.w = 1
196
 
                b.r = 0
197
 
                b.buf[0] = byte(b.lastByte)
198
 
                b.lastByte = -1
199
 
                return nil
200
 
        }
201
 
        if b.r <= 0 {
202
 
                return ErrInvalidUnreadByte
203
 
        }
204
 
        b.r--
 
218
        }
 
219
        b.buf[b.r] = byte(b.lastByte)
205
220
        b.lastByte = -1
 
221
        b.lastRuneSize = -1
206
222
        return nil
207
223
}
208
224
 
210
226
// rune and its size in bytes. If the encoded rune is invalid, it consumes one byte
211
227
// and returns unicode.ReplacementChar (U+FFFD) with a size of 1.
212
228
func (b *Reader) ReadRune() (r rune, size int, err error) {
213
 
        for b.r+utf8.UTFMax > b.w && !utf8.FullRune(b.buf[b.r:b.w]) && b.err == nil {
214
 
                b.fill()
 
229
        for b.r+utf8.UTFMax > b.w && !utf8.FullRune(b.buf[b.r:b.w]) && b.err == nil && b.w-b.r < len(b.buf) {
 
230
                b.fill() // b.w-b.r < len(buf) => buffer is not full
215
231
        }
216
232
        b.lastRuneSize = -1
217
233
        if b.r == b.w {
232
248
// regard it is stricter than UnreadByte, which will unread the last byte
233
249
// from any read operation.)
234
250
func (b *Reader) UnreadRune() error {
235
 
        if b.lastRuneSize < 0 || b.r == 0 {
 
251
        if b.lastRuneSize < 0 || b.r < b.lastRuneSize {
236
252
                return ErrInvalidUnreadRune
237
253
        }
238
254
        b.r -= b.lastRuneSize
255
271
// ReadBytes or ReadString instead.
256
272
// ReadSlice returns err != nil if and only if line does not end in delim.
257
273
func (b *Reader) ReadSlice(delim byte) (line []byte, err error) {
258
 
        // Look in buffer.
259
 
        if i := bytes.IndexByte(b.buf[b.r:b.w], delim); i >= 0 {
260
 
                line1 := b.buf[b.r : b.r+i+1]
261
 
                b.r += i + 1
262
 
                return line1, nil
263
 
        }
264
 
 
265
 
        // Read more into buffer, until buffer fills or we find delim.
266
274
        for {
 
275
                // Search buffer.
 
276
                if i := bytes.IndexByte(b.buf[b.r:b.w], delim); i >= 0 {
 
277
                        line = b.buf[b.r : b.r+i+1]
 
278
                        b.r += i + 1
 
279
                        break
 
280
                }
 
281
 
 
282
                // Pending error?
267
283
                if b.err != nil {
268
 
                        line := b.buf[b.r:b.w]
269
 
                        b.r = b.w
270
 
                        return line, b.readErr()
271
 
                }
272
 
 
273
 
                n := b.Buffered()
274
 
                b.fill()
275
 
 
276
 
                // Search new part of buffer
277
 
                if i := bytes.IndexByte(b.buf[n:b.w], delim); i >= 0 {
278
 
                        line := b.buf[0 : n+i+1]
279
 
                        b.r = n + i + 1
280
 
                        return line, nil
281
 
                }
282
 
 
283
 
                // Buffer is full?
284
 
                if b.Buffered() >= len(b.buf) {
285
 
                        b.r = b.w
286
 
                        return b.buf, ErrBufferFull
287
 
                }
288
 
        }
 
284
                        line = b.buf[b.r:b.w]
 
285
                        b.r = b.w
 
286
                        err = b.readErr()
 
287
                        break
 
288
                }
 
289
 
 
290
                // Buffer full?
 
291
                if n := b.Buffered(); n >= len(b.buf) {
 
292
                        b.r = b.w
 
293
                        line = b.buf
 
294
                        err = ErrBufferFull
 
295
                        break
 
296
                }
 
297
 
 
298
                b.fill() // buffer is not full
 
299
        }
 
300
 
 
301
        // Handle last byte, if any.
 
302
        if i := len(line) - 1; i >= 0 {
 
303
                b.lastByte = int(line[i])
 
304
        }
 
305
 
 
306
        return
289
307
}
290
308
 
291
309
// ReadLine is a low-level line-reading primitive. Most callers should use
301
319
//
302
320
// The text returned from ReadLine does not include the line end ("\r\n" or "\n").
303
321
// No indication or error is given if the input ends without a final line end.
 
322
// Calling UnreadByte after ReadLine will always unread the last byte read
 
323
// (possibly a character belonging to the line end) even if that byte is not
 
324
// part of the line returned by ReadLine.
304
325
func (b *Reader) ReadLine() (line []byte, isPrefix bool, err error) {
305
326
        line, err = b.ReadSlice('\n')
306
327
        if err == ErrBufferFull {
410
431
                return n, err
411
432
        }
412
433
 
413
 
        for b.fill(); b.r < b.w; b.fill() {
 
434
        if w, ok := w.(io.ReaderFrom); ok {
 
435
                m, err := w.ReadFrom(b.rd)
 
436
                n += m
 
437
                return n, err
 
438
        }
 
439
 
 
440
        if b.w-b.r < len(b.buf) {
 
441
                b.fill() // buffer not full
 
442
        }
 
443
 
 
444
        for b.r < b.w {
 
445
                // b.r < b.w => buffer is not empty
414
446
                m, err := b.writeBuf(w)
415
447
                n += m
416
448
                if err != nil {
417
449
                        return n, err
418
450
                }
 
451
                b.fill() // buffer is empty
419
452
        }
420
453
 
421
454
        if b.err == io.EOF {
428
461
// writeBuf writes the Reader's buffer to the writer.
429
462
func (b *Reader) writeBuf(w io.Writer) (int64, error) {
430
463
        n, err := w.Write(b.buf[b.r:b.w])
 
464
        if n < b.r-b.w {
 
465
                panic(errors.New("bufio: writer did not write all data"))
 
466
        }
431
467
        b.r += n
432
468
        return int64(n), err
433
469
}
619
655
                                return n, err1
620
656
                        }
621
657
                }
622
 
                m, err = r.Read(b.buf[b.n:])
623
 
                if m == 0 {
624
 
                        break
 
658
                nr := 0
 
659
                for nr < maxConsecutiveEmptyReads {
 
660
                        m, err = r.Read(b.buf[b.n:])
 
661
                        if m != 0 || err != nil {
 
662
                                break
 
663
                        }
 
664
                        nr++
 
665
                }
 
666
                if nr == maxConsecutiveEmptyReads {
 
667
                        return n, io.ErrNoProgress
625
668
                }
626
669
                b.n += m
627
670
                n += int64(m)