nokogiri 1.2.3-x86-mswin32-60 → 1.4.5-x86-mswin32-60

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

@@ -0,0 +1,53 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,51 @@
+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

@@ -0,0 +1,124 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,35 @@
+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