The XML C parser and toolkit of Gnome

Note: this is the flat content of the website

libxml, a.k.a. gnome-xml

"Programmingwithlibxml2 is like the thrilling embrace of an exotic stranger." MarkPilgrim

Libxml2 is the XML C parser and toolkit developed for the Gnomeproject(but usable outside of the Gnome platform), it is free softwareavailableunder the MITLicense.XML itself is a metalanguage to design markup languages, i.e.text languagewhere semantic and structure are added to the content usingextra "markup"information enclosed between angle brackets. HTML is the mostwell-knownmarkup language. Though the library is written in C avariety of language bindingsmake it available inother environments.

Libxml2 is known to be very portable, the library should build andworkwithout serious troubles on a variety of systems (Linux, Unix,Windows,CygWin, MacOS, MacOS X, RISC Os, OS/2, VMS, QNX, MVS, ...)

Libxml2 implements a number of existing standards related tomarkuplanguages:

In most cases libxml2 tries to implement the specifications in arelativelystrictly compliant way. As of release 2.4.16, libxml2 passed all1800+ testsfrom the OASIS XMLTestsSuite.

To some extent libxml2 provides support for the followingadditionalspecifications but doesn't claim to implement them completely:

A partial implementation of XML Schemas Part1:Structureis being worked on but it would be far too early to makeanyconformance statement about it at the moment.

Separate documents:

Logo designed by Marc Liyanage.

Introduction

This document describes libxml, the XMLC parser and toolkit developed for theGnomeproject. XML is a standardfor buildingtag-basedstructured documents/data.

Here are some key points about libxml:

Warning: unless you are forced to because your application links withaGnome-1.X library requiring it, Do Not Use libxml1,uselibxml2

FAQ

Table of Contents:

License(s)

  1. Licensing Terms for libxml

    libxml2 is released under the MITLicense;see the file Copyright in the distribution for the precisewording

  2. Can I embed libxml2 in a proprietary application ?

    Yes. The MIT License allows you to keep proprietary the changesyoumade to libxml, but it would be graceful to send-back bug fixesandimprovements as patches for possible incorporation in themaindevelopment tree.

Installation

  1. Do NotUselibxml1, use libxml2
  2. Where can I get libxml?

    The original distribution comes from xmlsoft.orgor gnome.org

    Most Linux and BSD distributions include libxml, this is probablythesafer way for end-users to use libxml.

    David Doolin provides precompiled Windows versions at http://www.ce.berkeley.edu/~doolin/code/libxmlwin32/

  3. I see libxml and libxml2 releases, which one should I install ?
  4. I can't install the libxml package, it conflicts with libxml0

    You probably have an old libxml0 package used to provide thesharedlibrary for libxml.so.0, you can probably safely remove it. Thelibxmlpackages provided on xmlsoft.orgprovidelibxml.so.0

  5. I can't install the libxml(2) RPM package due tofaileddependencies

    The most generic solution is to re-fetch the latest src.rpm ,andrebuild it locally with

    rpm --rebuild libxml(2)-xxx.src.rpm.

    If everything goes well it will generate two binary rpm packages(oneproviding the shared libs and xmllint, and the other one, the-develpackage, providing includes, static libraries and scripts needed tobuildapplications with libxml(2)) that you can install locally.

Compilation

  1. What is the process to compile libxml2 ?

    As most UNIX libraries libxml2 follows the "standard":

    gunzip -c xxx.tar.gz | tar xvf -

    cd libxml-xxxx

    ./configure --help

    to see the options, then the compilation/installation proper

    ./configure [possible options]

    make

    make install

    At that point you may have to rerun ldconfig or a similar utilitytoupdate your list of installed shared libs.

  2. What other libraries are needed to compile/install libxml2 ?

    Libxml2 does not require any other library, the normal C ANSIAPIshould be sufficient (please report any violation to this rule youmayfind).

    However if found at configuration time libxml2 will detect and usethefollowing libs:

  3. Make check fails on some platforms

    Sometimes the regression tests' results don't completely matchthevalue produced by the parser, and the makefile uses diff to printthedelta. On some platforms the diff return breaks the compilationprocess;if the diff is small this is probably not a serious problem.

    Sometimes (especially on Solaris) make checks fail due tolimitationsin make. Try using GNU-make instead.

  4. I use the CVS version and there is no configure script

    The configure script (and other Makefiles) are generated. Usetheautogen.sh script to regenerate the configure script andMakefiles,like:

    ./autogen.sh --prefix=/usr --disable-shared

  5. I have troubles when running make tests with gcc-3.0

    It seems the initial release of gcc-3.0 has a problem withtheoptimizer which miscompiles the URI module. Please useanothercompiler.

Developercorner

  1. Troubles compiling or linking programs using libxml2

    Usually the problem comes from the fact that the compiler doesn'tgetthe right compilation or linking flags. There is a small shellscriptxml2-configwhich is installed as part of libxml2usualinstall process which provides those flags. Use

    xml2-config --cflags

    to get the compilation flags and

    xml2-config --libs

    to get the linker flags. Usually this is done directly fromtheMakefile as:

    CFLAGS=`xml2-config --cflags`

    LIBS=`xml2-config --libs`

  2. I want to install my own copy of libxml2 in my home directoryandlink my programs against it, but it doesn't work

    There are many different ways to accomplish this. Here is one waytodo this under Linux. Suppose your home directory is/home/user.Then:

  3. xmlDocDump() generates output on one line.

    Libxml2 will not inventspaces in the content ofadocument since all spaces in the content of a documentaresignificant. If you build a tree from the API andwantindentation:

    1. the correct way is to generate those yourself too.
    2. the dangerous way is to ask libxml2 to add those blanks toyourcontent modifying the content of your document intheprocess. The result may not be what you expect. ThereisNOway to guarantee that such a modificationwon'taffect other parts of the content of your document. See xmlKeepBlanksDefault()andxmlSaveFormatFile()
  4. Extra nodes in the document:

    For a XML file as below:

    <?xml version="1.0"?>
<PLAN xmlns="http://www.argus.ca/autotest/1.0/">
<NODE CommFlag="0"/>
<NODE CommFlag="1"/>
</PLAN>

    after parsing it with thefunctionpxmlDoc=xmlParseFile(...);

    I want to the get the content of the first node (node withtheCommFlag="0")

    so I did it as following;

    xmlNodePtr pnode;
pnode=pxmlDoc->children->children;

    but it does not work. If I change it to

    pnode=pxmlDoc->children->children->next;

    then it works. Can someone explain it to me.

    In XML all characters in the content of the document aresignificantincluding blanks and formatting linebreaks.

    The extra nodes you are wondering about are just that, text nodeswiththe formatting spaces which are part of the document but that peopletendto forget. There is a function xmlKeepBlanksDefault()toremove those at parse time, but that's an heuristic, and itsuse should belimited to cases where you are certain there is nomixed-content in thedocument.

  5. I get compilation errors of existing code like whenaccessingrootor child fieldsofnodes.

    You are compiling code developed for libxml version 1 and usingalibxml2 development environment. Either switch back to libxml v1 develoreven better fix the code to compile with libxml2 (or both) by following the instructions.

  6. I get compilation errors about nonexistingxmlRootNodeorxmlChildrenNodefields.

    The source code you are using has been upgradedto be able to compile with both libxmlandlibxml2, but you need to install a more recent version:libxml(-devel)>= 1.8.8 or libxml2(-devel) >= 2.1.0

  7. XPath implementation looks seriously broken

    XPath implementation prior to 2.3.0 was really incomplete. Upgrade toarecent version, there are no known bugs in the current version.

  8. The example provided in the web page does not compile.

    It's hard to maintain the documentation in sync with thecode<grin/> ...

    Check the previous points 1/ and 2/ raised before, and pleasesendpatches.

  9. Where can I get more examples and information than provided ontheweb page?

    Ideally a libxml2 book would be nice. I have no such plan ... Butyoucan:

  10. What about C++ ?

    libxml2 is written in pure C in order to allow easy reuse on anumberof platforms, including embedded systems. I don't intend to converttoC++.

    There is however a C++ wrapper which may fulfill your needs:

  11. How to validate a document a posteriori ?

    It is possible to validate documents which had not been validatedatinitial parsing time or documents which have been built fromscratchusing the API. Use the xmlValidateDtd()function.It is also possible to simply add a DTD to an existingdocument:

    xmlDocPtr doc; /* your existing document */
xmlDtdPtr dtd = xmlParseDTD(NULL, filename_of_dtd); /* parse the DTD */

        dtd->name = xmlStrDup((xmlChar*)"root_name"); /* use the given root */

        doc->intSubset = dtd;
        if (doc->children == NULL) xmlAddChild((xmlNodePtr)doc, (xmlNodePtr)dtd);
        else xmlAddPrevSibling(doc->children, (xmlNodePtr)dtd);
  12. So what is this funky "xmlChar" used all the time?

    It is a null terminated sequence of utf-8 characters. And onlyutf-8!You need to convert strings encoded in different ways to utf-8beforepassing them to the API. This can be accomplished with the iconvlibraryfor instance.

  13. etc ...

Developer Menu

There are several on-line resources related to using libxml:

  1. Use the search engineto lookupinformation.
  2. Check the FAQ.
  3. Check the extensivedocumentationautomaticallyextracted from code comments.
  4. Look at the documentation about libxmlinternationalization support.
  5. This page provides a global overview and someexampleson how to use libxml.
  6. Code examples
  7. John Fleck's libxml2 tutorial: htmlorpdf.
  8. If you need to parse large files, check the xmlReaderAPI tutorial
  9. James Henstridgewrote somenicedocumentationexplaining how to use the libxml SAX interface.
  10. George Lebl wrote anarticlefor IBM developerWorksabout using libxml.
  11. Check theTODOfile.
  12. Read the 1.x to 2.x upgrade pathdescription.If you are starting a new project using libxml you shouldreally use the2.x version.
  13. And don't forget to look at the mailing-list archive.

Reporting bugs and getting help

Well, bugs or missing features are always possible, and I will make apointof fixing them in a timely fashion. The best way to report a bug is touse theGnomebugtracking database(make sure to use the "libxml2" module name). Ilook atreports there regularly and it's good to have a reminder when a bugis stillopen. Be sure to specify that the bug is for the package libxml2.

For small problems you can try to get help on IRC, the #xml channelonirc.gnome.org (port 6667) usually have a few person subscribed which mayhelp(but there is no garantee and if a real issue is raised it should go onthemailing-list for archival).

There is also a mailing-list xml@gnome.orgfor libxml, with an on-line archive(old). To subscribe to this list,pleasevisit the associatedWebpage andfollow the instructions. Do not send code, I won'tdebug it(but patches are really appreciated!).

Please note that with the current amount of virus and SPAM, sending mailtothe list without being subscribed won't work. There is *far too manybounces*(in the order of a thousand a day !) I cannot approve them manuallyanymore.If your mail to the list bounced waiting for administrator approval,it isLOST ! Repost it and fix the problem triggering the error. Also pleasenotethat emails withalegal warning asking to not copy or redistribute freely the informationstheycontainare NOTacceptable for the mailing-list,suchmail will as much as possible be discarded automatically, and are lesslikelyto be answered if they made it to the list, DO NOTpost tothe list from an email address where such legal requirements areautomaticallyadded, get private paying support if you can't shareinformations.

Check the following beforeposting:

Then send the bug with associated information to reproduce it to the xml@gnome.orglist; if it's reallylibxmlrelated I will approve it. Please do not send mail to me directly, itmakesthings really hard to track and in some cases I am not the best persontoanswer a given question, ask on the list.

To be really clear about support:

Of course, bugs reported with a suggested patch for fixing themwillprobably be processed faster than those without.

If you're looking for help, a quick look at the list archivemayactuallyprovide the answer. I usually send source samples when answeringlibxml2usage questions. The auto-generateddocumentationisnot as polished as I would like (i need to learn moreabout DocBook), butit's a good starting point.

How to help

You can help the project in various ways, the best thing to do first istosubscribe to the mailing-list as explained before, check the archives and the Gnomebugdatabase:

  1. Provide patches when you find problems.
  2. Provide the diffs when you port libxml2 to a new platform. They maynotbe integrated in all cases but help pinpointing portabilityproblemsand
  3. Provide documentation fixes (either as patches to the code commentsoras HTML diffs).
  4. Provide new documentations pieces (translations, examples, etc...).
  5. Check the TODO file and try to close one of the items.
  6. Take one of the points raised in the archive or the bug databaseandprovide a fix. Get in touch withmebefore to avoid synchronization problems and check that thesuggestedfix will fit in nicely :-)

Downloads

The latest versions of libxml2 can be found on the xmlsoft.orgserver ( HTTP, FTPand rsync are available), there isalsomirrors (Australia(Web), France) or on the Gnome FTP serveras source archive,Antonin Sprinzl also provide amirror in Austria. (NOTE thatyou need both the libxml(2)and libxml(2)-develpackagesinstalled to compile applications using libxml.)

You can find all the history of libxml(2) and libxslt releases in the olddirectory. TheprecompiledWindows binaries made by Igor Zlatovic are available in the win32directory.

Binary ports:

If you know other supported binary ports, please contact me.

Snapshot:

Contributions:

I do accept external contributions, especially if compiling onanotherplatform, get in touch with the list to upload the package, wrappersforvarious languages have been provided, and can be found in the bindings section

Libxml2 is also available from CVS:

Releases

Items not finished and worked on, get in touch with the list if you wanttohelp those

The change logdescribes the recents commitstothe CVScode base.

There is the list of public releases:

2.6.26: Jun 6 2006

2.6.25: Jun 6 2006:

Do not use or package 2.6.25

2.6.24: Apr 28 2006

2.6.23: Jan 5 2006

2.6.22: Sep 12 2005

2.6.21: Sep 4 2005

2.6.20: Jul 10 2005

2.6.19: Apr 02 2005

2.6.18: Mar 13 2005

2.6.17: Jan 16 2005

2.6.16: Nov 10 2004

2.6.15: Oct 27 2004

2.6.14: Sep 29 2004

2.6.13: Aug 31 2004

2.6.12: Aug 22 2004

2.6.11: July 5 2004

2.6.10: May 17 2004

2.6.9: Apr 18 2004

2.6.8: Mar 23 2004

2.6.7: Feb 23 2004

2.6.6: Feb 12 2004

2.6.5: Jan 25 2004

2.6.4: Dec 24 2003

2.6.3: Dec 10 2003

2.6.2: Nov 4 2003

2.6.1: Oct 28 2003

2.6.0: Oct 20 2003

2.5.11: Sep 9 2003

A bugfix only release:

2.5.10: Aug 15 2003

A bugfixes only release

2.5.9: Aug 9 2003

2.5.8: Jul 6 2003

2.5.7: Apr 25 2003

2.5.6: Apr 1 2003

2.5.5: Mar 24 2003

2.5.4: Feb 20 2003

2.5.3: Feb 10 2003

2.5.2: Feb 5 2003

2.5.1: Jan 8 2003

2.5.0: Jan 6 2003

2.4.30: Dec 12 2002

2.4.29: Dec 11 2002

2.4.28: Nov 22 2002

2.4.27: Nov 17 2002

2.4.26: Oct 18 2002

2.4.25: Sep 26 2002

2.4.24: Aug 22 2002

2.4.23: July 6 2002

2.4.22: May 27 2002

2.4.21: Apr 29 2002

This release is both a bug fix release and also contains the earlyXMLSchemas structuresand datatypescode, beware,allinterfaces are likely to change, there is huge holes, it is clearly a workinprogress and don't even think of putting this code in a productionsystem,it's actually not compiled in by default. The real fixes are:

2.4.20: Apr 15 2002

2.4.19: Mar 25 2002

2.4.18: Mar 18 2002

2.4.17: Mar 8 2002

2.4.16: Feb 20 2002

2.4.15: Feb 11 2002

2.4.14: Feb 8 2002

2.4.13: Jan 14 2002

2.4.12: Dec 7 2001

2.4.11: Nov 26 2001

2.4.10: Nov 10 2001

2.4.9: Nov 6 2001

2.4.8: Nov 4 2001

2.4.7: Oct 30 2001

2.4.6: Oct 10 2001

2.4.5: Sep 14 2001

1.8.16: Sep 14 2001

2.4.4: Sep 12 2001

2.4.3: Aug 23 2001

2.4.2: Aug 15 2001

2.4.1: July 24 2001

2.4.0: July 10 2001

2.3.14: July 5 2001

2.3.13: June 28 2001

1.8.14: June 28 2001

2.3.12: June 26 2001

2.3.11: June 17 2001

2.3.10: June 1 2001

2.3.9: May 19 2001

Lots of bugfixes, and added a basic SGML catalog support:

1.8.13: May 14 2001

2.3.8: May 3 2001

2.3.7: April 22 2001

2.3.6: April 8 2001

2.3.5: Mar 23 2001

2.3.4: Mar 10 2001

2.3.3: Mar 1 2001

2.3.2: Feb 24 2001

2.3.1: Feb 15 2001

2.3.0: Feb 8 2001 (2.2.12 was on 25 Jan but I didn't kept track)

2.2.11: Jan 4 2001

2.2.10: Nov 25 2000

2.2.9: Nov 25 2000

2.2.8: Nov 13 2000

2.2.7: Oct 31 2000

2.2.6: Oct 25 2000:

2.2.5: Oct 15 2000:

2.2.4: Oct 1 2000:

2.2.3: Sep 17 2000

1.8.10: Sep 6 2000

2.2.2: August 12 2000

2.2.1: July 21 2000

2.2.0: July 14 2000

1.8.9: July 9 2000

2.1.1: July 1 2000

2.1.0 and 1.8.8: June 29 2000

2.0.0: Apr 12 2000

2.0.0beta: Mar 14 2000

1.8.7: Mar 6 2000

1.8.6: Jan 31 2000

1.8.5: Jan 21 2000

1.8.4: Jan 13 2000

1.8.3: Jan 5 2000

1.8.2: Dec 21 1999

1.8.1: Dec 18 1999

1.8.0: Dec 12 1999

1.7.4: Oct 25 1999

1.7.3: Sep 29 1999

1.7.1: Sep 24 1999

1.7.0: Sep 23 1999

XML

XML is astandardformarkup-based structured documents. Here is an example XMLdocument:

<?xml version="1.0"?>
<EXAMPLE prop1="gnome is great" prop2="&amp; linux too">
  <head>
   <title>Welcome to Gnome</title>
  </head>
  <chapter>
   <title>The Linux adventure</title>
   <p>bla bla bla ...</p>
   <image href="linus.gif"/>
   <p>...</p>
  </chapter>
</EXAMPLE>

The first line specifies that it is an XML document and givesusefulinformation about its encoding. Then the rest of the document is atextformat whose structure is specified by tags between brackets.Eachtag opened has to be closed. XML is pedantic about this.However, ifa tag is empty (no content), a single tag can serve as both theopening andclosing tag if it ends with />rather thanwith>. Note that, for example, the image tag has no content(justan attribute) and is closed by ending the tag with/>.

XML can be applied successfully to a wide range of tasks, ranging fromlongterm structured document maintenance (where it follows the steps ofSGML) tosimple data encoding mechanisms like configuration file formatting(glade),spreadsheets (gnumeric), or even shorter lived documents such asWebDAV whereit is used to encode remote calls between a client and aserver.

XSLT

Check the separate libxslt page

XSL Transformations, is alanguagefor transforming XML documents into other XML documents (orHTML/textualoutput).

A separate library called libxslt is available implementing XSLT-1.0forlibxml2. This module "libxslt" too can be found in the Gnome CVS base.

You can check the progresses on the libxslt Changelog.

Python and bindings

There are a number of language bindings and wrappers available forlibxml2,the list below is not exhaustive. Please contact the xml-bindings@gnome.org(archives) inorder toget updates to this list or to discuss the specific topic of libxml2orlibxslt wrappers or bindings:

The distribution includes a set of Python bindings, which are guaranteedtobe maintained as part of the library in the future, though thePythoninterface have not yet reached the completeness of the C API.

Note that some of the Python purist dislike the default set ofPythonbindings, rather than complaining I suggest they have a look at lxml the more pythonic bindings forlibxml2and libxsltand helpMartijnFaassencomplete those.

StéphaneBidoulmaintains aWindows portof the Python bindings.

Note to people interested in building bindings, the API is formalized asan XML API description filewhich allows toautomatea large part of the Python bindings, this includes functiondescriptions,enums, structures, typedefs, etc... The Python script used tobuild thebindings is python/generator.py in the source distribution.

To install the Python bindings there are 2 options:

The distribution includes a set of examples and regression tests forthepython bindings in the python/testsdirectory. Here aresomeexcerpts from those tests:

tst.py:

This is a basic test of the file interface and DOM navigation:

import libxml2, sys

doc = libxml2.parseFile("tst.xml")
if doc.name != "tst.xml":
    print "doc.name failed"
    sys.exit(1)
root = doc.children
if root.name != "doc":
    print "root.name failed"
    sys.exit(1)
child = root.children
if child.name != "foo":
    print "child.name failed"
    sys.exit(1)
doc.freeDoc()

The Python module is called libxml2; parseFile is the equivalentofxmlParseFile (most of the bindings are automatically generated, and thexmlprefix is removed and the casing convention are kept). All node seen atthebinding level share the same subset of accessors:

Also note the need to explicitly deallocate documents with freeDoc().Reference counting for libxml2 trees would need quite a lot of worktofunction properly, and rather than risk memory leaks if notimplementedcorrectly it sounds safer to have an explicit function to free atree. Thewrapper python objects like doc, root or child are themautomatically garbagecollected.

validate.py:

This test check the validation interfaces and redirection oferrormessages:

import libxml2

#deactivate error messages from the validation
def noerr(ctx, str):
    pass

libxml2.registerErrorHandler(noerr, None)

ctxt = libxml2.createFileParserCtxt("invalid.xml")
ctxt.validate(1)
ctxt.parseDocument()
doc = ctxt.doc()
valid = ctxt.isValid()
doc.freeDoc()
if valid != 0:
    print "validity check failed"

The first thing to notice is the call to registerErrorHandler(), itdefinesa new error handler global to the library. It is used to avoid seeingtheerror messages when trying to validate the invalid document.

The main interest of that test is the creation of a parser contextwithcreateFileParserCtxt() and how the behaviour can be changed beforecallingparseDocument() . Similarly the informations resulting from theparsing phaseare also available using context methods.

Contexts like nodes are defined as class and the libxml2 wrappers mapstheC function interfaces in terms of objects method as much as possible.Thebest to get a complete view of what methods are supported is to look atthelibxml2.py module containing all the wrappers.

push.py:

This test show how to activate the push parser interface:

import libxml2

ctxt = libxml2.createPushParser(None, "<foo", 4, "test.xml")
ctxt.parseChunk("/>", 2, 1)
doc = ctxt.doc()

doc.freeDoc()

The context is created with a special call based onthexmlCreatePushParser() from the C library. The first argument is anoptionalSAX callback object, then the initial set of data, the length and thename ofthe resource in case URI-References need to be computed by theparser.

Then the data are pushed using the parseChunk() method, the lastcallsetting the third argument terminate to 1.

pushSAX.py:

this test show the use of the event based parsing interfaces. In thiscasethe parser does not build a document, but provides callback informationasthe parser makes progresses analyzing the data being provided:

import libxml2
log = ""

class callback:
    def startDocument(self):
        global log
        log = log + "startDocument:"

    def endDocument(self):
        global log
        log = log + "endDocument:"

    def startElement(self, tag, attrs):
        global log
        log = log + "startElement %s %s:" % (tag, attrs)

    def endElement(self, tag):
        global log
        log = log + "endElement %s:" % (tag)

    def characters(self, data):
        global log
        log = log + "characters: %s:" % (data)

    def warning(self, msg):
        global log
        log = log + "warning: %s:" % (msg)

    def error(self, msg):
        global log
        log = log + "error: %s:" % (msg)

    def fatalError(self, msg):
        global log
        log = log + "fatalError: %s:" % (msg)

handler = callback()

ctxt = libxml2.createPushParser(handler, "<foo", 4, "test.xml")
chunk = " url='tst'>b"
ctxt.parseChunk(chunk, len(chunk), 0)
chunk = "ar</foo>"
ctxt.parseChunk(chunk, len(chunk), 1)

reference = "startDocument:startElement foo {'url': 'tst'}:" + \ 
            "characters: bar:endElement foo:endDocument:"
if log != reference:
    print "Error got: %s" % log
    print "Expected: %s" % reference

The key object in that test is the handler, it provides a number ofentrypoints which can be called by the parser as it makes progresses toindicatethe information set obtained. The full set of callback is larger thanwhatthe callback class in that specific example implements (see theSAXdefinition for a complete list). The wrapper will only call those suppliedbythe object when activated. The startElement receives the names of theelementand a dictionary containing the attributes carried by this element.

Also note that the reference string generated from the callback showsasingle character call even though the string "bar" is passed to theparserfrom 2 different call to parseChunk()

xpath.py:

This is a basic test of XPath wrappers support

import libxml2

doc = libxml2.parseFile("tst.xml")
ctxt = doc.xpathNewContext()
res = ctxt.xpathEval("//*")
if len(res) != 2:
    print "xpath query: wrong node set size"
    sys.exit(1)
if res[0].name != "doc" or res[1].name != "foo":
    print "xpath query: wrong node set value"
    sys.exit(1)
doc.freeDoc()
ctxt.xpathFreeContext()

This test parses a file, then create an XPath context to evaluateXPathexpression on it. The xpathEval() method execute an XPath query andreturnsthe result mapped in a Python way. String and numbers are nativelyconverted,and node sets are returned as a tuple of libxml2 Python nodeswrappers. Likethe document, the XPath context need to be freed explicitly,also not thatthe result of the XPath query may point back to the documenttree and hencethe document must be freed after the result of the query isused.

xpathext.py:

This test shows how to extend the XPath engine with functions writteninpython:

import libxml2

def foo(ctx, x):
    return x + 1

doc = libxml2.parseFile("tst.xml")
ctxt = doc.xpathNewContext()
libxml2.registerXPathFunction(ctxt._o, "foo", None, foo)
res = ctxt.xpathEval("foo(1)")
if res != 2:
    print "xpath extension failure"
doc.freeDoc()
ctxt.xpathFreeContext()

Note how the extension function is registered with the context (butthatpart is not yet finalized, this may change slightly in the future).

tstxpath.py:

This test is similar to the previous one but shows how theextensionfunction can access the XPath evaluation context:

def foo(ctx, x):
    global called

    #
    # test that access to the XPath evaluation contexts
    #
    pctxt = libxml2.xpathParserContext(_obj=ctx)
    ctxt = pctxt.context()
    called = ctxt.function()
    return x + 1

All the interfaces around the XPath parser(or rather evaluation)contextare not finalized, but it should be sufficient to do contextual workat theevaluation point.

Memory debugging:

last but not least, all tests starts with the following prologue:

#memory debug specific
libxml2.debugMemory(1)

and ends with the following epilogue:

#memory debug specific
libxml2.cleanupParser()
if libxml2.debugMemory(1) == 0:
    print "OK"
else:
    print "Memory leak %d bytes" % (libxml2.debugMemory(1))
    libxml2.dumpMemory()

Those activate the memory debugging interface of libxml2 whereallallocated block in the library are tracked. The prologue then cleans upthelibrary state and checks that all allocated memory has been freed. If notitcalls dumpMemory() which saves that list in a .memdumpfile.

libxml2 architecture

Libxml2 is made of multiple components; some of them are optional, andmostof the block interfaces are public. The main components are:

Graphically this gives the following:

a graphical view of the various

The tree output

The parser returns a tree built during the document analysis. Thevaluereturned is an xmlDocPtr(i.e., a pointer toanxmlDocstructure). This structure contains informationsuchas the file name, the document type, and achildrenpointerwhich is the root of the document (or moreexactly the first child under theroot which is the document). The tree ismade of xmlNodes,chained in double-linked lists of siblingsand with a children<->parentrelationship. An xmlNode can also carryproperties (a chain of xmlAttrstructures). An attribute may have a valuewhich is a list of TEXT orENTITY_REF nodes.

Here is an example (erroneous with respect to the XML spec sincethereshould be only one ELEMENT under the root):

structure.gif

In the source package there is a small program (not installed bydefault)called xmllintwhich parses XML files given asargument andprints them back as parsed. This is useful for detecting errorsboth in XMLcode and in the XML parser itself. It has an option--debugwhich prints the actual in-memory structure of thedocument; here is theresult with the examplegivenbefore:

DOCUMENT
version=1.0
standalone=true
  ELEMENT EXAMPLE
    ATTRIBUTE prop1
      TEXT
      content=gnome is great
    ATTRIBUTE prop2
      ENTITY_REF
      TEXT
      content= linux too 
    ELEMENT head
      ELEMENT title
        TEXT
        content=Welcome to Gnome
    ELEMENT chapter
      ELEMENT title
        TEXT
        content=The Linux adventure
      ELEMENT p
        TEXT
        content=bla bla bla ...
      ELEMENT image
        ATTRIBUTE href
          TEXT
          content=linus.gif
      ELEMENT p
        TEXT
        content=...

This should be useful for learning the internal representation model.

The SAX interface

Sometimes the DOM tree output is just too large to fit reasonablyintomemory. In that case (and if you don't expect to save back the XMLdocumentloaded using libxml), it's better to use the SAX interface of libxml.SAX isa callback-based interfaceto the parser. Beforeparsing,the application layer registers a customized set of callbacks whicharecalled by the library as it progresses through the XML input.

To get more detailed step-by-step guidance on using the SAX interfaceoflibxml, see the nicedocumentation.writtenby JamesHenstridge.

You can debug the SAX behaviour by using thetestSAXprogram located in the gnome-xml module (it's usuallynot shipped in thebinary packages of libxml, but you can find it in the tarsourcedistribution). Here is the sequence of callbacks that would be reportedbytestSAX when parsing the example XML document shown earlier:

SAX.setDocumentLocator()
SAX.startDocument()
SAX.getEntity(amp)
SAX.startElement(EXAMPLE, prop1='gnome is great', prop2='&amp; linux too')
SAX.characters(   , 3)
SAX.startElement(head)
SAX.characters(    , 4)
SAX.startElement(title)
SAX.characters(Welcome to Gnome, 16)
SAX.endElement(title)
SAX.characters(   , 3)
SAX.endElement(head)
SAX.characters(   , 3)
SAX.startElement(chapter)
SAX.characters(    , 4)
SAX.startElement(title)
SAX.characters(The Linux adventure, 19)
SAX.endElement(title)
SAX.characters(    , 4)
SAX.startElement(p)
SAX.characters(bla bla bla ..., 15)
SAX.endElement(p)
SAX.characters(    , 4)
SAX.startElement(image, href='linus.gif')
SAX.endElement(image)
SAX.characters(    , 4)
SAX.startElement(p)
SAX.characters(..., 3)
SAX.endElement(p)
SAX.characters(   , 3)
SAX.endElement(chapter)
SAX.characters( , 1)
SAX.endElement(EXAMPLE)
SAX.endDocument()

Most of the other interfaces of libxml2 are based on the DOMtree-buildingfacility, so nearly everything up to the end of this documentpresupposes theuse of the standard DOM tree build. Note that the DOM treeitself is built bya set of registered default callbacks, without internalspecificinterface.

Validation & DTDs

Table of Content:

  1. General overview
  2. The definition
  3. Simple rules
    1. How to reference a DTD from a document
    2. Declaring elements
    3. Declaring attributes
  4. Some examples
  5. How to validate
  6. Other resources

General overview

Well what is validation and what is a DTD ?

DTD is the acronym for Document Type Definition. This is a descriptionofthe content for a family of XML files. This is part of the XML1.0specification, and allows one to describe and verify that a givendocumentinstance conforms to the set of rules detailing its structure andcontent.

Validation is the process of checking a document against a DTD(moregenerally against a set of construction rules).

The validation process and building DTDs are the two most difficultpartsof the XML life cycle. Briefly a DTD defines all the possible elementsto befound within your document, what is the formal shape of your documenttree(by defining the allowed content of an element; either text, aregularexpression for the allowed list of children, or mixed content i.e.both textand children). The DTD also defines the valid attributes for allelements andthe types of those attributes.

The definition

The W3C XML Recommendation(Tim Bray's annotated versionofRev1):

(unfortunately) all this is inherited from the SGML world, the syntaxisancient...

Simple rules

Writing DTDs can be done in many ways. The rules to build them if youneedsomething permanent or something which can evolve over time can beradicallydifferent. Really complex DTDs like DocBook ones are flexible butquiteharder to design. I will just focus on DTDs for a formats with a fixedsimplestructure. It is just a set of basic rules, and definitely notexhaustive norusable for complex DTD design.

How to reference a DTD from a document:

Assuming the top element of the document is specand the dtdisplaced in the file mydtdin the subdirectorydtdsofthe directory from where the document were loaded:

<!DOCTYPE spec SYSTEM "dtds/mydtd">

Notes:

Declaring elements:

The following declares an element spec:

<!ELEMENT spec (front, body, back?)>

It also expresses that the spec element contains onefront,one bodyand one optionalbackchildren elements inthis order. The declaration of oneelement of the structure and its contentare done in a single declaration.Similarly the following declaresdiv1elements:

<!ELEMENT div1 (head, (p | list | note)*, div2?)>

which means div1 contains one headthen a series ofoptionalp, lists and notes and thenanoptional div2. And last but not least an element cancontaintext:

<!ELEMENT b (#PCDATA)>

bcontains text or being of mixed content (text and elementsinno particular order):

<!ELEMENT p (#PCDATA|a|ul|b|i|em)*>

p can contain text or a,ul,b, i or emelements inno particularorder.

Declaring attributes:

Again the attributes declaration includes their content definition:

<!ATTLIST termdef name CDATA #IMPLIED>

means that the element termdefcan have anameattribute containing text (CDATA) and which isoptional(#IMPLIED). The attribute value can also be definedwithin aset:

<!ATTLIST list type(bullets|ordered|glossary)"ordered">

means listelement have a typeattribute with3allowed values "bullets", "ordered" or "glossary" and which defaultto"ordered" if the attribute is not explicitly specified.

The content type of an attribute can be text(CDATA),anchor/reference/references(ID/IDREF/IDREFS),entity(ies)(ENTITY/ENTITIES) orname(s)(NMTOKEN/NMTOKENS). The following definesthat achapterelement can have an optionalidattributeof type ID, usable for reference fromattribute of typeIDREF:

<!ATTLIST chapter id ID #IMPLIED>

The last value of an attribute definition can be#REQUIREDmeaning that the attribute has to be given,#IMPLIEDmeaning that it is optional, or the default value(possibly prefixed by#FIXEDif it is the only allowed).

Notes:

Some examples

The directory test/valid/dtds/in the libxml2distributioncontains some complex DTD examples. The example in thefiletest/valid/dia.xmlshows an XML file where the simple DTDisdirectly included within the document.

How to validate

The simplest way is to use the xmllint program included with libxml.The--validoption turns-on validation of the files given asinput.For example the following validates a copy of the first revision of theXML1.0 specification:

xmllint --valid --noout test/valid/REC-xml-19980210.xml

the -- noout is used to disable output of the resulting tree.

The --dtdvalid dtdallows validation of the document(s)againsta given DTD.

Libxml2 exports an API to handle DTDs and validation, check the associateddescription.

Other resources

DTDs are as old as SGML. So there may be a number of examples on-line,Iwill just list one for now, others pointers welcome:

I suggest looking at the examples found under test/valid/dtd and any ofthelarge number of books available on XML. The dia example in test/validshouldbe both simple and complete enough to allow you to build your own.

Memory Management

Table of Content:

  1. General overview
  2. Setting libxml2 set of memory routines
  3. Cleaning up after parsing
  4. Debugging routines
  5. General memory requirements

General overview

The module xmlmemory.hprovidesthe interfaces to the libxml2 memory system:

Setting libxml2 set of memory routines

It is sometimes useful to not use the default memory allocator, eitherfordebugging, analysis or to implement a specific behaviour on memorymanagement(like on embedded systems). Two function calls are available to doso:

Of course a call to xmlMemSetup() should probably be done beforecallingany other libxml2 routines (unless you are sure your allocationsroutines arecompatibles).

Cleaning up after parsing

Libxml2 is not stateless, there is a few set of memory structuresneedingallocation before the parser is fully functional (some encodingstructuresfor example). This also mean that once parsing is finished there isa tinyamount of memory (a few hundred bytes) which can be recollected if youdon'treuse the parser immediately:

Generally xmlCleanupParser() is safe, if needed the state will berebuildat the next invocation of parser routines, but be careful of theconsequencesin multithreaded applications.

Debugging routines

When configured using --with-mem-debug flag (off by default), libxml2usesa set of memory allocation debugging routines keeping track of allallocatedblocks and the location in the code where the routine was called. Acouple ofother debugging routines allow to dump the memory allocated infos toa fileor call a specific routine when a given block number is allocated:

When developing libxml2 memory debug is enabled, the tests programscallxmlMemoryDump () and the "make test" regression tests will check foranymemory leak during the full regression test sequence, this helps alotensuring that libxml2 does not leak memory and bullet proofmemoryallocations use (some libc implementations are known to be far toopermissiveresulting in major portability problems!).

If the .memdump reports a leak, it displays the allocation functionandalso tries to give some informations about the content and structure oftheallocated blocks left. This is sufficient in most cases to find theculprit,but not always. Assuming the allocation problem is reproducible, itispossible to find more easily:

  1. write down the block number xxxx not allocated
  2. export the environment variable XML_MEM_BREAKPOINT=xxxx , theeasiestwhen using GDB is to simply give the command

    set environment XML_MEM_BREAKPOINT xxxx

    before running the program.

  3. run the program under a debugger and set a breakpointonxmlMallocBreakpoint() a specific function called when this preciseblockis allocated
  4. when the breakpoint is reached you can then do a fine analysis oftheallocation an step to see the condition resulting in themissingdeallocation.

I used to use a commercial tool to debug libxml2 memory problems butafternoticing that it was not detecting memory leaks that simple mechanismwasused and proved extremely efficient until now. Lately I have also used valgrindwith quite somesuccess,it is tied to the i386 architecture since it works by emulating theprocessorand instruction set, it is slow but extremely efficient, i.e. itspot memoryusage errors in a very precise way.

General memory requirements

How much libxml2 memory require ? It's hard to tell in average itdependsof a number of things:

Encodings support

If you are not really familiar with Internationalization (usual shortcutisI18N) , Unicode, characters and glyphs, I suggest you read a presentationbyTim Bray on Unicode and why you should care about it.

If you don't understand why it does not make sense to have astringwithout knowing what encoding it uses, then as Joel Spolsky said please do notwriteanother line of code until you finish reading that article.. It isaprerequisite to understand this page, and avoid a lot of problemswithlibxml2, XML or text processing in general.

Table of Content:

  1. What does internationalization supportmean?
  2. The internal encoding, howandwhy
  3. How is it implemented ?
  4. Default supported encodings
  5. How to extend theexistingsupport

What does internationalization support mean ?

XML was designed from the start to allow the support of any charactersetby using Unicode. Any conformant XML parser has to support the UTF-8andUTF-16 default encodings which can both express the full unicode ranges.UTF8is a variable length encoding whose greatest points are to reuse thesameencoding for ASCII and to save space for Western encodings, but it is abitmore complex to handle in practice. UTF-16 use 2 bytes per character(andsometimes combines two pairs), it makes implementation easier, but looksabit overkill for Western languages encoding. Moreover the XMLspecificationallows the document to be encoded in other encodings at thecondition thatthey are clearly labeled as such. For example the following isa wellformedXML document encoded in ISO-8859-1 and using accentuated lettersthat weFrench like for both markup and content:

<?xml version="1.0" encoding="ISO-8859-1"?>
<très>là</très>

Having internationalization support in libxml2 means the following:

Another very important point is that the whole libxml2 API, withtheexception of a few routines to read with a specific encoding or save toaspecific encoding, is completely agnostic about the original encoding ofthedocument.

It should be noted too that the HTML parser embedded in libxml2 nowobeythe same rules too, the following document will be (as of 2.2.2) handledinan internationalized fashion by libxml2 too:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"
                      "http://www.w3.org/TR/REC-html40/loose.dtd">
<html lang="fr">
<head>
  <META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=ISO-8859-1">
</head>
<body>
<p>W3C crée des standards pour le Web.</body>
</html>

The internal encoding, how and why

One of the core decisions was to force all documents to be converted toadefault internal encoding, and that encoding to be UTF-8, here aretherationales for those choices:

What does this mean in practice for the libxml2 user:

How is it implemented ?

Let's describe how all this works within libxml, basically theI18N(internationalization) support get triggered only during I/O operation,i.e.when reading a document or saving one. Let's look first at thereadingsequence:

  1. when a document is processed, we usually don't know the encoding,asimple heuristic allows to detect UTF-16 and UCS-4 from encodingswherethe ASCII range (0-0x7F) maps with ASCII
  2. the xml declaration if available is parsed, including theencodingdeclaration. At that point, if the autodetected encoding isdifferentfrom the one declared a call to xmlSwitchEncoding() isissued.
  3. If there is no encoding declaration, then the input has to be ineitherUTF-8 or UTF-16, if it is not then at some point when processingtheinput, the converter/checker of UTF-8 form will raise an encodingerror.You may end-up with a garbled document, or no document at all !Example: 
    ~/XML -> ./xmllint err.xml 
err.xml:1: error: Input is not proper UTF-8, indicate encoding !
<très>là</très>
   ^
err.xml:1: error: Bytes: 0xE8 0x73 0x3E 0x6C
<très>là</très>
   ^
  4. xmlSwitchEncoding() does an encoding name lookup, canonicalize it,andthen search the default registered encoding converters for thatencoding.If it's not within the default set and iconv() support has beencompiledit, it will ask iconv for such an encoder. If this fails then theparserwill report an error and stops processing: 
    ~/XML -> ./xmllint err2.xml 
err2.xml:1: error: Unsupported encoding UnsupportedEnc
<?xml version="1.0" encoding="UnsupportedEnc"?>
                                             ^
  5. From that point the encoder processes progressively the input (itisplugged as a front-end to the I/O module) for that entity. Itcapturesand converts on-the-fly the document to be parsed to UTF-8. Theparseritself just does UTF-8 checking of this input and processittransparently. The only difference is that the encoding informationhasbeen added to the parsing context (more precisely to theinputcorresponding to this entity).
  6. The result (when using DOM) is an internal form completely in UTF-8withjust an encoding information on the document node.

Ok then what happens when saving the document (assuming youcollected/builtan xmlDoc DOM like structure) ? It depends on the functioncalled,xmlSaveFile() will just try to save in the original encoding,whilexmlSaveFileTo() and xmlSaveFileEnc() can optionally save to agivenencoding:

  1. if no encoding is given, libxml2 will look for an encodingvalueassociated to the document and if it exists will try to save tothatencoding,

    otherwise everything is written in the internal form, i.e. UTF-8

  2. so if an encoding was specified, either at the API level or onthedocument, libxml2 will again canonicalize the encoding name, lookupfor aconverter in the registered set or through iconv. If not foundthefunction will return an error code
  3. the converter is placed before the I/O buffer layer, as another kindofbuffer, then libxml2 will simply push the UTF-8 serialization tothroughthat buffer, which will then progressively be converted and pushedontothe I/O layer.
  4. It is possible that the converter code fails on some input, forexampletrying to push an UTF-8 encoded Chinese character through theUTF-8 toISO-8859-1 converter won't work. Since the encoders areprogressive theywill just report the error and the number of bytesconverted, at thatpoint libxml2 will decode the offending character,remove it from thebuffer and replace it with the associated charRefencoding &#123; andresume the conversion. This guarantees that anydocument will be savedwithout losses (except for markup names where thisis not legal, this isa problem in the current version, in practice avoidusing non-asciicharacters for tag or attribute names). A special "ascii"encoding nameis used to save documents to a pure ascii form can be usedwhenportability is really crucial

Here are a few examples based on the same test document:

~/XML -> ./xmllint isolat1 
<?xml version="1.0" encoding="ISO-8859-1"?>
<très>là</très>
~/XML -> ./xmllint --encode UTF-8 isolat1 
<?xml version="1.0" encoding="UTF-8"?>
<très>là  </très>
~/XML ->

The same processing is applied (and reuse most of the code) for HTMLI18Nprocessing. Looking up and modifying the content encoding is a bitmoredifficult since it is located in a <meta> tag under the<head>,so a couple of functions htmlGetMetaEncoding() andhtmlSetMetaEncoding() havebeen provided. The parser also attempts to switchencoding on the fly whendetecting such a tag on input. Except for that theprocessing is the same(and again reuses the same code).

Default supported encodings

libxml2 has a set of default converters for the followingencodings(located in encoding.c):

  1. UTF-8 is supported by default (null handlers)
  2. UTF-16, both little and big endian
  3. ISO-Latin-1 (ISO-8859-1) covering most western languages
  4. ASCII, useful mostly for saving
  5. HTML, a specific handler for the conversion of UTF-8 to ASCII withHTMLpredefined entities like &copy; for the Copyright sign.

More over when compiled on an Unix platform with iconv support the fullsetof encodings supported by iconv can be instantly be used by libxml. On alinuxmachine with glibc-2.1 the list of supported encodings and aliases fill3 fullpages, and include UCS-4, the full set of ISO-Latin encodings, and thevariousJapanese ones.

To convert from the UTF-8 values returned from the API to anotherencodingthen it is possible to use the function provided from the encoding modulelike UTF8Toisolat1, or usethePOSIX iconv()APIdirectly.

Encoding aliases

From 2.2.3, libxml2 has support to register encoding names aliases.Thegoal is to be able to parse document whose encoding is supported butwherethe name differs (for example from the default set of names acceptedbyiconv). The following functions allow to register and handle new aliasesforexisting encodings. Once registered libxml2 will automatically lookupthealiases when handling a document:

How to extend the existing support

Well adding support for new encoding, or overriding one of theencoders(assuming it is buggy) should not be hard, just write input andoutputconversion routines to/from UTF-8, and register themusingxmlNewCharEncodingHandler(name, xxxToUTF8, UTF8Toxxx), and they willbecalled automatically if the parser(s) encounter such an encodingname(register it uppercase, this will help). The description of theencoders,their arguments and expected return values are described in theencoding.hheader.

I/O Interfaces

Table of Content:

  1. General overview
  2. The basic buffer type
  3. Input I/O handlers
  4. Output I/O handlers
  5. The entities loader
  6. Example of customized I/O

General overview

The module xmlIO.hprovidestheinterfaces to the libxml2 I/O system. This consists of 4 main parts:

The general mechanism used when loading http://rpmfind.net/xml.htmlforexample in the HTML parser is the following:

  1. The default entity loader callsxmlNewInputFromFile()withthe parsing context and the URIstring.
  2. the URI string is checked against the existing registered handlersusingtheir match() callback function, if the HTTP module was compiledin, it isregistered and its match() function will succeeds
  3. the open() function of the handler is called and if successfulwillreturn an I/O Input buffer
  4. the parser will the start reading from this buffer andprogressivelyfetch information from the resource, calling the read()function of thehandler until the resource is exhausted
  5. if an encoding change is detected it will be installed on theinputbuffer, providing buffering and efficient use of theconversionroutines
  6. once the parser has finished, the close() function of the handleriscalled once and the Input buffer and associated resourcesaredeallocated.

The user defined callbacks are checked first to allow overriding ofthedefault libxml2 I/O routines.

The basic buffer type

All the buffer manipulation handling is done usingthexmlBuffertype define in tree.hwhich isaresizable memory buffer. The buffer allocation strategy can be selected tobeeither best-fit or use an exponential doubling one (CPU vs. memoryusetrade-off). The values areXML_BUFFER_ALLOC_EXACTandXML_BUFFER_ALLOC_DOUBLEIT,and can be set individually or on asystem wide basis usingxmlBufferSetAllocationScheme(). A numberof functions allows tomanipulate buffers with names starting withthexmlBuffer...prefix.

Input I/O handlers

An Input I/O handler is a simplestructurexmlParserInputBuffercontaining a context associated totheresource (file descriptor, or pointer to a protocol handler), the read()andclose() callbacks to use and an xmlBuffer. And extra xmlBuffer and acharsetencoding handler are also present to support charset conversionwhenneeded.

Output I/O handlers

An Output handler xmlOutputBufferis completely similar toanInput one except the callbacks are write() and close().

The entities loader

The entity loader resolves requests for new entities and create inputsforthe parser. Creating an input from a filename or an URI string isdonethrough the xmlNewInputFromFile() routine. The default entity loader donothandle the PUBLIC identifier associated with an entity (if any). So itjustcalls xmlNewInputFromFile() with the SYSTEM identifier (which ismandatory inXML).

If you want to hook up a catalog mechanism then you simply need tooverridethe default entity loader, here is an example:

#include <libxml/xmlIO.h>

xmlExternalEntityLoader defaultLoader = NULL;

xmlParserInputPtr
xmlMyExternalEntityLoader(const char *URL, const char *ID,
                               xmlParserCtxtPtr ctxt) {
    xmlParserInputPtr ret;
    const char *fileID = NULL;
    /* lookup for the fileID depending on ID */

    ret = xmlNewInputFromFile(ctxt, fileID);
    if (ret != NULL)
        return(ret);
    if (defaultLoader != NULL)
        ret = defaultLoader(URL, ID, ctxt);
    return(ret);
}

int main(..) {
    ...

    /*
     * Install our own entity loader
     */
    defaultLoader = xmlGetExternalEntityLoader();
    xmlSetExternalEntityLoader(xmlMyExternalEntityLoader);

    ...
}

Example of customized I/O

This example come from areal use case,xmlDocDump() closes the FILE * passed by the applicationand this was aproblem. The solutionwasto redefine anew output handler with the closing call deactivated:

  1. First define a new I/O output allocator where the output don't closethefile: 
    xmlOutputBufferPtr
xmlOutputBufferCreateOwn(FILE *file, xmlCharEncodingHandlerPtr encoder) {
    xmlOutputBufferPtr ret;
    
    if (xmlOutputCallbackInitialized == 0)
        xmlRegisterDefaultOutputCallbacks();

    if (file == NULL) return(NULL);
    ret = xmlAllocOutputBuffer(encoder);
    if (ret != NULL) {
        ret->context = file;
        ret->writecallback = xmlFileWrite;
        ret->closecallback = NULL;  /* No close callback */
    }
    return(ret);
}
  2. And then use it to save the document: 
    FILE *f;
xmlOutputBufferPtr output;
xmlDocPtr doc;
int res;

f = ...
doc = ....

output = xmlOutputBufferCreateOwn(f, NULL);
res = xmlSaveFileTo(output, doc, NULL);

Catalog support

Table of Content:

  1. General overview
  2. The definition
  3. Using catalogs
  4. Some examples
  5. How to tune catalog usage
  6. How to debug catalog processing
  7. How to create and maintain catalogs
  8. The implementor corner quick review oftheAPI
  9. Other resources

General overview

What is a catalog? Basically it's a lookup mechanism used when an entity(afile or a remote resource) references another entity. The catalog lookupisinserted between the moment the reference is recognized by the software(XMLparser, stylesheet processing, or even images referenced for inclusionin arendering) and the time where loading that resource is actuallystarted.

It is basically used for 3 things:

The definitions

Libxml, as of 2.4.3 implements 2 kind of catalogs:

Using catalog

In a normal environment libxml2 will by default check the presence ofacatalog in /etc/xml/catalog, and assuming it has been correctlypopulated,the processing is completely transparent to the document user. Totake aconcrete example, suppose you are authoring a DocBook document, thisonestarts with the following DOCTYPE definition:

<?xml version='1.0'?>
<!DOCTYPE book PUBLIC "-//Norman Walsh//DTD DocBk XML V3.1.4//EN"
          "http://nwalsh.com/docbook/xml/3.1.4/db3xml.dtd">

When validating the document with libxml, the catalog will beautomaticallyconsulted to lookup the public identifier "-//Norman Walsh//DTDDocBk XMLV3.1.4//EN" and the systemidentifier"http://nwalsh.com/docbook/xml/3.1.4/db3xml.dtd", and if theseentities havebeen installed on your system and the catalogs actually point tothem, libxmlwill fetch them from the local disk.

Note: Really don't usethisDOCTYPE example it's a really old version, but is fine as an example.

Libxml2 will check the catalog each time that it is requested to loadanentity, this includes DTD, external parsed entities, stylesheets, etc ...Ifyour system is correctly configured all the authoring phase andprocessingshould use only local files, even if your document stays portablebecause ituses the canonical public and system ID, referencing the remotedocument.

Some examples:

Here is a couple of fragments from XML Catalogs used in libxml2earlyregression tests in test/catalogs:

<?xml version="1.0"?>
<!DOCTYPE catalog PUBLIC 
   "-//OASIS//DTD Entity Resolution XML Catalog V1.0//EN"
   "http://www.oasis-open.org/committees/entity/release/1.0/catalog.dtd">
<catalog xmlns="urn:oasis:names:tc:entity:xmlns:xml:catalog">
  <public publicId="-//OASIS//DTD DocBook XML V4.1.2//EN"
   uri="http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd"/>
...

This is the beginning of a catalog for DocBook 4.1.2, XML Catalogsarewritten in XML, there is a specific namespace for catalogelements"urn:oasis:names:tc:entity:xmlns:xml:catalog". The first entry inthiscatalog is a publicmapping it allows to associate aPublicIdentifier with an URI.

...
    <rewriteSystem systemIdStartString="http://www.oasis-open.org/docbook/"
                   rewritePrefix="file:///usr/share/xml/docbook/"/>
...

A rewriteSystemis a very powerful instruction, it saysthatany URI starting with a given prefix should be looked at anotherURIconstructed by replacing the prefix with an new one. In effect this actslikea cache system for a full area of the Web. In practice it is extremelyusefulwith a file prefix if you have installed a copy of those resources onyourlocal system.

...
<delegatePublic publicIdStartString="-//OASIS//DTD XML Catalog //"
                catalog="file:///usr/share/xml/docbook.xml"/>
<delegatePublic publicIdStartString="-//OASIS//ENTITIES DocBook XML"
                catalog="file:///usr/share/xml/docbook.xml"/>
<delegatePublic publicIdStartString="-//OASIS//DTD DocBook XML"
                catalog="file:///usr/share/xml/docbook.xml"/>
<delegateSystem systemIdStartString="http://www.oasis-open.org/docbook/"
                catalog="file:///usr/share/xml/docbook.xml"/>
<delegateURI uriStartString="http://www.oasis-open.org/docbook/"
                catalog="file:///usr/share/xml/docbook.xml"/>
...

Delegation is the core features which allows to build a tree ofcatalogs,easier to maintain than a single catalog, based on PublicIdentifier, SystemIdentifier or URI prefixes it instructs the catalogsoftware to look upentries in another resource. This feature allow to buildhierarchies ofcatalogs, the set of entries presented should be sufficient toredirect theresolution of all DocBook references to the specific catalogin/usr/share/xml/docbook.xmlthis one in turn could delegateallreferences for DocBook 4.2.1 to a specific catalog installed at the sametimeas the DocBook resources on the local machine.

How to tune catalog usage:

The user can change the default catalog behaviour by redirecting queriestoits own set of catalogs, this can be done by settingtheXML_CATALOG_FILESenvironment variable to a list of catalogs,anempty one should deactivate loading the default/etc/xml/catalogdefault catalog

How to debug catalog processing:

Setting up the XML_DEBUG_CATALOGenvironment variable willmakelibxml2 output debugging informations for each catalog operations,forexample:

orchis:~/XML -> xmllint --memory --noout test/ent2
warning: failed to load external entity "title.xml"
orchis:~/XML -> export XML_DEBUG_CATALOG=
orchis:~/XML -> xmllint --memory --noout test/ent2
Failed to parse catalog /etc/xml/catalog
Failed to parse catalog /etc/xml/catalog
warning: failed to load external entity "title.xml"
Catalogs cleanup
orchis:~/XML ->

The test/ent2 references an entity, running the parser from memorymakesthe base URI unavailable and the the "title.xml" entity cannot beloaded.Setting up the debug environment variable allows to detect that anattempt ismade to load the /etc/xml/catalogbut since it's notpresent theresolution fails.

But the most advanced way to debug XML catalog processing is to usethexmlcatalogcommand shipped with libxml2, it allows toloadcatalogs and make resolution queries to see what is going on. This isalsoused for the regression tests:

orchis:~/XML -> ./xmlcatalog test/catalogs/docbook.xml \
                   "-//OASIS//DTD DocBook XML V4.1.2//EN"
http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd
orchis:~/XML ->

For debugging what is going on, adding one -v flags increase theverbositylevel to indicate the processing done (adding a second flag alsoindicatewhat elements are recognized at parsing):

orchis:~/XML -> ./xmlcatalog -v test/catalogs/docbook.xml \
                   "-//OASIS//DTD DocBook XML V4.1.2//EN"
Parsing catalog test/catalogs/docbook.xml's content
Found public match -//OASIS//DTD DocBook XML V4.1.2//EN
http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd
Catalogs cleanup
orchis:~/XML ->

A shell interface is also available to debug and process multiplequeries(and for regression tests):

orchis:~/XML -> ./xmlcatalog -shell test/catalogs/docbook.xml \
                   "-//OASIS//DTD DocBook XML V4.1.2//EN"
> help   
Commands available:
public PublicID: make a PUBLIC identifier lookup
system SystemID: make a SYSTEM identifier lookup
resolve PublicID SystemID: do a full resolver lookup
add 'type' 'orig' 'replace' : add an entry
del 'values' : remove values
dump: print the current catalog state
debug: increase the verbosity level
quiet: decrease the verbosity level
exit:  quit the shell
> public "-//OASIS//DTD DocBook XML V4.1.2//EN"
http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd
> quit
orchis:~/XML ->

This should be sufficient for most debugging purpose, this wasactuallyused heavily to debug the XML Catalog implementation itself.

How to create and maintaincatalogs:

Basically XML Catalogs are XML files, you can either use XML toolstomanage them or use xmlcatalogfor this. The basic stepisto create a catalog the -create option provide this facility:

orchis:~/XML -> ./xmlcatalog --create tst.xml
<?xml version="1.0"?>
<!DOCTYPE catalog PUBLIC "-//OASIS//DTD Entity Resolution XML Catalog V1.0//EN"
         "http://www.oasis-open.org/committees/entity/release/1.0/catalog.dtd">
<catalog xmlns="urn:oasis:names:tc:entity:xmlns:xml:catalog"/>
orchis:~/XML ->

By default xmlcatalog does not overwrite the original catalog and savetheresult on the standard output, this can be overridden using the-nooutoption. The -addcommand allows to add entries inthecatalog:

orchis:~/XML -> ./xmlcatalog --noout --create --add "public" \
  "-//OASIS//DTD DocBook XML V4.1.2//EN" \
  http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd tst.xml
orchis:~/XML -> cat tst.xml
<?xml version="1.0"?>
<!DOCTYPE catalog PUBLIC "-//OASIS//DTD Entity Resolution XML Catalog V1.0//EN" \
  "http://www.oasis-open.org/committees/entity/release/1.0/catalog.dtd">
<catalog xmlns="urn:oasis:names:tc:entity:xmlns:xml:catalog">
<public publicId="-//OASIS//DTD DocBook XML V4.1.2//EN"
        uri="http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd"/>
</catalog>
orchis:~/XML ->

The -addoption will always take 3 parameters even if someofthe XML Catalog constructs (like nextCatalog) will have only asingleargument, just pass a third empty string, it will be ignored.

Similarly the -deloption remove matching entries fromthecatalog:

orchis:~/XML -> ./xmlcatalog --del \
  "http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd" tst.xml
<?xml version="1.0"?>
<!DOCTYPE catalog PUBLIC "-//OASIS//DTD Entity Resolution XML Catalog V1.0//EN"
    "http://www.oasis-open.org/committees/entity/release/1.0/catalog.dtd">
<catalog xmlns="urn:oasis:names:tc:entity:xmlns:xml:catalog"/>
orchis:~/XML ->

The catalog is now empty. Note that the matching of-delisexact and would have worked in a similar fashion with thePublic IDstring.

This is rudimentary but should be sufficient to manage a not toocomplexcatalog tree of resources.

The implementor corner quick review oftheAPI:

First, and like for every other module of libxml, there is anautomaticallygenerated API page forcatalogsupport.

The header for the catalog interfaces should be included as:

#include <libxml/catalog.h>

The API is voluntarily kept very simple. First it is not obviousthatapplications really need access to it since it is the default behaviouroflibxml2 (Note: it is possible to completely override libxml2 defaultcatalogby using xmlSetExternalEntityLoadertoplug anapplication specific resolver).

Basically libxml2 support 2 catalog lists:

the document one will be used first if it exists.

Initialization routines:

xmlInitializeCatalog(), xmlLoadCatalog() and xmlLoadCatalogs() shouldbeused at startup to initialize the catalog, if the catalog shouldbeinitialized with specific values xmlLoadCatalog() orxmlLoadCatalogs()should be called before xmlInitializeCatalog() which wouldotherwise do adefault initialization first.

The xmlCatalogAddLocal() call is used by the parser to grow thedocumentown catalog list if needed.

Preferences setup:

The XML Catalog spec requires the possibility to select defaultpreferencesbetween public and system delegation,xmlCatalogSetDefaultPrefer() allowsthis, xmlCatalogSetDefaults() andxmlCatalogGetDefaults() allow to control ifXML Catalogs resolution shouldbe forbidden, allowed for global catalog, fordocument catalog or both, thedefault is to allow both.

And of course xmlCatalogSetDebug() allows to generate debugmessages(through the xmlGenericError() mechanism).

Querying routines:

xmlCatalogResolve(), xmlCatalogResolveSystem(),xmlCatalogResolvePublic()and xmlCatalogResolveURI() are relatively explicitif you read the XMLCatalog specification they correspond to section 7algorithms, they shouldalso work if you have loaded an SGML catalog with asimplified semantic.

xmlCatalogLocalResolve() and xmlCatalogLocalResolveURI() are the samebutoperate on the document catalog list

Cleanup and Miscellaneous:

xmlCatalogCleanup() free-up the global catalog, xmlCatalogFreeLocal()isthe per-document equivalent.

xmlCatalogAdd() and xmlCatalogRemove() are used to dynamically modifythefirst catalog in the global list, and xmlCatalogDump() allows to dumpacatalog state, those routines are primarily designed for xmlcatalog, I'mnotsure that exposing more complex interfaces (like navigation ones) wouldbereally useful.

The xmlParseCatalogFile() is a function used to load XML Catalogfiles,it's similar as xmlParseFile() except it bypass all catalog lookups,it'sprovided because this functionality may be useful for client tools.

threaded environments:

Since the catalog tree is built progressively, some care has been takentotry to avoid troubles in multithreaded environments. The code is nowthreadsafe assuming that the libxml2 library has been compiled withthreadssupport.

Other resources

The XML Catalog specification is relatively recent so there isn'tmuchliterature to point at:

If you have suggestions for corrections or additions, simply contactme:

The parser interfaces

This section is directly intended to help programmers gettingbootstrappedusing the XML tollkit from the C language. It is not intended tobeextensive. I hope the automatically generated documents will providethecompleteness required, but as a separate set of documents. The interfacesofthe XML parser are by principle low level, Those interested in a higherlevelAPI should look at DOM.

The parser interfaces forXMLareseparated from the HTMLparserinterfaces. Let's have a look at how the XML parser can becalled:

Invoking the parser : the pull method

Usually, the first thing to do is to read an XML input. The parseracceptsdocuments either from in-memory strings or from files. The functionsaredefined in "parser.h":

xmlDocPtr xmlParseMemory(char *buffer, int size);

Parse a null-terminated string containing the document.

xmlDocPtr xmlParseFile(const char *filename);

Parse an XML document contained in a (possibly compressed)file.

The parser returns a pointer to the document structure (or NULL in caseoffailure).

Invoking the parser: the push method

In order for the application to keep the control when the document isbeingfetched (which is common for GUI based programs) libxml2 provides apushinterface, too, as of version 1.8.3. Here are the interfacefunctions:

xmlParserCtxtPtr xmlCreatePushParserCtxt(xmlSAXHandlerPtr sax,
                                         void *user_data,
                                         const char *chunk,
                                         int size,
                                         const char *filename);
int              xmlParseChunk          (xmlParserCtxtPtr ctxt,
                                         const char *chunk,
                                         int size,
                                         int terminate);

and here is a simple example showing how to use the interface:

            FILE *f;

            f = fopen(filename, "r");
            if (f != NULL) {
                int res, size = 1024;
                char chars[1024];
                xmlParserCtxtPtr ctxt;

                res = fread(chars, 1, 4, f);
                if (res > 0) {
                    ctxt = xmlCreatePushParserCtxt(NULL, NULL,
                                chars, res, filename);
                    while ((res = fread(chars, 1, size, f)) > 0) {
                        xmlParseChunk(ctxt, chars, res, 0);
                    }
                    xmlParseChunk(ctxt, chars, 0, 1);
                    doc = ctxt->myDoc;
                    xmlFreeParserCtxt(ctxt);
                }
            }

The HTML parser embedded into libxml2 also has a push interface;thefunctions are just prefixed by "html" rather than "xml".

Invoking the parser: the SAX interface

The tree-building interface makes the parser memory-hungry, firstloadingthe document in memory and then building the tree itself. Reading adocumentwithout building the tree is possible using the SAX interfaces (seeSAX.h andJamesHenstridge'sdocumentation). Note also that the push interface can belimited to SAX:just use the two first arguments ofxmlCreatePushParserCtxt().

Building a tree from scratch

The other way to get an XML tree in memory is by building it.Basicallythere is a set of functions dedicated to building new elements.(These arealso described in <libxml/tree.h>.) For example, here is apiece ofcode that produces the XML document used in the previous examples:

    #include <libxml/tree.h>
    xmlDocPtr doc;
    xmlNodePtr tree, subtree;

    doc = xmlNewDoc("1.0");
    doc->children = xmlNewDocNode(doc, NULL, "EXAMPLE", NULL);
    xmlSetProp(doc->children, "prop1", "gnome is great");
    xmlSetProp(doc->children, "prop2", "& linux too");
    tree = xmlNewChild(doc->children, NULL, "head", NULL);
    subtree = xmlNewChild(tree, NULL, "title", "Welcome to Gnome");
    tree = xmlNewChild(doc->children, NULL, "chapter", NULL);
    subtree = xmlNewChild(tree, NULL, "title", "The Linux adventure");
    subtree = xmlNewChild(tree, NULL, "p", "bla bla bla ...");
    subtree = xmlNewChild(tree, NULL, "image", NULL);
    xmlSetProp(subtree, "href", "linus.gif");

Not really rocket science ...

Traversing the tree

Basically by including"tree.h"yourcode has access to the internal structure of all the elementsof the tree.The names should be somewhat simple likeparent,children, next,prev,properties, etc... For example, stillwith the previousexample:

doc->children->children->children

points to the title element,

doc->children->children->next->children->children

points to the text node containing the chapter title "TheLinuxadventure".

NOTE: XML allows PIs and commentstobepresent before the document root, so doc->childrenmaypointto an element which is not the document Root Element; afunctionxmlDocGetRootElement()was added for this purpose.

Modifying the tree

Functions are provided for reading and writing the document content.Hereis an excerpt from the tree API:

xmlAttrPtr xmlSetProp(xmlNodePtr node, const xmlChar *name,constxmlChar *value);

This sets (or changes) an attribute carried by an ELEMENT node.Thevalue can be NULL.

const xmlChar *xmlGetProp(xmlNodePtr node, constxmlChar*name);

This function returns a pointer to new copy of thepropertycontent. Note that the user must deallocate the result.

Two functions are provided for reading and writing the text associatedwithelements:

xmlNodePtr xmlStringGetNodeList(xmlDocPtr doc, constxmlChar*value);

This function takes an "external" string and converts it toonetext node or possibly to a list of entity and text nodes.Allnon-predefined entity references like &Gnome; will bestoredinternally as entity nodes, hence the result of the function maynot bea single node.

xmlChar *xmlNodeListGetString(xmlDocPtr doc, xmlNodePtr list,intinLine);

This function is the inverseofxmlStringGetNodeList(). It generates a newstringcontaining the content of the text and entity nodes. Note theextraargument inLine. If this argument is set to 1, the function willexpandentity references. For example, instead of returning the&Gnome;XML encoding in the string, it will substitute it with itsvalue (say,"GNU Network Object Model Environment").

Saving a tree

Basically 3 options are possible:

void xmlDocDumpMemory(xmlDocPtr cur, xmlChar**mem,int*size);

Returns a buffer into which the document has been saved.

extern void xmlDocDump(FILE *f, xmlDocPtr doc);

Dumps a document to an open file descriptor.

int xmlSaveFile(const char *filename, xmlDocPtr cur);

Saves the document to a file. In this case, thecompressioninterface is triggered if it has been turned on.

Compression

The library transparently handles compression when doingfile-basedaccesses. The level of compression on saves can be turned on eithergloballyor individually for one file:

int xmlGetDocCompressMode (xmlDocPtr doc);

Gets the document compression ratio (0-9).

void xmlSetDocCompressMode (xmlDocPtr doc, int mode);

Sets the document compression ratio.

int xmlGetCompressMode(void);

Gets the default compression ratio.

void xmlSetCompressMode(int mode);

Sets the default compression ratio.

Entities or no entities

Entities in principle are similar to simple C macros. An entity definesanabbreviation for a given string that you can reuse many times throughoutthecontent of your document. Entities are especially useful when a givenstringmay occur frequently within a document, or to confine the change neededto adocument to a restricted area in the internal subset of the document (atthebeginning). Example:

1 <?xml version="1.0"?>
2 <!DOCTYPE EXAMPLE SYSTEM "example.dtd" [
3 <!ENTITY xml "Extensible Markup Language">
4 ]>
5 <EXAMPLE>
6    &xml;
7 </EXAMPLE>

Line 3 declares the xml entity. Line 6 uses the xml entity, byprefixingits name with '&' and following it by ';' without any spacesadded. Thereare 5 predefined entities in libxml2 allowing you to escapecharacters withpredefined meaning in some parts of the xml documentcontent:&lt;for the character '<',&gt;for the character '>',&apos;for the character''',&quot;for the character '"',and&amp;for the character '&'.

One of the problems related to entities is that you may want the parsertosubstitute an entity's content so that you can see the replacement textinyour application. Or you may prefer to keep entity references as such inthecontent to be able to save the document back without losing thisusuallyprecious information (if the user went through the pain ofexplicitlydefining entities, he may have a a rather negative attitude if youblindlysubstitute them as saving time). The xmlSubstituteEntitiesDefault()functionallows you to check and change the behaviour, which is to notsubstituteentities by default.

Here is the DOM tree built by libxml2 for the previous document inthedefault case:

/gnome/src/gnome-xml -> ./xmllint --debug test/ent1
DOCUMENT
version=1.0
   ELEMENT EXAMPLE
     TEXT
     content=
     ENTITY_REF
       INTERNAL_GENERAL_ENTITY xml
       content=Extensible Markup Language
     TEXT
     content=

And here is the result when substituting entities:

/gnome/src/gnome-xml -> ./tester --debug --noent test/ent1
DOCUMENT
version=1.0
   ELEMENT EXAMPLE
     TEXT
     content=     Extensible Markup Language

So, entities or no entities? Basically, it depends on your use case.Isuggest that you keep the non-substituting default behaviour and avoidusingentities in your XML document or data if you are not willing to handletheentity references elements in the DOM tree.

Note that at save time libxml2 enforces the conversion of thepredefinedentities where necessary to prevent well-formedness problems, andwill alsotransparently replace those with chars (i.e. it will not generateentityreference elements in the DOM tree or call the reference() SAX callbackwhenfinding them in the input).

WARNING: handlingentitieson top of the libxml2 SAX interface is difficult!!! If you plan tousenon-predefined entities in your documents, then the learning curve tohandlethen using the SAX API may be long. If you plan to use complexdocuments, Istrongly suggest you consider using the DOM interface instead andlet libxmldeal with the complexity rather than trying to do it yourself.

Namespaces

The libxml2 library implements XML namespacessupportbyrecognizing namespace constructs in the input, and does namespacelookupautomatically when building the DOM tree. A namespace declarationisassociated with an in-memory structure and all elements or attributeswithinthat namespace point to it. Hence testing the namespace is a simple andfastequality operation at the user level.

I suggest that people using libxml2 use a namespace, and declare it intheroot element of their document as the default namespace. Then they don'tneedto use the prefix in the content but we will have a basis for futuresemanticrefinement and merging of data from different sources. This doesn'tincreasethe size of the XML output significantly, but significantly increasesitsvalue in the long-term. Example:

<mydoc xmlns="http://mydoc.example.org/schemas/">
   <elem1>...</elem1>
   <elem2>...</elem2>
</mydoc>

The namespace value has to be an absolute URL, but the URL doesn't havetopoint to any existing resource on the Web. It will bind all the elementandattributes with that URL. I suggest to use an URL within a domainyoucontrol, and that the URL should contain some kind of version informationifpossible. For example, "http://www.gnome.org/gnumeric/1.0/"isagood namespace scheme.

Then when you load a file, make sure that a namespace carryingtheversion-independent prefix is installed on the root element of yourdocument,and if the version information don't match something you know, warnthe userand be liberal in what you accept as the input. Also do *not* try tobasenamespace checking on the prefix value. <foo:text> may be exactlythesame as <bar:text> in another document. What really matters is theURIassociated with the element or the attribute, not the prefix string (whichisjust a shortcut for the full URI). In libxml, element and attributes haveannsfield pointing to an xmlNs structure detailing thenamespaceprefix and its URI.

@@Interfaces@@

xmlNodePtr node;
if(!strncmp(node->name,"mytag",5)
  && node->ns
  && !strcmp(node->ns->href,"http://www.mysite.com/myns/1.0")) {
  ...
}

Usually people object to using namespaces together with validitychecking.I will try to make sure that using namespaces won't break validitychecking,so even if you plan to use or currently are using validation Istronglysuggest adding namespaces to your document. A default namespaceschemexmlns="http://...."should not break validity even onlessflexible parsers. Using namespaces to mix and differentiate contentcomingfrom multiple DTDs will certainly break current validation schemes. Tochecksuch documents one needs to use schema-validation, which is supportedinlibxml2 as well. See relagx-ngand w3c-schema.

Upgrading 1.x code

Incompatible changes:

Version 2 of libxml2 is the first version introducing seriousbackwardincompatible changes. The main goals were:

How to fix libxml-1.x code:

So client code of libxml designed to run with version 1.x may have tobechanged to compile against version 2.x of libxml. Here is a list ofchangesthat I have collected, they may not be sufficient, so in case you findotherchange which are required, dropme amail:

  1. The package name have changed from libxml to libxml2, the librarynameis now -lxml2 . There is a new xml2-config script which should beused toselect the right parameters libxml2
  2. Node childsfield has beenrenamedchildrenso s/childs/children/g should beapplied(probability of having "childs" anywhere else is close to 0+
  3. The document don't have anymore a rootelement ithasbeen replaced by childrenand usually you will getalist of element here. For example a Dtd element for the internalsubsetand it's declaration may be found in that list, as well asprocessinginstructions or comments found before or after the documentroot element.Use xmlDocGetRootElement(doc)to get theroot element ofa document. Alternatively if you are sure to not referenceDTDs nor havePIs or comments before or after the rootelements/->root/->children/g will probably do it.
  4. The white space issue, this one is more complex, unless special caseofvalidating parsing, the line breaks and spaces usually used forindentingand formatting the document content becomes significant. So theyarereported by SAX and if your using the DOM tree, corresponding nodesaregenerated. Too approach can be taken:
    1. lazy one, use the compatibilitycallxmlKeepBlanksDefault(0)but be aware that youarerelying on a special (and possibly broken) set of heuristicsoflibxml to detect ignorable blanks. Don't complain if it breaksormake your application not 100% clean w.r.t. to it's input.
    2. the Right Way: change you code to accept possiblyinsignificantblanks characters, or have your tree populated withweird blank textnodes. You can spot them using the commodityfunctionxmlIsBlankNode(node)returning 1 for suchblanknodes.

    Note also that with the new default the output functions don't addanyextra indentation when saving a tree in order to be able to roundtrip(read and save) without inflating the document with extraformattingchars.

  5. The include path has changed to $prefix/libxml/ and theincludesthemselves uses this new prefix in includes instructions... Ifyou areusing (as expected) the 
    xml2-config --cflags

    output to generate you compile commands this will probably work outofthe box

  6. xmlDetectCharEncoding takes an extra argument indicating the lengthinbyte of the head of the document available for character detection.

Ensuring both libxml-1.x and libxml-2.x compatibility

Two new version of libxml (1.8.11) and libxml2 (2.3.4) have beenreleasedto allow smooth upgrade of existing libxml v1code whileretainingcompatibility. They offers the following:

  1. similar include naming, one shoulduse#include<libxml/...>in both cases.
  2. similar identifiers defined via macros for the child and rootfields:respectivelyxmlChildrenNodeandxmlRootNode
  3. a new macro LIBXML_TEST_VERSIONwhich should beinsertedonce in the client code

So the roadmap to upgrade your existing libxml applications isthefollowing:

  1. install the libxml-1.8.8 (and libxml-devel-1.8.8) packages
  2. find all occurrences where the xmlDoc rootfield isusedand change it to xmlRootNode
  3. similarly find all occurrences where thexmlNodechildsfield is used and change ittoxmlChildrenNode
  4. add a LIBXML_TEST_VERSIONmacro somewhere inyourmain()or in the library init entry point
  5. Recompile, check compatibility, it should still work
  6. Change your configure script to look first for xml2-config and fallbackusing xml-config . Use the --cflags and --libs output of the commandasthe Include and Linking parameters needed to use libxml.
  7. install libxml2-2.3.x and libxml2-devel-2.3.x (libxml-1.8.yandlibxml-devel-1.8.y can be kept simultaneously)
  8. remove your config.cache, relaunch your configuration mechanism,andrecompile, if steps 2 and 3 were done right it should compileas-is
  9. Test that your application is still running correctly, if not thismaybe due to extra empty nodes due to formating spaces being kept inlibxml2contrary to libxml1, in that case insert xmlKeepBlanksDefault(1)in yourcode before calling the parser (nexttoLIBXML_TEST_VERSIONis a fine place).

Following those steps should work. It worked for some of my own code.

Let me put some emphasis on the fact that there is far more changesfromlibxml 1.x to 2.x than the ones you may have to patch for. The overallcodehas been considerably cleaned up and the conformance to the XMLspecificationhas been drastically improved too. Don't take those changes asan excuse tonot upgrade, it may cost a lot on the long term ...

Thread safety

Starting with 2.4.7, libxml2 makes provisions to ensure thatconcurrentthreads can safely work in parallel parsing different documents.There ishowever a couple of things to do to ensure it:

Note that the thread safety cannot be ensured for multiple threadssharingthe same document, the locking must be done at the application level,libxmlexports a basic mutex and reentrant mutexes API in<libxml/threads.h>.The parts of the library checked for thread safetyare:

XPath is supposed to be thread safe now, but this wasn'ttestedseriously.

DOM Principles

DOMstands for the DocumentObjectModel; this is an API for accessing XML or HTML structureddocuments.Native support for DOM in Gnome is on the way (module gnome-dom),and will bebased on gnome-xml. This will be a far cleaner interface tomanipulate XMLfiles within Gnome since it won't expose the internalstructure.

The current DOM implementation on top of libxml2 is the gdome2 Gnome module,thisis a full DOM interface, thanks to Paolo Casarini, check the Gdome2 homepageformoreinformations.

A real example

Here is a real size example, where the actual content of theapplicationdata is not kept in the DOM tree but uses internal structures. Itis based ona proposal to keep a database of jobs related to Gnome, with anXML basedstorage structure. Here is an XML encodedjobsbase:

<?xml version="1.0"?>
<gjob:Helping xmlns:gjob="http://www.gnome.org/some-location">
  <gjob:Jobs>

    <gjob:Job>
      <gjob:Project ID="3"/>
      <gjob:Application>GBackup</gjob:Application>
      <gjob:Category>Development</gjob:Category>

      <gjob:Update>
        <gjob:Status>Open</gjob:Status>
        <gjob:Modified>Mon, 07 Jun 1999 20:27:45 -0400 MET DST</gjob:Modified>
        <gjob:Salary>USD 0.00</gjob:Salary>
      </gjob:Update>

      <gjob:Developers>
        <gjob:Developer>
        </gjob:Developer>
      </gjob:Developers>

      <gjob:Contact>
        <gjob:Person>Nathan Clemons</gjob:Person>
        <gjob:Email>nathan@windsofstorm.net</gjob:Email>
        <gjob:Company>
        </gjob:Company>
        <gjob:Organisation>
        </gjob:Organisation>
        <gjob:Webpage>
        </gjob:Webpage>
        <gjob:Snailmail>
        </gjob:Snailmail>
        <gjob:Phone>
        </gjob:Phone>
      </gjob:Contact>

      <gjob:Requirements>
      The program should be released as free software, under the GPL.
      </gjob:Requirements>

      <gjob:Skills>
      </gjob:Skills>

      <gjob:Details>
      A GNOME based system that will allow a superuser to configure 
      compressed and uncompressed files and/or file systems to be backed 
      up with a supported media in the system.  This should be able to 
      perform via find commands generating a list of files that are passed 
      to tar, dd, cpio, cp, gzip, etc., to be directed to the tape machine 
      or via operations performed on the filesystem itself. Email 
      notification and GUI status display very important.
      </gjob:Details>

    </gjob:Job>

  </gjob:Jobs>
</gjob:Helping>

While loading the XML file into an internal DOM tree is a matter ofcallingonly a couple of functions, browsing the tree to gather the data andgeneratethe internal structures is harder, and more error prone.

The suggested principle is to be tolerant with respect to theinputstructure. For example, the ordering of the attributes is notsignificant,the XML specification is clear about it. It's also usually a goodidea not todepend on the order of the children of a given node, unless itreally makesthings harder. Here is some code to parse the information for aperson:

/*
 * A person record
 */
typedef struct person {
    char *name;
    char *email;
    char *company;
    char *organisation;
    char *smail;
    char *webPage;
    char *phone;
} person, *personPtr;

/*
 * And the code needed to parse it
 */
personPtr parsePerson(xmlDocPtr doc, xmlNsPtr ns, xmlNodePtr cur) {
    personPtr ret = NULL;

DEBUG("parsePerson\n");
    /*
     * allocate the struct
     */
    ret = (personPtr) malloc(sizeof(person));
    if (ret == NULL) {
        fprintf(stderr,"out of memory\n");
        return(NULL);
    }
    memset(ret, 0, sizeof(person));

    /* We don't care what the top level element name is */
    cur = cur->xmlChildrenNode;
    while (cur != NULL) {
        if ((!strcmp(cur->name, "Person")) && (cur->ns == ns))
            ret->name = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);
        if ((!strcmp(cur->name, "Email")) && (cur->ns == ns))
            ret->email = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);
        cur = cur->next;
    }

    return(ret);
}

Here are a couple of things to notice:

Here is another piece of code used to parse another level ofthestructure:

#include <libxml/tree.h>
/*
 * a Description for a Job
 */
typedef struct job {
    char *projectID;
    char *application;
    char *category;
    personPtr contact;
    int nbDevelopers;
    personPtr developers[100]; /* using dynamic alloc is left as an exercise */
} job, *jobPtr;

/*
 * And the code needed to parse it
 */
jobPtr parseJob(xmlDocPtr doc, xmlNsPtr ns, xmlNodePtr cur) {
    jobPtr ret = NULL;

DEBUG("parseJob\n");
    /*
     * allocate the struct
     */
    ret = (jobPtr) malloc(sizeof(job));
    if (ret == NULL) {
        fprintf(stderr,"out of memory\n");
        return(NULL);
    }
    memset(ret, 0, sizeof(job));

    /* We don't care what the top level element name is */
    cur = cur->xmlChildrenNode;
    while (cur != NULL) {
        
        if ((!strcmp(cur->name, "Project")) && (cur->ns == ns)) {
            ret->projectID = xmlGetProp(cur, "ID");
            if (ret->projectID == NULL) {
                fprintf(stderr, "Project has no ID\n");
            }
        }
        if ((!strcmp(cur->name, "Application")) && (cur->ns == ns))
            ret->application = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);
        if ((!strcmp(cur->name, "Category")) && (cur->ns == ns))
            ret->category = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);
        if ((!strcmp(cur->name, "Contact")) && (cur->ns == ns))
            ret->contact = parsePerson(doc, ns, cur);
        cur = cur->next;
    }

    return(ret);
}

Once you are used to it, writing this kind of code is quite simple,butboring. Ultimately, it could be possible to write stubbers taking eitherCdata structure definitions, a set of XML examples or an XML DTD andproducethe code needed to import and export the content between C data andXMLstorage. This is left as an exercise to the reader :-)

Feel free to use the code for the fullCparsing exampleas a template, it is also available with Makefile intheGnome CVS base under gnome-xml/example

Contributions