nokogiri 1.4.7-x86-mingw32 → 1.5.0-x86-mingw32

data/lib/nokogiri/ffi/structs/xml_node_set.rb

@@ -1,53 +0,0 @@
-module Nokogiri
-  module LibXML # :nodoc:
-
-    module XmlNodeSetMixin # :nodoc:
-      def self.included(base)
-        base.class_eval do
-
-          layout(
-            :nodeNr,    :int,
-            :nodeMax,   :int,
-            :nodeTab,   :pointer
-            )
-
-        end
-      end
-
-      def document
-        p = self[:doc]
-        p.null? ? nil : LibXML::XmlDocumentCast.new(p)
-      end
-
-      def nodeAt(index)
-        self[:nodeTab].get_pointer(LibXML.pointer_offset(index))
-      end
-
-      def nodeTab
-        self[:nodeTab].null? ? [] : self[:nodeTab].read_array_of_pointer(self[:nodeNr])
-      end
-
-      def nodeTab=(array)
-        # TODO: do we need to check nodeMax and allocate more memory? probably.
-        self[:nodeTab].write_array_of_pointer(array)
-      end
-    end
-
-
-    class XmlNodeSet < FFI::ManagedStruct # :nodoc:
-      include XmlNodeSetMixin
-
-      def self.release ptr
-        ns = XmlNodeSetCast.new(ptr)
-        LibXML.xmlFree ns[:nodeTab] if ns[:nodeTab]
-        LibXML.xmlFree ptr
-      end
-    end
-
-
-    class XmlNodeSetCast < FFI::Struct # :nodoc:
-      include XmlNodeSetMixin
-    end
-
-  end
-end

data/lib/nokogiri/ffi/structs/xml_notation.rb

@@ -1,11 +0,0 @@
-module Nokogiri
-  module LibXML # :nodoc:
-    class XmlNotation < FFI::Struct # :nodoc:
-      layout(
-        :name,          :string,
-        :PublicID,      :string,
-        :SystemID,      :string
-        )
-    end
-  end
-end

data/lib/nokogiri/ffi/structs/xml_ns.rb

@@ -1,15 +0,0 @@
-module Nokogiri
-  module LibXML # :nodoc:
-    class XmlNs < FFI::Struct # :nodoc:
-      layout(
-        :next,     :pointer,
-        :type,     :int,
-        :href,     :string,
-        :prefix,   :string,
-        :_private, :long # actually a pointer we're casting as an integer
-        )
-
-      include CommonNode
-    end
-  end
-end

data/lib/nokogiri/ffi/structs/xml_parser_context.rb

@@ -1,20 +0,0 @@
-module Nokogiri
-  # :stopdoc:
-  module LibXML
-    class XmlParserContext < FFI::Struct
-      layout(
-        :sax,               :pointer,
-        :userData,          :pointer,
-        :myDoc,             :pointer,
-        :wellFormed,        :int,
-        :replaceEntities,   :int,
-        :version,           :string,
-        :encoding,          :string,
-        :standalone,        :int,
-        :html,              :int,
-        :input,             :pointer
-      )
-    end
-  end
-  # :startdoc:
-end

data/lib/nokogiri/ffi/structs/xml_parser_input.rb

@@ -1,19 +0,0 @@
-module Nokogiri
-  # :stopdoc:
-  module LibXML
-    class XmlParserInput < FFI::Struct
-      layout(
-        :buf,               :pointer,
-        :filename,          :pointer,
-        :directory,         :pointer,
-        :base,              :pointer,
-        :cur,               :pointer,
-        :end,               :pointer,
-        :length,            :int,
-        :line,              :int,
-        :col,               :int
-      )
-    end
-  end
-  # :startdoc:
-end

data/lib/nokogiri/ffi/structs/xml_relax_ng.rb

@@ -1,14 +0,0 @@
-module Nokogiri
-  module LibXML # :nodoc:
-    class XmlRelaxNG < FFI::ManagedStruct # :nodoc:
-
-      layout :dummy, :int, 0 # to avoid @layout warnings
-
-      def self.release ptr
-        LibXML.xmlRelaxNGFree(ptr)
-      end
-
-    end
-  end
-end
-

data/lib/nokogiri/ffi/structs/xml_sax_handler.rb

@@ -1,51 +0,0 @@
-module Nokogiri
-  module LibXML # :nodoc:
-    class XmlSaxHandler < FFI::ManagedStruct # :nodoc:
-
-      XML_SAX2_MAGIC = 0xDEEDBEAF # see, the libxml2 authors DO have a sense of humor. i think.
-
-      layout(:internalSubset,           :pointer,
-             :isStandalone,             :pointer,
-             :hasInternalSubset,        :pointer,
-             :hasExternalSubset,        :pointer,
-             :resolveEntity,            :pointer,
-             :getEntity,                :pointer,
-             :entityDecl,               :pointer,
-             :notationDecl,             :pointer,
-             :attributeDecl,            :pointer,
-             :elementDecl,              :pointer,
-             :unparsedEntityDecl,       :pointer,
-             :setDocumentLocator,       :pointer,
-             :startDocument,            :start_document_sax_func, 
-             :endDocument,              :end_document_sax_func ,
-             :startElement,             :start_element_sax_func,
-             :endElement,               :end_element_sax_func,
-             :reference,                :pointer,
-             :characters,               :characters_sax_func,
-             :ignorableWhitespace,      :pointer,
-             :processingInstruction,    :pointer,
-             :comment,                  :comment_sax_func,
-             :warning,                  :warning_sax_func, 
-             :error,                    :error_sax_func,
-             :fatalError,               :pointer,
-             :getParameterEntity,       :pointer,
-             :cdataBlock,               :cdata_block_sax_func, 
-             :externalSubset,           :pointer,
-             :initialized,              :uint,
-             :_private,                 :pointer,
-             :startElementNs,           :start_element_ns_sax2_func,
-             :endElementNs,             :end_element_ns_sax2_func,
-             :serror,                   :syntax_error_handler
-             )
-
-      def self.allocate
-        new LibXML.calloc(1, LibXML::XmlSaxHandler.size)
-      end
-
-      def self.release ptr
-        LibXML.free(ptr)
-      end
-
-    end
-  end
-end

data/lib/nokogiri/ffi/structs/xml_sax_push_parser_context.rb

@@ -1,124 +0,0 @@
-module Nokogiri
-  # :stopdoc:
-  module LibXML
-    class XmlSaxPushParserContext < FFI::ManagedStruct
-
-      layout(
-        :sax,           :pointer,       # struct _xmlSAXHandler *sax;       /* The SAX handler */
-        :userData,      :pointer,       # void            *userData;        /* For SAX interface only, used by DOM build */
-        :myDoc,         :pointer,       # xmlDocPtr           myDoc;        /* the document being built */
-        :wellFormed,    :int,           # int            wellFormed;        /* is the document well formed */
-        :replaceEntities, :int,         # int       replaceEntities;        /* shall we replace entities ? */
-        :version,       :pointer,       # const xmlChar    *version;        /* the XML version string */
-        :encoding,      :pointer,       # const xmlChar   *encoding;        /* the declared encoding, if any */
-        :standalone,    :int,           # int            standalone;        /* standalone document */
-        :html,          :int,           # int                  html;        /* an HTML(1)/Docbook(2) document
-
-        :input,         :pointer,       # xmlParserInputPtr  input;         /* Current input stream */
-        :inputNr,       :int,           # int                inputNr;       /* Number of current input streams */
-        :inputMax,      :int,           # int                inputMax;      /* Max number of input streams */
-        :inputTab,      :pointer,       # xmlParserInputPtr *inputTab;      /* stack of inputs */
-
-        :node,          :pointer,       # xmlNodePtr         node;          /* Current parsed Node */
-        :nodeNr,        :int,           # int                nodeNr;        /* Depth of the parsing stack */
-        :nodeMax,       :int,           # int                nodeMax;       /* Max depth of the parsing stack */
-        :nodeTab,       :pointer,       # xmlNodePtr        *nodeTab;       /* array of nodes */
-
-        :record_info,   :int,           # int record_info;                  /* Whether node info should be kept */
-
-        # xmlParserNodeInfoSeq node_seq;    /* info about each node parsed */
-                :node_seq_maximum, :ulong,
-                :node_seq_length,  :ulong,
-                :node_seq_buffer,  :pointer,
-
-        :errNo,         :int,           # int errNo;                        /* error code */
-
-        :hasExternalSubset, :int,       # int     hasExternalSubset;        /* reference and external subset */
-        :hasPErefs,     :int,           # int             hasPErefs;        /* the internal subset has PE refs */
-        :external,      :int,           # int              external;        /* are we parsing an external entity */
-
-        :valid,         :int,           # int                 valid;        /* is the document valid */
-        :validate,      :int,           # int              validate;        /* shall we try to validate ? */
-
-        # xmlValidCtxt        vctxt;        /* The validity context */
-                :vctxt_userData,        :pointer,       # void *userData;			/* user specific data block */
-                :vctxt_error,           :pointer,       # xmlValidityErrorFunc error;		/* the callback in case of errors */
-                :vctxt_warning,         :pointer,       # xmlValidityWarningFunc warning;	/* the callback in case of warning */
-                :vctxt_node,            :pointer,       # xmlNodePtr         node;          /* Current parsed Node */
-                :vctxt_nodeNr,          :int,           # int                nodeNr;        /* Depth of the parsing stack */
-                :vctxt_nodeMax,         :int,           # int                nodeMax;       /* Max depth of the parsing stack */
-                :vctxt_nodeTab,         :pointer,       # xmlNodePtr        *nodeTab;       /* array of nodes */
-
-                :vctxt_finishDtd,       :int,           # unsigned int     finishDtd;       /* finished validating the Dtd ? */
-                :vctxt_doc,             :pointer,       # xmlDocPtr              doc;       /* the document */
-                :vctxt_valid,           :int,           # int                  valid;       /* temporary validity check result */
-                :vctxt_vstate,          :pointer,       # xmlValidState     *vstate;        /* current state */
-                :vctxt_vstatNr,         :int,           # int                vstateNr;      /* Depth of the validation stack */
-                :vctxt_vstateMax,       :int,           # int                vstateMax;     /* Max depth of the validation stack */
-                :vctxt_vstateTab,       :pointer,       # xmlValidState     *vstateTab;     /* array of validation states */
-                :vctxt_am,              :pointer,       # xmlAutomataPtr            am;     /* the automata */
-                :vctxt_state,           :pointer,       # xmlAutomataStatePtr    state;     /* used to build the automata */
-
-        :instate,       :int,           # xmlParserInputState instate;      /* current type of input */
-        :token,         :int,           # int                 token;        /* next char look-ahead */    
-
-        :directory,     :pointer,       # char           *directory;        /* the data directory */
-        :name,          :pointer,       # const xmlChar     *name;          /* Current parsed Node */
-        :nameNr,        :int,           # int                nameNr;        /* Depth of the parsing stack */
-        :nameMax,       :int,           # int                nameMax;       /* Max depth of the parsing stack */
-        :nameTab,       :pointer,       # const xmlChar *   *nameTab;       /* array of nodes */
-
-        :nbChars,       :long,          # long               nbChars;       /* number of xmlChar processed */
-        :checkIndex,    :long,          # long            checkIndex;       /* used by progressive parsing lookup */
-        :keepBlanks,    :int,           # int             keepBlanks;       /* ugly but ... */
-        :disableSAX,    :int,           # int             disableSAX;       /* SAX callbacks are disabled */
-        :inSubset,      :int,           # int               inSubset;       /* Parsing is in int 1/ext 2 subset */
-        :intSubName,    :pointer,       # const xmlChar *    intSubName;    /* name of subset */
-        :extSubURI,     :pointer,       # xmlChar *          extSubURI;     /* URI of external subset */
-        :extSubSystem,  :pointer,       # xmlChar *          extSubSystem;  /* SYSTEM ID of external subset */
-
-        :space,         :pointer,       # int *              space;         /* Should the parser preserve spaces */
-        :spaceNr,       :int,           # int                spaceNr;       /* Depth of the parsing stack */
-        :spaceMax,      :int,           # int                spaceMax;      /* Max depth of the parsing stack */
-        :spaceTab,      :pointer,       # int *              spaceTab;      /* array of space infos */
-        :depth,         :int,           # int                depth;         /* to prevent entity substitution loops */
-        :entity,        :pointer,       # xmlParserInputPtr  entity;        /* used to check entities boundaries */
-        :charset,       :int,           # int                charset;       /* encoding of the in-memory content
-        :nodelen,       :int,           # int                nodelen;       /* Those two fields are there to */
-        :nodemem,       :int,           # int                nodemem;       /* Speed up large node parsing */
-        :pedantic,      :int,           # int                pedantic;      /* signal pedantic warnings */
-        :_private,      :pointer,       # void              *_private;      /* For user data, libxml won't touch it */
-
-        :loadsubset,    :int,           # int                loadsubset;    /* should the external subset be loaded */
-        :linenumbers,   :int,           # int                linenumbers;   /* set line number in element content */
-        :catalogs,      :pointer,       # void              *catalogs;      /* document's own catalog */
-        :recovery,      :int,           # int                recovery;      /* run in recovery mode */
-        :progressive,   :int,           # int                progressive;   /* is this a progressive parsing */
-        :dict,          :pointer,       # xmlDictPtr         dict;          /* dictionnary for the parser */
-        :atts,          :pointer,       # const xmlChar *   *atts;          /* array for the attributes callbacks */
-        :maxatts,       :int,           # int                maxatts;       /* the size of the array */
-        :docdict,       :int,           # int                docdict;       /* use strings from dict to build tree */
-        :str_xml,       :pointer,       # const xmlChar *str_xml;
-        :str_xmlns,     :pointer,       # const xmlChar *str_xmlns;
-        :str_xml_ns,    :pointer,       # const xmlChar *str_xml_ns;
-
-        :sax2,          :int,           # int                sax2;          /* operating in the new SAX mode */
-        :nsNr,          :int,           # int                nsNr;          /* the number of inherited namespaces */
-        :nsMax,         :int,           # int                nsMax;         /* the size of the arrays */
-        :nsTab,         :pointer,       # const xmlChar *   *nsTab;         /* the array of prefix/namespace name */
-        :attallocs,     :pointer,       # int               *attallocs;     /* which attribute were allocated */
-        :pushTab,       :pointer,       # void *            *pushTab;       /* array of data for push */
-        :attsDefault,   :pointer,       # xmlHashTablePtr    attsDefault;   /* defaulted attributes if any */
-        :attsSpecial,   :pointer,       # xmlHashTablePtr    attsSpecial;   /* non-CDATA attributes if any */
-        :nsWellFormed,  :int,           # int                nsWellFormed;  /* is the document XML Nanespace okay */
-        :options,       :int            # int                options;       /* Extra options */
-        )
-
-      def self.release ptr
-        LibXML.xmlFreeParserCtxt(ptr)
-      end
-    end
-
-  end
-  # :startdoc:
-end

data/lib/nokogiri/ffi/structs/xml_schema.rb

@@ -1,13 +0,0 @@
-module Nokogiri
-  module LibXML # :nodoc:
-    class XmlSchema < FFI::ManagedStruct # :nodoc:
-
-      layout :dummy, :int, 0 # to avoid @layout warnings
-
-      def self.release ptr
-        LibXML.xmlSchemaFree(ptr)
-      end
-
-    end
-  end
-end

data/lib/nokogiri/ffi/structs/xml_syntax_error.rb

@@ -1,31 +0,0 @@
-module Nokogiri
-  module LibXML # :nodoc:
-    class XmlSyntaxError < FFI::ManagedStruct # :nodoc:
-
-      layout(
-        :domain,  :int,
-        :code,    :int,
-        :message, :pointer,
-        :level,   :int,
-        :file,    :string,
-        :line,    :int,
-        :str1,    :string,
-        :str2,    :string,
-        :str3,    :string,
-        :int1,    :int,
-        :int2,    :int,
-        :ctxt,    :pointer,
-        :node,    :pointer
-        )
-
-      def self.allocate
-        LibXML.calloc(1, LibXML::XmlSyntaxError.size)
-      end
-
-      def self.release(ptr)
-        LibXML.free(ptr)
-      end
-
-    end
-  end
-end

data/lib/nokogiri/ffi/structs/xml_text_reader.rb

@@ -1,12 +0,0 @@
-module Nokogiri
-  module LibXML # :nodoc:
-    class XmlTextReader < FFI::ManagedStruct # :nodoc:
-
-      layout :dummy, :int # to avoid @layout warnings
-
-      def self.release ptr
-        LibXML.xmlFreeTextReader(ptr)
-      end
-    end
-  end
-end

data/lib/nokogiri/ffi/structs/xml_xpath_context.rb

@@ -1,38 +0,0 @@
-module Nokogiri
-  module LibXML # :nodoc:
-    module XmlXpathContextMixin # :nodoc:
-      def self.included(base)
-        base.class_eval do
-
-          layout(
-            :doc,  :pointer,
-            :node, :pointer
-            )
-
-        end
-      end
-
-      def node
-        LibXML::XmlNode.new(self[:node])
-      end
-
-      def document
-        p = self[:doc]
-        p.null? ? nil : LibXML::XmlDocumentCast.new(p)
-      end
-    end
-
-    class XmlXpathContext < FFI::ManagedStruct # :nodoc:
-      include XmlXpathContextMixin
-
-      def self.release ptr
-        LibXML.xmlXPathFreeContext(ptr)
-      end
-    end
-
-    class XmlXpathContextCast < FFI::Struct # :nodoc:
-      include XmlXpathContextMixin
-    end
-
-  end
-end

data/lib/nokogiri/ffi/structs/xml_xpath_object.rb

@@ -1,35 +0,0 @@
-module Nokogiri
-  module LibXML # :nodoc:
-
-    class XmlXpathObject < FFI::ManagedStruct # :nodoc:
-
-      XPATH_UNDEFINED = 0
-      XPATH_NODESET = 1
-      XPATH_BOOLEAN = 2
-      XPATH_NUMBER = 3
-      XPATH_STRING = 4
-      XPATH_POINT = 5
-      XPATH_RANGE = 6
-      XPATH_LOCATIONSET = 7
-      XPATH_USERS = 8
-      XPATH_XSLT_TREE = 9
-
-      layout(
-        :type,          :int,
-        :nodesetval,    :pointer,
-        :boolval,       :int,
-        :floatval,      :double,
-        :stringval,     :string,
-        :user,          :pointer,
-        :index,         :int,
-        :user2,         :pointer,
-        :index2,        :int
-        )
-
-      def self.release ptr
-        LibXML.xmlXPathFreeNodeSetList(ptr) # despite the name, this frees the xpath but not the contained node set
-      end
-    end
-
-  end
-end