Fix errors and warnings on 0.6 (#14)

Author: yuyichao

REQUIRE

@@ -1,2 +1,2 @@
 julia 0.4
-Compat 0.8.4
+Compat 0.9.5

src/LegacyStrings.jl

@@ -24,7 +24,6 @@ import Base:
     endof,
     getindex,
     isvalid,
-    lastidx,
     lcfirst,
     length,
     lowercase,
@@ -43,6 +42,12 @@ import Base:
     uppercase,
     write
 
+using Compat
+
+    if isdefined(Base, :lastidx)
+        import Base: lastidx
+    end
+
     if VERSION >= v"0.5.0-"
         immutable ASCIIString <: DirectIndexString
             data::Array{UInt8,1}

src/ascii.jl

@@ -29,7 +29,7 @@ function string(c::ASCIIString...)
     for s in c
         n += length(s.data)
     end
-    v = Array(UInt8,n)
+    v = Vector{UInt8}(n)
     o = 1
     for s in c
         ls = length(s.data)
@@ -97,7 +97,7 @@ write(io::IO, s::ASCIIString) = write(io, s.data)
 
 ascii(x) = convert(ASCIIString, x)
 convert(::Type{ASCIIString}, s::ASCIIString) = s
-convert(::Type{ASCIIString}, s::String) = ascii(s.data)
+convert(::Type{ASCIIString}, s::String) = ascii(Vector{UInt8}(s))
 convert(::Type{ASCIIString}, s::UTF8String) = ascii(s.data)
 convert(::Type{ASCIIString}, a::Vector{UInt8}) = begin
     isvalid(ASCIIString,a) || throw(ArgumentError("invalid ASCII sequence"))

src/support.jl

@@ -279,7 +279,8 @@ isvalid(::Type{UTF8String}, s::Union{Vector{UInt8},ByteString}) = byte_string_cl
 bytestring() = ASCIIString("")
 function bytestring(s::AbstractString...)
     str = Base.print_to_string(s...)
-    isvalid(ASCIIString, str.data) ? ASCIIString(str.data) : UTF8String(str.data)
+    data = Vector{UInt8}(str)
+    isvalid(ASCIIString, data) ? ASCIIString(data) : UTF8String(data)
 end
 bytestring(s::Vector{UInt8}) = bytestring(String(s))
 bytestring(p::Union{Ptr{UInt8},Ptr{Int8},Cstring}) = unsafe_string(p)

src/utf16.jl

@@ -226,15 +226,15 @@ function convert(T::Type{UTF16String}, bytes::AbstractArray{UInt8})
     data = reinterpret(UInt16, bytes)
     # check for byte-order mark (BOM):
     if data[1] == 0xfeff        # native byte order
-        d = Array(UInt16, length(data))
+        d = Vector{UInt16}(length(data))
         copy!(d,1, data,2, length(data)-1)
     elseif data[1] == 0xfffe    # byte-swapped
-        d = Array(UInt16, length(data))
+        d = Vector{UInt16}(length(data))
         for i = 2:length(data)
             d[i-1] = bswap(data[i])
         end
     else
-        d = Array(UInt16, length(data) + 1)
+        d = Vector{UInt16}(length(data) + 1)
         copy!(d,1, data,1, length(data)) # assume native byte order
     end
     d[end] = 0 # NULL terminate

src/utf32.jl

@@ -135,12 +135,12 @@ convert{T<:AbstractString, S<:Union{UInt32,Char,Int32}}(::Type{T}, v::AbstractVe
 
 # specialize for performance reasons:
 function convert{T<:ByteString, S<:Union{UInt32,Char,Int32}}(::Type{T}, data::AbstractVector{S})
-    s = IOBuffer(Array(UInt8,length(data)), true, true)
+    s = IOBuffer(Vector{UInt8}(length(data)), true, true)
     truncate(s,0)
     for x in data
         print(s, Char(x))
     end
-    convert(T, takebuf_string(s))
+    convert(T, String(take!(s)))
 end
 
 convert(::Type{Vector{UInt32}}, str::UTF32String) = str.data
@@ -155,15 +155,15 @@ function convert(T::Type{UTF32String}, bytes::AbstractArray{UInt8})
     data = reinterpret(UInt32, bytes)
     # check for byte-order mark (BOM):
     if data[1] == 0x0000feff # native byte order
-        d = Array(UInt32, length(data))
+        d = Vector{UInt32}(length(data))
         copy!(d,1, data, 2, length(data)-1)
     elseif data[1] == 0xfffe0000 # byte-swapped
-        d = Array(UInt32, length(data))
+        d = Vector{UInt32}(length(data))
         for i = 2:length(data)
             @inbounds d[i-1] = bswap(data[i])
         end
     else
-        d = Array(UInt32, length(data) + 1)
+        d = Vector{UInt32}(length(data) + 1)
         copy!(d, 1, data, 1, length(data)) # assume native byte order
     end
     d[end] = 0 # NULL terminate

src/utf8.jl

@@ -150,15 +150,15 @@ function string(a::ByteString...)
         return a[1]::UTF8String
     end
     # ^^ at least one must be UTF-8 or the ASCII-only method would get called
-    data = Array(UInt8,0)
+    data = Vector{UInt8}(0)
     for d in a
         append!(data,d.data)
     end
     UTF8String(data)
 end
 
 function string(a::Union{ByteString,Char}...)
-    s = Array(UInt8,0)
+    s = Vector{UInt8}(0)
     for d in a
         if isa(d,Char)
             c = UInt32(d::Char)
@@ -300,7 +300,7 @@ function convert(::Type{UTF8String}, a::Vector{UInt8}, invalids_as::AbstractStri
             endn += 1
         end
         (endn > idx) && (endn -= 1)
-        splice!(a, idx:endn, invalids_as.data)
+        splice!(a, idx:endn, Vector{UInt8}(invalids_as))
         l = length(a)
     end
     UTF8String(a)

test/runtests.jl

@@ -1,7 +1,8 @@
 # This file includes code that was formerly a part of Julia. License is MIT: http://julialang.org/license
 
 using Base.Test
-using Compat: view
+using Compat
+using Compat: view, String
 importall LegacyStrings
 import LegacyStrings:
     ascii,
@@ -27,7 +28,7 @@ let io = IOBuffer()
     else
         check = "UnicodeError: invalid UTF-8 sequence starting at index 1 (0xa) missing one or more continuation bytes)"
     end
-    @test takebuf_string(io) == check
+    @test String(take!(io)) == check
 end
 
 ## Test invalid sequences
@@ -243,7 +244,7 @@ u16 = utf16(u8)
 @test length(u16) == 5
 @test utf8(u16) == u8
 @test collect(u8) == collect(u16)
-@test u8 == utf16(u16.data[1:end-1]) == utf16(copy!(Array(UInt8, 18), 1, reinterpret(UInt8, u16.data), 1, 18))
+@test u8 == utf16(u16.data[1:end-1]) == utf16(copy!(Vector{UInt8}(18), 1, reinterpret(UInt8, u16.data), 1, 18))
 @test u8 == utf16(pointer(u16)) == utf16(convert(Ptr{Int16}, pointer(u16)))
 @test_throws UnicodeError utf16(utf32(Char(0x120000)))
 @test_throws UnicodeError utf16(UInt8[1,2,3])
@@ -264,7 +265,7 @@ u32 = utf32(u8)
 @test length(u32) == 5
 @test utf8(u32) == u8
 @test collect(u8) == collect(u32)
-@test u8 == utf32(u32.data[1:end-1]) == utf32(copy!(Array(UInt8, 20), 1, reinterpret(UInt8, u32.data), 1, 20))
+@test u8 == utf32(u32.data[1:end-1]) == utf32(copy!(Vector{UInt8}(20), 1, reinterpret(UInt8, u32.data), 1, 20))
 @test u8 == utf32(pointer(u32)) == utf32(convert(Ptr{Int32}, pointer(u32)))
 @test_throws UnicodeError utf32(UInt8[1,2,3])