enable precompilation (fix #30)

Author: stevengj

src/LightXML.jl

@@ -1,8 +1,12 @@
-VERSION >= v"0.4.0-dev+6521" && __precompile__(false)
+VERSION >= v"0.4.0-dev+6521" && __precompile__()
 
 module LightXML
 
-    export
+using Compat
+
+const libxml2 = @windows? Pkg.dir("WinRPM","deps","usr","$(Sys.ARCH)-w64-mingw32","sys-root","mingw","bin","libxml2-2") : "libxml2"
+
+export
 
     # common
     name, free,
@@ -22,12 +26,23 @@ module LightXML
     XMLDocument, version, encoding, compression, standalone, root,
     parse_file, parse_string, save_file, set_root, create_root
 
-    using Compat
-    include("clib.jl")
-    include("errors.jl")
+typealias Xchar UInt8
+typealias Xstr Ptr{Xchar}
+
+# opaque pointer type (do not dereference!) corresponding to xmlBufferPtr in C
+immutable xmlBuffer end
+typealias Xptr Ptr{xmlBuffer}
+
+# pre-condition: p is not null
+# (After tests, it seems that free in libc instead of xmlFree
+#  should be used here.)
+_xcopystr(p::Xstr) = (r = bytestring(p); Libc.free(p); r)
+
+include("errors.jl")
+
+include("utils.jl")
+include("nodes.jl")
+include("document.jl")
+include("cdata.jl")
 
-    include("utils.jl")
-    include("nodes.jl")
-    include("document.jl")
-    include("cdata.jl")
 end

src/cdata.jl

@@ -1,5 +1,5 @@
 function new_cdatanode(xdoc::XMLDocument, txt::ASCIIString)
-        p = ccall(xmlNewCDataBlock, Xptr, (Xptr, Xstr, Cint), xdoc.ptr, txt, length(txt)+1)
+        p = ccall((:xmlNewCDataBlock,libxml2), Xptr, (Xptr, Xstr, Cint), xdoc.ptr, txt, length(txt)+1)
         XMLNode(p)
 end
 

src/clib.jl

@@ -5,7 +5,7 @@ immutable _XMLDocStruct  # use the same layout as C
     # common part
     _private::Ptr{Void}
     nodetype::Cint
-    name::Ptr{Cchar}
+    name::Xstr
     children::Xptr
     last::Xptr
     parent::Xptr
@@ -48,7 +48,7 @@ type XMLDocument
 
     function XMLDocument()
         # create an empty document
-        ptr = ccall(xmlNewDoc, Xptr, (Ptr{Cchar},), "1.0")
+        ptr = ccall((:xmlNewDoc,libxml2), Xptr, (Cstring,), "1.0")
         XMLDocument(ptr)
     end
 end
@@ -59,59 +59,59 @@ compression(xdoc::XMLDocument) = @compat Int(xdoc._struct.compression)
 standalone(xdoc::XMLDocument) = @compat Int(xdoc._struct.standalone)
 
 function root(xdoc::XMLDocument)
-    pr = ccall(xmlDocGetRootElement, Ptr{Void}, (Ptr{Void},), xdoc.ptr)
-    pr != nullptr || throw(XMLNoRootError())
+    pr = ccall((:xmlDocGetRootElement,libxml2), Xptr, (Xptr,), xdoc.ptr)
+    pr != C_NULL || throw(XMLNoRootError())
     XMLElement(pr)
 end
 
 
 #### construction & free
 
 function free(xdoc::XMLDocument)
-    ccall(xmlFreeDoc, Void, (Ptr{Void},), xdoc.ptr)
-    xdoc.ptr = nullptr
+    ccall((:xmlFreeDoc,libxml2), Void, (Xptr,), xdoc.ptr)
+    xdoc.ptr = C_NULL
 end
 
 function set_root(xdoc::XMLDocument, xroot::XMLElement)
-    ccall(xmlDocSetRootElement, Xptr, (Xptr, Xptr), xdoc.ptr, xroot.node.ptr)
+    ccall((:xmlDocSetRootElement,libxml2), Xptr, (Xptr, Xptr), xdoc.ptr, xroot.node.ptr)
 end
 
-function create_root(xdoc::XMLDocument, name::String)
+function create_root(xdoc::XMLDocument, name::AbstractString)
     xroot = new_element(name)
     set_root(xdoc, xroot)
     return xroot
 end
 
 #### parse and free
 
-function parse_file(filename::String)
-    p = ccall(xmlParseFile, Xptr, (Ptr{Cchar},), filename)
-    p != nullptr || throw(XMLParseError("Failure in parsing an XML file."))
+function parse_file(filename::AbstractString)
+    p = ccall((:xmlParseFile,libxml2), Xptr, (Cstring,), filename)
+    p != C_NULL || throw(XMLParseError("Failure in parsing an XML file."))
     XMLDocument(p)
 end
 
-function parse_string(s::String)
-    p = ccall(xmlParseMemory, Xptr, (Ptr{Cchar}, Cint), s, sizeof(s) + 1)
-    p != nullptr || throw(XMLParseError("Failure in parsing an XML string."))
+function parse_string(s::AbstractString)
+    p = ccall((:xmlParseMemory,libxml2), Xptr, (Xstr, Cint), s, sizeof(s) + 1)
+    p != C_NULL || throw(XMLParseError("Failure in parsing an XML string."))
     XMLDocument(p)
 end
 
 
 #### output
 
-function save_file(xdoc::XMLDocument, filename::String; encoding::String="utf-8")
-    ret = ccall(xmlSaveFormatFileEnc, Cint, (Ptr{Cchar}, Xptr, Ptr{Cchar}, Cint),
+function save_file(xdoc::XMLDocument, filename::AbstractString; encoding::AbstractString="utf-8")
+    ret = ccall((:xmlSaveFormatFileEnc,libxml2), Cint, (Cstring, Xptr, Cstring, Cint),
         filename, xdoc.ptr, encoding, 1)
     if ret < 0
         throw(XMLWriteError("Failed to save XML to file $filename"))
     end
     return @compat Int(ret)  # number of bytes written
 end
 
-function Base.string(xdoc::XMLDocument; encoding::String="utf-8")
+function Base.string(xdoc::XMLDocument; encoding::AbstractString="utf-8")
     buf_out = Array(Xstr, 1)
     len_out = Array(Cint, 1)
-    ccall(xmlDocDumpFormatMemoryEnc, Void, (Xptr, Ptr{Xstr}, Ptr{Cint}, Ptr{Cchar}, Cint),
+    ccall((:xmlDocDumpFormatMemoryEnc,libxml2), Void, (Xptr, Ptr{Xstr}, Ptr{Cint}, Cstring, Cint),
         xdoc.ptr, buf_out, len_out, encoding, 1)
     _xcopystr(buf_out[1])
 end

src/document.jl

@@ -1,8 +1,8 @@
 
 abstract XMLError <: Exception
 
-immutable XMLParseError <: XMLError
-    msg::String
+immutable XMLParseError{T<:AbstractString} <: XMLError
+    msg::T
 end
 
 immutable XMLNoRootError <: XMLError
@@ -11,12 +11,12 @@ end
 immutable XMLAttributeNotFound <: XMLError
 end
 
-immutable XMLWriteError <: XMLError
-    msg::String
+immutable XMLWriteError{T<:AbstractString} <: XMLError
+    msg::T
 end
 
-immutable XMLTreeError <: XMLError
-    msg::String
+immutable XMLTreeError{T<:AbstractString} <: XMLError
+    msg::T
 end
 
 const dom_exception_causes = [
@@ -33,9 +33,9 @@ const dom_exception_causes = [
 ]
 
 
-immutable DOMException <: XMLError
+immutable DOMException{T<:AbstractString} <: XMLError
     code::Int
-    cause::String
+    cause::T
 
     DOMException(code::Int) = new(code, dom_exception_causes[code])
 end