Quash lots of depwarns

staticfloat · staticfloat · commit f4cc793bd7f9 · 2018-08-08T09:05:55.000+01:00
diff --git a/REQUIRE b/REQUIRE
@@ -1,4 +1,3 @@
-julia 0.6
+julia 0.7.0-rc3
 StructIO 0.2
-Reexport
-Compat
+Reexport
diff --git a/src/Abstract/DynamicLink.jl b/src/Abstract/DynamicLink.jl
@@ -107,7 +107,7 @@ Return the list of paths that will be searched for shared libraries.
 """
 @mustimplement rpaths(rpath::RPath)
 
-endof(rpath::RPath) = endof(rpaths(rpath))
+endof(rpath::RPath) = lastindex(rpaths(rpath))
 start(rpath::RPath) = 1
 done(rpath::RPath, idx) = idx > length(rpath)
 next(rpath::RPath, idx) = (rpath[idx], idx+1)
diff --git a/src/Abstract/Printing.jl b/src/Abstract/Printing.jl
@@ -25,17 +25,17 @@ function show_collection(io::IO, stuff::ST, ::Type{H}) where {ST} where {H <: Ob
     if limited && length(stuff) > 20
         for idx in 1:10
             print(io, "\n  [$(idx)] ")
-            showcompact(io, stuff[idx])
+            show(IOContext(io, :compact => true), stuff[idx])
         end
         print(io, "\n   \u2026")
         for idx in length(stuff)-10:length(stuff)
             print(io, "\n  [$(idx)] ")
-            showcompact(io, stuff[idx])
+            show(IOContext(io, :compact => true), stuff[idx])
         end
     else
         for idx in 1:length(stuff)
             print(io, "\n  [$(idx)] ")
-            showcompact(io, stuff[idx])
+            show(IOContext(io, :compact => true), stuff[idx])
         end
     end
-end
+end
diff --git a/src/Abstract/Section.jl b/src/Abstract/Section.jl
@@ -340,9 +340,9 @@ function show(io::IO, s::Union{Section{H},SectionRef{H}}) where {H <: ObjectHand
     if !get(io, :compact, false)
         println(io)
         println(io, "       Name: $(section_name(s))")
-        println(io, "       Size: 0x$(hex(section_size(s)))")
-        println(io, "     Offset: 0x$(hex(section_offset(s)))")
-        print(io,   "    Address: 0x$(hex(section_address(s)))")
+        println(io, "       Size: 0x$(string(section_size(s), base=16))")
+        println(io, "     Offset: 0x$(string(section_offset(s), base=16))")
+        print(io,   "    Address: 0x$(string(section_address(s), base=16))")
     else
         print(io, " \"$(section_name(s))\"")
     end
diff --git a/src/COFF/COFF.jl b/src/COFF/COFF.jl
@@ -4,8 +4,19 @@ using StructIO
 
 # Bring in ObjectFile definitions
 using ObjectFile
-importall ObjectFile
-
+import ObjectFile: DynamicLink, DynamicLinks, RPath, ObjectHandle, Section, Sections, SectionRef,
+                   Segment, Segments, SegmentRef, StrTab, Symbols, SymtabEntry, SymbolRef,
+                   getindex, endof, length, start, next, done, eltype, handle, header, path,
+                   rpaths, canonical_rpaths, find_library, readmeta, seek, seekstart, skip,
+                   iostream, position, read, readuntil, eof, endianness, is64bit, isrelocatable,
+                   isexecutable, islibrary, isdynamic, mangle_section_name, mangle_symbol_name,
+                   format_string, section_header_offset, section_header_size, section_header_type,
+                   segment_header_offset, segment_header_size, segment_header_type,
+                   symtab_entry_offset, symtab_entry_size, symtab_entry_type, find_libraries,
+                   find, findfirst, deref, contents, section_name, section_size,
+                   section_offset, section_address, section_number, segment_name, segment_offset,
+                   segment_file_size, segment_memory_size, segment_address, strtab_lookup,
+                   symbol_name, symbol_value, isundef, isglobal, islocal, isweak, symbol_number
 # Load in imported C #define constants
 include("constants.jl")
 
@@ -18,4 +29,4 @@ include("COFFStrTab.jl")
 include("COFFSymbol.jl")
 include("COFFDynamicLink.jl")
 
-end # module COFF
+end # module COFF
diff --git a/src/COFF/COFFDynamicLink.jl b/src/COFF/COFFDynamicLink.jl
@@ -49,7 +49,7 @@ end
 DynamicLinks(oh::COFFHandle) = COFFDynamicLinks(oh)
 
 handle(dls::COFFDynamicLinks) = dls.handle
-endof(dls::COFFDynamicLinks) = endof(dls.links)
+endof(dls::COFFDynamicLinks) = lastindex(dls.links)
 getindex(dls::COFFDynamicLinks, idx) = getindex(dls.links, idx)
 
 
diff --git a/src/COFF/COFFHandle.jl b/src/COFF/COFFHandle.jl
@@ -49,8 +49,8 @@ function readmeta(io::IO, ::Type{H}) where {H <: COFFHandle}
     magic = [read(io, UInt8) for idx in 1:4]
     if any(magic .!= PE_magic)
         msg = """
-        Magic Number 0x$(join(hex.(magic),"")) does not match expected PE
-        magic number 0x$(join("", hex.(PE_magic)))
+        Magic Number 0x$(join(string.(magic, base=16),"")) does not match expected PE
+        magic number 0x$(join("", string.(PE_magic, base=16)))
         """
         throw(MagicMismatch(replace(strip(msg), "\n" => " ")))
     end
diff --git a/src/COFF/COFFOptionalHeader.jl b/src/COFF/COFFOptionalHeader.jl
@@ -116,7 +116,7 @@ function read(io::IO, ::Type{COFFOptionalHeader})
         dirs = unpack(io, COFFDataDirectories)
         return COFFOptionalHeader64(standard, windows, dirs)
     else
-        error("Unknown COFF optional header magic 0x$(hex(standard.Magic))")
+        error("Unknown COFF optional header magic 0x$(string(standard.Magic, base=16))")
     end
 end
 
diff --git a/src/COFF/COFFSymbol.jl b/src/COFF/COFFSymbol.jl
@@ -159,9 +159,9 @@ function symbol_type_string(sym::COFFSymtabEntry)
 
     # If we didn't get ANY info, complain
     if isempty(type_string)
-        string("Unknown Symbol Type (0x", hex(sym.Type), ")")
+        string("Unknown Symbol Type (0x", string(sym.Type, base=16), ")")
     end
     
     return type_string
 end
-@derefmethod symbol_type_string(s::COFFSymbolRef)
+@derefmethod symbol_type_string(s::COFFSymbolRef)
diff --git a/src/ELF/ELF.jl b/src/ELF/ELF.jl
@@ -4,9 +4,19 @@ using StructIO
 
 # Bring in ObjectFile definitions
 using ObjectFile
-importall ObjectFile
-using Compat
-
+import ObjectFile: DynamicLink, DynamicLinks, RPath, ObjectHandle, Section, Sections, SectionRef,
+                   Segment, Segments, SegmentRef, StrTab, Symbols, SymtabEntry, SymbolRef,
+                   getindex, endof, length, start, next, done, eltype, handle, header, path,
+                   rpaths, canonical_rpaths, find_library, readmeta, seek, seekstart, skip,
+                   iostream, position, read, readuntil, eof, endianness, is64bit, isrelocatable,
+                   isexecutable, islibrary, isdynamic, mangle_section_name, mangle_symbol_name,
+                   format_string, section_header_offset, section_header_size, section_header_type,
+                   segment_header_offset, segment_header_size, segment_header_type,
+                   symtab_entry_offset, symtab_entry_size, symtab_entry_type, find_libraries,
+                   find, findfirst, deref, contents, section_name, section_size,
+                   section_offset, section_address, section_number, segment_name, segment_offset,
+                   segment_file_size, segment_memory_size, segment_address, strtab_lookup,
+                   symbol_name, symbol_value, isundef, isglobal, islocal, isweak, symbol_number
 # Load in imported C #define constants
 include("constants.jl")
 
diff --git a/src/ELF/ELFDynEntry.jl b/src/ELF/ELFDynEntry.jl
@@ -70,7 +70,7 @@ function dyn_entry_type_string(d::ELFDynEntry)
     if haskey(DYNAMIC_TYPE, d_type)
         return DYNAMIC_TYPE[d_type]
     end
-    return string("Unknown DynEntry Type (0x", hex(d_type), ")")
+    return string("Unknown DynEntry Type (0x", string(d_type, base=16), ")")
 end
 
 struct ELFDynEntryRef{H <: ELFHandle}
@@ -143,4 +143,4 @@ if they are one of the `kinds` passed in, such as `DT_NEEDED`.
 """
 function ELFDynEntries(oh::ELFHandle, kinds::Vector)
     return [d for d in ELFDynEntries(oh) if dyn_entry_type(d) in kinds]
-end
+end
diff --git a/src/ELF/ELFDynamicLink.jl b/src/ELF/ELFDynamicLink.jl
@@ -45,7 +45,7 @@ function DynamicLinks(oh::ELFHandle)
 end
 Section(dls::ELFDynamicLinks) = dls.section_ref
 handle(dls::ELFDynamicLinks) = handle(Section(dls))
-endof(dls::ELFDynamicLinks) = endof(dls.links)
+endof(dls::ELFDynamicLinks) = lastindex(dls.links)
 getindex(dls::ELFDynamicLinks, idx) = getindex(dls.links, idx)
 
 """
diff --git a/src/ELF/ELFHandle.jl b/src/ELF/ELFHandle.jl
@@ -38,8 +38,8 @@ function readmeta(io::IO, ::Type{H}) where {H <: ELFHandle}
     magic = [read(io, UInt8) for idx in 1:4]    
     if any(magic .!= elven_magic)
         msg = """
-        Magic Number 0x$(join(hex.(magic),"")) does not match expected ELF
-        magic number 0x$(join("", hex.(elven_magic)))
+        Magic Number 0x$(join(string.(magic, base=16),"")) does not match expected ELF
+        magic number 0x$(join("", string.(elven_magic, base=16)))
         """
         throw(MagicMismatch(replace(strip(msg), "\n" => " ")))
     end
diff --git a/src/ELF/ELFHeader.jl b/src/ELF/ELFHeader.jl
@@ -45,15 +45,15 @@ function filetype(e_type)
     if haskey(ET_TYPES, e_type)
         return ET_TYPES[e_type]
     end
-    return string("Unknown (0x",hex(e_type),")")
+    return string("Unknown (0x",string(e_type, base=16),")")
 end
 
 
 function machinetype(e_machine)
     if haskey(EM_MACHINES, e_machine)
         return EM_MACHINES[e_machine]
     end
-    return string("Unknown (0x",hex(e_machine),")")
+    return string("Unknown (0x",string(e_machine, base=16),")")
 end
 
 
@@ -62,14 +62,14 @@ function show(io::IO, header::ELFHeader)
     println(io, "  Type ", filetype(header.e_type))
     println(io, "  Machine ", machinetype(header.e_machine))
     # Skip e_version (not particularly useful)
-    println(io, "  Entrypoint ", "0x", hex(header.e_entry))
-    println(io, "  PH Offset ", "0x", hex(header.e_phoff))
-    println(io, "  SH Offset ", "0x", hex(header.e_shoff))
+    println(io, "  Entrypoint ", "0x", string(header.e_entry, base=16))
+    println(io, "  PH Offset ", "0x", string(header.e_phoff, base=16))
+    println(io, "  SH Offset ", "0x", string(header.e_shoff, base=16))
     # Skip flags
-    println(io, "  Header Size ", "0x", hex(header.e_ehsize))
-    println(io, "  PH Entry Size ", "0x", hex(header.e_phentsize))
-    println(io, "  PH Entry Count ", dec(header.e_phnum))
-    println(io, "  SH Entry Size ", "0x", hex(header.e_shentsize))
-    println(io, "  SH Entry Count ", dec(header.e_shnum))
-    println(io, "  Strtab Index ", dec(header.e_shstrndx))
-end
+    println(io, "  Header Size ", "0x", string(header.e_ehsize, base=16))
+    println(io, "  PH Entry Size ", "0x", string(header.e_phentsize, base=16))
+    println(io, "  PH Entry Count ", string(header.e_phnum, base=10))
+    println(io, "  SH Entry Size ", "0x", string(header.e_shentsize, base=16))
+    println(io, "  SH Entry Count ", string(header.e_shnum, base=10))
+    println(io, "  Strtab Index ", string(header.e_shstrndx, base=10))
+end
diff --git a/src/ELF/ELFSection.jl b/src/ELF/ELFSection.jl
@@ -107,6 +107,6 @@ function section_type_string(s::ELFSection)
     if haskey(SHT_TYPES, sh_type)
         return SHT_TYPES[sh_type]
     end
-    return string("Unknown Section Type (0x", hex(sh_type), ")")
+    return string("Unknown Section Type (0x", string(sh_type, base=16), ")")
 end
-@derefmethod section_type_string(s::ELFSectionRef)
+@derefmethod section_type_string(s::ELFSectionRef)
diff --git a/src/ELF/ELFSegment.jl b/src/ELF/ELFSegment.jl
@@ -162,25 +162,25 @@ function segment_type_string(s::ELFSegment)
     if haskey(P_TYPE, s_type)
         return P_TYPE[s_type]
     end
-    return string("Unknown Segment Type (0x", hex(s_type), ")")
+    return string("Unknown Segment Type (0x", string(s_type, base=16), ")")
 end
 @derefmethod segment_type_string(s::ELFSegmentRef)
 
 function show(io::IO, seg::Union{ELFSegment,ELFSegmentRef})
     print(io, "ELFSegment")
 
     if !get(io, :compact, false)
-        fsz = hex(segment_file_size(seg))
-        msz = hex(segment_memory_size(seg))
-        paddr = hex(segment_physical_address(seg))
-        vaddr = hex(segment_virtual_address(seg))
+        fsz = string(segment_file_size(seg), base=16)
+        msz = string(segment_memory_size(seg), base=16)
+        paddr = string(segment_physical_address(seg), base=16)
+        vaddr = string(segment_virtual_address(seg), base=16)
 
         println(io)
         println(io, "       Type: $(segment_type_string(seg))")
         println(io, "       Size: (File: 0x$(fsz),   Mem: 0x$(msz))")
-        println(io, "     Offset: 0x$(hex(segment_offset(seg)))")
+        println(io, "     Offset: 0x$(string(segment_offset(seg), base=16))")
         print(io,   "    Address:  (Phy: 0x$(paddr) Virt: 0x$(vaddr))")
     else
         print(io, " $(segment_type_string(seg))")
     end
-end
+end
diff --git a/src/ELF/ELFStrTab.jl b/src/ELF/ELFStrTab.jl
@@ -19,7 +19,7 @@ struct ELFStrTab{H <: ELFHandle} <: StrTab{H}
             Loading Section $(section_idx) as a StrTab, despite it having section
             type $(section_type_string(section)), not SHT_STRTAB.
             """)
-            Compat.@warn(replace(msg, "\n" => " "), key=(handle(section), section_idx))
+            @warn(replace(msg, "\n" => " "), key=(handle(section), section_idx))
         end
         
         return new(section)
diff --git a/src/MachO/MachO.jl b/src/MachO/MachO.jl
@@ -4,8 +4,19 @@ using StructIO
 
 # Bring in ObjectFile definitions
 using ObjectFile
-importall ObjectFile
-
+import ObjectFile: DynamicLink, DynamicLinks, RPath, ObjectHandle, Section, Sections, SectionRef,
+                   Segment, Segments, SegmentRef, StrTab, Symbols, SymtabEntry, SymbolRef,
+                   getindex, endof, length, start, next, done, eltype, handle, header, path,
+                   rpaths, canonical_rpaths, find_library, readmeta, seek, seekstart, skip,
+                   iostream, position, read, readuntil, eof, endianness, is64bit, isrelocatable,
+                   isexecutable, islibrary, isdynamic, mangle_section_name, mangle_symbol_name,
+                   format_string, section_header_offset, section_header_size, section_header_type,
+                   segment_header_offset, segment_header_size, segment_header_type,
+                   symtab_entry_offset, symtab_entry_size, symtab_entry_type, find_libraries,
+                   find, findfirst, deref, contents, section_name, section_size,
+                   section_offset, section_address, section_number, segment_name, segment_offset,
+                   segment_file_size, segment_memory_size, segment_address, strtab_lookup,
+                   symbol_name, symbol_value, isundef, isglobal, islocal, isweak, symbol_number
 # Load in imported C #define constants
 include("constants.jl")
 
diff --git a/src/MachO/MachODynamicLink.jl b/src/MachO/MachODynamicLink.jl
@@ -14,7 +14,7 @@ MachODynamicLinks(oh::MachOHandle) = MachODynamicLinks(MachOLoadCmds(oh))
 DynamicLinks(oh::MachOHandle) = MachODynamicLinks(oh)
 DynamicLinks(lcs::MachOLoadCmds) = MachODynamicLinks(lcs)
 
-endof(dls::MachODynamicLinks) = endof(dls.cmds)
+endof(dls::MachODynamicLinks) = lastindex(dls.cmds)
 function getindex(dls::MachODynamicLinks, idx)
     return MachODynamicLink(dls, dls.cmds[idx])
 end
@@ -54,4 +54,4 @@ handle(mrp::MachORPath) = mrp.handle
 
 function rpaths(mrp::MachORPath)
     return [rpath(c) for c in mrp.cmds]
-end
+end
diff --git a/src/MachO/MachOHeader.jl b/src/MachO/MachOHeader.jl
@@ -45,7 +45,7 @@ function macho_header_type(magic::UInt32)
     elseif magic in (FAT_MAGIC, FAT_CIGAM)
         return MachOFatHeader{MachOHandle}
     else
-        throw(MagicMismatch("Invalid Magic ($(hex(magic)))!"))
+        throw(MagicMismatch("Invalid Magic ($(string(magic, base=16)))!"))
     end
 end
 
@@ -61,7 +61,7 @@ function macho_is64bit(magic::UInt32)
     elseif magic in (MH_MAGIC, MH_CIGAM, FAT_MAGIC, FAT_CIGAM)
         return false
     else
-        throw(MagicMismatch("Invalid Magic ($(hex(magic)))!"))
+        throw(MagicMismatch("Invalid Magic ($(string(magic, base=16)))!"))
     end
 end
 
@@ -77,7 +77,7 @@ function macho_endianness(magic::UInt32)
     elseif magic in (MH_MAGIC, MH_MAGIC_64, FAT_MAGIC)
         return :LittleEndian
     else
-        throw(MagicMismatch("Invalid Magic ($(hex(magic)))!"))
+        throw(MagicMismatch("Invalid Magic ($(string(magic, base=16)))!"))
     end
 end
 
@@ -88,4 +88,4 @@ function show(io::IO, header::MachOHeader)
     println(io, "  File Type ", header.filetype)
     println(io, "  Number of load commands ", header.ncmds)
     println(io, "  Flags ", header.flags)
-end
+end
diff --git a/src/MachO/MachOLoadCmd.jl b/src/MachO/MachOLoadCmd.jl
@@ -201,7 +201,7 @@ function load_cmd_type_string(header::MachOLoadCmdHeader{H}) where {H <: MachOHa
     if haskey(LCTYPES, header.cmd)
         return LCTYPES[header.cmd]
     end
-    return string("Unknown Type (0x", hex(header.cmd), ")")
+    return string("Unknown Type (0x", string(header.cmd, base=16), ")")
 end
 
 """
diff --git a/src/MachO/MachOSection.jl b/src/MachO/MachOSection.jl
@@ -97,7 +97,7 @@ function MachOSections(segs::MachOSegments)
 end
 
 handle(sections::MachOSections) = sections.handle
-endof(sections::MachOSections) = endof(sections.sections)
+endof(sections::MachOSections) = lastindex(sections.sections)
 getindex(sections::MachOSections, idx) = getindex(sections.sections, idx)
 
 Sections(segs::MachOSegments) = MachOSections(segs)
diff --git a/src/MachO/MachOSegment.jl b/src/MachO/MachOSegment.jl
@@ -20,7 +20,7 @@ function Segments(oh::MachOHandle)
 end
 
 handle(segments::MachOSegments) = segments.handle
-endof(segments::MachOSegments) = endof(segments.segments)
+endof(segments::MachOSegments) = lastindex(segments.segments)
 function getindex(segs::MachOSegments{H}, idx) where {H <: MachOHandle}
     seg = MachOSegment(segs.segments[idx])
     return MachOSegmentRef(segs, seg, UInt32(idx))
@@ -86,15 +86,15 @@ function show(io::IO, seg::Union{MachOSegment,MachOSegmentRef})
     print(io, "MachO Segment", is64bit(seg) ? " (64 bit)" : "")
 
     if !get(io, :compact, false)
-        fsz = hex(segment_file_size(seg))
-        msz = hex(segment_memory_size(seg))
+        fsz = string(segment_file_size(seg), base=16)
+        msz = string(segment_memory_size(seg), base=16)
 
         println(io)
         println(io, "       Name: $(segment_name(seg))")
         println(io, "       Size: (File: 0x$(fsz),   Mem: 0x$(msz))")
-        println(io, "     Offset: 0x$(hex(segment_offset(seg)))")
+        println(io, "     Offset: 0x$(string(segment_offset(seg), base=16))")
         print(io,   "   Sections: $(segment_num_sections(seg))")
     else
         print(io, " $(segment_name(seg))")
     end
-end
+end
diff --git a/src/ObjectFile.jl b/src/ObjectFile.jl
diff --git a/src/string_utils.jl b/src/string_utils.jl
diff --git a/test/runtests.jl b/test/runtests.jl
