Fix eof() and read*() behaviour for ::File and ::LibuvStream

base/filesystem.jl

@@ -39,7 +39,8 @@ export File,
  S_IROTH, S_IWOTH, S_IXOTH, S_IRWXO
 
 import Base: uvtype, uvhandle, eventloop, fd, position, stat, close,
- write, read, read!, isopen, show,
+ write, read, readavailable, read!, isopen, show,
+ seek, seekend, skip, eof,
  check_open, _sizeof_uv_fs, uv_error, UVError
 
 include("path.jl")
@@ -158,27 +159,53 @@ function read!(f::File, a::Vector{UInt8}, nel=length(a))
  end
  ret = ccall(:jl_fs_read, Int32, (Int32, Ptr{Void}, Csize_t),
  f.handle, a, nel)
+ if ret < nel
+ throw(EOFError())
+ end
  uv_error("read",ret)
  return a
 end
 
 nb_available(f::File) = filesize(f) - position(f)
 
+eof(f::File) = nb_available(f) == 0
+
 function readbytes!(f::File, b::Array{UInt8}, nb=length(b))
  nr = min(nb, nb_available(f))
  if length(b) < nr
  resize!(b, nr)
  end
- read!(f, b, nr)
- return nr
+ ret = ccall(:jl_fs_read, Int32, (Int32, Ptr{Void}, Csize_t),
+ f.handle, b, nr)
+ uv_error("read",ret)
+ return ret
 end
 read(io::File) = read!(io, Array(UInt8, nb_available(io)))
+readavailable(io::File) = read(io)
 read(io::File, nb::Integer) = read!(io, Array(UInt8, min(nb, nb_available(io))))
 
 const SEEK_SET = Int32(0)
 const SEEK_CUR = Int32(1)
 const SEEK_END = Int32(2)
 
+function seek(f::File, n::Integer)
+ ret = ccall(:jl_lseek, Int64, (Int32, Int64, Int32), f.handle, n, SEEK_SET)
+ systemerror("seek", ret == -1)
+ return f
+end
+
+function seekend(f::File)
+ ret = ccall(:jl_lseek, Int64, (Int32, Int64, Int32), f.handle, 0, SEEK_END)
+ systemerror("seekend", ret == -1)
+ return f
+end
+
+function skip(f::File, n::Integer)
+ ret = ccall(:jl_lseek, Int64, (Int32, Int64, Int32), f.handle, n, SEEK_CUR)
+ systemerror("skip", ret == -1)
+ return f
+end
+
 function position(f::File)
  check_open(f)
  ret = ccall(:jl_lseek, Int64, (Int32, Int64, Int32), f.handle, 0, SEEK_CUR)

base/io.jl

@@ -348,7 +348,10 @@ type EachLine
  EachLine(stream, ondone) = new(stream, ondone)
 end
 eachline(stream::IO) = EachLine(stream)
-eachline(filename::AbstractString) = EachLine(open(filename), close)
+function eachline(filename::AbstractString)
+ s = open(filename)
+ EachLine(s, ()->close(s))
+end
 
 start(itr::EachLine) = nothing
 function done(itr::EachLine, nada)

base/iobuffer.jl

@@ -337,6 +337,7 @@ function readbytes!(io::AbstractIOBuffer, b::Array{UInt8}, nb=length(b))
  return nr
 end
 read(io::AbstractIOBuffer) = read!(io, Array(UInt8, nb_available(io)))
+readavailable(io::AbstractIOBuffer) = read(io)
 read(io::AbstractIOBuffer, nb::Integer) = read!(io, Array(UInt8, min(nb, nb_available(io))))
 
 function search(buf::IOBuffer, delim::UInt8)

base/iostream.jl

@@ -158,6 +158,8 @@ end
 # num bytes available without blocking
 nb_available(s::IOStream) = ccall(:jl_nb_available, Int32, (Ptr{Void},), s.ios)
 
+readavailable(s::IOStream) = read!(s, Vector{UInt8}(nb_available(s)))
+
 function read(s::IOStream, ::Type{UInt8})
  b = ccall(:ios_getc, Cint, (Ptr{Void},), s.ios)
  if b == -1

base/stream.jl

@@ -894,32 +894,32 @@ function stop_reading(stream::LibuvStream)
  end
 end
 
-function readbytes!(s::LibuvStream, b::AbstractArray{UInt8}, nb=length(b))
- wait_readnb(s, nb)
- nr = nb_available(s)
- resize!(b, nr) # shrink to just contain input data if was resized
- read!(s.buffer, b)
- return nr
+function read!(s::LibuvStream, b::Vector{UInt8})
+ nb = length(b)
+ r = readbytes!(s, b, nb)
+ if r < nb
+ throw(EOFError())
+ end
+ return b
 end
 
 function read(stream::LibuvStream)
  wait_readnb(stream, typemax(Int))
  return takebuf_array(stream.buffer)
 end
 
-function read!(s::LibuvStream, a::Array{UInt8, 1})
- nb = length(a)
+function readbytes!(s::LibuvStream, a::Vector{UInt8}, nb = length(a))
  sbuf = s.buffer
  @assert sbuf.seekable == false
  @assert sbuf.maxsize >= nb
 
  if nb_available(sbuf) >= nb
- return read!(sbuf, a)
+ return readbytes!(sbuf, a, nb)
  end
 
  if nb <= SZ_UNBUFFERED_IO # Under this limit we are OK with copying the array from the stream's buffer
  wait_readnb(s, nb)
- read!(sbuf, a)
+ r = readbytes!(sbuf, a, nb)
  else
  try
  stop_reading(s) # Just playing it safe, since we are going to switch buffers.
@@ -928,14 +928,15 @@ function read!(s::LibuvStream, a::Array{UInt8, 1})
  s.buffer = newbuf
  write(newbuf, sbuf)
  wait_readnb(s, nb)
+ r = nb_available(newbuf)
  finally
  s.buffer = sbuf
  if !isempty(s.readnotify.waitq)
  start_reading(s) # resume reading iff there are currently other read clients of the stream
  end
  end
  end
- return a
+ return r
 end
 
 function read(this::LibuvStream, ::Type{UInt8})

src/builtins.c

@@ -182,6 +182,14 @@ JL_DLLEXPORT void JL_NORETURN jl_bounds_error_ints(jl_value_t *v, size_t *idxs,
  jl_throw(jl_new_struct((jl_datatype_t*)jl_boundserror_type, v, t));
 }
 
+JL_DLLEXPORT void JL_NORETURN jl_eof_error(void)
+{
+ jl_datatype_t *eof_error =
+ (jl_datatype_t*)jl_get_global(jl_base_module, jl_symbol("EOFError"));
+ assert(eof_error != NULL);
+ jl_exceptionf(eof_error, "");
+}
+
 JL_CALLABLE(jl_f_throw)
 {
  JL_NARGS(throw, 1, 1);

src/jl_uv.c

@@ -339,9 +339,12 @@ JL_DLLEXPORT int jl_fs_read_byte(int handle)
  buf[0].len = 1;
  int ret = uv_fs_read(jl_io_loop, &req, handle, buf, 1, -1, NULL);
  uv_fs_req_cleanup(&req);
- if (ret == -1)
- return ret;
- return (int)c;
+ switch (ret) {
+ case -1: return ret;
+ case 0: jl_eof_error();
+ case 1: return (int)c;
+ default: assert(0);
+ }
 }
 
 JL_DLLEXPORT int jl_fs_close(int handle)

src/julia.h

@@ -1250,6 +1250,7 @@ JL_DLLEXPORT void JL_NORETURN jl_bounds_error_tuple_int(jl_value_t **v,
  size_t nv, size_t i);
 JL_DLLEXPORT void JL_NORETURN jl_bounds_error_unboxed_int(void *v, jl_value_t *vt, size_t i);
 JL_DLLEXPORT void JL_NORETURN jl_bounds_error_ints(jl_value_t *v, size_t *idxs, size_t nidxs);
+JL_DLLEXPORT void JL_NORETURN jl_eof_error(void);
 JL_DLLEXPORT jl_value_t *jl_exception_occurred(void);
 JL_DLLEXPORT void jl_exception_clear(void);
 

src/sys.c

@@ -308,13 +308,6 @@ JL_DLLEXPORT jl_value_t *jl_readuntil(ios_t *s, uint8_t delim)
  return (jl_value_t*)a;
 }
 
-static void JL_NORETURN throw_eof_error(void)
-{
- jl_datatype_t *eof_error = (jl_datatype_t*)jl_get_global(jl_base_module, jl_symbol("EOFError"));
- assert(eof_error != NULL);
- jl_exceptionf(eof_error, "");
-}
-
 JL_DLLEXPORT uint64_t jl_ios_get_nbyte_int(ios_t *s, const size_t n)
 {
  assert(n <= 8);
@@ -323,7 +316,7 @@ JL_DLLEXPORT uint64_t jl_ios_get_nbyte_int(ios_t *s, const size_t n)
  space = (size_t)(s->size - s->bpos);
  ret = ios_readprep(s, n);
  if (space == ret && ret < n)
- throw_eof_error();
+ jl_eof_error();
  } while(ret < n);
  uint64_t x = 0;
  uint8_t *buf = (uint8_t*)&s->buf[s->bpos];

test/choosetests.jl

@@ -23,7 +23,7 @@ function choosetests(choices = [])
  "bitarray", "copy", "math", "fastmath", "functional",
  "operators", "path", "ccall", "parse", "loading",
  "bigint", "sorting", "statistics", "spawn", "backtrace",
- "priorityqueue", "file", "mmap", "version", "resolve",
+ "priorityqueue", "file", "read", "mmap", "version", "resolve",
  "pollfd", "mpfr", "broadcast", "complex", "socket",
  "floatapprox", "datafmt", "reflection", "regex", "float16",
  "combinatorics", "sysinfo", "rounding", "ranges", "mod2pi",

test/file.jl

@@ -1115,3 +1115,36 @@ end
 @test copy(DevNull) === DevNull
 @test eof(DevNull)
 @test print(DevNull, "go to /dev/null") === nothing
+
+# Filesystem.File
+tmpdir = mktempdir() do d
+ f = joinpath(d, "test.txt")
+ open(io->write(io, "123"), f, "w")
+ f1 = open(f)
+ f2 = Base.Filesystem.open(f, Base.Filesystem.JL_O_RDONLY)
+ @test read(f1, UInt8) == read(f2, UInt8)
+ @test read(f1, UInt8) == read(f2, UInt8)
+ @test read(f1, UInt8) == read(f2, UInt8)
+ @test_throws EOFError read(f1, UInt8)
+ @test_throws EOFError read(f2, UInt8)
+ close(f1)
+ close(f2)
+
+ a = UInt8[0,0,0]
+ f1 = open(f)
+ f2 = Base.Filesystem.open(f, Base.Filesystem.JL_O_RDONLY)
+ @test read!(f1, a) == read!(f2, a)
+ @test_throws EOFError read!(f1, a)
+ @test_throws EOFError read!(f2, a)
+ close(f1)
+ close(f2)
+
+ a = UInt8[0,0,0,0]
+ f1 = open(f)
+ f2 = Base.Filesystem.open(f, Base.Filesystem.JL_O_RDONLY)
+ @test_throws EOFError read!(f1, a)
+ @test_throws EOFError read!(f2, a)
+ close(f1)
+ close(f2)
+end
+