src - OpenBSD base system

diff options


context:
space:
mode:

author	Aleksander Piotrowski <alek@cvs.openbsd.org>	2006-05-06 16:09:32 +0000
committer	Aleksander Piotrowski <alek@cvs.openbsd.org>	2006-05-06 16:09:32 +0000
commit	0941726c718d0c63478583c6d822d4a893c9b7a9 (patch)
tree	c5afe263729a3dff78207e39d910197f0f1450fd /lib
parent	4202274c4958484629e8a5c593c1dd7dcf582469 (diff)

Update to 2.0.0; keep our local changes

ok espie@, djm@

Diffstat (limited to 'lib')

-rw-r--r--

lib/libexpat/COPYING

-rw-r--r--

lib/libexpat/Changes

-rw-r--r--

lib/libexpat/Makefile

-rw-r--r--

lib/libexpat/README

-rw-r--r--

lib/libexpat/doc/reference.html

794

-rw-r--r--

lib/libexpat/doc/style.css

-rw-r--r--

lib/libexpat/examples/elements.c

-rw-r--r--

lib/libexpat/examples/outline.c

-rw-r--r--

lib/libexpat/lib/amigaconfig.h

-rw-r--r--

lib/libexpat/lib/expat.h

322

-rw-r--r--

lib/libexpat/lib/expat_external.h

115

-rw-r--r--

lib/libexpat/lib/internal.h

-rw-r--r--

lib/libexpat/lib/macconfig.h

-rw-r--r--

lib/libexpat/lib/winconfig.h

-rw-r--r--

lib/libexpat/lib/xmlparse.c

1474

-rw-r--r--

lib/libexpat/lib/xmlrole.c

-rw-r--r--

lib/libexpat/lib/xmltok.c

-rw-r--r--

lib/libexpat/lib/xmltok.h

-rw-r--r--

lib/libexpat/lib/xmltok_impl.c

-rw-r--r--

lib/libexpat/lib/xmltok_ns.c

-rw-r--r--

lib/libexpat/shlib_version

21 files changed, 2321 insertions, 822 deletions

diff --git a/lib/libexpat/COPYING b/lib/libexpat/COPYING
index e3ad54e969a..dcb45064296 100644
--- a/lib/libexpat/COPYING
+++ b/lib/libexpat/COPYING

@@ -1,6 +1,6 @@

and Clark Cooper

Permission is hereby granted, free of charge, to any person obtaining

a copy of this software and associated documentation files (the

diff --git a/lib/libexpat/Changes b/lib/libexpat/Changes
index c5f75d0c8ea..63818663fca 100644
--- a/lib/libexpat/Changes
+++ b/lib/libexpat/Changes

@@ -1,3 +1,44 @@

+Release 2.0.0 Wed Jan 11 2006

+ - We no longer use the "check" library for C unit testing; we

+ always use the (partial) internal implementation of the API.

+ - Report XML_NS setting via XML_GetFeatureList().

+ - Fixed headers for use from C++.

+ - XML_GetCurrentLineNumber() and XML_GetCurrentColumnNumber()

+ now return unsigned integers.

+ - Added XML_LARGE_SIZE switch to enable 64-bit integers for

+ byte indexes and line/column numbers.

+ - Updated to use libtool 1.5.22 (the most recent).

+ - Added support for AmigaOS.

+ - Some mostly minor bug fixes. SF issues include: 1006708,

+ 1021776, 1023646, 1114960, 1156398, 1221160, 1271642.

+Release 1.95.8 Fri Jul 23 2004

+ - Major new feature: suspend/resume. Handlers can now request

+ that a parse be suspended for later resumption or aborted

+ altogether. See "Temporarily Stopping Parsing" in the

+ documentation for more details.

+ - Some mostly minor bug fixes, but compilation should no

+ longer generate warnings on most platforms. SF issues

+ include: 827319, 840173, 846309, 888329, 896188, 923913,

+ 928113, 961698, 985192.

+Release 1.95.7 Mon Oct 20 2003

+ - Fixed enum XML_Status issue (reported on SourceForge many

+ times), so compilers that are properly picky will be happy.

+ - Introduced an XMLCALL macro to control the calling

+ convention used by the Expat API; this macro should be used

+ to annotate prototypes and definitions of callback

+ implementations in code compiled with a calling convention

+ other than the default convention for the host platform.

+ - Improved ability to build without the configure-generated

+ expat_config.h header. This is useful for applications

+ which embed Expat rather than linking in the library.

+ - Fixed a variety of bugs: see SF issues 458907, 609603,

+ 676844, 679754, 692878, 692964, 695401, 699323, 699487,

+ 820946.

+ - Improved hash table lookups.

+ - Added more regression tests and improved documentation.

Release 1.95.6 Tue Jan 28 2003

- Added XML_FreeContentModel().

- Added XML_MemMalloc(), XML_MemRealloc(), XML_MemFree().

diff --git a/lib/libexpat/Makefile b/lib/libexpat/Makefile
index 7a89a1365c5..446de54b6a5 100644
--- a/lib/libexpat/Makefile
+++ b/lib/libexpat/Makefile

@@ -1,14 +1,17 @@

-# $OpenBSD: Makefile,v 1.3 2005/11/24 20:49:17 deraadt Exp $

+# $OpenBSD: Makefile,v 1.4 2006/05/06 16:09:30 alek Exp $

.PATH: ${.CURDIR}/lib

LIB= expat

WANTLINT=

SRCS= xmlparse.c xmltok.c xmlrole.c

-CFLAGS+=-I${.CURDIR}

+CFLAGS+=-I${.CURDIR} -DHAVE_EXPAT_CONFIG_H

includes:

@cmp -s ${DESTDIR}/usr/include/expat.h ${.CURDIR}/lib/expat.h || \

${INSTALL} ${INSTALL_COPY} -m 444 -o $(BINOWN) -g $(BINGRP) \

${.CURDIR}/lib/expat.h ${DESTDIR}/usr/include/expat.h

+ @cmp -s ${DESTDIR}/usr/include/expat_external.h ${.CURDIR}/lib/expat_external.h || \

+ ${INSTALL} ${INSTALL_COPY} -m 444 -o $(BINOWN) -g $(BINGRP) \

+ ${.CURDIR}/lib/expat_external.h ${DESTDIR}/usr/include/expat_external.h

.include <bsd.lib.mk>

diff --git a/lib/libexpat/README b/lib/libexpat/README
index 3bab5a02c4e..585bcc1bf6e 100644
--- a/lib/libexpat/README
+++ b/lib/libexpat/README

@@ -1,5 +1,5 @@

- Expat, Release 1.95.6

+ Expat, Release 2.0.0

This is Expat, a C library for parsing XML, written by James Clark.

Expat is a stream-oriented XML parser. This means that you register

@@ -9,7 +9,7 @@ document being parsed. A start tag is an example of the kind of

structures for which you may register handlers.

Windows users should use the expat_win32bin package, which includes

-both precompiled libraries and executalbes, and source code for

+both precompiled libraries and executables, and source code for

developers.

Expat is free software. You may copy, distribute, and modify it under

@@ -48,14 +48,20 @@ into /home/me/mystuff/lib, /home/me/mystuff/include, and

/home/me/mystuff/bin, you can tell configure about that with:

./configure --prefix=/home/me/mystuff

+Another interesting option is to enable 64-bit integer support for

+line and column numbers and the over-all byte index:

+ ./configure CPPFLAGS=-DXML_LARGE_SIZE

After running the configure script, the "make" command will build

things and "make install" will install things into their proper

-location. Note that you need to have write permission into the

-directories into which things will be installed.

+location. Have a look at the "Makefile" to learn about additional

+"make" options. Note that you need to have write permission into

+the directories into which things will be installed.

If you are interested in building Expat to provide document

-information in UTF-16 rather than the default UTF-8, following these

+information in UTF-16 rather than the default UTF-8, follow these

instructions:

1. For UTF-16 output as unsigned short (and version/error

@@ -109,4 +115,4 @@ Discussion related to the direction of future expat development takes

place on expat-discuss@mail.libexpat.org. Archives of this list and

other Expat-related lists may be found at:

- http://mail.libexpat.org/mailman-21/listinfo/

+ http://mail.libexpat.org/mailman/listinfo/

diff --git a/lib/libexpat/doc/reference.html b/lib/libexpat/doc/reference.html
index 13726e818c6..0292ea272e5 100644
--- a/lib/libexpat/doc/reference.html
+++ b/lib/libexpat/doc/reference.html

@@ -13,7 +13,17 @@

</head>

<body>

-<h1>Expat XML Parser</h1>

+ <table cellspacing="0" cellpadding="0" width="100%">

+ <tr>

+ <td class="corner"><img src="expat.png" alt="(Expat logo)" /></td>

+ <td class="banner"><h1>The Expat XML Parser</h1></td>

+ </tr>

+ <tr>

+ <td class="releaseno">Release 2.0.0</td>

+ <td></td>

+ </tr>

+ </table>

+<div class="content">

<p>Expat is a library, written in C, for parsing XML documents. It's

the underlying XML parser for the open source Mozilla project, Perl's

@@ -31,9 +41,13 @@ href="../COPYING">MIT/X Consortium license</a>. You may download it

from <a href="http://www.libexpat.org/">the Expat home page</a>.

</p>

-<p>The bulk of this document was originally commissioned as an article by

-<a href="http://www.xml.com/">XML.com</a>. They graciously allowed

-Clark Cooper to retain copyright and to distribute it with Expat.</p>

+<p>The bulk of this document was originally commissioned as an article

+by <a href="http://www.xml.com/">XML.com</a>. They graciously allowed

+Clark Cooper to retain copyright and to distribute it with Expat.

+This version has been substantially extended to include documentation

+on features which have been added since the original article was

+published, and additional information on using the original

+interface.</p>

<hr />

<h2>Table of Contents</h2>

@@ -58,6 +72,9 @@ Clark Cooper to retain copyright and to distribute it with Expat.</p>

<li><a href="#XML_Parse">XML_Parse</a></li>

<li><a href="#XML_ParseBuffer">XML_ParseBuffer</a></li>

<li><a href="#XML_GetBuffer">XML_GetBuffer</a></li>

+ <li><a href="#XML_StopParser">XML_StopParser</a></li>

+ <li><a href="#XML_ResumeParser">XML_ResumeParser</a></li>

+ <li><a href="#XML_GetParsingStatus">XML_GetParsingStatus</a></li>

</ul>

</li>

<li><a href="#setting">Handler Setting Functions</a>

@@ -182,7 +199,7 @@ variable.</p>

int Depth;

-void

+void XMLCALL

start(void *data, const char *el, const char **attr) {

int i;

@@ -203,12 +220,44 @@ start(void *data, const char *el, const char **attr) {

<p>The end tag simply does the bookkeeping work of decrementing

<code>Depth</code>.</p>

-void

+void XMLCALL

end(void *data, const char *el) {

Depth--;

} /* End of end handler */

</pre>

+<p>Note the <code>XMLCALL</code> annotation used for the callbacks.

+This is used to ensure that the Expat and the callbacks are using the

+same calling convention in case the compiler options used for Expat

+itself and the client code are different. Expat tries not to care

+what the default calling convention is, though it may require that it

+be compiled with a default convention of "cdecl" on some platforms.

+For code which uses Expat, however, the calling convention is

+specified by the <code>XMLCALL</code> annotation on most platforms;

+callbacks should be defined using this annotation.</p>

+<p>The <code>XMLCALL</code> annotation was added in Expat 1.95.7, but

+existing working Expat applications don't need to add it (since they

+are already using the "cdecl" calling convention, or they wouldn't be

+working). The annotation is only needed if the default calling

+convention may be something other than "cdecl". To use the annotation

+safely with older versions of Expat, you can conditionally define it

+<em>after</em> including Expat's header file:</p>

+<pre class="eg">

+#include <expat.h>

+#ifndef XMLCALL

+#if defined(_MSC_EXTENSIONS) && !defined(__BEOS__) && !defined(__CYGWIN__)

+#define XMLCALL __cdecl

+#elif defined(__GNUC__)

+#define XMLCALL __attribute__((cdecl))

+#else

+#define XMLCALL

+#endif

+</pre>

<p>After creating the parser, the main program just has the job of

shoveling the document to the parser so that it can do its work.</p>

@@ -242,9 +291,9 @@ and you have permission on your system to install into /usr/local, you

can install Expat with this sequence of commands:</p>

- ./configure

- make

- make install

+./configure

+make

+make install

</pre>

<p>There are some options that you can provide to this script, but the

@@ -260,6 +309,68 @@ library and header would get installed in

<code>/home/me/mystuff/lib</code> and

<code>/home/me/mystuff/include</code> respectively.</p>

+<h3>Configuring Expat Using the Pre-Processor</h3>

+<p>Expat's feature set can be configured using a small number of

+pre-processor definitions. The definition of this symbols does not

+affect the set of entry points for Expat, only the behavior of the API

+and the definition of character types in the case of

+<code>XML_UNICODE_WCHAR_T</code>. The symbols are:</p>

+<dl class="cpp-symbols">

+<dt>XML_DTD</dt>

+<dd>Include support for using and reporting DTD-based content. If

+this is defined, default attribute values from an external DTD subset

+are reported and attribute value normalization occurs based on the

+type of attributes defined in the external subset. Without

+this, Expat has a smaller memory footprint and can be faster, but will

+not load external entities or process conditional sections. This does

+not affect the set of functions available in the API.</dd>

+<dt>XML_NS</dt>

+<dd>When defined, support for the <cite><a href=

+"http://www.w3.org/TR/REC-xml-names/" >Namespaces in XML</a></cite>

+specification is included.</dd>

+<dt>XML_UNICODE</dt>

+<dd>When defined, character data reported to the application is

+encoded in UTF-16 using wide characters of the type

+<code>XML_Char</code>. This is implied if

+<code>XML_UNICODE_WCHAR_T</code> is defined.</dd>

+<dt>XML_UNICODE_WCHAR_T</dt>

+<dd>If defined, causes the <code>XML_Char</code> character type to be

+defined using the <code>wchar_t</code> type; otherwise, <code>unsigned

+short</code> is used. Defining this implies

+<code>XML_UNICODE</code>.</dd>

+<dt>XML_LARGE_SIZE</dt>

+<dd>If defined, causes the <code>XML_Size</code> and <code>XML_Index</code>

+integer types to be at least 64 bits in size. This is intended to support

+processing of very large input streams, where the return values of

+<code><a href="#XML_GetCurrentByteIndex" >XML_GetCurrentByteIndex</a></code>,

+<code><a href="#XML_GetCurrentLineNumber" >XML_GetCurrentLineNumber</a></code> and

+<code><a href="#XML_GetCurrentColumnNumber" >XML_GetCurrentColumnNumber</a></code>

+could overflow. It may not be supported by all compilers, and is turned

+off by default.</dd>

+<dt>XML_CONTEXT_BYTES</dt>

+<dd>The number of input bytes of markup context which the parser will

+ensure are available for reporting via <code><a href=

+"#XML_GetInputContext" >XML_GetInputContext</a></code>. This is

+normally set to 1024, and must be set to a positive interger. If this

+is not defined, the input context will not be available and <code><a

+href= "#XML_GetInputContext" >XML_GetInputContext</a></code> will

+always report NULL. Without this, Expat has a smaller memory

+footprint and can be faster.</dd>

+<dt>XML_STATIC</dt>

+<dd>On Windows, this should be set if Expat is going to be linked

+statically with the code that calls it; this is required to get all

+the right MSVC magic annotations correct. This is ignored on other

+platforms.</dd>

+</dl>

<hr />

<h2><a name="using">Using Expat</a></h2>

@@ -318,7 +429,7 @@ by these functions is an opaque pointer (i.e. "expat.h" declares it as

void *) to data with further internal structure. In order to free the

memory associated with this object you must call <code><a href=

"#XML_ParserFree" >XML_ParserFree</a></code>. Note that if you have

-provided any <a href="userdata">user data</a> that gets stored in the

+provided any <a href="#userdata">user data</a> that gets stored in the

parser, then your application is responsible for freeing it prior to

calling <code>XML_ParserFree</code>.</p>

@@ -360,7 +471,7 @@ init_info(Parseinfo *info) {

/* Other initializations here */

} /* End of init_info */

-void

+void XMLCALL

rawstart(void *data, const char *el, const char **attr) {

Parseinfo *inf = (Parseinfo *) data;

@@ -375,7 +486,7 @@ rawstart(void *data, const char *el, const char **attr) {

inf->depth++;

} /* End of rawstart */

-void

+void XMLCALL

rawend(void *data, const char *el) {

Parseinfo *inf = (Parseinfo *) data;

@@ -405,8 +516,31 @@ handler.</p>

without using globals, you'll need to define a data structure to hold

the shared variables. You can then tell Expat (with the <code><a href=

"#XML_SetUserData" >XML_SetUserData</a></code> function) to pass a

-pointer to this structure to the handlers. This is typically the first

-argument received by most handlers.</p>

+pointer to this structure to the handlers. This is the first

+argument received by most handlers. In the <a href="#reference"

+>reference section</a>, an argument to a callback function is named

+<code>userData</code> and have type <code>void *</code> if the user

+data is passed; it will have the type <code>XML_Parser</code> if the

+parser itself is passed. When the parser is passed, the user data may

+be retrieved using <code><a href="#XML_GetUserData"

+>XML_GetUserData</a></code>.</p>

+<p>One common case where multiple calls to a single handler may need

+to communicate using an application data structure is the case when

+content passed to the character data handler (set by <code><a href=

+"#XML_SetCharacterDataHandler"

+>XML_SetCharacterDataHandler</a></code>) needs to be accumulated. A

+common first-time mistake with any of the event-oriented interfaces to

+an XML parser is to expect all the text contained in an element to be

+reported by a single call to the character data handler. Expat, like

+many other XML parsers, reports such data as a sequence of calls;

+there's no way to know when the end of the sequence is reached until a

+different callback is made. A buffer referenced by the user data

+structure proves both an effective and convenient place to accumulate

+character data.</p>

+

<h3>XML Version</h3>

@@ -425,7 +559,7 @@ version number of <code>"1.0"</code> is accepted:</p>

static int wrong_version;

static XML_Parser parser;

-static void

+static void XMLCALL

xmldecl_handler(void *userData,

const XML_Char *version,

const XML_Char *encoding,

@@ -467,12 +601,12 @@ this expanded form is a concatenation of the namespace URI, the

separator character (which is the 2nd argument to <code><a href=

"#XML_ParserCreateNS" >XML_ParserCreateNS</a></code>), and the local

name (i.e. the part after the colon). Names with undeclared prefixes

-are passed through to the handlers unchanged, with the prefix and

-colon still attached. Unprefixed attribute names are never expanded,

+are not well-formed when namespace processing is enabled, and will

+trigger an error. Unprefixed attribute names are never expanded,

and unprefixed element names are only expanded when they are in the

scope of a default namespace.</p>

-<p>However if <code><a href= "XML_SetReturnNSTriplet"

+<p>However if <code><a href= "#XML_SetReturnNSTriplet"

>XML_SetReturnNSTriplet</a></code> has been called with a non-zero

<code>do_nst</code> parameter, then the expanded form for names with

an explicit prefix is a concatenation of: URI, separator, local name,

@@ -482,7 +616,7 @@ separator, prefix.</p>

for the end of a scope of a declaration with the <code><a href=

"#XML_SetNamespaceDeclHandler" >XML_SetNamespaceDeclHandler</a></code>

function. The StartNamespaceDeclHandler is called prior to the start

-tag handler and the EndNamespaceDeclHandler is called before the

+tag handler and the EndNamespaceDeclHandler is called after the

corresponding end tag that ends the namespace's scope. The namespace

start handler gets passed the prefix and URI for the namespace. For a

default namespace declaration (xmlns='...'), the prefix will be null.

@@ -607,6 +741,149 @@ arguments:</p>

<p>In order to read an external DTD, you also have to set an external

entity reference handler as described above.</p>

+<h3 id="stop-resume">Temporarily Stopping Parsing</h3>

+<p>Expat 1.95.8 introduces a new feature: its now possible to stop

+parsing temporarily from within a handler function, even if more data

+has already been passed into the parser. Applications for this

+include</p>

+<ul>

+ <li>Supporting the <a href= "http://www.w3.org/TR/xinclude/"

+ >XInclude</a> specification.</li>

+ <li>Delaying further processing until additional information is

+ available from some other source.</li>

+ <li>Adjusting processor load as task priorities shift within an

+ application.</li>

+ <li>Stopping parsing completely (simply free or reset the parser

+ instead of resuming in the outer parsing loop). This can be useful

+ if a application-domain error is found in the XML being parsed or if

+ the result of the parse is determined not to be useful after

+ all.</li>

+</ul>

+<p>To take advantage of this feature, the main parsing loop of an

+application needs to support this specifically. It cannot be

+supported with a parsing loop compatible with Expat 1.95.7 or

+earlier (though existing loops will continue to work without

+supporting the stop/resume feature).</p>

+<p>An application that uses this feature for a single parser will have

+the rough structure (in pseudo-code):</p>

+<pre class="pseudocode">

+fd = open_input()

+p = create_parser()

+if parse_xml(p, fd) {

+ /* suspended */

+ int suspended = 1;

+ while (suspended) {

+ do_something_else()

+ if ready_to_resume() {

+ suspended = continue_parsing(p, fd);

+ }

+</pre>

+<p>An application that may resume any of several parsers based on

+input (either from the XML being parsed or some other source) will

+certainly have more interesting control structures.</p>

+<p>This C function could be used for the <code>parse_xml</code>

+function mentioned in the pseudo-code above:</p>

+<pre class="eg">

+#define BUFF_SIZE 10240

+/* Parse a document from the open file descriptor 'fd' until the parse

+ is complete (the document has been completely parsed, or there's

+ been an error), or the parse is stopped. Return non-zero when

+ the parse is merely suspended.

+*/

+int

+parse_xml(XML_Parser p, int fd)

+ for (;;) {

+ int last_chunk;

+ int bytes_read;

+ enum XML_Status status;

+ void *buff = XML_GetBuffer(p, BUFF_SIZE);

+ if (buff == NULL) {

+ /* handle error... */

+ return 0;

+ }

+ bytes_read = read(fd, buff, BUFF_SIZE);

+ if (bytes_read < 0) {

+ /* handle error... */

+ return 0;

+ }

+ status = XML_ParseBuffer(p, bytes_read, bytes_read == 0);

+ switch (status) {

+ case XML_STATUS_ERROR:

+ /* handle error... */

+ return 0;

+ case XML_STATUS_SUSPENDED:

+ return 1;

+ }

+ if (bytes_read == 0)

+ return 0;

+ }

+</pre>

+<p>The corresponding <code>continue_parsing</code> function is

+somewhat simpler, since it only need deal with the return code from

+<code><a href= "#XML_ResumeParser">XML_ResumeParser</a></code>; it can

+delegate the input handling to the <code>parse_xml</code>

+function:</p>

+<pre class="eg">

+/* Continue parsing a document which had been suspended. The 'p' and

+ 'fd' arguments are the same as passed to parse_xml(). Return

+ non-zero when the parse is suspended.

+*/

+int

+continue_parsing(XML_Parser p, int fd)

+ enum XML_Status status = XML_ResumeParser(p);

+ switch (status) {

+ case XML_STATUS_ERROR:

+ /* handle error... */

+ return 0;

+ case XML_ERROR_NOT_SUSPENDED:

+ /* handle error... */

+ return 0;.

+ case XML_STATUS_SUSPENDED:

+ return 1;

+ }

+ return parse_xml(p, fd);

+</pre>

+<p>Now that we've seen what a mess the top-level parsing loop can

+become, what have we gained? Very simply, we can now use the <code><a

+href= "#XML_StopParser" >XML_StopParser</a></code> function to stop

+parsing, without having to go to great lengths to avoid additional

+processing that we're expecting to ignore. As a bonus, we get to stop

+parsing <em>temporarily</em>, and come back to it when we're

+ready.</p>

+<p>To stop parsing from a handler function, use the <code><a href=

+"#XML_StopParser" >XML_StopParser</a></code> function. This function

+takes two arguments; the parser being stopped and a flag indicating

+whether the parse can be resumed in the future.</p>

+

<hr />

@@ -615,7 +892,7 @@ entity reference handler as described above.</p>

<h3><a name="creation">Parser Creation</a></h3>

-XML_Parser

+XML_Parser XMLCALL

XML_ParserCreate(const XML_Char *encoding);

</pre>

@@ -632,7 +909,7 @@ Any other value will invoke a call to the UnknownEncodingHandler.

</div>

-XML_Parser

+XML_Parser XMLCALL

XML_ParserCreateNS(const XML_Char *encoding,

XML_Char sep);

</pre>

@@ -641,19 +918,23 @@ Constructs a new parser that has namespace processing in effect. Namespace

expanded element names and attribute names are returned as a concatenation

of the namespace URI, <em>sep</em>, and the local part of the name. This

means that you should pick a character for <em>sep</em> that can't be

-part of a legal URI.</div>

+part of a legal URI. There is a special case when <em>sep</em> is the null

+character <code>'\0'</code>: the namespace URI and the local part will be

+concatenated without any separator - this is intended to support RDF processors.

+It is a programming error to use the null separator with

+<a href= "#XML_SetReturnNSTriplet">namespace triplets</a>.</div>

-XML_Parser

+XML_Parser XMLCALL

XML_ParserCreate_MM(const XML_Char *encoding,

const XML_Memory_Handling_Suite *ms,

const XML_Char *sep);

</pre>

typedef struct {

- void *(*malloc_fcn)(size_t size);

- void *(*realloc_fcn)(void *ptr, size_t size);

- void (*free_fcn)(void *ptr);

+ void *(XMLCALL *malloc_fcn)(size_t size);

+ void *(XMLCALL *realloc_fcn)(void *ptr, size_t size);

+ void (XMLCALL *free_fcn)(void *ptr);

} XML_Memory_Handling_Suite;

</pre>

@@ -666,7 +947,7 @@ the namespace URI and the local part of the name.</p>

</div>

-XML_Parser

+XML_Parser XMLCALL

XML_ExternalEntityParserCreate(XML_Parser p,

const XML_Char *context,

const XML_Char *encoding);

@@ -682,7 +963,7 @@ differently than the parent parser).

</div>

-void

+void XMLCALL

XML_ParserFree(XML_Parser p);

</pre>

@@ -691,14 +972,17 @@ freeing any memory associated with <a href="#userdata">user data</a>.

</div>

-XML_Bool

-XML_ParserReset(XML_Parser p);

+XML_Bool XMLCALL

+XML_ParserReset(XML_Parser p,

+ const XML_Char *encoding);

</pre>

Clean up the memory structures maintained by the parser so that it may

be used again. After this has been called, <code>parser</code> is

-ready to start parsing a new document. This function may not be used

-on a parser created using <code><a href=

+ready to start parsing a new document. All handlers are cleared from

+the parser, except for the unknownEncodingHandler. The parser's external

+state is re-initialized except for the values of ns and ns_triplets.

+This function may not be used on a parser created using <code><a href=

"#XML_ExternalEntityParserCreate" >XML_ExternalEntityParserCreate</a

></code>; it will return <code>XML_FALSE</code> in that case. Returns

<code>XML_TRUE</code> on success. Your application is responsible for

@@ -708,18 +992,26 @@ dealing with any memory associated with <a href="#userdata">user data</a>.

<h3><a name="parsing">Parsing</a></h3>

<p>To state the obvious: the three parsing functions <code><a href=

-"#XML_Parse" >XML_Parse</a></code>, <code><a href= "#XML_ParseBuffer"

->XML_ParseBuffer</a></code> and <code><a href= "#XML_GetBuffer"

->>XML_GetBuffer</a></code> must not be

-called from within a handler unless they operate on a separate parser

-instance, that is, one that did not call the handler. For example, it

-is OK to call the parsing functions from within an

-<code>XML_ExternalEntityRefHandler</code>, if they apply to the parser

-created by <code><a href= "#XML_ExternalEntityParserCreate"

+"#XML_Parse" >XML_Parse</a></code>, <code><a href= "#XML_ParseBuffer">

+XML_ParseBuffer</a></code> and <code><a href= "#XML_GetBuffer">

+XML_GetBuffer</a></code> must not be called from within a handler

+unless they operate on a separate parser instance, that is, one that

+did not call the handler. For example, it is OK to call the parsing

+functions from within an <code>XML_ExternalEntityRefHandler</code>,

+if they apply to the parser created by

+<code><a href= "#XML_ExternalEntityParserCreate"

>XML_ExternalEntityParserCreate</a></code>.</p>

+<p>Note: the <code>len</code> argument passed to these functions

+should be considerably less than the maximum value for an integer,

+as it could create an integer overflow situation if the added

+lengths of a buffer and the unprocessed portion of the previous buffer

+exceed the maximum integer value. Input data at the end of a buffer

+will remain unprocessed if it is part of an XML token for which the

+end is not part of that buffer.</p>

-XML_Status

+enum XML_Status XMLCALL

XML_Parse(XML_Parser p,

const char *s,

int len,

@@ -746,7 +1038,7 @@ Otherwise it returns <code>XML_STATUS_OK</code> value.

</div>

-XML_Status

+enum XML_Status XMLCALL

XML_ParseBuffer(XML_Parser p,

int len,

int isFinal);

@@ -760,7 +1052,7 @@ copying of the input.

</div>

-void *

+void * XMLCALL

XML_GetBuffer(XML_Parser p,

int len);

</pre>

@@ -794,6 +1086,125 @@ for (;;) {

</pre>

</div>

+<pre class="fcndec" id="XML_StopParser">

+enum XML_Status XMLCALL

+XML_StopParser(XML_Parser p,

+ XML_Bool resumable);

+</pre>

+<div class="fcndef">

+<p>Stops parsing, causing <code><a href= "#XML_Parse"

+>XML_Parse</a></code> or <code><a href= "#XML_ParseBuffer"

+>XML_ParseBuffer</a></code> to return. Must be called from within a

+call-back handler, except when aborting (when <code>resumable</code>

+is <code>XML_FALSE</code>) an already suspended parser. Some

+call-backs may still follow because they would otherwise get

+lost, including

+<ul>

+ <li> the end element handler for empty elements when stopped in the

+ start element handler,</li>

+ <li> end namespace declaration handler when stopped in the end

+ element handler,</li>

+</ul>

+and possibly others.</p>

+<p>This can be called from most handlers, including DTD related

+call-backs, except when parsing an external parameter entity and

+<code>resumable</code> is <code>XML_TRUE</code>. Returns

+<code>XML_STATUS_OK</code> when successful,

+<code>XML_STATUS_ERROR</code> otherwise. The possible error codes

+are:</p>

+<dl>

+ <dt><code>XML_ERROR_SUSPENDED</code></dt>

+ <dd>when suspending an already suspended parser.</dd>

+ <dt><code>XML_ERROR_FINISHED</code></dt>

+ <dd>when the parser has already finished.</dd>

+ <dt><code>XML_ERROR_SUSPEND_PE</code></dt>

+ <dd>when suspending while parsing an external PE.</dd>

+</dl>

+<p>Since the stop/resume feature requires application support in the

+outer parsing loop, it is an error to call this function for a parser

+not being handled appropriately; see <a href= "#stop-resume"

+>Temporarily Stopping Parsing</a> for more information.</p>

+<p>When <code>resumable</code> is <code>XML_TRUE</code> then parsing

+is <em>suspended</em>, that is, <code><a href= "#XML_Parse"

+>XML_Parse</a></code> and <code><a href= "#XML_ParseBuffer"

+>XML_ParseBuffer</a></code> return <code>XML_STATUS_SUSPENDED</code>.

+Otherwise, parsing is <em>aborted</em>, that is, <code><a href=

+"#XML_Parse" >XML_Parse</a></code> and <code><a href=

+"#XML_ParseBuffer" >XML_ParseBuffer</a></code> return

+<code>XML_STATUS_ERROR</code> with error code

+<code>XML_ERROR_ABORTED</code>.</p>

+<p><strong>Note:</strong>

+This will be applied to the current parser instance only, that is, if

+there is a parent parser then it will continue parsing when the

+external entity reference handler returns. It is up to the

+implementation of that handler to call <code><a href=

+"#XML_StopParser" >XML_StopParser</a></code> on the parent parser

+(recursively), if one wants to stop parsing altogether.</p>

+<p>When suspended, parsing can be resumed by calling <code><a href=

+"#XML_ResumeParser" >XML_ResumeParser</a></code>.</p>

+<p>New in Expat 1.95.8.</p>

+</div>

+<pre class="fcndec" id="XML_ResumeParser">

+enum XML_Status XMLCALL

+XML_ResumeParser(XML_Parser p);

+</pre>

+<div class="fcndef">

+<p>Resumes parsing after it has been suspended with <code><a href=

+"#XML_StopParser" >XML_StopParser</a></code>. Must not be called from

+within a handler call-back. Returns same status codes as <code><a

+href= "#XML_Parse">XML_Parse</a></code> or <code><a href=

+"#XML_ParseBuffer" >XML_ParseBuffer</a></code>. An additional error

+code, <code>XML_ERROR_NOT_SUSPENDED</code>, will be returned if the

+parser was not currently suspended.</p>

+<p><strong>Note:</strong>

+This must be called on the most deeply nested child parser instance

+first, and on its parent parser only after the child parser has

+finished, to be applied recursively until the document entity's parser

+is restarted. That is, the parent parser will not resume by itself

+and it is up to the application to call <code><a href=

+"#XML_ResumeParser" >XML_ResumeParser</a></code> on it at the

+appropriate moment.</p>

+<p>New in Expat 1.95.8.</p>

+</div>

+<pre class="fcndec" id="XML_GetParsingStatus">

+void XMLCALL

+XML_GetParsingStatus(XML_Parser p,

+ XML_ParsingStatus *status);

+</pre>

+<pre class="signature">

+enum XML_Parsing {

+ XML_INITIALIZED,

+ XML_PARSING,

+ XML_FINISHED,

+ XML_SUSPENDED

+};

+typedef struct {

+ enum XML_Parsing parsing;

+ XML_Bool finalBuffer;

+} XML_ParsingStatus;

+</pre>

+<div class="fcndef">

+<p>Returns status of parser with respect to being initialized,

+parsing, finished, or suspended, and whether the final buffer is being

+processed. The <code>status</code> parameter <em>must not</em> be

+NULL.</p>

+<p>New in Expat 1.95.8.</p>

+</div>

<h3><a name="setting">Handler Setting</a></h3>

<p>Although handlers are typically set prior to parsing and left alone, an

@@ -808,21 +1219,23 @@ appropriate handler setter. None of the handler setting functions have

a return value.</p>

<p>Your handlers will be receiving strings in arrays of type

-<code>XML_Char</code>. This type is defined in expat.h as <code>char

-*</code> and contains bytes encoding UTF-8. Note that you'll receive

-them in this form independent of the original encoding of the

-document.</p>

+<code>XML_Char</code>. This type is conditionally defined in expat.h as

+either <code>char</code>, <code>wchar_t</code> or <code>unsigned short</code>.

+The former implies UTF-8 encoding, the latter two imply UTF-16 encoding.

+Note that you'll receive them in this form independent of the original

+encoding of the document.</p>

+void XMLCALL

XML_SetStartElementHandler(XML_Parser p,

XML_StartElementHandler start);

</pre>

typedef void

-(*XML_StartElementHandler)(void *userData,

- const XML_Char *name,

- const XML_Char **atts);

+(XMLCALL *XML_StartElementHandler)(void *userData,

+ const XML_Char *name,

+ const XML_Char **atts);

</pre>

<p>Set handler for start (and empty) tags. Attributes are passed to the start

handler as a pointer to a vector of char pointers. Each attribute seen in

@@ -835,13 +1248,14 @@ by a null pointer.</p>

+void XMLCALL

XML_SetEndElementHandler(XML_Parser p,

XML_EndElementHandler);

</pre>

typedef void

-(*XML_EndElementHandler)(void *userData,

- const XML_Char *name);

+(XMLCALL *XML_EndElementHandler)(void *userData,

+ const XML_Char *name);

</pre>

<p>Set handler for end (and empty) tags. As noted above, an empty tag

generates a call to both start and end handlers.</p>

@@ -849,6 +1263,7 @@ generates a call to both start and end handlers.</p>

+void XMLCALL

XML_SetElementHandler(XML_Parser p,

XML_StartElementHandler start,

XML_EndElementHandler end);

@@ -858,14 +1273,15 @@ XML_SetElementHandler(XML_Parser p,

+void XMLCALL

XML_SetCharacterDataHandler(XML_Parser p,

XML_CharacterDataHandler charhndl)

</pre>

typedef void

-(*XML_CharacterDataHandler)(void *userData,

- const XML_Char *s,

- int len);

+(XMLCALL *XML_CharacterDataHandler)(void *userData,

+ const XML_Char *s,

+ int len);

</pre>

<p>Set a text handler. The string your handler receives

is <em>NOT nul-terminated</em>. You have to use the length argument

@@ -877,14 +1293,15 @@ be split across calls to this handler.</p>

+void XMLCALL

XML_SetProcessingInstructionHandler(XML_Parser p,

XML_ProcessingInstructionHandler proc)

</pre>

typedef void

-(*XML_ProcessingInstructionHandler)(void *userData,

- const XML_Char *target,

- const XML_Char *data);

+(XMLCALL *XML_ProcessingInstructionHandler)(void *userData,

+ const XML_Char *target,

+ const XML_Char *data);

</pre>

<p>Set a handler for processing instructions. The target is the first word

@@ -894,13 +1311,14 @@ it after skipping all whitespace after the initial word.</p>

+void XMLCALL

XML_SetCommentHandler(XML_Parser p,

XML_CommentHandler cmnt)

</pre>

typedef void

-(*XML_CommentHandler)(void *userData,

- const XML_Char *data);

+(XMLCALL *XML_CommentHandler)(void *userData,

+ const XML_Char *data);

</pre>

<p>Set a handler for comments. The data is all text inside the comment

delimiters.</p>

@@ -908,30 +1326,33 @@ delimiters.</p>

+void XMLCALL

XML_SetStartCdataSectionHandler(XML_Parser p,

XML_StartCdataSectionHandler start);

</pre>

typedef void

-(*XML_StartCdataSectionHandler)(void *userData);

+(XMLCALL *XML_StartCdataSectionHandler)(void *userData);

</pre>

<p>Set a handler that gets called at the beginning of a CDATA section.</p>

</div>

+void XMLCALL

XML_SetEndCdataSectionHandler(XML_Parser p,

XML_EndCdataSectionHandler end);

</pre>

typedef void

-(*XML_EndCdataSectionHandler)(void *userData);

+(XMLCALL *XML_EndCdataSectionHandler)(void *userData);

</pre>

<p>Set a handler that gets called at the end of a CDATA section.</p>

</div>

+void XMLCALL

XML_SetCdataSectionHandler(XML_Parser p,

XML_StartCdataSectionHandler start,

XML_EndCdataSectionHandler end)

@@ -941,14 +1362,15 @@ XML_SetCdataSectionHandler(XML_Parser p,

+void XMLCALL

XML_SetDefaultHandler(XML_Parser p,

XML_DefaultHandler hndl)

</pre>

typedef void

-(*XML_DefaultHandler)(void *userData,

- const XML_Char *s,

- int len);

+(XMLCALL *XML_DefaultHandler)(void *userData,

+ const XML_Char *s,

+ int len);

</pre>

<p>Sets a handler for any characters in the document which wouldn't

@@ -971,14 +1393,15 @@ href="#XML_DefaultCurrent">XML_DefaultCurrent</a></code>.</p>

+void XMLCALL

XML_SetDefaultHandlerExpand(XML_Parser p,

XML_DefaultHandler hndl)

</pre>

typedef void

-(*XML_DefaultHandler)(void *userData,

- const XML_Char *s,

- int len);

+(XMLCALL *XML_DefaultHandler)(void *userData,

+ const XML_Char *s,

+ int len);

</pre>

<p>This sets a default handler, but doesn't inhibit the expansion of

internal entity references. The entity reference will not be passed

@@ -990,16 +1413,17 @@ href="#XML_DefaultCurrent">XML_DefaultCurrent</a></code>.</p>

+void XMLCALL

XML_SetExternalEntityRefHandler(XML_Parser p,

XML_ExternalEntityRefHandler hndl)

</pre>

typedef int

-(*XML_ExternalEntityRefHandler)(XML_Parser p,

- const XML_Char *context,

- const XML_Char *base,

- const XML_Char *systemId,

- const XML_Char *publicId);

+(XMLCALL *XML_ExternalEntityRefHandler)(XML_Parser p,

+ const XML_Char *context,

+ const XML_Char *base,

+ const XML_Char *systemId,

+ const XML_Char *publicId);

</pre>

<p>Set an external entity reference handler. This handler is also

called for processing an external DTD subset if parameter entity parsing

@@ -1042,6 +1466,7 @@ information into global or static variables.</p>

</div>

+void XMLCALL

XML_SetExternalEntityRefHandlerArg(XML_Parser p,

void *arg)

</pre>

@@ -1067,14 +1492,15 @@ properly.</p>

+void XMLCALL

XML_SetSkippedEntityHandler(XML_Parser p,

XML_SkippedEntityHandler handler)

</pre>

typedef void

-(*XML_SkippedEntityHandler)(void *userData,

- const XML_Char *entityName,

- int is_parameter_entity);

+(XMLCALL *XML_SkippedEntityHandler)(void *userData,

+ const XML_Char *entityName,

+ int is_parameter_entity);

</pre>

<p>Set a skipped entity handler. This is called in two situations:</p>

<ol>

@@ -1093,21 +1519,22 @@ sync with the reporting of the declarations or attribute values</p>

+void XMLCALL

XML_SetUnknownEncodingHandler(XML_Parser p,

XML_UnknownEncodingHandler enchandler,

void *encodingHandlerData)

</pre>

typedef int

-(*XML_UnknownEncodingHandler)(void *encodingHandlerData,

- const XML_Char *name,

- XML_Encoding *info);

+(XMLCALL *XML_UnknownEncodingHandler)(void *encodingHandlerData,

+ const XML_Char *name,

+ XML_Encoding *info);

typedef struct {

int map[256];

void *data;

- int (*convert)(void *data, const char *s);

- void (*release)(void *data);

+ int (XMLCALL *convert)(void *data, const char *s);

+ void (XMLCALL *release)(void *data);

} XML_Encoding;

</pre>

<p>Set a handler to deal with encodings other than the <a

@@ -1116,8 +1543,8 @@ href="#builtin_encodings">built in set</a>. This should be done before

"#XML_ParseBuffer" >XML_ParseBuffer</a></code> have been called on the

given parser.</p> <p>If the handler knows how to deal with an encoding

with the given name, it should fill in the <code>info</code> data

-structure and return <code>XML_STATUS_ERROR</code>. Otherwise it

-should return <code>XML_STATUS_OK</code>. The handler will be called

+structure and return <code>XML_STATUS_OK</code>. Otherwise it

+should return <code>XML_STATUS_ERROR</code>. The handler will be called

at most once per parsed (external) entity. The optional application

data pointer <code>encodingHandlerData</code> will be passed back to

the handler.</p>

@@ -1141,76 +1568,61 @@ parser when it is finished with the encoding. It may be NULL.</p>

+void XMLCALL

XML_SetStartNamespaceDeclHandler(XML_Parser p,

XML_StartNamespaceDeclHandler start);

</pre>

typedef void

-(*XML_StartNamespaceDeclHandler)(void *userData,

- const XML_Char *prefix,

- const XML_Char *uri);

+(XMLCALL *XML_StartNamespaceDeclHandler)(void *userData,

+ const XML_Char *prefix,

+ const XML_Char *uri);

</pre>

<p>Set a handler to be called when a namespace is declared. Namespace

declarations occur inside start tags. But the namespace declaration start

handler is called before the start tag handler for each namespace declared

in that start tag.</p>

-<p><strong>Note:</strong>

-Due to limitations of the implementation, the

-StartNamespaceDeclHandler is not called unless the StartElementHandler

-is also set. The specific value of the StartElementHandler is allowed

-to change freely, so long as it is not NULL.</p>

</div>

+void XMLCALL

XML_SetEndNamespaceDeclHandler(XML_Parser p,

XML_EndNamespaceDeclHandler end);

</pre>

typedef void

-(*XML_EndNamespaceDeclHandler)(void *userData,

- const XML_Char *prefix);

+(XMLCALL *XML_EndNamespaceDeclHandler)(void *userData,

+ const XML_Char *prefix);

</pre>

<p>Set a handler to be called when leaving the scope of a namespace

declaration. This will be called, for each namespace declaration,

after the handler for the end tag of the element in which the

namespace was declared.</p>

-<p><strong>Note:</strong>

-Due to limitations of the implementation, the EndNamespaceDeclHandler

-is not called unless the StartElementHandler is also set. The

-specific value of the StartElementHandler is allowed to change freely,

-so long as it is not NULL.</p>

</div>

+void XMLCALL

XML_SetNamespaceDeclHandler(XML_Parser p,

XML_StartNamespaceDeclHandler start,

XML_EndNamespaceDeclHandler end)

</pre>

<p>Sets both namespace declaration handlers with a single call.</p>

-<p><strong>Note:</strong>

-Due to limitations of the implementation, the

-StartNamespaceDeclHandler and EndNamespaceDeclHandler are not called

-unless the StartElementHandler is also set. The specific value of the

-StartElementHandler is allowed to change freely, so long as it is not

-NULL.</p>

</div>

+void XMLCALL

XML_SetXmlDeclHandler(XML_Parser p,

XML_XmlDeclHandler xmldecl);

</pre>

typedef void

-(*XML_XmlDeclHandler) (void *userData,

- const XML_Char *version,

- const XML_Char *encoding,

- int standalone);

+(XMLCALL *XML_XmlDeclHandler)(void *userData,

+ const XML_Char *version,

+ const XML_Char *encoding,

+ int standalone);

</pre>

<p>Sets a handler that is called for XML declarations and also for

text declarations discovered in external entities. The way to

@@ -1224,16 +1636,17 @@ that it was given as yes.</p>

+void XMLCALL

XML_SetStartDoctypeDeclHandler(XML_Parser p,

XML_StartDoctypeDeclHandler start);

</pre>

typedef void

-(*XML_StartDoctypeDeclHandler)(void *userData,

- const XML_Char *doctypeName,

- const XML_Char *sysid,

- const XML_Char *pubid,

- int has_internal_subset);

+(XMLCALL *XML_StartDoctypeDeclHandler)(void *userData,

+ const XML_Char *doctypeName,

+ const XML_Char *sysid,

+ const XML_Char *pubid,

+ int has_internal_subset);

</pre>

<p>Set a handler that is called at the start of a DOCTYPE declaration,

before any external or internal subset is parsed. Both <code>sysid</code>

@@ -1243,12 +1656,13 @@ will be non-zero if the DOCTYPE declaration has an internal subset.</p>

+void XMLCALL

XML_SetEndDoctypeDeclHandler(XML_Parser p,

XML_EndDoctypeDeclHandler end);

</pre>

typedef void

-(*XML_EndDoctypeDeclHandler)(void *userData);

+(XMLCALL *XML_EndDoctypeDeclHandler)(void *userData);

</pre>

<p>Set a handler that is called at the end of a DOCTYPE declaration,

after parsing any external subset.</p>

@@ -1256,6 +1670,7 @@ after parsing any external subset.</p>

+void XMLCALL

XML_SetDoctypeDeclHandler(XML_Parser p,

XML_StartDoctypeDeclHandler start,

XML_EndDoctypeDeclHandler end);

@@ -1265,14 +1680,15 @@ XML_SetDoctypeDeclHandler(XML_Parser p,

+void XMLCALL

XML_SetElementDeclHandler(XML_Parser p,

XML_ElementDeclHandler eldecl);

</pre>

typedef void

-(*XML_ElementDeclHandler)(void *userData,

- const XML_Char *name,

- XML_Content *model);

+(XMLCALL *XML_ElementDeclHandler)(void *userData,

+ const XML_Char *name,

+ XML_Content *model);

</pre>

enum XML_Content_Type {

@@ -1336,17 +1752,18 @@ or sequence and <code>children</code> points to the nodes.</p>

+void XMLCALL

XML_SetAttlistDeclHandler(XML_Parser p,

XML_AttlistDeclHandler attdecl);

</pre>

typedef void

-(*XML_AttlistDeclHandler) (void *userData,

- const XML_Char *elname,

- const XML_Char *attname,

- const XML_Char *att_type,

- const XML_Char *dflt,

- int isrequired);

+(XMLCALL *XML_AttlistDeclHandler)(void *userData,

+ const XML_Char *elname,

+ const XML_Char *attname,

+ const XML_Char *att_type,

+ const XML_Char *dflt,

+ int isrequired);

</pre>

<p>Set a handler for attlist declarations in the DTD. This handler is

called for <em>each</em> attribute. So a single attlist declaration

@@ -1368,20 +1785,21 @@ in the <code>dflt</code> parameter.</p>

+void XMLCALL

XML_SetEntityDeclHandler(XML_Parser p,

XML_EntityDeclHandler handler);

</pre>

typedef void

-(*XML_EntityDeclHandler) (void *userData,

- const XML_Char *entityName,

- int is_parameter_entity,

- const XML_Char *value,

- int value_length,

- const XML_Char *base,

- const XML_Char *systemId,

- const XML_Char *publicId,

- const XML_Char *notationName);

+(XMLCALL *XML_EntityDeclHandler)(void *userData,

+ const XML_Char *entityName,

+ int is_parameter_entity,

+ const XML_Char *value,

+ int value_length,

+ const XML_Char *base,

+ const XML_Char *systemId,

+ const XML_Char *publicId,

+ const XML_Char *notationName);

</pre>

<p>Sets a handler that will be called for all entity declarations.

The <code>is_parameter_entity</code> argument will be non-zero in the

@@ -1401,17 +1819,18 @@ declarations.</p>

+void XMLCALL

XML_SetUnparsedEntityDeclHandler(XML_Parser p,

XML_UnparsedEntityDeclHandler h)

</pre>

typedef void

-(*XML_UnparsedEntityDeclHandler)(void *userData,

- const XML_Char *entityName,

- const XML_Char *base,

- const XML_Char *systemId,

- const XML_Char *publicId,

- const XML_Char *notationName);

+(XMLCALL *XML_UnparsedEntityDeclHandler)(void *userData,

+ const XML_Char *entityName,

+ const XML_Char *base,

+ const XML_Char *systemId,

+ const XML_Char *publicId,

+ const XML_Char *notationName);

</pre>

<p>Set a handler that receives declarations of unparsed entities. These

are entity declarations that have a notation (NDATA) field:</p>

@@ -1426,28 +1845,30 @@ compatibility. Use instead <a href= "#XML_SetEntityDeclHandler"

+void XMLCALL

XML_SetNotationDeclHandler(XML_Parser p,

XML_NotationDeclHandler h)

</pre>

typedef void

-(*XML_NotationDeclHandler)(void *userData,

- const XML_Char *notationName,

- const XML_Char *base,

- const XML_Char *systemId,

- const XML_Char *publicId);

+(XMLCALL *XML_NotationDeclHandler)(void *userData,

+ const XML_Char *notationName,

+ const XML_Char *base,

+ const XML_Char *systemId,

+ const XML_Char *publicId);

</pre>

<p>Set a handler that receives notation declarations.</p>

</div>

+void XMLCALL

XML_SetNotStandaloneHandler(XML_Parser p,

XML_NotStandaloneHandler h)

</pre>

typedef int

-(*XML_NotStandaloneHandler)(void *userData);

+(XMLCALL *XML_NotStandaloneHandler)(void *userData);

</pre>

<p>Set a handler that is called if the document is not "standalone".

This happens when there is an external subset or a reference to a

@@ -1461,18 +1882,22 @@ error.</p>

<p>These are the functions you'll want to call when the parse

functions return <code>XML_STATUS_ERROR</code> (a parse error has

-ocurred), although the position reporting functions are useful outside

+occurred), although the position reporting functions are useful outside

of errors. The position reported is the byte position (in the original

document or entity encoding) of the first of the sequence of

characters that generated the current event (or the error that caused

-the parse functions to return <code>XML_STATUS_ERROR</code>.)</p>

+the parse functions to return <code>XML_STATUS_ERROR</code>.) The

+exceptions are callbacks trigged by declarations in the document

+prologue, in which case they exact position reported is somewhere in the

+relevant markup, but not necessarily as meaningful as for other

+events.</p>

<p>The position reporting functions are accurate only outside of the

DTD. In other words, they usually return bogus information when

called from within a DTD declaration handler.</p>

-enum XML_Error

+enum XML_Error XMLCALL

XML_GetErrorCode(XML_Parser p);

</pre>

@@ -1480,8 +1905,8 @@ Return what type of error has occurred.

</div>

-const XML_LChar *

-XML_ErrorString(int code);

+const XML_LChar * XMLCALL

+XML_ErrorString(enum XML_Error code);

</pre>

Return a string describing the error corresponding to code.

@@ -1490,23 +1915,27 @@ The code should be one of the enums that can be returned from

</div>

-long

+XML_Index XMLCALL

XML_GetCurrentByteIndex(XML_Parser p);

</pre>

-Return the byte offset of the position.

+Return the byte offset of the position. This always corresponds to

+the values returned by <code><a href= "#XML_GetCurrentLineNumber"

+>XML_GetCurrentLineNumber</a></code> and <code><a href=

+"#XML_GetCurrentColumnNumber" >XML_GetCurrentColumnNumber</a></code>.

</div>

-int

+XML_Size XMLCALL

XML_GetCurrentLineNumber(XML_Parser p);

</pre>

-Return the line number of the position.

+Return the line number of the position. The first line is reported as

+<code>1</code>.

</div>

-int

+XML_Size XMLCALL

XML_GetCurrentColumnNumber(XML_Parser p);

</pre>

@@ -1515,7 +1944,7 @@ the position.

</div>

-int

+int XMLCALL

XML_GetCurrentByteCount(XML_Parser p);

</pre>

@@ -1527,7 +1956,7 @@ separate start and end tags).

</div>

-const char *

+const char * XMLCALL

XML_GetInputContext(XML_Parser p,

int *offset,

int *size);

@@ -1547,6 +1976,9 @@ untranslated bytes of the input.</p>

<p>Only a limited amount of context is kept, so if the event

triggering a call spans over a very large amount of input, the actual

parse position may be before the beginning of the buffer.</p>

+<p>If <code>XML_CONTEXT_BYTES</code> is not defined, this will always

+return NULL.</p>

</div>

<h3><a name="miscellaneous">Miscellaneous functions</a></h3>

@@ -1555,7 +1987,7 @@ parse position may be before the beginning of the buffer.</p>

the parser or can be used to dynamicly set parser options.</p>

-void

+void XMLCALL

XML_SetUserData(XML_Parser p,

void *userData);

</pre>

@@ -1570,7 +2002,7 @@ memory.

</div>

-void *

+void * XMLCALL

XML_GetUserData(XML_Parser p);

</pre>

@@ -1579,7 +2011,7 @@ It is actually implemented as a macro.

</div>

-void

+void XMLCALL

XML_UseParserAsHandlerArg(XML_Parser p);

</pre>

@@ -1590,7 +2022,7 @@ using the <code><a href= "#XML_GetUserData"

</div>

-enum XML_Status

+enum XML_Status XMLCALL

XML_SetBase(XML_Parser p,

const XML_Char *base);

</pre>

@@ -1602,7 +2034,7 @@ there's no memory to store base, otherwise it's

</div>

-const XML_Char *

+const XML_Char * XMLCALL

XML_GetBase(XML_Parser p);

</pre>

@@ -1610,7 +2042,7 @@ Return the base for resolving relative URIs.

</div>

-int

+int XMLCALL

XML_GetSpecifiedAttributeCount(XML_Parser p);

</pre>

@@ -1626,7 +2058,7 @@ means the current call.

</div>

-int

+int XMLCALL

XML_GetIdAttributeIndex(XML_Parser p);

</pre>

@@ -1638,7 +2070,7 @@ current call.

</div>

-enum XML_Status

+enum XML_Status XMLCALL

XML_SetEncoding(XML_Parser p,

const XML_Char *encoding);

</pre>

@@ -1653,7 +2085,7 @@ Returns <code>XML_STATUS_OK</code> on success or

</div>

-int

+int XMLCALL

XML_SetParamEntityParsing(XML_Parser p,

enum XML_ParamEntityParsing code);

</pre>

@@ -1670,7 +2102,7 @@ The choices for <code>code</code> are:

</div>

-enum XML_Error

+enum XML_Error XMLCALL

XML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD);

</pre>

@@ -1699,10 +2131,15 @@ external entity reference handler set via <code><a href=

DTD support, it returns

<code>XML_ERROR_FEATURE_REQUIRES_XML_DTD</code>. Otherwise, it

returns <code>XML_ERROR_NONE</code>.</p>

+<p><b>Note:</b> For the purpose of checking WFC: Entity Declared, passing

+<code>useDTD == XML_TRUE</code> will make the parser behave as if

+the document had a DTD with an external subset. This holds true even if

+the external entity reference handler returns without action.</p>

</div>

-void

+void XMLCALL

XML_SetReturnNSTriplet(XML_Parser parser,

int do_nst);

</pre>

@@ -1724,7 +2161,7 @@ separator.</p>

</div>

-void

+void XMLCALL

XML_DefaultCurrent(XML_Parser parser);

</pre>

@@ -1738,7 +2175,7 @@ not a default handler.

</div>

-XML_LChar *

+XML_LChar * XMLCALL

XML_ExpatVersion();

</pre>

@@ -1746,7 +2183,7 @@ Return the library version as a string (e.g. <code>"expat_1.95.1"</code>).

</div>

-struct XML_Expat_Version

+struct XML_Expat_Version XMLCALL

XML_ExpatVersionInfo();

</pre>

@@ -1770,7 +2207,7 @@ particular parts of the Expat API are available.

</div>

-const XML_Feature *

+const XML_Feature * XMLCALL

XML_GetFeatureList();

</pre>

@@ -1829,7 +2266,7 @@ time, the following features have been defined to have values:</p>

</div>

-void

+void XMLCALL

XML_FreeContentModel(XML_Parser parser, XML_Content *model);

</pre>

@@ -1848,7 +2285,7 @@ libraries which use different C standard libraries (this can happen on

Windows, at least).</p>

-void *

+void * XMLCALL

XML_MemMalloc(XML_Parser parser, size_t size);

</pre>

@@ -1860,7 +2297,7 @@ way must be freed using <code><a href="#XML_MemFree"

</div>

-void *

+void * XMLCALL

XML_MemRealloc(XML_Parser parser, void *ptr, size_t size);

</pre>

@@ -1879,7 +2316,7 @@ original block. Memory allocated in this way must be freed using

</div>

-void

+void XMLCALL

XML_MemFree(XML_Parser parser, void *ptr);

</pre>

@@ -1894,5 +2331,6 @@ have been allocated by <code><a href="#XML_MemMalloc"

src="valid-xhtml10.png" alt="Valid XHTML 1.0!"

height="31" width="88" class="noborder" /></a></p>

-->

+</div>

</body>

</html>

diff --git a/lib/libexpat/doc/style.css b/lib/libexpat/doc/style.css
index 6f4886077ac..69df30bcecb 100644
--- a/lib/libexpat/doc/style.css
+++ b/lib/libexpat/doc/style.css

@@ -1,5 +1,37 @@

body {

- background-color: white

+ background-color: white;

+ border: 0px;

+ margin: 0px;

+ padding: 0px;

+.corner {

+ width: 200px;

+ height: 80px;

+ text-align: center;

+.banner {

+ background-color: rgb(110,139,61);

+ color: rgb(255,236,176);

+ padding-left: 2em;

+.banner h1 {

+ font-size: 200%;

+.content {

+ padding: 0em 2em 1em 2em;

+.releaseno {

+ background-color: rgb(110,139,61);

+ color: rgb(255,236,176);

+ padding-bottom: 0.3em;

+ padding-top: 0.5em;

+ text-align: center;

+ font-weight: bold;

}

.noborder {

@@ -17,6 +49,17 @@ body {

margin-right: 10%;

}

+.pseudocode {

+ padding-left: 1em;

+ padding-top: .5em;

+ padding-bottom: .5em;

+ border: solid thin;

+ margin: 1em 0;

+ background-color: rgb(250,220,180);

+ margin-left: 2em;

+ margin-right: 10%;

.handler {

width: 100%;

border-top-width: thin;

@@ -49,3 +92,10 @@ body {

dd {

margin-bottom: 2em;

}

+.cpp-symbols dt {

+ font-family: monospace;

+.cpp-symbols dd {

+ margin-bottom: 1em;

diff --git a/lib/libexpat/examples/elements.c b/lib/libexpat/examples/elements.c
index 4ed4da6a346..421a1ce7793 100644
--- a/lib/libexpat/examples/elements.c
+++ b/lib/libexpat/examples/elements.c

@@ -2,31 +2,48 @@

reads an XML document from standard input and writes a line with

the name of each element to standard output indenting child

elements by one tab stop more than their parent element.

+ It must be used with Expat compiled for UTF-8 output.

#include <stdio.h>

#include "expat.h"

-static void

+#ifdef XML_LARGE_SIZE

+#if defined(XML_USE_MSC_EXTENSIONS) && _MSC_VER < 1400

+#define XML_FMT_INT_MOD "I64"

+#else

+#define XML_FMT_INT_MOD "ll"

+#endif

+#else

+#define XML_FMT_INT_MOD "l"

+#endif

+static void XMLCALL

startElement(void *userData, const char *name, const char **atts)

{

int i;

- int *depthPtr = userData;

+ int *depthPtr = (int *)userData;

for (i = 0; i < *depthPtr; i++)

putchar('\t');

puts(name);

*depthPtr += 1;

}

-static void

+static void XMLCALL

endElement(void *userData, const char *name)

{

- int *depthPtr = userData;

+ int *depthPtr = (int *)userData;

*depthPtr -= 1;

}

+#ifdef AMIGA_SHARED_LIB

+#include <proto/expat.h>

+int

+amiga_main(int argc, char *argv[])

+#else

int

main(int argc, char *argv[])

+#endif

{

char buf[BUFSIZ];

XML_Parser parser = XML_ParserCreate(NULL);

@@ -39,7 +56,7 @@ main(int argc, char *argv[])

done = len < sizeof(buf);

if (XML_Parse(parser, buf, len, done) == XML_STATUS_ERROR) {

fprintf(stderr,

- "%s at line %d\n",

+ "%s at line %" XML_FMT_INT_MOD "u\n",

XML_ErrorString(XML_GetErrorCode(parser)),

XML_GetCurrentLineNumber(parser));

return 1;

diff --git a/lib/libexpat/examples/outline.c b/lib/libexpat/examples/outline.c
index 10f6d1db5b8..807ddb89e03 100644
--- a/lib/libexpat/examples/outline.c
+++ b/lib/libexpat/examples/outline.c

@@ -18,19 +18,30 @@

* Read an XML document from standard input and print an element

* outline on standard output.

+ * Must be used with Expat compiled for UTF-8 output.

#include <stdio.h>

#include <expat.h>

+#ifdef XML_LARGE_SIZE

+#if defined(XML_USE_MSC_EXTENSIONS) && _MSC_VER < 1400

+#define XML_FMT_INT_MOD "I64"

+#else

+#define XML_FMT_INT_MOD "ll"

+#endif

+#else

+#define XML_FMT_INT_MOD "l"

+#endif

#define BUFFSIZE 8192

char Buff[BUFFSIZE];

int Depth;

-static void

+static void XMLCALL

start(void *data, const char *el, const char **attr)

{

int i;

@@ -48,14 +59,20 @@ start(void *data, const char *el, const char **attr)

Depth++;

}

-static void

+static void XMLCALL

end(void *data, const char *el)

{

Depth--;

}

+#ifdef AMIGA_SHARED_LIB

+#include <proto/expat.h>

+int

+amiga_main(int argc, char *argv[])

+#else

int

main(int argc, char *argv[])

+#endif

{

XML_Parser p = XML_ParserCreate(NULL);

if (! p) {

@@ -77,7 +94,7 @@ main(int argc, char *argv[])

done = feof(stdin);

if (XML_Parse(p, Buff, len, done) == XML_STATUS_ERROR) {

- fprintf(stderr, "Parse error at line %d:\n%s\n",

+ fprintf(stderr, "Parse error at line %" XML_FMT_INT_MOD "u:\n%s\n",

XML_GetCurrentLineNumber(p),

XML_ErrorString(XML_GetErrorCode(p)));

exit(-1);

diff --git a/lib/libexpat/lib/amigaconfig.h b/lib/libexpat/lib/amigaconfig.h
new file mode 100644
index 00000000000..6781a714a6b
--- /dev/null
+++ b/lib/libexpat/lib/amigaconfig.h

@@ -0,0 +1,96 @@

+#ifndef AMIGACONFIG_H

+#define AMIGACONFIG_H

+/* 1234 = LIL_ENDIAN, 4321 = BIGENDIAN */

+#define BYTEORDER 4321

+/* Define to 1 if you have the `bcopy' function. */

+#define HAVE_BCOPY 1

+/* Define to 1 if you have the <check.h> header file. */

+#undef HAVE_CHECK_H

+/* Define to 1 if you have the <dlfcn.h> header file. */

+#undef HAVE_DLFCN_H

+/* Define to 1 if you have the <fcntl.h> header file. */

+#define HAVE_FCNTL_H 1

+/* Define to 1 if you have the `getpagesize' function. */

+#undef HAVE_GETPAGESIZE

+/* Define to 1 if you have the <inttypes.h> header file. */

+#define HAVE_INTTYPES_H 1

+/* Define to 1 if you have the `memmove' function. */

+#define HAVE_MEMMOVE 1

+/* Define to 1 if you have the <memory.h> header file. */

+#undef HAVE_MEMORY_H

+/* Define to 1 if you have a working `mmap' system call. */

+#undef HAVE_MMAP

+/* Define to 1 if you have the <stdint.h> header file. */

+#define HAVE_STDINT_H 1

+/* Define to 1 if you have the <stdlib.h> header file. */

+#define HAVE_STDLIB_H 1

+/* Define to 1 if you have the <strings.h> header file. */

+#define HAVE_STRINGS_H 1

+/* Define to 1 if you have the <string.h> header file. */

+#define HAVE_STRING_H 1

+/* Define to 1 if you have the <sys/stat.h> header file. */

+#define HAVE_SYS_STAT_H 1

+/* Define to 1 if you have the <sys/types.h> header file. */

+#define HAVE_SYS_TYPES_H 1

+/* Define to 1 if you have the <unistd.h> header file. */

+#define HAVE_UNISTD_H 1

+/* Define to the address where bug reports for this package should be sent. */

+#define PACKAGE_BUGREPORT "expat-bugs@mail.libexpat.org"

+/* Define to the full name of this package. */

+#define PACKAGE_NAME "expat"

+/* Define to the full name and version of this package. */

+#define PACKAGE_STRING "expat 1.95.8"

+/* Define to the one symbol short name of this package. */

+#undef PACKAGE_TARNAME

+/* Define to the version of this package. */

+#define PACKAGE_VERSION "1.95.8"

+/* Define to 1 if you have the ANSI C header files. */

+#define STDC_HEADERS 1

+/* whether byteorder is bigendian */

+#define WORDS_BIGENDIAN

+/* Define to specify how much context to retain around the current parse

+ point. */

+#define XML_CONTEXT_BYTES 1024

+/* Define to make parameter entity parsing functionality available. */

+#define XML_DTD

+/* Define to make XML Namespaces functionality available. */

+#define XML_NS

+/* Define to empty if `const' does not conform to ANSI C. */

+#undef const

+/* Define to `long' if <sys/types.h> does not define. */

+#undef off_t

+/* Define to `unsigned' if <sys/types.h> does not define. */

+#undef size_t

+#endif /* AMIGACONFIG_H */

diff --git a/lib/libexpat/lib/expat.h b/lib/libexpat/lib/expat.h
index 5322bea77e3..cf113eeaf24 100644
--- a/lib/libexpat/lib/expat.h
+++ b/lib/libexpat/lib/expat.h

@@ -2,8 +2,8 @@

See the file COPYING for copying permission.

-#ifndef XmlParse_INCLUDED

-#define XmlParse_INCLUDED 1

+#ifndef Expat_INCLUDED

+#define Expat_INCLUDED 1

#ifdef __VMS

/* 0 1 2 3 0 1 2 3

@@ -15,43 +15,15 @@

#endif

#include <stdlib.h>

-#ifndef XMLPARSEAPI

-#if defined(_MSC_EXTENSIONS) && !defined(__BEOS__) && !defined(__CYGWIN__)

-#ifdef XML_STATIC

-#define XMLPARSEAPI(type) type __cdecl

-#else

-#define XMLPARSEAPI(type) __declspec(dllimport) type __cdecl

-#endif

-#else

-#define XMLPARSEAPI(type) type

-#endif

-#endif /* not defined XMLPARSEAPI */

+#include "expat_external.h"

#ifdef __cplusplus

extern "C" {

#endif

-#ifdef XML_UNICODE_WCHAR_T

-#define XML_UNICODE

-#endif

struct XML_ParserStruct;

typedef struct XML_ParserStruct *XML_Parser;

-#ifdef XML_UNICODE /* Information is UTF-16 encoded. */

-#ifdef XML_UNICODE_WCHAR_T

-typedef wchar_t XML_Char;

-typedef wchar_t XML_LChar;

-#else

-typedef unsigned short XML_Char;

-typedef char XML_LChar;

-#endif /* XML_UNICODE_WCHAR_T */

-#else /* Information is UTF-8 encoded. */

-typedef char XML_Char;

-typedef char XML_LChar;

-#endif /* XML_UNICODE */

/* Should this be defined using stdbool.h when C99 is available? */

typedef unsigned char XML_Bool;

#define XML_TRUE ((XML_Bool) 1)

@@ -73,8 +45,10 @@ typedef unsigned char XML_Bool;

enum XML_Status {

XML_STATUS_ERROR = 0,

#define XML_STATUS_ERROR XML_STATUS_ERROR

- XML_STATUS_OK = 1

+ XML_STATUS_OK = 1,

#define XML_STATUS_OK XML_STATUS_OK

+ XML_STATUS_SUSPENDED = 2

+#define XML_STATUS_SUSPENDED XML_STATUS_SUSPENDED

};

enum XML_Error {

@@ -104,7 +78,24 @@ enum XML_Error {

XML_ERROR_UNEXPECTED_STATE,

XML_ERROR_ENTITY_DECLARED_IN_PE,

XML_ERROR_FEATURE_REQUIRES_XML_DTD,

- XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING

+ XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING,

+ /* Added in 1.95.7. */

+ XML_ERROR_UNBOUND_PREFIX,

+ /* Added in 1.95.8. */

+ XML_ERROR_UNDECLARING_PREFIX,

+ XML_ERROR_INCOMPLETE_PE,

+ XML_ERROR_XML_DECL,

+ XML_ERROR_TEXT_DECL,

+ XML_ERROR_PUBLICID,

+ XML_ERROR_SUSPENDED,

+ XML_ERROR_NOT_SUSPENDED,

+ XML_ERROR_ABORTED,

+ XML_ERROR_FINISHED,

+ XML_ERROR_SUSPEND_PE,

+ /* Added in 2.0. */

+ XML_ERROR_RESERVED_PREFIX_XML,

+ XML_ERROR_RESERVED_PREFIX_XMLNS,

+ XML_ERROR_RESERVED_NAMESPACE_URI

};

enum XML_Content_Type {

@@ -156,9 +147,9 @@ struct XML_cp {

description of the model argument. It's the caller's responsibility

to free model when finished with it.

-typedef void (*XML_ElementDeclHandler) (void *userData,

- const XML_Char *name,

- XML_Content *model);

+typedef void (XMLCALL *XML_ElementDeclHandler) (void *userData,

+ const XML_Char *name,

+ XML_Content *model);

XMLPARSEAPI(void)

XML_SetElementDeclHandler(XML_Parser parser,

@@ -172,12 +163,13 @@ XML_SetElementDeclHandler(XML_Parser parser,

value will be NULL in the case of "#REQUIRED". If "isrequired" is

true and default is non-NULL, then this is a "#FIXED" default.

-typedef void (*XML_AttlistDeclHandler) (void *userData,

- const XML_Char *elname,

- const XML_Char *attname,

- const XML_Char *att_type,

- const XML_Char *dflt,

- int isrequired);

+typedef void (XMLCALL *XML_AttlistDeclHandler) (

+ void *userData,

+ const XML_Char *elname,

+ const XML_Char *attname,

+ const XML_Char *att_type,

+ const XML_Char *dflt,

+ int isrequired);

XMLPARSEAPI(void)

XML_SetAttlistDeclHandler(XML_Parser parser,

@@ -191,10 +183,10 @@ XML_SetAttlistDeclHandler(XML_Parser parser,

was no standalone parameter in the declaration, that it was given

as no, or that it was given as yes.

-typedef void (*XML_XmlDeclHandler) (void *userData,

- const XML_Char *version,

- const XML_Char *encoding,

- int standalone);

+typedef void (XMLCALL *XML_XmlDeclHandler) (void *userData,

+ const XML_Char *version,

+ const XML_Char *encoding,

+ int standalone);

XMLPARSEAPI(void)

XML_SetXmlDeclHandler(XML_Parser parser,

@@ -221,8 +213,8 @@ XML_ParserCreate(const XML_Char *encoding);

URI, the namespace separator character, and the local part of the

name. If the namespace separator is '\0' then the namespace URI

and the local part will be concatenated without any separator.

- When a namespace is not declared, the name and prefix will be

- passed through without expansion.

+ It is a programming error to use the separator '\0' with namespace

+ triplets (see XML_SetReturnNSTriplet).

XMLPARSEAPI(XML_Parser)

XML_ParserCreateNS(const XML_Char *encoding, XML_Char namespaceSeparator);

@@ -257,29 +249,31 @@ XML_ParserReset(XML_Parser parser, const XML_Char *encoding);

/* atts is array of name/value pairs, terminated by 0;

names and values are 0 terminated.

-typedef void (*XML_StartElementHandler)(void *userData,

- const XML_Char *name,

- const XML_Char **atts);

+typedef void (XMLCALL *XML_StartElementHandler) (void *userData,

+ const XML_Char *name,

+ const XML_Char **atts);

-typedef void (*XML_EndElementHandler)(void *userData,

- const XML_Char *name);

+typedef void (XMLCALL *XML_EndElementHandler) (void *userData,

+ const XML_Char *name);

/* s is not 0 terminated. */

-typedef void (*XML_CharacterDataHandler)(void *userData,

- const XML_Char *s,

- int len);

+typedef void (XMLCALL *XML_CharacterDataHandler) (void *userData,

+ const XML_Char *s,

+ int len);

/* target and data are 0 terminated */

-typedef void (*XML_ProcessingInstructionHandler)(void *userData,

- const XML_Char *target,

- const XML_Char *data);

+typedef void (XMLCALL *XML_ProcessingInstructionHandler) (

+ void *userData,

+ const XML_Char *target,

+ const XML_Char *data);

/* data is 0 terminated */

-typedef void (*XML_CommentHandler)(void *userData, const XML_Char *data);

+typedef void (XMLCALL *XML_CommentHandler) (void *userData,

+ const XML_Char *data);

-typedef void (*XML_StartCdataSectionHandler)(void *userData);

-typedef void (*XML_EndCdataSectionHandler)(void *userData);

+typedef void (XMLCALL *XML_StartCdataSectionHandler) (void *userData);

+typedef void (XMLCALL *XML_EndCdataSectionHandler) (void *userData);

/* This is called for any characters in the XML document for which

there is no applicable handler. This includes both characters that

@@ -294,14 +288,15 @@ typedef void (*XML_EndCdataSectionHandler)(void *userData);

default handler: for example, a comment might be split between

multiple calls.

-typedef void (*XML_DefaultHandler)(void *userData,

- const XML_Char *s,

- int len);

+typedef void (XMLCALL *XML_DefaultHandler) (void *userData,

+ const XML_Char *s,

+ int len);

/* This is called for the start of the DOCTYPE declaration, before

any DTD or internal subset is parsed.

-typedef void (*XML_StartDoctypeDeclHandler)(void *userData,

+typedef void (XMLCALL *XML_StartDoctypeDeclHandler) (

+ void *userData,

const XML_Char *doctypeName,

const XML_Char *sysid,

const XML_Char *pubid,

@@ -311,7 +306,7 @@ typedef void (*XML_StartDoctypeDeclHandler)(void *userData,

closing > is encountered, but after processing any external

subset.

-typedef void (*XML_EndDoctypeDeclHandler)(void *userData);

+typedef void (XMLCALL *XML_EndDoctypeDeclHandler)(void *userData);

/* This is called for entity declarations. The is_parameter_entity

argument will be non-zero if the entity is a parameter entity, zero

@@ -331,15 +326,16 @@ typedef void (*XML_EndDoctypeDeclHandler)(void *userData);

Note that is_parameter_entity can't be changed to XML_Bool, since

that would break binary compatibility.

-typedef void (*XML_EntityDeclHandler) (void *userData,

- const XML_Char *entityName,

- int is_parameter_entity,

- const XML_Char *value,

- int value_length,

- const XML_Char *base,

- const XML_Char *systemId,

- const XML_Char *publicId,

- const XML_Char *notationName);

+typedef void (XMLCALL *XML_EntityDeclHandler) (

+ void *userData,

+ const XML_Char *entityName,

+ int is_parameter_entity,

+ const XML_Char *value,

+ int value_length,

+ const XML_Char *base,

+ const XML_Char *systemId,

+ const XML_Char *publicId,

+ const XML_Char *notationName);

XMLPARSEAPI(void)

XML_SetEntityDeclHandler(XML_Parser parser,

@@ -354,22 +350,24 @@ XML_SetEntityDeclHandler(XML_Parser parser,

entityName, systemId and notationName arguments will never be

NULL. The other arguments may be.

-typedef void (*XML_UnparsedEntityDeclHandler)(void *userData,

- const XML_Char *entityName,

- const XML_Char *base,

- const XML_Char *systemId,

- const XML_Char *publicId,

- const XML_Char *notationName);

+typedef void (XMLCALL *XML_UnparsedEntityDeclHandler) (

+ void *userData,

+ const XML_Char *entityName,

+ const XML_Char *base,

+ const XML_Char *systemId,

+ const XML_Char *publicId,

+ const XML_Char *notationName);

/* This is called for a declaration of notation. The base argument is

whatever was set by XML_SetBase. The notationName will never be

NULL. The other arguments can be.

-typedef void (*XML_NotationDeclHandler)(void *userData,

- const XML_Char *notationName,

- const XML_Char *base,

- const XML_Char *systemId,

- const XML_Char *publicId);

+typedef void (XMLCALL *XML_NotationDeclHandler) (

+ void *userData,

+ const XML_Char *notationName,

+ const XML_Char *base,

+ const XML_Char *systemId,

+ const XML_Char *publicId);

/* When namespace processing is enabled, these are called once for

each namespace declaration. The call to the start and end element

@@ -377,12 +375,14 @@ typedef void (*XML_NotationDeclHandler)(void *userData,

declaration handlers. For an xmlns attribute, prefix will be

NULL. For an xmlns="" attribute, uri will be NULL.

-typedef void (*XML_StartNamespaceDeclHandler)(void *userData,

- const XML_Char *prefix,

- const XML_Char *uri);

+typedef void (XMLCALL *XML_StartNamespaceDeclHandler) (

+ void *userData,

+ const XML_Char *prefix,

+ const XML_Char *uri);

-typedef void (*XML_EndNamespaceDeclHandler)(void *userData,

- const XML_Char *prefix);

+typedef void (XMLCALL *XML_EndNamespaceDeclHandler) (

+ void *userData,

+ const XML_Char *prefix);

/* This is called if the document is not standalone, that is, it has an

external subset or a reference to a parameter entity, but does not

@@ -393,7 +393,7 @@ typedef void (*XML_EndNamespaceDeclHandler)(void *userData,

conditions above this handler will only be called if the referenced

entity was actually read.

-typedef int (*XML_NotStandaloneHandler)(void *userData);

+typedef int (XMLCALL *XML_NotStandaloneHandler) (void *userData);

/* This is called for a reference to an external parsed general

entity. The referenced entity is not automatically parsed. The

@@ -429,11 +429,12 @@ typedef int (*XML_NotStandaloneHandler)(void *userData);

Note that unlike other handlers the first argument is the parser,

not userData.

-typedef int (*XML_ExternalEntityRefHandler)(XML_Parser parser,

- const XML_Char *context,

- const XML_Char *base,

- const XML_Char *systemId,

- const XML_Char *publicId);

+typedef int (XMLCALL *XML_ExternalEntityRefHandler) (

+ XML_Parser parser,

+ const XML_Char *context,

+ const XML_Char *base,

+ const XML_Char *systemId,

+ const XML_Char *publicId);

/* This is called in two situations:

1) An entity reference is encountered for which no declaration

@@ -445,9 +446,10 @@ typedef int (*XML_ExternalEntityRefHandler)(XML_Parser parser,

the event would be out of sync with the reporting of the

declarations or attribute values

-typedef void (*XML_SkippedEntityHandler)(void *userData,

- const XML_Char *entityName,

- int is_parameter_entity);

+typedef void (XMLCALL *XML_SkippedEntityHandler) (

+ void *userData,

+ const XML_Char *entityName,

+ int is_parameter_entity);

/* This structure is filled in by the XML_UnknownEncodingHandler to

provide information to the parser about encodings that are unknown

@@ -504,8 +506,8 @@ typedef void (*XML_SkippedEntityHandler)(void *userData,

typedef struct {

int map[256];

void *data;

- int (*convert)(void *data, const char *s);

- void (*release)(void *data);

+ int (XMLCALL *convert)(void *data, const char *s);

+ void (XMLCALL *release)(void *data);

} XML_Encoding;

/* This is called for an encoding that is unknown to the parser.

@@ -523,9 +525,10 @@ typedef struct {

If info does not describe a suitable encoding, then the parser will

return an XML_UNKNOWN_ENCODING error.

-typedef int (*XML_UnknownEncodingHandler)(void *encodingHandlerData,

- const XML_Char *name,

- XML_Encoding *info);

+typedef int (XMLCALL *XML_UnknownEncodingHandler) (

+ void *encodingHandlerData,

+ const XML_Char *name,

+ XML_Encoding *info);

XMLPARSEAPI(void)

XML_SetElementHandler(XML_Parser parser,

@@ -533,10 +536,12 @@ XML_SetElementHandler(XML_Parser parser,

XML_EndElementHandler end);

XMLPARSEAPI(void)

-XML_SetStartElementHandler(XML_Parser, XML_StartElementHandler);

+XML_SetStartElementHandler(XML_Parser parser,

+ XML_StartElementHandler handler);

XMLPARSEAPI(void)

-XML_SetEndElementHandler(XML_Parser, XML_EndElementHandler);

+XML_SetEndElementHandler(XML_Parser parser,

+ XML_EndElementHandler handler);

XMLPARSEAPI(void)

XML_SetCharacterDataHandler(XML_Parser parser,

@@ -625,7 +630,8 @@ XML_SetExternalEntityRefHandler(XML_Parser parser,

instead of the parser object.

XMLPARSEAPI(void)

-XML_SetExternalEntityRefHandlerArg(XML_Parser, void *arg);

+XML_SetExternalEntityRefHandlerArg(XML_Parser parser,

+ void *arg);

XMLPARSEAPI(void)

XML_SetSkippedEntityHandler(XML_Parser parser,

@@ -688,6 +694,9 @@ XML_UseParserAsHandlerArg(XML_Parser parser);

specified in the document. In such a case the parser will call the

externalEntityRefHandler with a value of NULL for the systemId

argument (the publicId and context arguments will be NULL as well).

+ Note: For the purpose of checking WFC: Entity Declared, passing

+ useDTD == XML_TRUE will make the parser behave as if the document

+ had a DTD with an external subset.

Note: If this function is called, then this must be done before

the first call to XML_Parse or XML_ParseBuffer, since it will

have no effect after that. Returns

@@ -751,6 +760,75 @@ XML_GetBuffer(XML_Parser parser, int len);

XMLPARSEAPI(enum XML_Status)

XML_ParseBuffer(XML_Parser parser, int len, int isFinal);

+/* Stops parsing, causing XML_Parse() or XML_ParseBuffer() to return.

+ Must be called from within a call-back handler, except when aborting

+ (resumable = 0) an already suspended parser. Some call-backs may

+ still follow because they would otherwise get lost. Examples:

+ - endElementHandler() for empty elements when stopped in

+ startElementHandler(),

+ - endNameSpaceDeclHandler() when stopped in endElementHandler(),

+ and possibly others.

+ Can be called from most handlers, including DTD related call-backs,

+ except when parsing an external parameter entity and resumable != 0.

+ Returns XML_STATUS_OK when successful, XML_STATUS_ERROR otherwise.

+ Possible error codes:

+ - XML_ERROR_SUSPENDED: when suspending an already suspended parser.

+ - XML_ERROR_FINISHED: when the parser has already finished.

+ - XML_ERROR_SUSPEND_PE: when suspending while parsing an external PE.

+ When resumable != 0 (true) then parsing is suspended, that is,

+ XML_Parse() and XML_ParseBuffer() return XML_STATUS_SUSPENDED.

+ Otherwise, parsing is aborted, that is, XML_Parse() and XML_ParseBuffer()

+ return XML_STATUS_ERROR with error code XML_ERROR_ABORTED.

+ *Note*:

+ This will be applied to the current parser instance only, that is, if

+ there is a parent parser then it will continue parsing when the

+ externalEntityRefHandler() returns. It is up to the implementation of

+ the externalEntityRefHandler() to call XML_StopParser() on the parent

+ parser (recursively), if one wants to stop parsing altogether.

+ When suspended, parsing can be resumed by calling XML_ResumeParser().

+*/

+XMLPARSEAPI(enum XML_Status)

+XML_StopParser(XML_Parser parser, XML_Bool resumable);

+/* Resumes parsing after it has been suspended with XML_StopParser().

+ Must not be called from within a handler call-back. Returns same

+ status codes as XML_Parse() or XML_ParseBuffer().

+ Additional error code XML_ERROR_NOT_SUSPENDED possible.

+ *Note*:

+ This must be called on the most deeply nested child parser instance

+ first, and on its parent parser only after the child parser has finished,

+ to be applied recursively until the document entity's parser is restarted.

+ That is, the parent parser will not resume by itself and it is up to the

+ application to call XML_ResumeParser() on it at the appropriate moment.

+*/

+XMLPARSEAPI(enum XML_Status)

+XML_ResumeParser(XML_Parser parser);

+enum XML_Parsing {

+ XML_INITIALIZED,

+ XML_PARSING,

+ XML_FINISHED,

+ XML_SUSPENDED

+};

+typedef struct {

+ enum XML_Parsing parsing;

+ XML_Bool finalBuffer;

+} XML_ParsingStatus;

+/* Returns status of parser with respect to being initialized, parsing,

+ finished, or suspended and processing the final buffer.

+ XXX XML_Parse() and XML_ParseBuffer() should return XML_ParsingStatus,

+ XXX with XML_FINISHED_OK or XML_FINISHED_ERROR replacing XML_FINISHED

+*/

+XMLPARSEAPI(void)

+XML_GetParsingStatus(XML_Parser parser, XML_ParsingStatus *status);

/* Creates an XML_Parser object that can parse an external general

entity; context is a '\0'-terminated string specifying the parse

context; encoding is a '\0'-terminated string giving the name of

@@ -813,8 +891,13 @@ XML_GetErrorCode(XML_Parser parser);

/* These functions return information about the current parse

location. They may be called from any callback called to report

- some parse event; in this case the location is the location of

- the first of the sequence of characters that generated the event.

+ some parse event; in this case the location is the location of the

+ first of the sequence of characters that generated the event. When

+ called from callbacks generated by declarations in the document

+ prologue, the location identified isn't as neatly defined, but will

+ be within the relevant markup. When called outside of the callback

+ functions, the position indicated will be just past the last parse

+ event (regardless of whether there was an associated callback).

They may also be called after returning from a call to XML_Parse

or XML_ParseBuffer. If the return value is XML_STATUS_ERROR then

@@ -822,9 +905,9 @@ XML_GetErrorCode(XML_Parser parser);

was detected; otherwise the location is the location of the last

parse event, as described above.

-XMLPARSEAPI(int) XML_GetCurrentLineNumber(XML_Parser parser);

-XMLPARSEAPI(int) XML_GetCurrentColumnNumber(XML_Parser parser);

-XMLPARSEAPI(long) XML_GetCurrentByteIndex(XML_Parser parser);

+XMLPARSEAPI(XML_Size) XML_GetCurrentLineNumber(XML_Parser parser);

+XMLPARSEAPI(XML_Size) XML_GetCurrentColumnNumber(XML_Parser parser);

+XMLPARSEAPI(XML_Index) XML_GetCurrentByteIndex(XML_Parser parser);

/* Return the number of bytes in the current event.

Returns 0 if the event is in an internal entity.

@@ -899,7 +982,8 @@ enum XML_FeatureEnum {

XML_FEATURE_CONTEXT_BYTES,

XML_FEATURE_MIN_SIZE,

XML_FEATURE_SIZEOF_XML_CHAR,

- XML_FEATURE_SIZEOF_XML_LCHAR

+ XML_FEATURE_SIZEOF_XML_LCHAR,

+ XML_FEATURE_NS

/* Additional features must be added to the end of this enum. */

};

@@ -918,12 +1002,12 @@ XML_GetFeatureList(void);

releases. Micro is bumped with each release, and set to 0 with each

change to major or minor version.

-#define XML_MAJOR_VERSION 1

-#define XML_MINOR_VERSION 95

-#define XML_MICRO_VERSION 6

+#define XML_MAJOR_VERSION 2

+#define XML_MINOR_VERSION 0

+#define XML_MICRO_VERSION 0

#ifdef __cplusplus

}

#endif

-#endif /* not XmlParse_INCLUDED */

+#endif /* not Expat_INCLUDED */

diff --git a/lib/libexpat/lib/expat_external.h b/lib/libexpat/lib/expat_external.h
new file mode 100644
index 00000000000..8a2d708f146
--- /dev/null
+++ b/lib/libexpat/lib/expat_external.h

@@ -0,0 +1,115 @@

+ See the file COPYING for copying permission.

+*/

+#ifndef Expat_External_INCLUDED

+#define Expat_External_INCLUDED 1

+/* External API definitions */

+#if defined(_MSC_EXTENSIONS) && !defined(__BEOS__) && !defined(__CYGWIN__)

+#define XML_USE_MSC_EXTENSIONS 1

+#endif

+/* Expat tries very hard to make the API boundary very specifically

+ defined. There are two macros defined to control this boundary;

+ each of these can be defined before including this header to

+ achieve some different behavior, but doing so it not recommended or

+ tested frequently.

+ XMLCALL - The calling convention to use for all calls across the

+ "library boundary." This will default to cdecl, and

+ try really hard to tell the compiler that's what we

+ want.

+ XMLIMPORT - Whatever magic is needed to note that a function is

+ to be imported from a dynamically loaded library

+ (.dll, .so, or .sl, depending on your platform).

+ The XMLCALL macro was added in Expat 1.95.7. The only one which is

+ expected to be directly useful in client code is XMLCALL.

+ Note that on at least some Unix versions, the Expat library must be

+ compiled with the cdecl calling convention as the default since

+ system headers may assume the cdecl convention.

+*/

+#ifndef XMLCALL

+#if defined(XML_USE_MSC_EXTENSIONS)

+#define XMLCALL __cdecl

+#elif defined(__GNUC__) && defined(__i386)

+#define XMLCALL __attribute__((cdecl))

+#else

+/* For any platform which uses this definition and supports more than

+ one calling convention, we need to extend this definition to

+ declare the convention used on that platform, if it's possible to

+ do so.

+ If this is the case for your platform, please file a bug report

+ with information on how to identify your platform via the C

+ pre-processor and how to specify the same calling convention as the

+ platform's malloc() implementation.

+*/

+#define XMLCALL

+#endif

+#endif /* not defined XMLCALL */

+#if !defined(XML_STATIC) && !defined(XMLIMPORT)

+#ifndef XML_BUILDING_EXPAT

+/* using Expat from an application */

+#ifdef XML_USE_MSC_EXTENSIONS

+#define XMLIMPORT __declspec(dllimport)

+#endif

+#endif /* not defined XML_STATIC */

+/* If we didn't define it above, define it away: */

+#ifndef XMLIMPORT

+#define XMLIMPORT

+#endif

+#define XMLPARSEAPI(type) XMLIMPORT type XMLCALL

+#ifdef __cplusplus

+extern "C" {

+#endif

+#ifdef XML_UNICODE_WCHAR_T

+#define XML_UNICODE

+#endif

+#ifdef XML_UNICODE /* Information is UTF-16 encoded. */

+#ifdef XML_UNICODE_WCHAR_T

+typedef wchar_t XML_Char;

+typedef wchar_t XML_LChar;

+#else

+typedef unsigned short XML_Char;

+typedef char XML_LChar;

+#endif /* XML_UNICODE_WCHAR_T */

+#else /* Information is UTF-8 encoded. */

+typedef char XML_Char;

+typedef char XML_LChar;

+#endif /* XML_UNICODE */

+#ifdef XML_LARGE_SIZE /* Use large integers for file/stream positions. */

+#if defined(XML_USE_MSC_EXTENSIONS) && _MSC_VER < 1400

+typedef __int64 XML_Index;

+typedef unsigned __int64 XML_Size;

+#else

+typedef long long XML_Index;

+typedef unsigned long long XML_Size;

+#endif

+#else

+typedef long XML_Index;

+typedef unsigned long XML_Size;

+#endif /* XML_LARGE_SIZE */

+#ifdef __cplusplus

+#endif

+#endif /* not Expat_External_INCLUDED */

diff --git a/lib/libexpat/lib/internal.h b/lib/libexpat/lib/internal.h
index 0b351c13f97..0e669891caf 100644
--- a/lib/libexpat/lib/internal.h
+++ b/lib/libexpat/lib/internal.h

@@ -21,16 +21,19 @@

#if defined(__GNUC__) && (defined(__i386__) || defined(__amd64__))

-/* Instability reported with egcs on a RedHat Linux 7.3.

- Let's comment it out:

+/* We'll use this version by default only where we know it helps.

+ regparm() generates warnings on Solaris boxes. See SF bug #692878.

+ Instability reported with egcs on a RedHat Linux 7.3.

+ Let's comment out:

#define FASTCALL __attribute__((stdcall, regparm(3)))

and let's try this:

#define FASTCALL __attribute__((regparm(3)))

-#define PTRCALL

#define PTRFASTCALL __attribute__((regparm(3)))

+#endif

-#elif defined(WIN32)

/* Using __fastcall seems to have an unexpected negative effect under

MS VC++, especially for function pointers, so we won't use it for

now on that platform. It may be reconsidered for a future release

@@ -38,11 +41,8 @@

Likely reason: __fastcall on Windows is like stdcall, therefore

the compiler cannot perform stack optimizations for call clusters.

-#define FASTCALL

-#define PTRCALL

-#define PTRFASTCALL

-#endif

+/* Make sure all of these are defined if they aren't already. */

#ifndef FASTCALL

#define FASTCALL

diff --git a/lib/libexpat/lib/macconfig.h b/lib/libexpat/lib/macconfig.h
new file mode 100644
index 00000000000..2725caaf54a
--- /dev/null
+++ b/lib/libexpat/lib/macconfig.h

@@ -0,0 +1,53 @@

+/*================================================================

+**

+** This is free software. You are permitted to copy, distribute, or modify

+** it under the terms of the MIT/X license (contained in the COPYING file

+** with this distribution.)

+**

+*/

+#ifndef MACCONFIG_H

+#define MACCONFIG_H

+/* 1234 = LIL_ENDIAN, 4321 = BIGENDIAN */

+#define BYTEORDER 4321

+/* Define to 1 if you have the `bcopy' function. */

+#undef HAVE_BCOPY

+/* Define to 1 if you have the `memmove' function. */

+#define HAVE_MEMMOVE

+/* Define to 1 if you have a working `mmap' system call. */

+#undef HAVE_MMAP

+/* Define to 1 if you have the <unistd.h> header file. */

+#undef HAVE_UNISTD_H

+/* whether byteorder is bigendian */

+#define WORDS_BIGENDIAN

+/* Define to specify how much context to retain around the current parse

+ point. */

+#undef XML_CONTEXT_BYTES

+/* Define to make parameter entity parsing functionality available. */

+#define XML_DTD

+/* Define to make XML Namespaces functionality available. */

+#define XML_NS

+/* Define to empty if `const' does not conform to ANSI C. */

+#undef const

+/* Define to `long' if <sys/types.h> does not define. */

+#define off_t long

+/* Define to `unsigned' if <sys/types.h> does not define. */

+#undef size_t

+#endif /* ifndef MACCONFIG_H */

diff --git a/lib/libexpat/lib/winconfig.h b/lib/libexpat/lib/winconfig.h
index 922ba1061ec..c1b791d62d0 100644
--- a/lib/libexpat/lib/winconfig.h
+++ b/lib/libexpat/lib/winconfig.h

@@ -1,30 +1,30 @@

-/*================================================================

-**

-** This is free software. You are permitted to copy, distribute, or modify

-** it under the terms of the MIT/X license (contained in the COPYING file

-** with this distribution.)

-*/

-#ifndef WINCONFIG_H

-#define WINCONFIG_H

-#define WIN32_LEAN_AND_MEAN

-#include <windows.h>

-#undef WIN32_LEAN_AND_MEAN

-#include <memory.h>

-#include <string.h>

-#define XML_NS 1

-#define XML_DTD 1

-#define XML_CONTEXT_BYTES 1024

-/* we will assume all Windows platforms are little endian */

-#define BYTEORDER 1234

-/* Windows has memmove() available. */

-#define HAVE_MEMMOVE

-#endif /* ndef WINCONFIG_H */

+/*================================================================

+**

+** This is free software. You are permitted to copy, distribute, or modify

+** it under the terms of the MIT/X license (contained in the COPYING file

+** with this distribution.)

+*/

+#ifndef WINCONFIG_H

+#define WINCONFIG_H

+#define WIN32_LEAN_AND_MEAN

+#include <windows.h>

+#undef WIN32_LEAN_AND_MEAN

+#include <memory.h>

+#include <string.h>

+#define XML_NS 1

+#define XML_DTD 1

+#define XML_CONTEXT_BYTES 1024

+/* we will assume all Windows platforms are little endian */

+#define BYTEORDER 1234

+/* Windows has memmove() available. */

+#define HAVE_MEMMOVE

+#endif /* ndef WINCONFIG_H */

diff --git a/lib/libexpat/lib/xmlparse.c b/lib/libexpat/lib/xmlparse.c
index 5509ce46252..44c71cf2c5d 100644
--- a/lib/libexpat/lib/xmlparse.c
+++ b/lib/libexpat/lib/xmlparse.c

@@ -4,34 +4,22 @@

#include <stddef.h>

#include <string.h> /* memset(), memcpy() */

+#include <assert.h>

-#ifdef COMPILED_FROM_DSP

+#define XML_BUILDING_EXPAT 1

+#ifdef COMPILED_FROM_DSP

#include "winconfig.h"

-#define XMLPARSEAPI(type) type __cdecl

-#include "expat.h"

-#undef XMLPARSEAPI

#elif defined(MACOS_CLASSIC)

#include "macconfig.h"

-#include "expat.h"

-#else

+#elif defined(__amigaos4__)

+#include "amigaconfig.h"

+#elif defined(HAVE_EXPAT_CONFIG_H)

#include <expat_config.h>

-#ifdef __declspec

-#define XMLPARSEAPI(type) type __cdecl

-#endif

+#endif /* ndef COMPILED_FROM_DSP */

#include "expat.h"

-#ifdef __declspec

-#undef XMLPARSEAPI

-#endif

-#endif /* ndef COMPILED_FROM_DSP */

#ifdef XML_UNICODE

#define XML_ENCODE_MAX XML_UTF16_ENCODE_MAX

#define XmlConvert XmlUtf16Convert

@@ -102,12 +90,37 @@ typedef struct {

typedef struct {

NAMED **v;

+ unsigned char power;

size_t size;

size_t used;

- size_t usedLim;

const XML_Memory_Handling_Suite *mem;

} HASH_TABLE;

+/* Basic character hash algorithm, taken from Python's string hash:

+ h = h * 1000003 ^ character, the constant being a prime number.

+*/

+#ifdef XML_UNICODE

+#define CHAR_HASH(h, c) \

+ (((h) * 0xF4243) ^ (unsigned short)(c))

+#else

+#define CHAR_HASH(h, c) \

+ (((h) * 0xF4243) ^ (unsigned char)(c))

+#endif

+/* For probing (after a collision) we need a step size relative prime

+ to the hash table size, which is a power of 2. We use double-hashing,

+ since we can calculate a second hash value cheaply by taking those bits

+ of the first hash value that were discarded (masked out) when the table

+ index was calculated: index = hash & mask, where mask = table->size - 1.

+ We limit the maximum step size to table->size / 4 (mask >> 2) and make

+ it odd, since odd numbers are always relative prime to a power of 2.

+*/

+#define SECOND_HASH(hash, mask, power) \

+ ((((hash) & ~(mask)) >> ((power) - 1)) & ((mask) >> 2))

+#define PROBE_STEP(hash, mask, power) \

+ ((unsigned char)((SECOND_HASH(hash, mask, power)) | 1))

typedef struct {

NAMED **p;

NAMED **end;

@@ -116,6 +129,7 @@ typedef struct {

#define INIT_TAG_BUF_SIZE 32 /* must be a multiple of sizeof(XML_Char) */

#define INIT_DATA_BUF_SIZE 1024

#define INIT_ATTS_SIZE 16

+#define INIT_ATTS_VERSION 0xFFFFFFFF

#define INIT_BLOCK_SIZE 1024

#define INIT_BUFFER_SIZE 1024

@@ -171,7 +185,8 @@ typedef struct tag {

typedef struct {

const XML_Char *name;

const XML_Char *textPtr;

- int textLen;

+ int textLen; /* length in XML_Chars */

+ int processed; /* # of processed bytes - when suspended */

const XML_Char *systemId;

const XML_Char *base;

const XML_Char *publicId;

@@ -224,6 +239,12 @@ typedef struct {

} DEFAULT_ATTRIBUTE;

typedef struct {

+ unsigned long version;

+ unsigned long hash;

+ const XML_Char *uriName;

+} NS_ATT;

+typedef struct {

const XML_Char *name;

PREFIX *prefix;

const ATTRIBUTE_ID *idAtt;

@@ -266,6 +287,8 @@ typedef struct open_internal_entity {

const char *internalEventEndPtr;

struct open_internal_entity *next;

ENTITY *entity;

+ int startTagLevel;

+ XML_Bool betweenDecl; /* WFC: PE Between Declarations */

} OPEN_INTERNAL_ENTITY;

typedef enum XML_Error PTRCALL Processor(XML_Parser parser,

@@ -290,29 +313,33 @@ static Processor externalEntityInitProcessor;

static Processor externalEntityInitProcessor2;

static Processor externalEntityInitProcessor3;

static Processor externalEntityContentProcessor;

+static Processor internalEntityProcessor;

static enum XML_Error

handleUnknownEncoding(XML_Parser parser, const XML_Char *encodingName);

static enum XML_Error

processXmlDecl(XML_Parser parser, int isGeneralTextEntity,

- const char *, const char *);

+ const char *s, const char *next);

static enum XML_Error

initializeEncoding(XML_Parser parser);

static enum XML_Error

-doProlog(XML_Parser parser, const ENCODING *enc, const char *s,

- const char *end, int tok, const char *next, const char **nextPtr);

+doProlog(XML_Parser parser, const ENCODING *enc, const char *s,

+ const char *end, int tok, const char *next, const char **nextPtr,

+ XML_Bool haveMore);

static enum XML_Error

-processInternalParamEntity(XML_Parser parser, ENTITY *entity);

+processInternalEntity(XML_Parser parser, ENTITY *entity,

+ XML_Bool betweenDecl);

static enum XML_Error

doContent(XML_Parser parser, int startTagLevel, const ENCODING *enc,

- const char *start, const char *end, const char **endPtr);

+ const char *start, const char *end, const char **endPtr,

+ XML_Bool haveMore);

static enum XML_Error

doCdataSection(XML_Parser parser, const ENCODING *, const char **startPtr,

- const char *end, const char **nextPtr);

+ const char *end, const char **nextPtr, XML_Bool haveMore);

#ifdef XML_DTD

static enum XML_Error

doIgnoreSection(XML_Parser parser, const ENCODING *, const char **startPtr,

- const char *end, const char **nextPtr);

+ const char *end, const char **nextPtr, XML_Bool haveMore);

#endif /* XML_DTD */

static enum XML_Error

@@ -322,9 +349,8 @@ static enum XML_Error

addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId,

const XML_Char *uri, BINDING **bindingsPtr);

static int

-defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *,

- XML_Bool isCdata, XML_Bool isId, const XML_Char *dfltValue,

- XML_Parser parser);

+defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *, XML_Bool isCdata,

+ XML_Bool isId, const XML_Char *dfltValue, XML_Parser parser);

static enum XML_Error

storeAttributeValue(XML_Parser parser, const ENCODING *, XML_Bool isCdata,

const char *, const char *, STRING_POOL *);

@@ -432,7 +458,7 @@ struct XML_ParserStruct {

char *m_bufferEnd;

/* allocated end of buffer */

const char *m_bufferLim;

- long m_parseEndByteIndex;

+ XML_Index m_parseEndByteIndex;

const char *m_parseEndPtr;

XML_Char *m_dataBuf;

XML_Char *m_dataBufEnd;

@@ -468,7 +494,7 @@ struct XML_ParserStruct {

void *m_unknownEncodingMem;

void *m_unknownEncodingData;

void *m_unknownEncodingHandlerData;

- void (*m_unknownEncodingRelease)(void *);

+ void (XMLCALL *m_unknownEncodingRelease)(void *);

PROLOG_STATE m_prologState;

Processor *m_processor;

enum XML_Error m_errorCode;

@@ -476,6 +502,7 @@ struct XML_ParserStruct {

const char *m_eventEndPtr;

const char *m_positionPtr;

OPEN_INTERNAL_ENTITY *m_openInternalEntities;

+ OPEN_INTERNAL_ENTITY *m_freeInternalEntities;

XML_Bool m_defaultExpandInternalEntities;

int m_tagLevel;

ENTITY *m_declEntity;

@@ -499,13 +526,17 @@ struct XML_ParserStruct {

int m_nSpecifiedAtts;

int m_idAttIndex;

ATTRIBUTE *m_atts;

+ NS_ATT *m_nsAtts;

+ unsigned long m_nsAttsVersion;

+ unsigned char m_nsAttsPower;

POSITION m_position;

STRING_POOL m_tempPool;

STRING_POOL m_temp2Pool;

char *m_groupConnector;

- unsigned m_groupSize;

+ unsigned int m_groupSize;

XML_Char m_namespaceSeparator;

XML_Parser m_parentParser;

+ XML_ParsingStatus m_parsingStatus;

#ifdef XML_DTD

XML_Bool m_isParamEntity;

XML_Bool m_useForeignDTD;

@@ -569,6 +600,7 @@ struct XML_ParserStruct {

#define positionPtr (parser->m_positionPtr)

#define position (parser->m_position)

#define openInternalEntities (parser->m_openInternalEntities)

+#define freeInternalEntities (parser->m_freeInternalEntities)

#define defaultExpandInternalEntities \

(parser->m_defaultExpandInternalEntities)

#define tagLevel (parser->m_tagLevel)

@@ -601,38 +633,32 @@ struct XML_ParserStruct {

#define attsSize (parser->m_attsSize)

#define nSpecifiedAtts (parser->m_nSpecifiedAtts)

#define idAttIndex (parser->m_idAttIndex)

+#define nsAtts (parser->m_nsAtts)

+#define nsAttsVersion (parser->m_nsAttsVersion)

+#define nsAttsPower (parser->m_nsAttsPower)

#define tempPool (parser->m_tempPool)

#define temp2Pool (parser->m_temp2Pool)

#define groupConnector (parser->m_groupConnector)

#define groupSize (parser->m_groupSize)

#define namespaceSeparator (parser->m_namespaceSeparator)

#define parentParser (parser->m_parentParser)

+#define ps_parsing (parser->m_parsingStatus.parsing)

+#define ps_finalBuffer (parser->m_parsingStatus.finalBuffer)

#ifdef XML_DTD

#define isParamEntity (parser->m_isParamEntity)

#define useForeignDTD (parser->m_useForeignDTD)

#define paramEntityParsing (parser->m_paramEntityParsing)

#endif /* XML_DTD */

-#define parsing \

- (parentParser \

- ? \

- (isParamEntity \

- ? \

- (processor != externalParEntInitProcessor) \

- : \

- (processor != externalEntityInitProcessor)) \

- : \

- (processor != prologInitProcessor))

#define MAXLEN 0x7fffffff

-XML_Parser

+XML_Parser XMLCALL

XML_ParserCreate(const XML_Char *encodingName)

{

return XML_ParserCreate_MM(encodingName, NULL, NULL);

}

-XML_Parser

+XML_Parser XMLCALL

XML_ParserCreateNS(const XML_Char *encodingName, XML_Char nsSep)

{

XML_Char tmp[2];

@@ -647,7 +673,7 @@ static const XML_Char implicitContext[] = {

'n', 'a', 'm', 'e', 's', 'p', 'a', 'c', 'e', '\0'

};

-XML_Parser

+XML_Parser XMLCALL

XML_ParserCreate_MM(const XML_Char *encodingName,

const XML_Memory_Handling_Suite *memsuite,

const XML_Char *nameSep)

@@ -729,6 +755,7 @@ parserCreate(const XML_Char *encodingName,

freeBindingList = NULL;

freeTagList = NULL;

+ freeInternalEntities = NULL;

groupSize = 0;

groupConnector = NULL;

@@ -740,6 +767,10 @@ parserCreate(const XML_Char *encodingName,

ns = XML_FALSE;

ns_triplets = XML_FALSE;

+ nsAtts = NULL;

+ nsAttsVersion = 0;

+ nsAttsPower = 0;

poolInit(&tempPool, &(parser->m_mem));

poolInit(&temp2Pool, &(parser->m_mem));

parserInit(parser, encodingName);

@@ -815,7 +846,7 @@ parserInit(XML_Parser parser, const XML_Char *encodingName)

eventPtr = NULL;

eventEndPtr = NULL;

positionPtr = NULL;

- openInternalEntities = 0;

+ openInternalEntities = NULL;

defaultExpandInternalEntities = XML_TRUE;

tagLevel = 0;

tagStack = NULL;

@@ -825,6 +856,7 @@ parserInit(XML_Parser parser, const XML_Char *encodingName)

unknownEncodingRelease = NULL;

unknownEncodingData = NULL;

parentParser = NULL;

+ ps_parsing = XML_INITIALIZED;

#ifdef XML_DTD

isParamEntity = XML_FALSE;

useForeignDTD = XML_FALSE;

@@ -844,10 +876,11 @@ moveToFreeBindingList(XML_Parser parser, BINDING *bindings)

}

-XML_Bool

+XML_Bool XMLCALL

XML_ParserReset(XML_Parser parser, const XML_Char *encodingName)

{

TAG *tStk;

+ OPEN_INTERNAL_ENTITY *openEntityList;

if (parentParser)

return XML_FALSE;

/* move tagStack to freeTagList */

@@ -860,9 +893,16 @@ XML_ParserReset(XML_Parser parser, const XML_Char *encodingName)

tag->bindings = NULL;

freeTagList = tag;

}

+ /* move openInternalEntities to freeInternalEntities */

+ openEntityList = openInternalEntities;

+ while (openEntityList) {

+ OPEN_INTERNAL_ENTITY *openEntity = openEntityList;

+ openEntityList = openEntity->next;

+ openEntity->next = freeInternalEntities;

+ freeInternalEntities = openEntity;

+ }

moveToFreeBindingList(parser, inheritedBindings);

- if (unknownEncodingMem)

- FREE(unknownEncodingMem);

+ FREE(unknownEncodingMem);

if (unknownEncodingRelease)

unknownEncodingRelease(unknownEncodingData);

poolClear(&tempPool);

@@ -872,14 +912,14 @@ XML_ParserReset(XML_Parser parser, const XML_Char *encodingName)

return setContext(parser, implicitContext);

}

-enum XML_Status

+enum XML_Status XMLCALL

XML_SetEncoding(XML_Parser parser, const XML_Char *encodingName)

{

/* Block after XML_Parse()/XML_ParseBuffer() has been called.

XXX There's no way for the caller to determine which of the

XXX possible error cases caused the XML_STATUS_ERROR return.

- if (parsing)

+ if (ps_parsing == XML_PARSING || ps_parsing == XML_SUSPENDED)

return XML_STATUS_ERROR;

if (encodingName == NULL)

protocolEncodingName = NULL;

@@ -891,7 +931,7 @@ XML_SetEncoding(XML_Parser parser, const XML_Char *encodingName)

return XML_STATUS_OK;

}

-XML_Parser

+XML_Parser XMLCALL

XML_ExternalEntityParserCreate(XML_Parser oldParser,

const XML_Char *context,

const XML_Char *encodingName)

@@ -1034,23 +1074,44 @@ destroyBindings(BINDING *bindings, XML_Parser parser)

}

-void

+void XMLCALL

XML_ParserFree(XML_Parser parser)

{

+ TAG *tagList;

+ OPEN_INTERNAL_ENTITY *entityList;

+ if (parser == NULL)

+ return;

+ /* free tagStack and freeTagList */

+ tagList = tagStack;

for (;;) {

TAG *p;

- if (tagStack == NULL) {

+ if (tagList == NULL) {

if (freeTagList == NULL)

break;

- tagStack = freeTagList;

+ tagList = freeTagList;

freeTagList = NULL;

}

- p = tagStack;

- tagStack = tagStack->parent;

+ p = tagList;

+ tagList = tagList->parent;

FREE(p->buf);

destroyBindings(p->bindings, parser);

FREE(p);

}

+ /* free openInternalEntities and freeInternalEntities */

+ entityList = openInternalEntities;

+ for (;;) {

+ OPEN_INTERNAL_ENTITY *openEntity;

+ if (entityList == NULL) {

+ if (freeInternalEntities == NULL)

+ break;

+ entityList = freeInternalEntities;

+ freeInternalEntities = NULL;

+ }

+ openEntity = entityList;

+ entityList = entityList->next;

+ FREE(openEntity);

+ }

destroyBindings(freeBindingList, parser);

destroyBindings(inheritedBindings, parser);

poolDestroy(&tempPool);

@@ -1065,30 +1126,28 @@ XML_ParserFree(XML_Parser parser)

#endif /* XML_DTD */

dtdDestroy(_dtd, (XML_Bool)!parentParser, &parser->m_mem);

FREE((void *)atts);

- if (groupConnector)

- FREE(groupConnector);

- if (buffer)

- FREE(buffer);

+ FREE(groupConnector);

+ FREE(buffer);

FREE(dataBuf);

- if (unknownEncodingMem)

- FREE(unknownEncodingMem);

+ FREE(nsAtts);

+ FREE(unknownEncodingMem);

if (unknownEncodingRelease)

unknownEncodingRelease(unknownEncodingData);

FREE(parser);

}

-void

+void XMLCALL

XML_UseParserAsHandlerArg(XML_Parser parser)

{

handlerArg = parser;

}

-enum XML_Error

+enum XML_Error XMLCALL

XML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD)

{

#ifdef XML_DTD

/* block after XML_Parse()/XML_ParseBuffer() has been called */

- if (parsing)

+ if (ps_parsing == XML_PARSING || ps_parsing == XML_SUSPENDED)

return XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING;

useForeignDTD = useDTD;

return XML_ERROR_NONE;

@@ -1097,16 +1156,16 @@ XML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD)

#endif

}

-void

+void XMLCALL

XML_SetReturnNSTriplet(XML_Parser parser, int do_nst)

{

/* block after XML_Parse()/XML_ParseBuffer() has been called */

- if (parsing)

+ if (ps_parsing == XML_PARSING || ps_parsing == XML_SUSPENDED)

return;

ns_triplets = do_nst ? XML_TRUE : XML_FALSE;

}

-void

+void XMLCALL

XML_SetUserData(XML_Parser parser, void *p)

{

if (handlerArg == userData)

@@ -1115,7 +1174,7 @@ XML_SetUserData(XML_Parser parser, void *p)

userData = p;

}

-enum XML_Status

+enum XML_Status XMLCALL

XML_SetBase(XML_Parser parser, const XML_Char *p)

{

if (p) {

@@ -1129,25 +1188,25 @@ XML_SetBase(XML_Parser parser, const XML_Char *p)

return XML_STATUS_OK;

}

-const XML_Char *

+const XML_Char * XMLCALL

XML_GetBase(XML_Parser parser)

{

return curBase;

}

-int

+int XMLCALL

XML_GetSpecifiedAttributeCount(XML_Parser parser)

{

return nSpecifiedAtts;

}

-int

+int XMLCALL

XML_GetIdAttributeIndex(XML_Parser parser)

{

return idAttIndex;

}

-void

+void XMLCALL

XML_SetElementHandler(XML_Parser parser,

XML_StartElementHandler start,

XML_EndElementHandler end)

@@ -1156,40 +1215,40 @@ XML_SetElementHandler(XML_Parser parser,

endElementHandler = end;

}

-void

+void XMLCALL

XML_SetStartElementHandler(XML_Parser parser,

XML_StartElementHandler start) {

startElementHandler = start;

}

-void

+void XMLCALL

XML_SetEndElementHandler(XML_Parser parser,

XML_EndElementHandler end) {

endElementHandler = end;

}

-void

+void XMLCALL

XML_SetCharacterDataHandler(XML_Parser parser,

XML_CharacterDataHandler handler)

{

characterDataHandler = handler;

}

-void

+void XMLCALL

XML_SetProcessingInstructionHandler(XML_Parser parser,

XML_ProcessingInstructionHandler handler)

{

processingInstructionHandler = handler;

}

-void

+void XMLCALL

XML_SetCommentHandler(XML_Parser parser,

XML_CommentHandler handler)

{

commentHandler = handler;

}

-void

+void XMLCALL

XML_SetCdataSectionHandler(XML_Parser parser,

XML_StartCdataSectionHandler start,

XML_EndCdataSectionHandler end)

@@ -1198,19 +1257,19 @@ XML_SetCdataSectionHandler(XML_Parser parser,

endCdataSectionHandler = end;

}

-void

+void XMLCALL

XML_SetStartCdataSectionHandler(XML_Parser parser,

XML_StartCdataSectionHandler start) {

startCdataSectionHandler = start;

}

-void

+void XMLCALL

XML_SetEndCdataSectionHandler(XML_Parser parser,

XML_EndCdataSectionHandler end) {

endCdataSectionHandler = end;

}

-void

+void XMLCALL

XML_SetDefaultHandler(XML_Parser parser,

XML_DefaultHandler handler)

{

@@ -1218,7 +1277,7 @@ XML_SetDefaultHandler(XML_Parser parser,

defaultExpandInternalEntities = XML_FALSE;

}

-void

+void XMLCALL

XML_SetDefaultHandlerExpand(XML_Parser parser,

XML_DefaultHandler handler)

{

@@ -1226,7 +1285,7 @@ XML_SetDefaultHandlerExpand(XML_Parser parser,

defaultExpandInternalEntities = XML_TRUE;

}

-void

+void XMLCALL

XML_SetDoctypeDeclHandler(XML_Parser parser,

XML_StartDoctypeDeclHandler start,

XML_EndDoctypeDeclHandler end)

@@ -1235,33 +1294,33 @@ XML_SetDoctypeDeclHandler(XML_Parser parser,

endDoctypeDeclHandler = end;

}

-void

+void XMLCALL

XML_SetStartDoctypeDeclHandler(XML_Parser parser,

XML_StartDoctypeDeclHandler start) {

startDoctypeDeclHandler = start;

}

-void

+void XMLCALL

XML_SetEndDoctypeDeclHandler(XML_Parser parser,

XML_EndDoctypeDeclHandler end) {

endDoctypeDeclHandler = end;

}

-void

+void XMLCALL

XML_SetUnparsedEntityDeclHandler(XML_Parser parser,

XML_UnparsedEntityDeclHandler handler)

{

unparsedEntityDeclHandler = handler;

}

-void

+void XMLCALL

XML_SetNotationDeclHandler(XML_Parser parser,

XML_NotationDeclHandler handler)

{

notationDeclHandler = handler;

}

-void

+void XMLCALL

XML_SetNamespaceDeclHandler(XML_Parser parser,

XML_StartNamespaceDeclHandler start,

XML_EndNamespaceDeclHandler end)

@@ -1270,33 +1329,33 @@ XML_SetNamespaceDeclHandler(XML_Parser parser,

endNamespaceDeclHandler = end;

}

-void

+void XMLCALL

XML_SetStartNamespaceDeclHandler(XML_Parser parser,

XML_StartNamespaceDeclHandler start) {

startNamespaceDeclHandler = start;

}

-void

+void XMLCALL

XML_SetEndNamespaceDeclHandler(XML_Parser parser,

XML_EndNamespaceDeclHandler end) {

endNamespaceDeclHandler = end;

}

-void

+void XMLCALL

XML_SetNotStandaloneHandler(XML_Parser parser,

XML_NotStandaloneHandler handler)

{

notStandaloneHandler = handler;

}

-void

+void XMLCALL

XML_SetExternalEntityRefHandler(XML_Parser parser,

XML_ExternalEntityRefHandler handler)

{

externalEntityRefHandler = handler;

}

-void

+void XMLCALL

XML_SetExternalEntityRefHandlerArg(XML_Parser parser, void *arg)

{

if (arg)

@@ -1305,14 +1364,14 @@ XML_SetExternalEntityRefHandlerArg(XML_Parser parser, void *arg)

externalEntityRefHandlerArg = parser;

}

-void

+void XMLCALL

XML_SetSkippedEntityHandler(XML_Parser parser,

XML_SkippedEntityHandler handler)

{

skippedEntityHandler = handler;

}

-void

+void XMLCALL

XML_SetUnknownEncodingHandler(XML_Parser parser,

XML_UnknownEncodingHandler handler,

void *data)

@@ -1321,39 +1380,39 @@ XML_SetUnknownEncodingHandler(XML_Parser parser,

unknownEncodingHandlerData = data;

}

-void

+void XMLCALL

XML_SetElementDeclHandler(XML_Parser parser,

XML_ElementDeclHandler eldecl)

{

elementDeclHandler = eldecl;

}

-void

+void XMLCALL

XML_SetAttlistDeclHandler(XML_Parser parser,

XML_AttlistDeclHandler attdecl)

{

attlistDeclHandler = attdecl;

}

-void

+void XMLCALL

XML_SetEntityDeclHandler(XML_Parser parser,

XML_EntityDeclHandler handler)

{

entityDeclHandler = handler;

}

-void

+void XMLCALL

XML_SetXmlDeclHandler(XML_Parser parser,

XML_XmlDeclHandler handler) {

xmlDeclHandler = handler;

}

-int

+int XMLCALL

XML_SetParamEntityParsing(XML_Parser parser,

enum XML_ParamEntityParsing peParsing)

{

/* block after XML_Parse()/XML_ParseBuffer() has been called */

- if (parsing)

+ if (ps_parsing == XML_PARSING || ps_parsing == XML_SUSPENDED)

return 0;

#ifdef XML_DTD

paramEntityParsing = peParsing;

@@ -1363,19 +1422,50 @@ XML_SetParamEntityParsing(XML_Parser parser,

#endif

}

-enum XML_Status

+enum XML_Status XMLCALL

XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)

{

/* Avoid integer overflow */

if (len > MAXLEN / 2)

- return XML_STATUS_ERROR;

+ return XML_STATUS_ERROR;

+ switch (ps_parsing) {

+ case XML_SUSPENDED:

+ errorCode = XML_ERROR_SUSPENDED;

+ return XML_STATUS_ERROR;

+ case XML_FINISHED:

+ errorCode = XML_ERROR_FINISHED;

+ return XML_STATUS_ERROR;

+ default:

+ ps_parsing = XML_PARSING;

+ }

if (len == 0) {

+ ps_finalBuffer = (XML_Bool)isFinal;

if (!isFinal)

return XML_STATUS_OK;

positionPtr = bufferPtr;

- errorCode = processor(parser, bufferPtr, parseEndPtr = bufferEnd, 0);

- if (errorCode == XML_ERROR_NONE)

- return XML_STATUS_OK;

+ parseEndPtr = bufferEnd;

+ /* If data are left over from last buffer, and we now know that these

+ data are the final chunk of input, then we have to check them again

+ to detect errors based on that fact.

+ */

+ errorCode = processor(parser, bufferPtr, parseEndPtr, &bufferPtr);

+ if (errorCode == XML_ERROR_NONE) {

+ switch (ps_parsing) {

+ case XML_SUSPENDED:

+ XmlUpdatePosition(encoding, positionPtr, bufferPtr, &position);

+ positionPtr = bufferPtr;

+ return XML_STATUS_SUSPENDED;

+ case XML_INITIALIZED:

+ case XML_PARSING:

+ ps_parsing = XML_FINISHED;

+ /* fall through */

+ default:

+ return XML_STATUS_OK;

+ }

eventEndPtr = eventPtr;

processor = errorProcessor;

return XML_STATUS_ERROR;

@@ -1384,24 +1474,34 @@ XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)

else if (bufferPtr == bufferEnd) {

const char *end;

int nLeftOver;

+ enum XML_Error result;

parseEndByteIndex += len;

positionPtr = s;

- if (isFinal) {

- errorCode = processor(parser, s, parseEndPtr = s + len, 0);

- if (errorCode == XML_ERROR_NONE)

- return XML_STATUS_OK;

- eventEndPtr = eventPtr;

- processor = errorProcessor;

- return XML_STATUS_ERROR;

- }

+ ps_finalBuffer = (XML_Bool)isFinal;

errorCode = processor(parser, s, parseEndPtr = s + len, &end);

if (errorCode != XML_ERROR_NONE) {

eventEndPtr = eventPtr;

processor = errorProcessor;

return XML_STATUS_ERROR;

}

+ else {

+ switch (ps_parsing) {

+ case XML_SUSPENDED:

+ result = XML_STATUS_SUSPENDED;

+ break;

+ case XML_INITIALIZED:

+ case XML_PARSING:

+ result = XML_STATUS_OK;

+ if (isFinal) {

+ ps_parsing = XML_FINISHED;

+ return result;

+ }

XmlUpdatePosition(encoding, positionPtr, end, &position);

- positionPtr = end;

nLeftOver = s + len - end;

if (nLeftOver) {

if (buffer == NULL || nLeftOver > bufferLim - buffer) {

@@ -1423,10 +1523,14 @@ XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)

bufferLim = buffer + len * 2;

}

memcpy(buffer, end, nLeftOver);

- bufferPtr = buffer;

- bufferEnd = buffer + nLeftOver;

}

- return XML_STATUS_OK;

+ bufferPtr = buffer;

+ bufferEnd = buffer + nLeftOver;

+ positionPtr = bufferPtr;

+ parseEndPtr = bufferEnd;

+ eventPtr = bufferPtr;

+ eventEndPtr = bufferPtr;

+ return result;

}

#endif /* not defined XML_CONTEXT_BYTES */

else {

@@ -1440,39 +1544,77 @@ XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)

}

-enum XML_Status

+enum XML_Status XMLCALL

XML_ParseBuffer(XML_Parser parser, int len, int isFinal)

{

- const char *start = bufferPtr;

+ const char *start;

+ enum XML_Status result = XML_STATUS_OK;

+ switch (ps_parsing) {

+ case XML_SUSPENDED:

+ errorCode = XML_ERROR_SUSPENDED;

+ return XML_STATUS_ERROR;

+ case XML_FINISHED:

+ errorCode = XML_ERROR_FINISHED;

+ return XML_STATUS_ERROR;

+ default:

+ ps_parsing = XML_PARSING;

+ }

+ start = bufferPtr;

positionPtr = start;

bufferEnd += len;

+ parseEndPtr = bufferEnd;

parseEndByteIndex += len;

- errorCode = processor(parser, start, parseEndPtr = bufferEnd,

- isFinal ? (const char **)NULL : &bufferPtr);

- if (errorCode == XML_ERROR_NONE) {

- if (!isFinal) {

- XmlUpdatePosition(encoding, positionPtr, bufferPtr, &position);

- positionPtr = bufferPtr;

- }

- return XML_STATUS_OK;

- }

- else {

+ ps_finalBuffer = (XML_Bool)isFinal;

+ errorCode = processor(parser, start, parseEndPtr, &bufferPtr);

+ if (errorCode != XML_ERROR_NONE) {

eventEndPtr = eventPtr;

processor = errorProcessor;

return XML_STATUS_ERROR;

}

+ else {

+ switch (ps_parsing) {

+ case XML_SUSPENDED:

+ result = XML_STATUS_SUSPENDED;

+ break;

+ case XML_INITIALIZED:

+ case XML_PARSING:

+ if (isFinal) {

+ ps_parsing = XML_FINISHED;

+ return result;

+ }

+ default: ; /* should not happen */

+ }

+ XmlUpdatePosition(encoding, positionPtr, bufferPtr, &position);

+ positionPtr = bufferPtr;

+ return result;

}

-void *

+void * XMLCALL

XML_GetBuffer(XML_Parser parser, int len)

{

/* Avoid integer overflow */

if (len > MAXLEN - (bufferEnd - bufferPtr))

- return NULL;

+ return NULL;

+ switch (ps_parsing) {

+ case XML_SUSPENDED:

+ errorCode = XML_ERROR_SUSPENDED;

+ return NULL;

+ case XML_FINISHED:

+ errorCode = XML_ERROR_FINISHED;

+ return NULL;

+ default: ;

+ }

if (len > bufferLim - bufferEnd) {

- int neededSize = len + (bufferEnd - bufferPtr);

+ int neededSize = len + (int)(bufferEnd - bufferPtr);

#ifdef XML_CONTEXT_BYTES

- int keep = bufferPtr - buffer;

+ int keep = (int)(bufferPtr - buffer);

if (keep > XML_CONTEXT_BYTES)

keep = XML_CONTEXT_BYTES;

@@ -1481,7 +1623,7 @@ XML_GetBuffer(XML_Parser parser, int len)

if (neededSize <= bufferLim - buffer) {

#ifdef XML_CONTEXT_BYTES

if (keep < bufferPtr - buffer) {

- int offset = (bufferPtr - buffer) - keep;

+ int offset = (int)(bufferPtr - buffer) - keep;

memmove(buffer, &buffer[offset], bufferEnd - bufferPtr + keep);

bufferEnd -= offset;

bufferPtr -= offset;

@@ -1494,7 +1636,7 @@ XML_GetBuffer(XML_Parser parser, int len)

}

else {

char *newBuf;

- int bufferSize = bufferLim - bufferPtr;

+ int bufferSize = (int)(bufferLim - bufferPtr);

if (bufferSize == 0)

bufferSize = INIT_BUFFER_SIZE;

do {

@@ -1508,7 +1650,7 @@ XML_GetBuffer(XML_Parser parser, int len)

bufferLim = newBuf + bufferSize;

#ifdef XML_CONTEXT_BYTES

if (bufferPtr) {

- int keep = bufferPtr - buffer;

+ int keep = (int)(bufferPtr - buffer);

if (keep > XML_CONTEXT_BYTES)

keep = XML_CONTEXT_BYTES;

memcpy(newBuf, &bufferPtr[-keep], bufferEnd - bufferPtr + keep);

@@ -1534,13 +1676,88 @@ XML_GetBuffer(XML_Parser parser, int len)

return bufferEnd;

}

-enum XML_Error

+enum XML_Status XMLCALL

+XML_StopParser(XML_Parser parser, XML_Bool resumable)

+ switch (ps_parsing) {

+ case XML_SUSPENDED:

+ if (resumable) {

+ errorCode = XML_ERROR_SUSPENDED;

+ return XML_STATUS_ERROR;

+ }

+ ps_parsing = XML_FINISHED;

+ break;

+ case XML_FINISHED:

+ errorCode = XML_ERROR_FINISHED;

+ return XML_STATUS_ERROR;

+ default:

+ if (resumable) {

+#ifdef XML_DTD

+ if (isParamEntity) {

+ errorCode = XML_ERROR_SUSPEND_PE;

+ return XML_STATUS_ERROR;

+ }

+#endif

+ ps_parsing = XML_SUSPENDED;

+ }

+ else

+ ps_parsing = XML_FINISHED;

+ }

+ return XML_STATUS_OK;

+enum XML_Status XMLCALL

+XML_ResumeParser(XML_Parser parser)

+ enum XML_Status result = XML_STATUS_OK;

+ if (ps_parsing != XML_SUSPENDED) {

+ errorCode = XML_ERROR_NOT_SUSPENDED;

+ return XML_STATUS_ERROR;

+ }

+ ps_parsing = XML_PARSING;

+ errorCode = processor(parser, bufferPtr, parseEndPtr, &bufferPtr);

+ if (errorCode != XML_ERROR_NONE) {

+ eventEndPtr = eventPtr;

+ processor = errorProcessor;

+ return XML_STATUS_ERROR;

+ }

+ else {

+ switch (ps_parsing) {

+ case XML_SUSPENDED:

+ result = XML_STATUS_SUSPENDED;

+ break;

+ case XML_INITIALIZED:

+ case XML_PARSING:

+ if (ps_finalBuffer) {

+ ps_parsing = XML_FINISHED;

+ return result;

+ }

+ default: ;

+ }

+ XmlUpdatePosition(encoding, positionPtr, bufferPtr, &position);

+ positionPtr = bufferPtr;

+ return result;

+void XMLCALL

+XML_GetParsingStatus(XML_Parser parser, XML_ParsingStatus *status)

+ assert(status != NULL);

+ *status = parser->m_parsingStatus;

+enum XML_Error XMLCALL

XML_GetErrorCode(XML_Parser parser)

{

return errorCode;

}

-long

+XML_Index XMLCALL

XML_GetCurrentByteIndex(XML_Parser parser)

{

if (eventPtr)

@@ -1548,72 +1765,72 @@ XML_GetCurrentByteIndex(XML_Parser parser)

return -1;

}

-int

+int XMLCALL

XML_GetCurrentByteCount(XML_Parser parser)

{

if (eventEndPtr && eventPtr)

- return eventEndPtr - eventPtr;

+ return (int)(eventEndPtr - eventPtr);

return 0;

}

-const char *

+const char * XMLCALL

XML_GetInputContext(XML_Parser parser, int *offset, int *size)

{

#ifdef XML_CONTEXT_BYTES

if (eventPtr && buffer) {

- *offset = eventPtr - buffer;

- *size = bufferEnd - buffer;

+ *offset = (int)(eventPtr - buffer);

+ *size = (int)(bufferEnd - buffer);

return buffer;

}

#endif /* defined XML_CONTEXT_BYTES */

return (char *) 0;

}

-int

+XML_Size XMLCALL

XML_GetCurrentLineNumber(XML_Parser parser)

{

- if (eventPtr) {

+ if (eventPtr && eventPtr >= positionPtr) {

XmlUpdatePosition(encoding, positionPtr, eventPtr, &position);

positionPtr = eventPtr;

}

return position.lineNumber + 1;

}

-int

+XML_Size XMLCALL

XML_GetCurrentColumnNumber(XML_Parser parser)

{

- if (eventPtr) {

+ if (eventPtr && eventPtr >= positionPtr) {

XmlUpdatePosition(encoding, positionPtr, eventPtr, &position);

positionPtr = eventPtr;

}

return position.columnNumber;

}

-void

+void XMLCALL

XML_FreeContentModel(XML_Parser parser, XML_Content *model)

{

FREE(model);

}

-void *

+void * XMLCALL

XML_MemMalloc(XML_Parser parser, size_t size)

{

return MALLOC(size);

}

-void *

+void * XMLCALL

XML_MemRealloc(XML_Parser parser, void *ptr, size_t size)

{

return REALLOC(ptr, size);

}

-void

+void XMLCALL

XML_MemFree(XML_Parser parser, void *ptr)

{

FREE(ptr);

}

-void

+void XMLCALL

XML_DefaultCurrent(XML_Parser parser)

{

if (defaultHandler) {

@@ -1627,10 +1844,10 @@ XML_DefaultCurrent(XML_Parser parser)

}

-const XML_LChar *

+const XML_LChar * XMLCALL

XML_ErrorString(enum XML_Error code)

{

- static const XML_LChar *message[] = {

+ static const XML_LChar* const message[] = {

XML_L("out of memory"),

XML_L("syntax error"),

@@ -1648,7 +1865,7 @@ XML_ErrorString(enum XML_Error code)

XML_L("reference to invalid character number"),

XML_L("reference to binary entity"),

XML_L("reference to external entity in attribute"),

- XML_L("xml declaration not at start of external entity"),

+ XML_L("XML or text declaration not at start of entity"),

XML_L("unknown encoding"),

XML_L("encoding specified in XML declaration is incorrect"),

XML_L("unclosed CDATA section"),

@@ -1657,14 +1874,28 @@ XML_ErrorString(enum XML_Error code)

XML_L("unexpected parser state - please send a bug report"),

XML_L("entity declared in parameter entity"),

XML_L("requested feature requires XML_DTD support in Expat"),

- XML_L("cannot change setting once parsing has begun")

+ XML_L("cannot change setting once parsing has begun"),

+ XML_L("unbound prefix"),

+ XML_L("must not undeclare prefix"),

+ XML_L("incomplete markup in parameter entity"),

+ XML_L("XML declaration not well-formed"),

+ XML_L("text declaration not well-formed"),

+ XML_L("illegal character(s) in public id"),

+ XML_L("parser suspended"),

+ XML_L("parser not suspended"),

+ XML_L("parsing aborted"),

+ XML_L("parsing finished"),

+ XML_L("cannot suspend in external parameter entity"),

+ XML_L("reserved prefix (xml) must not be undeclared or bound to another namespace name"),

+ XML_L("reserved prefix (xmlns) must not be declared or undeclared"),

+ XML_L("prefix must not be bound to one of the reserved namespace names")

};

if (code > 0 && code < sizeof(message)/sizeof(message[0]))

return message[code];

return NULL;

}

-const XML_LChar *

+const XML_LChar * XMLCALL

XML_ExpatVersion(void) {

/* V1 is used to string-ize the version number. However, it would

@@ -1684,7 +1915,7 @@ XML_ExpatVersion(void) {

#undef V2

}

-XML_Expat_Version

+XML_Expat_Version XMLCALL

XML_ExpatVersionInfo(void)

{

XML_Expat_Version version;

@@ -1696,33 +1927,36 @@ XML_ExpatVersionInfo(void)

return version;

}

-const XML_Feature *

+const XML_Feature * XMLCALL

XML_GetFeatureList(void)

{

- static XML_Feature features[] = {

- {XML_FEATURE_SIZEOF_XML_CHAR, XML_L("sizeof(XML_Char)")},

- {XML_FEATURE_SIZEOF_XML_LCHAR, XML_L("sizeof(XML_LChar)")},

+ static const XML_Feature features[] = {

+ {XML_FEATURE_SIZEOF_XML_CHAR, XML_L("sizeof(XML_Char)"),

+ sizeof(XML_Char)},

+ {XML_FEATURE_SIZEOF_XML_LCHAR, XML_L("sizeof(XML_LChar)"),

+ sizeof(XML_LChar)},

#ifdef XML_UNICODE

- {XML_FEATURE_UNICODE, XML_L("XML_UNICODE")},

+ {XML_FEATURE_UNICODE, XML_L("XML_UNICODE"), 0},

#endif

#ifdef XML_UNICODE_WCHAR_T

- {XML_FEATURE_UNICODE_WCHAR_T, XML_L("XML_UNICODE_WCHAR_T")},

+ {XML_FEATURE_UNICODE_WCHAR_T, XML_L("XML_UNICODE_WCHAR_T"), 0},

#endif

#ifdef XML_DTD

- {XML_FEATURE_DTD, XML_L("XML_DTD")},

+ {XML_FEATURE_DTD, XML_L("XML_DTD"), 0},

#endif

#ifdef XML_CONTEXT_BYTES

{XML_FEATURE_CONTEXT_BYTES, XML_L("XML_CONTEXT_BYTES"),

XML_CONTEXT_BYTES},

#endif

#ifdef XML_MIN_SIZE

- {XML_FEATURE_MIN_SIZE, XML_L("XML_MIN_SIZE")},

+ {XML_FEATURE_MIN_SIZE, XML_L("XML_MIN_SIZE"), 0},

+#endif

+#ifdef XML_NS

+ {XML_FEATURE_NS, XML_L("XML_NS"), 0},

#endif

- {XML_FEATURE_END, NULL}

+ {XML_FEATURE_END, NULL, 0}

};

- features[0].value = sizeof(XML_Char);

- features[1].value = sizeof(XML_LChar);

return features;

}

@@ -1782,12 +2016,12 @@ contentProcessor(XML_Parser parser,

const char *end,

const char **endPtr)

{

- enum XML_Error result =

- doContent(parser, 0, encoding, start, end, endPtr);

- if (result != XML_ERROR_NONE)

- return result;

- if (!storeRawNames(parser))

- return XML_ERROR_NO_MEMORY;

+ enum XML_Error result = doContent(parser, 0, encoding, start, end,

+ endPtr, (XML_Bool)!ps_finalBuffer);

+ if (result == XML_ERROR_NONE) {

+ if (!storeRawNames(parser))

+ return XML_ERROR_NO_MEMORY;

+ }

return result;

}

@@ -1819,21 +2053,21 @@ externalEntityInitProcessor2(XML_Parser parser,

doContent (by detecting XML_TOK_NONE) without processing any xml text

declaration - causing the error XML_ERROR_MISPLACED_XML_PI in doContent.

- if (next == end && endPtr) {

+ if (next == end && !ps_finalBuffer) {

*endPtr = next;

return XML_ERROR_NONE;

}

start = next;

break;

case XML_TOK_PARTIAL:

- if (endPtr) {

+ if (!ps_finalBuffer) {

*endPtr = start;

return XML_ERROR_NONE;

}

eventPtr = start;

return XML_ERROR_UNCLOSED_TOKEN;

case XML_TOK_PARTIAL_CHAR:

- if (endPtr) {

+ if (!ps_finalBuffer) {

*endPtr = start;

return XML_ERROR_NONE;

}

@@ -1850,30 +2084,41 @@ externalEntityInitProcessor3(XML_Parser parser,

const char *end,

const char **endPtr)

{

+ int tok;

const char *next = start; /* XmlContentTok doesn't always set the last arg */

- int tok = XmlContentTok(encoding, start, end, &next);

+ eventPtr = start;

+ tok = XmlContentTok(encoding, start, end, &next);

+ eventEndPtr = next;

switch (tok) {

case XML_TOK_XML_DECL:

{

- enum XML_Error result = processXmlDecl(parser, 1, start, next);

+ enum XML_Error result;

+ result = processXmlDecl(parser, 1, start, next);

if (result != XML_ERROR_NONE)

return result;

- start = next;

+ switch (ps_parsing) {

+ case XML_SUSPENDED:

+ *endPtr = next;

+ return XML_ERROR_NONE;

+ case XML_FINISHED:

+ return XML_ERROR_ABORTED;

+ default:

+ start = next;

+ }

}

break;

case XML_TOK_PARTIAL:

- if (endPtr) {

+ if (!ps_finalBuffer) {

*endPtr = start;

return XML_ERROR_NONE;

}

- eventPtr = start;

return XML_ERROR_UNCLOSED_TOKEN;

case XML_TOK_PARTIAL_CHAR:

- if (endPtr) {

+ if (!ps_finalBuffer) {

*endPtr = start;

return XML_ERROR_NONE;

}

- eventPtr = start;

return XML_ERROR_PARTIAL_CHAR;

}

processor = externalEntityContentProcessor;

@@ -1887,12 +2132,12 @@ externalEntityContentProcessor(XML_Parser parser,

const char *end,

const char **endPtr)

{

- enum XML_Error result =

- doContent(parser, 1, encoding, start, end, endPtr);

- if (result != XML_ERROR_NONE)

- return result;

- if (!storeRawNames(parser))

- return XML_ERROR_NO_MEMORY;

+ enum XML_Error result = doContent(parser, 1, encoding, start, end,

+ endPtr, (XML_Bool)!ps_finalBuffer);

+ if (result == XML_ERROR_NONE) {

+ if (!storeRawNames(parser))

+ return XML_ERROR_NO_MEMORY;

+ }

return result;

}

@@ -1902,9 +2147,12 @@ doContent(XML_Parser parser,

const ENCODING *enc,

const char *s,

const char *end,

- const char **nextPtr)

+ const char **nextPtr,

+ XML_Bool haveMore)

{

- DTD * const dtd = _dtd; /* save one level of indirection */

+ /* save one level of indirection */

+ DTD * const dtd = _dtd;

const char **eventPP;

const char **eventEndPP;

if (enc == encoding) {

@@ -1916,13 +2164,14 @@ doContent(XML_Parser parser,

eventEndPP = &(openInternalEntities->internalEventEndPtr);

}

*eventPP = s;

for (;;) {

const char *next = s; /* XmlContentTok doesn't always set the last arg */

int tok = XmlContentTok(enc, s, end, &next);

*eventEndPP = next;

switch (tok) {

case XML_TOK_TRAILING_CR:

- if (nextPtr) {

+ if (haveMore) {

*nextPtr = s;

return XML_ERROR_NONE;

}

@@ -1933,19 +2182,24 @@ doContent(XML_Parser parser,

}

else if (defaultHandler)

reportDefault(parser, enc, s, end);

+ /* We are at the end of the final buffer, should we check for

+ XML_SUSPENDED, XML_FINISHED?

+ */

if (startTagLevel == 0)

return XML_ERROR_NO_ELEMENTS;

if (tagLevel != startTagLevel)

return XML_ERROR_ASYNC_ENTITY;

+ *nextPtr = end;

return XML_ERROR_NONE;

case XML_TOK_NONE:

- if (nextPtr) {

+ if (haveMore) {

*nextPtr = s;

return XML_ERROR_NONE;

}

if (startTagLevel > 0) {

if (tagLevel != startTagLevel)

return XML_ERROR_ASYNC_ENTITY;

+ *nextPtr = s;

return XML_ERROR_NONE;

}

return XML_ERROR_NO_ELEMENTS;

@@ -1953,13 +2207,13 @@ doContent(XML_Parser parser,

*eventPP = next;

return XML_ERROR_INVALID_TOKEN;

case XML_TOK_PARTIAL:

- if (nextPtr) {

+ if (haveMore) {

*nextPtr = s;

return XML_ERROR_NONE;

}

return XML_ERROR_UNCLOSED_TOKEN;

case XML_TOK_PARTIAL_CHAR:

- if (nextPtr) {

+ if (haveMore) {

*nextPtr = s;

return XML_ERROR_NONE;

}

@@ -2008,7 +2262,6 @@ doContent(XML_Parser parser,

return XML_ERROR_BINARY_ENTITY_REF;

if (entity->textPtr) {

enum XML_Error result;

- OPEN_INTERNAL_ENTITY openEntity;

if (!defaultExpandInternalEntities) {

if (skippedEntityHandler)

skippedEntityHandler(handlerArg, entity->name, 0);

@@ -2016,21 +2269,8 @@ doContent(XML_Parser parser,

reportDefault(parser, enc, s, next);

break;

}

- entity->open = XML_TRUE;

- openEntity.next = openInternalEntities;

- openInternalEntities = &openEntity;

- openEntity.entity = entity;

- openEntity.internalEventPtr = NULL;

- openEntity.internalEventEndPtr = NULL;

- result = doContent(parser,

- tagLevel,

- internalEncoding,

- (char *)entity->textPtr,

- (char *)(entity->textPtr + entity->textLen),

- 0);

- entity->open = XML_FALSE;

- openInternalEntities = openEntity.next;

- if (result)

+ result = processInternalEntity(parser, entity, XML_FALSE);

+ if (result != XML_ERROR_NONE)

return result;

}

else if (externalEntityRefHandler) {

@@ -2040,7 +2280,7 @@ doContent(XML_Parser parser,

entity->open = XML_FALSE;

if (!context)

return XML_ERROR_NO_MEMORY;

- if (!externalEntityRefHandler((XML_Parser)externalEntityRefHandlerArg,

+ if (!externalEntityRefHandler(externalEntityRefHandlerArg,

context,

entity->base,

entity->systemId,

@@ -2092,12 +2332,12 @@ doContent(XML_Parser parser,

XmlConvert(enc,

&fromPtr, rawNameEnd,

(ICHAR **)&toPtr, (ICHAR *)tag->bufEnd - 1);

- convLen = toPtr - (XML_Char *)tag->buf;

+ convLen = (int)(toPtr - (XML_Char *)tag->buf);

if (fromPtr == rawNameEnd) {

tag->name.strLen = convLen;

break;

}

- bufSize = (tag->bufEnd - tag->buf) << 1;

+ bufSize = (int)(tag->bufEnd - tag->buf) << 1;

{

char *temp = (char *)REALLOC(tag->buf, bufSize);

if (temp == NULL)

@@ -2266,15 +2506,17 @@ doContent(XML_Parser parser,

#endif

else if (defaultHandler)

reportDefault(parser, enc, s, next);

- result = doCdataSection(parser, enc, &next, end, nextPtr);

- if (!next) {

+ result = doCdataSection(parser, enc, &next, end, nextPtr, haveMore);

+ if (result != XML_ERROR_NONE)

+ return result;

+ else if (!next) {

processor = cdataSectionProcessor;

return result;

}

break;

case XML_TOK_TRAILING_RSQB:

- if (nextPtr) {

+ if (haveMore) {

*nextPtr = s;

return XML_ERROR_NONE;

}

@@ -2283,15 +2525,18 @@ doContent(XML_Parser parser,

ICHAR *dataPtr = (ICHAR *)dataBuf;

XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)dataBufEnd);

characterDataHandler(handlerArg, dataBuf,

- dataPtr - (ICHAR *)dataBuf);

+ (int)(dataPtr - (ICHAR *)dataBuf));

}

else

characterDataHandler(handlerArg,

(XML_Char *)s,

- (XML_Char *)end - (XML_Char *)s);

+ (int)((XML_Char *)end - (XML_Char *)s));

}

else if (defaultHandler)

reportDefault(parser, enc, s, end);

+ /* We are at the end of the final buffer, should we check for

+ XML_SUSPENDED, XML_FINISHED?

+ */

if (startTagLevel == 0) {

*eventPP = end;

return XML_ERROR_NO_ELEMENTS;

@@ -2300,6 +2545,7 @@ doContent(XML_Parser parser,

*eventPP = end;

return XML_ERROR_ASYNC_ENTITY;

}

+ *nextPtr = end;

return XML_ERROR_NONE;

case XML_TOK_DATA_CHARS:

if (characterDataHandler) {

@@ -2309,7 +2555,7 @@ doContent(XML_Parser parser,

XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd);

*eventEndPP = s;

characterDataHandler(handlerArg, dataBuf,

- dataPtr - (ICHAR *)dataBuf);

+ (int)(dataPtr - (ICHAR *)dataBuf));

if (s == next)

break;

*eventPP = s;

@@ -2318,7 +2564,7 @@ doContent(XML_Parser parser,

else

characterDataHandler(handlerArg,

(XML_Char *)s,

- (XML_Char *)next - (XML_Char *)s);

+ (int)((XML_Char *)next - (XML_Char *)s));

}

else if (defaultHandler)

reportDefault(parser, enc, s, next);

@@ -2337,6 +2583,14 @@ doContent(XML_Parser parser,

break;

}

*eventPP = s = next;

+ switch (ps_parsing) {

+ case XML_SUSPENDED:

+ *nextPtr = next;

+ return XML_ERROR_NONE;

+ case XML_FINISHED:

+ return XML_ERROR_ABORTED;

+ default: ;

+ }

}

/* not reached */

}

@@ -2357,8 +2611,8 @@ storeAtts(XML_Parser parser, const ENCODING *enc,

BINDING **bindingsPtr)

{

DTD * const dtd = _dtd; /* save one level of indirection */

- ELEMENT_TYPE *elementType = NULL;

- int nDefaultAtts = 0;

+ ELEMENT_TYPE *elementType;

+ int nDefaultAtts;

const XML_Char **appAtts; /* the attribute list for the application */

int attIndex = 0;

int prefixLen;

@@ -2406,7 +2660,10 @@ storeAtts(XML_Parser parser, const ENCODING *enc,

+ XmlNameLength(enc, atts[i].name));

if (!attId)

return XML_ERROR_NO_MEMORY;

- /* detect duplicate attributes */

+ /* Detect duplicate attributes by their QNames. This does not work when

+ namespace processing is turned on and different prefixes for the same

+ namespace are used. For this case we have a check further down.

+ */

if ((attId->name)[-1]) {

if (enc == encoding)

eventPtr = atts[i].name;

@@ -2506,58 +2763,128 @@ storeAtts(XML_Parser parser, const ENCODING *enc,

}

appAtts[attIndex] = 0;

+ /* expand prefixed attribute names, check for duplicates,

+ and clear flags that say whether attributes were specified */

i = 0;

if (nPrefixes) {

- /* expand prefixed attribute names */

+ int j; /* hash table index */

+ unsigned long version = nsAttsVersion;

+ int nsAttsSize = (int)1 << nsAttsPower;

+ /* size of hash table must be at least 2 * (# of prefixed attributes) */

+ if ((nPrefixes << 1) >> nsAttsPower) { /* true for nsAttsPower = 0 */

+ NS_ATT *temp;

+ /* hash table size must also be a power of 2 and >= 8 */

+ while (nPrefixes >> nsAttsPower++);

+ if (nsAttsPower < 3)

+ nsAttsPower = 3;

+ nsAttsSize = (int)1 << nsAttsPower;

+ temp = (NS_ATT *)REALLOC(nsAtts, nsAttsSize * sizeof(NS_ATT));

+ if (!temp)

+ return XML_ERROR_NO_MEMORY;

+ nsAtts = temp;

+ version = 0; /* force re-initialization of nsAtts hash table */

+ }

+ /* using a version flag saves us from initializing nsAtts every time */

+ if (!version) { /* initialize version flags when version wraps around */

+ version = INIT_ATTS_VERSION;

+ for (j = nsAttsSize; j != 0; )

+ nsAtts[--j].version = version;

+ }

+ nsAttsVersion = --version;

+ /* expand prefixed names and check for duplicates */

for (; i < attIndex; i += 2) {

- if (appAtts[i][-1] == 2) {

+ const XML_Char *s = appAtts[i];

+ if (s[-1] == 2) { /* prefixed */

ATTRIBUTE_ID *id;

- ((XML_Char *)(appAtts[i]))[-1] = 0;

- id = (ATTRIBUTE_ID *)lookup(&dtd->attributeIds, appAtts[i], 0);

- if (id->prefix->binding) {

- int j;

- const BINDING *b = id->prefix->binding;

- const XML_Char *s = appAtts[i];

- for (j = 0; j < b->uriLen; j++) {

- if (!poolAppendChar(&tempPool, b->uri[j]))

- return XML_ERROR_NO_MEMORY;

+ const BINDING *b;

+ unsigned long uriHash = 0;

+ ((XML_Char *)s)[-1] = 0; /* clear flag */

+ id = (ATTRIBUTE_ID *)lookup(&dtd->attributeIds, s, 0);

+ b = id->prefix->binding;

+ if (!b)

+ return XML_ERROR_UNBOUND_PREFIX;

+ /* as we expand the name we also calculate its hash value */

+ for (j = 0; j < b->uriLen; j++) {

+ const XML_Char c = b->uri[j];

+ if (!poolAppendChar(&tempPool, c))

+ return XML_ERROR_NO_MEMORY;

+ uriHash = CHAR_HASH(uriHash, c);

+ }

+ while (*s++ != XML_T(':'))

+ ;

+ do { /* copies null terminator */

+ const XML_Char c = *s;

+ if (!poolAppendChar(&tempPool, *s))

+ return XML_ERROR_NO_MEMORY;

+ uriHash = CHAR_HASH(uriHash, c);

+ } while (*s++);

+ { /* Check hash table for duplicate of expanded name (uriName).

+ Derived from code in lookup(HASH_TABLE *table, ...).

+ */

+ unsigned char step = 0;

+ unsigned long mask = nsAttsSize - 1;

+ j = uriHash & mask; /* index into hash table */

+ while (nsAtts[j].version == version) {

+ /* for speed we compare stored hash values first */

+ if (uriHash == nsAtts[j].hash) {

+ const XML_Char *s1 = poolStart(&tempPool);

+ const XML_Char *s2 = nsAtts[j].uriName;

+ /* s1 is null terminated, but not s2 */

+ for (; *s1 == *s2 && *s1 != 0; s1++, s2++);

+ if (*s1 == 0)

+ return XML_ERROR_DUPLICATE_ATTRIBUTE;

+ }

+ if (!step)

+ step = PROBE_STEP(uriHash, mask, nsAttsPower);

+ j < step ? (j += nsAttsSize - step) : (j -= step);

}

- while (*s++ != XML_T(':'))

- ;

+ }

+ if (ns_triplets) { /* append namespace separator and prefix */

+ tempPool.ptr[-1] = namespaceSeparator;

+ s = b->prefix->name;

do {

if (!poolAppendChar(&tempPool, *s))

return XML_ERROR_NO_MEMORY;

} while (*s++);

- if (ns_triplets) {

- tempPool.ptr[-1] = namespaceSeparator;

- s = b->prefix->name;

- do {

- if (!poolAppendChar(&tempPool, *s))

- return XML_ERROR_NO_MEMORY;

- } while (*s++);

- }

- appAtts[i] = poolStart(&tempPool);

- poolFinish(&tempPool);

}

- if (!--nPrefixes)

+ /* store expanded name in attribute list */

+ s = poolStart(&tempPool);

+ poolFinish(&tempPool);

+ appAtts[i] = s;

+ /* fill empty slot with new version, uriName and hash value */

+ nsAtts[j].version = version;

+ nsAtts[j].hash = uriHash;

+ nsAtts[j].uriName = s;

+ if (!--nPrefixes) {

+ i += 2;

break;

+ }

}

- else

- ((XML_Char *)(appAtts[i]))[-1] = 0;

+ else /* not prefixed */

+ ((XML_Char *)s)[-1] = 0; /* clear flag */

}

- /* clear the flags that say whether attributes were specified */

+ /* clear flags for the remaining attributes */

for (; i < attIndex; i += 2)

((XML_Char *)(appAtts[i]))[-1] = 0;

for (binding = *bindingsPtr; binding; binding = binding->nextTagBinding)

binding->attId->name[-1] = 0;

+ if (!ns)

+ return XML_ERROR_NONE;

/* expand the element type name */

if (elementType->prefix) {

binding = elementType->prefix->binding;

if (!binding)

- return XML_ERROR_NONE;

+ return XML_ERROR_UNBOUND_PREFIX;

localPart = tagNamePtr->str;

while (*localPart++ != XML_T(':'))

;

@@ -2569,16 +2896,16 @@ storeAtts(XML_Parser parser, const ENCODING *enc,

else

return XML_ERROR_NONE;

prefixLen = 0;

- if (ns && ns_triplets && binding->prefix->name) {

+ if (ns_triplets && binding->prefix->name) {

for (; binding->prefix->name[prefixLen++];)

- ;

+ ; /* prefixLen includes null terminator */

}

tagNamePtr->localPart = localPart;

tagNamePtr->uriLen = binding->uriLen;

tagNamePtr->prefix = binding->prefix->name;

tagNamePtr->prefixLen = prefixLen;

for (i = 0; localPart[i++];)

- ;

+ ; /* i includes null terminator */

n = i + binding->uriLen + prefixLen;

if (n > binding->uriAlloc) {

TAG *p;

@@ -2593,11 +2920,13 @@ storeAtts(XML_Parser parser, const ENCODING *enc,

FREE(binding->uri);

binding->uri = uri;

}

+ /* if namespaceSeparator != '\0' then uri includes it already */

uri = binding->uri + binding->uriLen;

memcpy(uri, localPart, i * sizeof(XML_Char));

+ /* we always have a namespace separator between localPart and prefix */

if (prefixLen) {

- uri = uri + (i - 1);

- if (namespaceSeparator) { *(uri) = namespaceSeparator; }

+ uri += i - 1;

+ *uri = namespaceSeparator; /* replace null terminator */

memcpy(uri + 1, binding->prefix->name, prefixLen * sizeof(XML_Char));

}

tagNamePtr->str = binding->uri;

@@ -2611,15 +2940,66 @@ static enum XML_Error

addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId,

const XML_Char *uri, BINDING **bindingsPtr)

{

+ static const XML_Char xmlNamespace[] = {

+ 'h', 't', 't', 'p', ':', '/', '/',

+ 'w', 'w', 'w', '.', 'w', '3', '.', 'o', 'r', 'g', '/',

+ 'X', 'M', 'L', '/', '1', '9', '9', '8', '/',

+ 'n', 'a', 'm', 'e', 's', 'p', 'a', 'c', 'e', '\0'

+ };

+ static const int xmlLen =

+ (int)sizeof(xmlNamespace)/sizeof(XML_Char) - 1;

+ static const XML_Char xmlnsNamespace[] = {

+ 'h', 't', 't', 'p', ':', '/', '/',

+ 'w', 'w', 'w', '.', 'w', '3', '.', 'o', 'r', 'g', '/',

+ '2', '0', '0', '0', '/', 'x', 'm', 'l', 'n', 's', '/', '\0'

+ };

+ static const int xmlnsLen =

+ (int)sizeof(xmlnsNamespace)/sizeof(XML_Char) - 1;

+ XML_Bool mustBeXML = XML_FALSE;

+ XML_Bool isXML = XML_TRUE;

+ XML_Bool isXMLNS = XML_TRUE;

BINDING *b;

int len;

- /* empty string is only valid when there is no prefix per XML NS 1.0 */

+ /* empty URI is only valid for default namespace per XML NS 1.0 (not 1.1) */

if (*uri == XML_T('\0') && prefix->name)

- return XML_ERROR_SYNTAX;

+ return XML_ERROR_UNDECLARING_PREFIX;

+ if (prefix->name

+ && prefix->name[0] == XML_T('x')

+ && prefix->name[1] == XML_T('m')

+ && prefix->name[2] == XML_T('l')) {

+ /* Not allowed to bind xmlns */

+ if (prefix->name[3] == XML_T('n')

+ && prefix->name[4] == XML_T('s')

+ && prefix->name[5] == XML_T('\0'))

+ return XML_ERROR_RESERVED_PREFIX_XMLNS;

+ if (prefix->name[3] == XML_T('\0'))

+ mustBeXML = XML_TRUE;

+ }

+ for (len = 0; uri[len]; len++) {

+ if (isXML && (len > xmlLen || uri[len] != xmlNamespace[len]))

+ isXML = XML_FALSE;

+ if (!mustBeXML && isXMLNS

+ && (len > xmlnsLen || uri[len] != xmlnsNamespace[len]))

+ isXMLNS = XML_FALSE;

+ }

+ isXML = isXML && len == xmlLen;

+ isXMLNS = isXMLNS && len == xmlnsLen;

+ if (mustBeXML != isXML)

+ return mustBeXML ? XML_ERROR_RESERVED_PREFIX_XML

+ : XML_ERROR_RESERVED_NAMESPACE_URI;

+ if (isXMLNS)

+ return XML_ERROR_RESERVED_NAMESPACE_URI;

- for (len = 0; uri[len]; len++)

- ;

if (namespaceSeparator)

len++;

if (freeBindingList) {

@@ -2652,13 +3032,15 @@ addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId,

b->prefix = prefix;

b->attId = attId;

b->prevPrefixBinding = prefix->binding;

+ /* NULL binding when default namespace undeclared */

if (*uri == XML_T('\0') && prefix == &_dtd->defaultPrefix)

prefix->binding = NULL;

else

prefix->binding = b;

b->nextTagBinding = *bindingsPtr;

*bindingsPtr = b;

- if (startNamespaceDeclHandler)

+ /* if attId == NULL then we are not starting a namespace scope */

+ if (attId && startNamespaceDeclHandler)

startNamespaceDeclHandler(handlerArg, prefix->name,

prefix->binding ? uri : 0);

return XML_ERROR_NONE;

@@ -2673,8 +3055,10 @@ cdataSectionProcessor(XML_Parser parser,

const char *end,

const char **endPtr)

{

- enum XML_Error result = doCdataSection(parser, encoding, &start,

- end, endPtr);

+ enum XML_Error result = doCdataSection(parser, encoding, &start, end,

+ endPtr, (XML_Bool)!ps_finalBuffer);

+ if (result != XML_ERROR_NONE)

+ return result;

if (start) {

if (parentParser) { /* we are parsing an external entity */

processor = externalEntityContentProcessor;

@@ -2688,7 +3072,7 @@ cdataSectionProcessor(XML_Parser parser,

return result;

}

-/* startPtr gets set to non-null is the section is closed, and to null if

+/* startPtr gets set to non-null if the section is closed, and to null if

the section is not yet closed.

static enum XML_Error

@@ -2696,7 +3080,8 @@ doCdataSection(XML_Parser parser,

const ENCODING *enc,

const char **startPtr,

const char *end,

- const char **nextPtr)

+ const char **nextPtr,

+ XML_Bool haveMore)

{

const char *s = *startPtr;

const char **eventPP;

@@ -2712,6 +3097,7 @@ doCdataSection(XML_Parser parser,

}

*eventPP = s;

*startPtr = NULL;

for (;;) {

const char *next;

int tok = XmlCdataSectionTok(enc, s, end, &next);

@@ -2728,7 +3114,11 @@ doCdataSection(XML_Parser parser,

else if (defaultHandler)

reportDefault(parser, enc, s, next);

*startPtr = next;

- return XML_ERROR_NONE;

+ *nextPtr = next;

+ if (ps_parsing == XML_FINISHED)

+ return XML_ERROR_ABORTED;

+ else

+ return XML_ERROR_NONE;

case XML_TOK_DATA_NEWLINE:

if (characterDataHandler) {

XML_Char c = 0xA;

@@ -2745,7 +3135,7 @@ doCdataSection(XML_Parser parser,

XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd);

*eventEndPP = next;

characterDataHandler(handlerArg, dataBuf,

- dataPtr - (ICHAR *)dataBuf);

+ (int)(dataPtr - (ICHAR *)dataBuf));

if (s == next)

break;

*eventPP = s;

@@ -2754,7 +3144,7 @@ doCdataSection(XML_Parser parser,

else

characterDataHandler(handlerArg,

(XML_Char *)s,

- (XML_Char *)next - (XML_Char *)s);

+ (int)((XML_Char *)next - (XML_Char *)s));

}

else if (defaultHandler)

reportDefault(parser, enc, s, next);

@@ -2763,14 +3153,14 @@ doCdataSection(XML_Parser parser,

*eventPP = next;

return XML_ERROR_INVALID_TOKEN;

case XML_TOK_PARTIAL_CHAR:

- if (nextPtr) {

+ if (haveMore) {

*nextPtr = s;

return XML_ERROR_NONE;

}

return XML_ERROR_PARTIAL_CHAR;

case XML_TOK_PARTIAL:

case XML_TOK_NONE:

- if (nextPtr) {

+ if (haveMore) {

*nextPtr = s;

return XML_ERROR_NONE;

}

@@ -2779,7 +3169,16 @@ doCdataSection(XML_Parser parser,

*eventPP = next;

return XML_ERROR_UNEXPECTED_STATE;

}

*eventPP = s = next;

+ switch (ps_parsing) {

+ case XML_SUSPENDED:

+ *nextPtr = next;

+ return XML_ERROR_NONE;

+ case XML_FINISHED:

+ return XML_ERROR_ABORTED;

+ default: ;

+ }

}

/* not reached */

}

@@ -2795,8 +3194,10 @@ ignoreSectionProcessor(XML_Parser parser,

const char *end,

const char **endPtr)

{

- enum XML_Error result = doIgnoreSection(parser, encoding, &start,

- end, endPtr);

+ enum XML_Error result = doIgnoreSection(parser, encoding, &start, end,

+ endPtr, (XML_Bool)!ps_finalBuffer);

+ if (result != XML_ERROR_NONE)

+ return result;

if (start) {

processor = prologProcessor;

return prologProcessor(parser, start, end, endPtr);

@@ -2812,7 +3213,8 @@ doIgnoreSection(XML_Parser parser,

const ENCODING *enc,

const char **startPtr,

const char *end,

- const char **nextPtr)

+ const char **nextPtr,

+ XML_Bool haveMore)

{

const char *next;

int tok;

@@ -2837,19 +3239,23 @@ doIgnoreSection(XML_Parser parser,

if (defaultHandler)

reportDefault(parser, enc, s, next);

*startPtr = next;

- return XML_ERROR_NONE;

+ *nextPtr = next;

+ if (ps_parsing == XML_FINISHED)

+ return XML_ERROR_ABORTED;

+ else

+ return XML_ERROR_NONE;

case XML_TOK_INVALID:

*eventPP = next;

return XML_ERROR_INVALID_TOKEN;

case XML_TOK_PARTIAL_CHAR:

- if (nextPtr) {

+ if (haveMore) {

*nextPtr = s;

return XML_ERROR_NONE;

}

return XML_ERROR_PARTIAL_CHAR;

case XML_TOK_PARTIAL:

case XML_TOK_NONE:

- if (nextPtr) {

+ if (haveMore) {

*nextPtr = s;

return XML_ERROR_NONE;

}

@@ -2914,8 +3320,12 @@ processXmlDecl(XML_Parser parser, int isGeneralTextEntity,

&versionend,

&encodingName,

&newEncoding,

- &standalone))

- return XML_ERROR_SYNTAX;

+ &standalone)) {

+ if (isGeneralTextEntity)

+ return XML_ERROR_TEXT_DECL;

+ else

+ return XML_ERROR_XML_DECL;

+ }

if (!isGeneralTextEntity && standalone == 1) {

_dtd->standalone = XML_TRUE;

#ifdef XML_DTD

@@ -3061,35 +3471,47 @@ entityValueInitProcessor(XML_Parser parser,

const char *end,

const char **nextPtr)

{

- const char *start = s;

- const char *next = s;

int tok;

+ const char *start = s;

+ const char *next = start;

+ eventPtr = start;

- for (;;) {

+ for (;;) {

tok = XmlPrologTok(encoding, start, end, &next);

+ eventEndPtr = next;

if (tok <= 0) {

- if (nextPtr != 0 && tok != XML_TOK_INVALID) {

- *nextPtr = s;

- return XML_ERROR_NONE;

+ if (!ps_finalBuffer && tok != XML_TOK_INVALID) {

+ *nextPtr = s;

+ return XML_ERROR_NONE;

}

switch (tok) {

case XML_TOK_INVALID:

- return XML_ERROR_INVALID_TOKEN;

+ return XML_ERROR_INVALID_TOKEN;

case XML_TOK_PARTIAL:

- return XML_ERROR_UNCLOSED_TOKEN;

+ return XML_ERROR_UNCLOSED_TOKEN;

case XML_TOK_PARTIAL_CHAR:

- return XML_ERROR_PARTIAL_CHAR;

+ return XML_ERROR_PARTIAL_CHAR;

case XML_TOK_NONE: /* start == end */

default:

break;

}

+ /* found end of entity value - can store it now */

return storeEntityValue(parser, encoding, s, end);

}

else if (tok == XML_TOK_XML_DECL) {

- enum XML_Error result = processXmlDecl(parser, 0, start, next);

- if (result != XML_ERROR_NONE)

- return result;

- if (nextPtr) *nextPtr = next;

+ enum XML_Error result;

+ result = processXmlDecl(parser, 0, start, next);

+ if (result != XML_ERROR_NONE)

+ return result;

+ switch (ps_parsing) {

+ case XML_SUSPENDED:

+ *nextPtr = next;

+ return XML_ERROR_NONE;

+ case XML_FINISHED:

+ return XML_ERROR_ABORTED;

+ default:

+ *nextPtr = next;

+ }

/* stop scanning for text declaration - we found one */

processor = entityValueProcessor;

return entityValueProcessor(parser, next, end, nextPtr);

@@ -3101,11 +3523,12 @@ entityValueInitProcessor(XML_Parser parser,

then, when this routine is entered the next time, XmlPrologTok will

return XML_TOK_INVALID, since the BOM is still in the buffer

- else if (tok == XML_TOK_BOM && next == end && nextPtr) {

+ else if (tok == XML_TOK_BOM && next == end && !ps_finalBuffer) {

*nextPtr = next;

return XML_ERROR_NONE;

}

start = next;

+ eventPtr = start;

}

@@ -3115,13 +3538,12 @@ externalParEntProcessor(XML_Parser parser,

const char *end,

const char **nextPtr)

{

- const char *start = s;

const char *next = s;

int tok;

- tok = XmlPrologTok(encoding, start, end, &next);

+ tok = XmlPrologTok(encoding, s, end, &next);

if (tok <= 0) {

- if (nextPtr != 0 && tok != XML_TOK_INVALID) {

+ if (!ps_finalBuffer && tok != XML_TOK_INVALID) {

*nextPtr = s;

return XML_ERROR_NONE;

}

@@ -3147,7 +3569,8 @@ externalParEntProcessor(XML_Parser parser,

}

processor = prologProcessor;

- return doProlog(parser, encoding, s, end, tok, next, nextPtr);

+ return doProlog(parser, encoding, s, end, tok, next,

+ nextPtr, (XML_Bool)!ps_finalBuffer);

}

static enum XML_Error PTRCALL

@@ -3164,21 +3587,22 @@ entityValueProcessor(XML_Parser parser,

for (;;) {

tok = XmlPrologTok(enc, start, end, &next);

if (tok <= 0) {

- if (nextPtr != 0 && tok != XML_TOK_INVALID) {

+ if (!ps_finalBuffer && tok != XML_TOK_INVALID) {

*nextPtr = s;

return XML_ERROR_NONE;

}

switch (tok) {

case XML_TOK_INVALID:

- return XML_ERROR_INVALID_TOKEN;

+ return XML_ERROR_INVALID_TOKEN;

case XML_TOK_PARTIAL:

- return XML_ERROR_UNCLOSED_TOKEN;

+ return XML_ERROR_UNCLOSED_TOKEN;

case XML_TOK_PARTIAL_CHAR:

- return XML_ERROR_PARTIAL_CHAR;

+ return XML_ERROR_PARTIAL_CHAR;

case XML_TOK_NONE: /* start == end */

default:

break;

}

+ /* found end of entity value - can store it now */

return storeEntityValue(parser, enc, s, end);

}

start = next;

@@ -3195,7 +3619,8 @@ prologProcessor(XML_Parser parser,

{

const char *next = s;

int tok = XmlPrologTok(encoding, s, end, &next);

- return doProlog(parser, encoding, s, end, tok, next, nextPtr);

+ return doProlog(parser, encoding, s, end, tok, next,

+ nextPtr, (XML_Bool)!ps_finalBuffer);

}

static enum XML_Error

@@ -3205,7 +3630,8 @@ doProlog(XML_Parser parser,

const char *end,

int tok,

const char *next,

- const char **nextPtr)

+ const char **nextPtr,

+ XML_Bool haveMore)

{

#ifdef XML_DTD

static const XML_Char externalSubsetName[] = { '#' , '\0' };

@@ -3226,7 +3652,8 @@ doProlog(XML_Parser parser,

static const XML_Char enumValueSep[] = { '|', '\0' };

static const XML_Char enumValueStart[] = { '(', '\0' };

- DTD * const dtd = _dtd; /* save one level of indirection */

+ /* save one level of indirection */

+ DTD * const dtd = _dtd;

const char **eventPP;

const char **eventEndPP;

@@ -3240,13 +3667,14 @@ doProlog(XML_Parser parser,

eventPP = &(openInternalEntities->internalEventPtr);

eventEndPP = &(openInternalEntities->internalEventEndPtr);

}

for (;;) {

int role;

XML_Bool handleDefault = XML_TRUE;

*eventPP = s;

*eventEndPP = next;

if (tok <= 0) {

- if (nextPtr != 0 && tok != XML_TOK_INVALID) {

+ if (haveMore && tok != XML_TOK_INVALID) {

*nextPtr = s;

return XML_ERROR_NONE;

}

@@ -3260,12 +3688,20 @@ doProlog(XML_Parser parser,

return XML_ERROR_PARTIAL_CHAR;

case XML_TOK_NONE:

#ifdef XML_DTD

- if (enc != encoding)

+ /* for internal PE NOT referenced between declarations */

+ if (enc != encoding && !openInternalEntities->betweenDecl) {

+ *nextPtr = s;

return XML_ERROR_NONE;

- if (isParamEntity) {

+ }

+ /* WFC: PE Between Declarations - must check that PE contains

+ complete markup, not only for external PEs, but also for

+ internal PEs if the reference occurs between declarations.

+ */

+ if (isParamEntity || enc != encoding) {

if (XmlTokenRole(&prologState, XML_TOK_NONE, end, end, enc)

== XML_ROLE_ERROR)

- return XML_ERROR_SYNTAX;

+ return XML_ERROR_INCOMPLETE_PE;

+ *nextPtr = s;

return XML_ERROR_NONE;

}

#endif /* XML_DTD */

@@ -3321,28 +3757,31 @@ doProlog(XML_Parser parser,

case XML_ROLE_DOCTYPE_PUBLIC_ID:

#ifdef XML_DTD

useForeignDTD = XML_FALSE;

+ declEntity = (ENTITY *)lookup(&dtd->paramEntities,

+ externalSubsetName,

+ sizeof(ENTITY));

+ if (!declEntity)

+ return XML_ERROR_NO_MEMORY;

#endif /* XML_DTD */

dtd->hasParamEntityRefs = XML_TRUE;

if (startDoctypeDeclHandler) {

+ if (!XmlIsPublicId(enc, s, next, eventPP))

+ return XML_ERROR_PUBLICID;

doctypePubid = poolStoreString(&tempPool, enc,

s + enc->minBytesPerChar,

next - enc->minBytesPerChar);

if (!doctypePubid)

return XML_ERROR_NO_MEMORY;

+ normalizePublicId((XML_Char *)doctypePubid);

poolFinish(&tempPool);

handleDefault = XML_FALSE;

+ goto alreadyChecked;

}

-#ifdef XML_DTD

- declEntity = (ENTITY *)lookup(&dtd->paramEntities,

- externalSubsetName,

- sizeof(ENTITY));

- if (!declEntity)

- return XML_ERROR_NO_MEMORY;

-#endif /* XML_DTD */

/* fall through */

case XML_ROLE_ENTITY_PUBLIC_ID:

if (!XmlIsPublicId(enc, s, next, eventPP))

- return XML_ERROR_SYNTAX;

+ return XML_ERROR_PUBLICID;

+ alreadyChecked:

if (dtd->keepProcessing && declEntity) {

XML_Char *tem = poolStoreString(&dtd->pool,

enc,

@@ -3370,7 +3809,8 @@ doProlog(XML_Parser parser,

#ifdef XML_DTD

if (doctypeSysid || useForeignDTD) {

- dtd->hasParamEntityRefs = XML_TRUE; /* when docTypeSysid == NULL */

+ XML_Bool hadParamEntityRefs = dtd->hasParamEntityRefs;

+ dtd->hasParamEntityRefs = XML_TRUE;

if (paramEntityParsing && externalEntityRefHandler) {

ENTITY *entity = (ENTITY *)lookup(&dtd->paramEntities,

externalSubsetName,

@@ -3386,11 +3826,17 @@ doProlog(XML_Parser parser,

entity->systemId,

entity->publicId))

return XML_ERROR_EXTERNAL_ENTITY_HANDLING;

- if (dtd->paramEntityRead &&

- !dtd->standalone &&

- notStandaloneHandler &&

- !notStandaloneHandler(handlerArg))

- return XML_ERROR_NOT_STANDALONE;

+ if (dtd->paramEntityRead) {

+ if (!dtd->standalone &&

+ notStandaloneHandler &&

+ !notStandaloneHandler(handlerArg))

+ return XML_ERROR_NOT_STANDALONE;

+ }

+ /* if we didn't read the foreign DTD then this means that there

+ is no external subset and we must reset dtd->hasParamEntityRefs

+ */

+ else if (!doctypeSysid)

+ dtd->hasParamEntityRefs = hadParamEntityRefs;

/* end of DTD - no need to update dtd->keepProcessing */

}

useForeignDTD = XML_FALSE;

@@ -3407,6 +3853,7 @@ doProlog(XML_Parser parser,

last chance to read the foreign DTD

if (useForeignDTD) {

+ XML_Bool hadParamEntityRefs = dtd->hasParamEntityRefs;

dtd->hasParamEntityRefs = XML_TRUE;

if (paramEntityParsing && externalEntityRefHandler) {

ENTITY *entity = (ENTITY *)lookup(&dtd->paramEntities,

@@ -3422,11 +3869,17 @@ doProlog(XML_Parser parser,

entity->systemId,

entity->publicId))

return XML_ERROR_EXTERNAL_ENTITY_HANDLING;

- if (dtd->paramEntityRead &&

- !dtd->standalone &&

- notStandaloneHandler &&

- !notStandaloneHandler(handlerArg))

- return XML_ERROR_NOT_STANDALONE;

+ if (dtd->paramEntityRead) {

+ if (!dtd->standalone &&

+ notStandaloneHandler &&

+ !notStandaloneHandler(handlerArg))

+ return XML_ERROR_NOT_STANDALONE;

+ }

+ /* if we didn't read the foreign DTD then this means that there

+ is no external subset and we must reset dtd->hasParamEntityRefs

+ */

+ else

+ dtd->hasParamEntityRefs = hadParamEntityRefs;

/* end of DTD - no need to update dtd->keepProcessing */

}

@@ -3499,8 +3952,8 @@ doProlog(XML_Parser parser,

case XML_ROLE_REQUIRED_ATTRIBUTE_VALUE:

if (dtd->keepProcessing) {

if (!defineAttribute(declElementType, declAttributeId,

- declAttributeIsCdata, declAttributeIsId, 0,

- parser))

+ declAttributeIsCdata, declAttributeIsId,

+ 0, parser))

return XML_ERROR_NO_MEMORY;

if (attlistDeclHandler && declAttributeType) {

if (*declAttributeType == XML_T('(')

@@ -3526,11 +3979,11 @@ doProlog(XML_Parser parser,

case XML_ROLE_FIXED_ATTRIBUTE_VALUE:

if (dtd->keepProcessing) {

const XML_Char *attVal;

- enum XML_Error result

- = storeAttributeValue(parser, enc, declAttributeIsCdata,

- s + enc->minBytesPerChar,

- next - enc->minBytesPerChar,

- &dtd->pool);

+ enum XML_Error result =

+ storeAttributeValue(parser, enc, declAttributeIsCdata,

+ s + enc->minBytesPerChar,

+ next - enc->minBytesPerChar,

+ &dtd->pool);

if (result)

return result;

attVal = poolStart(&dtd->pool);

@@ -3567,7 +4020,7 @@ doProlog(XML_Parser parser,

next - enc->minBytesPerChar);

if (declEntity) {

declEntity->textPtr = poolStart(&dtd->entityValuePool);

- declEntity->textLen = poolLength(&dtd->entityValuePool);

+ declEntity->textLen = (int)(poolLength(&dtd->entityValuePool));

poolFinish(&dtd->entityValuePool);

if (entityDeclHandler) {

*eventEndPP = s;

@@ -3765,7 +4218,7 @@ doProlog(XML_Parser parser,

break;

case XML_ROLE_NOTATION_PUBLIC_ID:

if (!XmlIsPublicId(enc, s, next, eventPP))

- return XML_ERROR_SYNTAX;

+ return XML_ERROR_PUBLICID;

if (declNotationName) { /* means notationDeclHandler != NULL */

XML_Char *tem = poolStoreString(&tempPool,

enc,

@@ -3812,6 +4265,8 @@ doProlog(XML_Parser parser,

case XML_ROLE_ERROR:

switch (tok) {

case XML_TOK_PARAM_ENTITY_REF:

+ /* PE references in internal subset are

+ not allowed within declarations. */

return XML_ERROR_PARAM_ENTITY_REF;

case XML_TOK_XML_DECL:

return XML_ERROR_MISPLACED_XML_PI;

@@ -3825,8 +4280,10 @@ doProlog(XML_Parser parser,

if (defaultHandler)

reportDefault(parser, enc, s, next);

handleDefault = XML_FALSE;

- result = doIgnoreSection(parser, enc, &next, end, nextPtr);

- if (!next) {

+ result = doIgnoreSection(parser, enc, &next, end, nextPtr, haveMore);

+ if (result != XML_ERROR_NONE)

+ return result;

+ else if (!next) {

processor = ignoreSectionProcessor;

return result;

}

@@ -3891,11 +4348,6 @@ doProlog(XML_Parser parser,

case XML_ROLE_PARAM_ENTITY_REF:

#ifdef XML_DTD

case XML_ROLE_INNER_PARAM_ENTITY_REF:

- /* PE references in internal subset are

- not allowed within declarations */

- if (prologState.documentEntity &&

- role == XML_ROLE_INNER_PARAM_ENTITY_REF)

- return XML_ERROR_PARAM_ENTITY_REF;

dtd->hasParamEntityRefs = XML_TRUE;

if (!paramEntityParsing)

dtd->keepProcessing = dtd->standalone;

@@ -3935,7 +4387,9 @@ doProlog(XML_Parser parser,

return XML_ERROR_RECURSIVE_ENTITY_REF;

if (entity->textPtr) {

enum XML_Error result;

- result = processInternalParamEntity(parser, entity);

+ XML_Bool betweenDecl =

+ (role == XML_ROLE_PARAM_ENTITY_REF ? XML_TRUE : XML_FALSE);

+ result = processInternalEntity(parser, entity, betweenDecl);

if (result != XML_ERROR_NONE)

return result;

handleDefault = XML_FALSE;

@@ -4127,8 +4581,16 @@ doProlog(XML_Parser parser,

if (handleDefault && defaultHandler)

reportDefault(parser, enc, s, next);

- s = next;

- tok = XmlPrologTok(enc, s, end, &next);

+ switch (ps_parsing) {

+ case XML_SUSPENDED:

+ *nextPtr = next;

+ return XML_ERROR_NONE;

+ case XML_FINISHED:

+ return XML_ERROR_ABORTED;

+ default:

+ s = next;

+ tok = XmlPrologTok(enc, s, end, &next);

+ }

}

/* not reached */

}

@@ -4149,15 +4611,14 @@ epilogProcessor(XML_Parser parser,

/* report partial linebreak - it might be the last token */

case -XML_TOK_PROLOG_S:

if (defaultHandler) {

- eventEndPtr = next;

reportDefault(parser, encoding, s, next);

+ if (ps_parsing == XML_FINISHED)

+ return XML_ERROR_ABORTED;

}

- if (nextPtr)

- *nextPtr = next;

+ *nextPtr = next;

return XML_ERROR_NONE;

case XML_TOK_NONE:

- if (nextPtr)

- *nextPtr = s;

+ *nextPtr = s;

return XML_ERROR_NONE;

case XML_TOK_PROLOG_S:

if (defaultHandler)

@@ -4175,13 +4636,13 @@ epilogProcessor(XML_Parser parser,

eventPtr = next;

return XML_ERROR_INVALID_TOKEN;

case XML_TOK_PARTIAL:

- if (nextPtr) {

+ if (!ps_finalBuffer) {

*nextPtr = s;

return XML_ERROR_NONE;

}

return XML_ERROR_UNCLOSED_TOKEN;

case XML_TOK_PARTIAL_CHAR:

- if (nextPtr) {

+ if (!ps_finalBuffer) {

*nextPtr = s;

return XML_ERROR_NONE;

}

@@ -4190,34 +4651,134 @@ epilogProcessor(XML_Parser parser,

return XML_ERROR_JUNK_AFTER_DOC_ELEMENT;

}

eventPtr = s = next;

+ switch (ps_parsing) {

+ case XML_SUSPENDED:

+ *nextPtr = next;

+ return XML_ERROR_NONE;

+ case XML_FINISHED:

+ return XML_ERROR_ABORTED;

+ default: ;

+ }

}

-#ifdef XML_DTD

static enum XML_Error

-processInternalParamEntity(XML_Parser parser, ENTITY *entity)

+processInternalEntity(XML_Parser parser, ENTITY *entity,

+ XML_Bool betweenDecl)

{

- const char *s, *end, *next;

- int tok;

+ const char *textStart, *textEnd;

+ const char *next;

enum XML_Error result;

- OPEN_INTERNAL_ENTITY openEntity;

+ OPEN_INTERNAL_ENTITY *openEntity;

+ if (freeInternalEntities) {

+ openEntity = freeInternalEntities;

+ freeInternalEntities = openEntity->next;

+ }

+ else {

+ openEntity = (OPEN_INTERNAL_ENTITY *)MALLOC(sizeof(OPEN_INTERNAL_ENTITY));

+ if (!openEntity)

+ return XML_ERROR_NO_MEMORY;

+ }

entity->open = XML_TRUE;

- openEntity.next = openInternalEntities;

- openInternalEntities = &openEntity;

- openEntity.entity = entity;

- openEntity.internalEventPtr = NULL;

- openEntity.internalEventEndPtr = NULL;

- s = (char *)entity->textPtr;

- end = (char *)(entity->textPtr + entity->textLen);

- tok = XmlPrologTok(internalEncoding, s, end, &next);

- result = doProlog(parser, internalEncoding, s, end, tok, next, 0);

- entity->open = XML_FALSE;

- openInternalEntities = openEntity.next;

+ entity->processed = 0;

+ openEntity->next = openInternalEntities;

+ openInternalEntities = openEntity;

+ openEntity->entity = entity;

+ openEntity->startTagLevel = tagLevel;

+ openEntity->betweenDecl = betweenDecl;

+ openEntity->internalEventPtr = NULL;

+ openEntity->internalEventEndPtr = NULL;

+ textStart = (char *)entity->textPtr;

+ textEnd = (char *)(entity->textPtr + entity->textLen);

+#ifdef XML_DTD

+ if (entity->is_param) {

+ int tok = XmlPrologTok(internalEncoding, textStart, textEnd, &next);

+ result = doProlog(parser, internalEncoding, textStart, textEnd, tok,

+ next, &next, XML_FALSE);

+ }

+ else

+#endif /* XML_DTD */

+ result = doContent(parser, tagLevel, internalEncoding, textStart,

+ textEnd, &next, XML_FALSE);

+ if (result == XML_ERROR_NONE) {

+ if (textEnd != next && ps_parsing == XML_SUSPENDED) {

+ entity->processed = (int)(next - textStart);

+ processor = internalEntityProcessor;

+ }

+ else {

+ entity->open = XML_FALSE;

+ openInternalEntities = openEntity->next;

+ /* put openEntity back in list of free instances */

+ openEntity->next = freeInternalEntities;

+ freeInternalEntities = openEntity;

+ }

return result;

}

+static enum XML_Error PTRCALL

+internalEntityProcessor(XML_Parser parser,

+ const char *s,

+ const char *end,

+ const char **nextPtr)

+ ENTITY *entity;

+ const char *textStart, *textEnd;

+ const char *next;

+ enum XML_Error result;

+ OPEN_INTERNAL_ENTITY *openEntity = openInternalEntities;

+ if (!openEntity)

+ return XML_ERROR_UNEXPECTED_STATE;

+ entity = openEntity->entity;

+ textStart = ((char *)entity->textPtr) + entity->processed;

+ textEnd = (char *)(entity->textPtr + entity->textLen);

+#ifdef XML_DTD

+ if (entity->is_param) {

+ int tok = XmlPrologTok(internalEncoding, textStart, textEnd, &next);

+ result = doProlog(parser, internalEncoding, textStart, textEnd, tok,

+ next, &next, XML_FALSE);

+ }

+ else

#endif /* XML_DTD */

+ result = doContent(parser, openEntity->startTagLevel, internalEncoding,

+ textStart, textEnd, &next, XML_FALSE);

+ if (result != XML_ERROR_NONE)

+ return result;

+ else if (textEnd != next && ps_parsing == XML_SUSPENDED) {

+ entity->processed = (int)(next - (char *)entity->textPtr);

+ return result;

+ }

+ else {

+ entity->open = XML_FALSE;

+ openInternalEntities = openEntity->next;

+ /* put openEntity back in list of free instances */

+ openEntity->next = freeInternalEntities;

+ freeInternalEntities = openEntity;

+ }

+#ifdef XML_DTD

+ if (entity->is_param) {

+ int tok;

+ processor = prologProcessor;

+ tok = XmlPrologTok(encoding, s, end, &next);

+ return doProlog(parser, encoding, s, end, tok, next, nextPtr,

+ (XML_Bool)!ps_finalBuffer);

+ }

+ else

+#endif /* XML_DTD */

+ {

+ processor = contentProcessor;

+ /* see externalEntityContentProcessor vs contentProcessor */

+ return doContent(parser, parentParser ? 1 : 0, encoding, s, end,

+ nextPtr, (XML_Bool)!ps_finalBuffer);

+ }

static enum XML_Error PTRCALL

errorProcessor(XML_Parser parser,

@@ -4324,9 +4885,8 @@ appendAttributeValue(XML_Parser parser, const ENCODING *enc, XML_Bool isCdata,

return XML_ERROR_NO_MEMORY;

entity = (ENTITY *)lookup(&dtd->generalEntities, name, 0);

poolDiscard(&temp2Pool);

- /* first, determine if a check for an existing declaration is needed;

- if yes, check that the entity exists, and that it is internal,

- otherwise call the default handler (if called from content)

+ /* First, determine if a check for an existing declaration is needed;

+ if yes, check that the entity exists, and that it is internal.

if (pool == &dtd->pool) /* are we called from prolog? */

checkEntityDecl =

@@ -4345,13 +4905,16 @@ appendAttributeValue(XML_Parser parser, const ENCODING *enc, XML_Bool isCdata,

return XML_ERROR_ENTITY_DECLARED_IN_PE;

}

else if (!entity) {

- /* cannot report skipped entity here - see comments on

- skippedEntityHandler

+ /* Cannot report skipped entity here - see comments on

+ skippedEntityHandler.

if (skippedEntityHandler)

skippedEntityHandler(handlerArg, name, 0);

+ /* Cannot call the default handler because this would be

+ out of sync with the call to the startElementHandler.

if ((pool == &tempPool) && defaultHandler)

reportDefault(parser, enc, ptr, next);

+ */

break;

}

if (entity->open) {

@@ -4481,8 +5044,8 @@ storeEntityValue(XML_Parser parser,

break;

}

#endif /* XML_DTD */

- /* in the internal subset, PE references are not legal

- within markup declarations, e.g entity values in this case */

+ /* In the internal subset, PE references are not legal

+ within markup declarations, e.g entity values in this case. */

eventPtr = entityTextPtr;

result = XML_ERROR_PARAM_ENTITY_REF;

goto endEntityValue;

@@ -4651,12 +5214,12 @@ reportDefault(XML_Parser parser, const ENCODING *enc,

ICHAR *dataPtr = (ICHAR *)dataBuf;

XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)dataBufEnd);

*eventEndPP = s;

- defaultHandler(handlerArg, dataBuf, dataPtr - (ICHAR *)dataBuf);

+ defaultHandler(handlerArg, dataBuf, (int)(dataPtr - (ICHAR *)dataBuf));

*eventPP = s;

} while (s != end);

}

else

- defaultHandler(handlerArg, (XML_Char *)s, (XML_Char *)end - (XML_Char *)s);

+ defaultHandler(handlerArg, (XML_Char *)s, (int)((XML_Char *)end - (XML_Char *)s));

}

@@ -4678,7 +5241,7 @@ defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *attId, XML_Bool isCdata,

if (type->nDefaultAtts == type->allocDefaultAtts) {

if (type->allocDefaultAtts == 0) {

type->allocDefaultAtts = 8;

- type->defaultAtts = (DEFAULT_ATTRIBUTE *)MALLOC(type->allocDefaultAtts

+ type->defaultAtts = (DEFAULT_ATTRIBUTE *)MALLOC(type->allocDefaultAtts

* sizeof(DEFAULT_ATTRIBUTE));

if (!type->defaultAtts)

return 0;

@@ -4746,6 +5309,7 @@ getAttributeId(XML_Parser parser, const ENCODING *enc,

name = poolStoreString(&dtd->pool, enc, start, end);

if (!name)

return NULL;

+ /* skip quotation mark - its storage will be re-used (like in name[-1]) */

++name;

id = (ATTRIBUTE_ID *)lookup(&dtd->attributeIds, name, sizeof(ATTRIBUTE_ID));

if (!id)

@@ -4771,6 +5335,7 @@ getAttributeId(XML_Parser parser, const ENCODING *enc,

else {

int i;

for (i = 0; name[i]; i++) {

+ /* attributes without prefix are *not* in the default namespace */

if (name[i] == XML_T(':')) {

int j;

for (j = 0; j < i; j++) {

@@ -4808,7 +5373,7 @@ getContext(XML_Parser parser)

if (!poolAppendChar(&tempPool, XML_T('=')))

return NULL;

len = dtd->defaultPrefix.binding->uriLen;

- if (namespaceSeparator != XML_T('\0'))

+ if (namespaceSeparator)

len--;

for (i = 0; i < len; i++)

if (!poolAppendChar(&tempPool, dtd->defaultPrefix.binding->uri[i]))

@@ -4834,7 +5399,7 @@ getContext(XML_Parser parser)

if (!poolAppendChar(&tempPool, XML_T('=')))

return NULL;

len = prefix->binding->uriLen;

- if (namespaceSeparator != XML_T('\0'))

+ if (namespaceSeparator)

len--;

for (i = 0; i < len; i++)

if (!poolAppendChar(&tempPool, prefix->binding->uri[i]))

@@ -4908,7 +5473,7 @@ setContext(XML_Parser parser, const XML_Char *context)

return XML_FALSE;

if (!poolAppendChar(&tempPool, XML_T('\0')))

return XML_FALSE;

- if (addBinding(parser, prefix, 0, poolStart(&tempPool),

+ if (addBinding(parser, prefix, NULL, poolStart(&tempPool),

&inheritedBindings) != XML_ERROR_NONE)

return XML_FALSE;

poolDiscard(&tempPool);

@@ -4954,9 +5519,7 @@ dtdCreate(const XML_Memory_Handling_Suite *ms)

if (p == NULL)

return p;

poolInit(&(p->pool), ms);

-#ifdef XML_DTD

poolInit(&(p->entityValuePool), ms);

-#endif /* XML_DTD */

hashTableInit(&(p->generalEntities), ms);

hashTableInit(&(p->elementTypes), ms);

hashTableInit(&(p->attributeIds), ms);

@@ -5003,21 +5566,17 @@ dtdReset(DTD *p, const XML_Memory_Handling_Suite *ms)

hashTableClear(&(p->attributeIds));

hashTableClear(&(p->prefixes));

poolClear(&(p->pool));

-#ifdef XML_DTD

poolClear(&(p->entityValuePool));

-#endif /* XML_DTD */

p->defaultPrefix.name = NULL;

p->defaultPrefix.binding = NULL;

p->in_eldecl = XML_FALSE;

- if (p->scaffIndex) {

- ms->free_fcn(p->scaffIndex);

- p->scaffIndex = NULL;

- }

- if (p->scaffold) {

- ms->free_fcn(p->scaffold);

- p->scaffold = NULL;

- }

+ ms->free_fcn(p->scaffIndex);

+ p->scaffIndex = NULL;

+ ms->free_fcn(p->scaffold);

+ p->scaffold = NULL;

p->scaffLevel = 0;

p->scaffSize = 0;

p->scaffCount = 0;

@@ -5048,14 +5607,10 @@ dtdDestroy(DTD *p, XML_Bool isDocEntity, const XML_Memory_Handling_Suite *ms)

hashTableDestroy(&(p->attributeIds));

hashTableDestroy(&(p->prefixes));

poolDestroy(&(p->pool));

-#ifdef XML_DTD

poolDestroy(&(p->entityValuePool));

-#endif /* XML_DTD */

if (isDocEntity) {

- if (p->scaffIndex)

- ms->free_fcn(p->scaffIndex);

- if (p->scaffold)

- ms->free_fcn(p->scaffold);

+ ms->free_fcn(p->scaffIndex);

+ ms->free_fcn(p->scaffold);

}

ms->free_fcn(p);

}

@@ -5259,15 +5814,15 @@ copyEntityTable(HASH_TABLE *newTable,

return 1;

}

-#define INIT_SIZE 64

+#define INIT_POWER 6

-static int FASTCALL

+static XML_Bool FASTCALL

keyeq(KEY s1, KEY s2)

{

for (; *s1 == *s2; s1++, s2++)

if (*s1 == 0)

- return 1;

- return 0;

+ return XML_TRUE;

+ return XML_FALSE;

}

static unsigned long FASTCALL

@@ -5275,7 +5830,7 @@ hash(KEY s)

{

unsigned long h = 0;

while (*s)

- h = (h << 5) + h + (unsigned char)*s++;

+ h = CHAR_HASH(h, *s++);

return h;

}

@@ -5285,31 +5840,40 @@ lookup(HASH_TABLE *table, KEY name, size_t createSize)

size_t i;

if (table->size == 0) {

size_t tsize;

if (!createSize)

return NULL;

- tsize = INIT_SIZE * sizeof(NAMED *);

+ table->power = INIT_POWER;

+ /* table->size is a power of 2 */

+ table->size = (size_t)1 << INIT_POWER;

+ tsize = table->size * sizeof(NAMED *);

table->v = (NAMED **)table->mem->malloc_fcn(tsize);

- if (!table->v)

+ if (!table->v) {

+ table->size = 0;

return NULL;

+ }

memset(table->v, 0, tsize);

- table->size = INIT_SIZE;

- table->usedLim = INIT_SIZE / 2;

- i = hash(name) & (table->size - 1);

+ i = hash(name) & ((unsigned long)table->size - 1);

}

else {

unsigned long h = hash(name);

- for (i = h & (table->size - 1);

- table->v[i];

- i == 0 ? i = table->size - 1 : --i) {

+ unsigned long mask = (unsigned long)table->size - 1;

+ unsigned char step = 0;

+ i = h & mask;

+ while (table->v[i]) {

if (keyeq(name, table->v[i]->name))

return table->v[i];

+ if (!step)

+ step = PROBE_STEP(h, mask, table->power);

+ i < step ? (i += table->size - step) : (i -= step);

}

if (!createSize)

return NULL;

- if (table->used == table->usedLim) {

- /* check for overflow */

- size_t newSize = table->size * 2;

+ /* check for overflow (table is half full) */

+ if (table->used >> (table->power - 1)) {

+ unsigned char newPower = table->power + 1;

+ size_t newSize = (size_t)1 << newPower;

+ unsigned long newMask = (unsigned long)newSize - 1;

size_t tsize = newSize * sizeof(NAMED *);

NAMED **newV = (NAMED **)table->mem->malloc_fcn(tsize);

if (!newV)

@@ -5317,21 +5881,27 @@ lookup(HASH_TABLE *table, KEY name, size_t createSize)

memset(newV, 0, tsize);

for (i = 0; i < table->size; i++)

if (table->v[i]) {

- size_t j;

- for (j = hash(table->v[i]->name) & (newSize - 1);

- newV[j];

- j == 0 ? j = newSize - 1 : --j)

- ;

+ unsigned long newHash = hash(table->v[i]->name);

+ size_t j = newHash & newMask;

+ step = 0;

+ while (newV[j]) {

+ if (!step)

+ step = PROBE_STEP(newHash, newMask, newPower);

+ j < step ? (j += newSize - step) : (j -= step);

+ }

newV[j] = table->v[i];

}

table->mem->free_fcn(table->v);

table->v = newV;

+ table->power = newPower;

table->size = newSize;

- table->usedLim = newSize/2;

- for (i = h & (table->size - 1);

- table->v[i];

- i == 0 ? i = table->size - 1 : --i)

- ;

+ i = h & newMask;

+ step = 0;

+ while (table->v[i]) {

+ if (!step)

+ step = PROBE_STEP(h, newMask, newPower);

+ i < step ? (i += newSize - step) : (i -= step);

+ }

}

table->v[i] = (NAMED *)table->mem->malloc_fcn(createSize);

@@ -5348,13 +5918,9 @@ hashTableClear(HASH_TABLE *table)

{

size_t i;

for (i = 0; i < table->size; i++) {

- NAMED *p = table->v[i];

- if (p) {

- table->mem->free_fcn(p);

- table->v[i] = NULL;

- }

+ table->mem->free_fcn(table->v[i]);

+ table->v[i] = NULL;

}

- table->usedLim = table->size / 2;

table->used = 0;

}

@@ -5362,20 +5928,16 @@ static void FASTCALL

hashTableDestroy(HASH_TABLE *table)

{

size_t i;

- for (i = 0; i < table->size; i++) {

- NAMED *p = table->v[i];

- if (p)

- table->mem->free_fcn(p);

- }

- if (table->v)

- table->mem->free_fcn(table->v);

+ for (i = 0; i < table->size; i++)

+ table->mem->free_fcn(table->v[i]);

+ table->mem->free_fcn(table->v);

}

static void FASTCALL

hashTableInit(HASH_TABLE *p, const XML_Memory_Handling_Suite *ms)

{

+ p->power = 0;

p->size = 0;

- p->usedLim = 0;

p->used = 0;

p->v = NULL;

p->mem = ms;

@@ -5539,11 +6101,11 @@ poolGrow(STRING_POOL *pool)

}

if (pool->blocks && pool->start == pool->blocks->s) {

- int blockSize = (pool->end - pool->start)*2;

+ int blockSize = (int)(pool->end - pool->start)*2;

pool->blocks = (BLOCK *)

pool->mem->realloc_fcn(pool->blocks,

- (offsetof(BLOCK, s)

- + blockSize * sizeof(XML_Char)));

+ (offsetof(BLOCK, s)

+ + blockSize * sizeof(XML_Char)));

if (pool->blocks == NULL)

return XML_FALSE;

pool->blocks->size = blockSize;

@@ -5553,13 +6115,13 @@ poolGrow(STRING_POOL *pool)

}

else {

BLOCK *tem;

- int blockSize = pool->end - pool->start;

+ int blockSize = (int)(pool->end - pool->start);

if (blockSize < INIT_BLOCK_SIZE)

blockSize = INIT_BLOCK_SIZE;

else

blockSize *= 2;

tem = (BLOCK *)pool->mem->malloc_fcn(offsetof(BLOCK, s)

- + blockSize * sizeof(XML_Char));

+ + blockSize * sizeof(XML_Char));

if (!tem)

return XML_FALSE;

tem->size = blockSize;

diff --git a/lib/libexpat/lib/xmlrole.c b/lib/libexpat/lib/xmlrole.c
index 8ef185d54e3..3782f1ec441 100644
--- a/lib/libexpat/lib/xmlrole.c
+++ b/lib/libexpat/lib/xmlrole.c

@@ -2,14 +2,21 @@

See the file COPYING for copying permission.

+#include <stddef.h>

#ifdef COMPILED_FROM_DSP

#include "winconfig.h"

#elif defined(MACOS_CLASSIC)

#include "macconfig.h"

+#elif defined(__amigaos4__)

+#include "amigaconfig.h"

#else

+#ifdef HAVE_EXPAT_CONFIG_H

#include <expat_config.h>

+#endif

#endif /* ndef COMPILED_FROM_DSP */

+#include "expat_external.h"

#include "internal.h"

#include "xmlrole.h"

#include "ascii.h"

@@ -368,6 +375,8 @@ internalSubset(PROLOG_STATE *state,

case XML_TOK_CLOSE_BRACKET:

state->handler = doctype5;

return XML_ROLE_DOCTYPE_NONE;

+ case XML_TOK_NONE:

+ return XML_ROLE_NONE;

}

return common(state, tok);

}

@@ -786,7 +795,7 @@ attlist2(PROLOG_STATE *state,

return XML_ROLE_ATTLIST_NONE;

case XML_TOK_NAME:

{

- static const char *types[] = {

+ static const char * const types[] = {

KW_CDATA,

KW_ID,

KW_IDREF,

diff --git a/lib/libexpat/lib/xmltok.c b/lib/libexpat/lib/xmltok.c
index 5f101afe87e..26cee4d4e55 100644
--- a/lib/libexpat/lib/xmltok.c
+++ b/lib/libexpat/lib/xmltok.c

@@ -2,14 +2,21 @@

See the file COPYING for copying permission.

+#include <stddef.h>

#ifdef COMPILED_FROM_DSP

#include "winconfig.h"

#elif defined(MACOS_CLASSIC)

#include "macconfig.h"

+#elif defined(__amigaos4__)

+#include "amigaconfig.h"

#else

+#ifdef HAVE_EXPAT_CONFIG_H

#include <expat_config.h>

+#endif

#endif /* ndef COMPILED_FROM_DSP */

+#include "expat_external.h"

#include "internal.h"

#include "xmltok.h"

#include "nametab.h"

@@ -1231,7 +1238,7 @@ XmlUtf16Encode(int charNum, unsigned short *buf)

struct unknown_encoding {

struct normal_encoding normal;

- int (*convert)(void *userData, const char *p);

+ CONVERTER convert;

void *userData;

unsigned short utf16[256];

char utf8[256][4];

@@ -1446,7 +1453,7 @@ static const char KW_UTF_16LE[] = {

static int FASTCALL

getEncodingIndex(const char *name)

{

- static const char *encodingNames[] = {

+ static const char * const encodingNames[] = {

KW_ISO_8859_1,

KW_US_ASCII,

KW_UTF_8,

@@ -1479,7 +1486,7 @@ getEncodingIndex(const char *name)

static int

-initScan(const ENCODING **encodingTable,

+initScan(const ENCODING * const *encodingTable,

const INIT_ENCODING *enc,

int state,

const char *ptr,

diff --git a/lib/libexpat/lib/xmltok.h b/lib/libexpat/lib/xmltok.h
index 3d776be71fc..ca867aa6b42 100644
--- a/lib/libexpat/lib/xmltok.h
+++ b/lib/libexpat/lib/xmltok.h

@@ -111,8 +111,8 @@ extern "C" {

typedef struct position {

/* first line and first column are 0 not 1 */

- unsigned long lineNumber;

- unsigned long columnNumber;

+ XML_Size lineNumber;

+ XML_Size columnNumber;

} POSITION;

typedef struct {

@@ -281,7 +281,8 @@ int FASTCALL XmlUtf8Encode(int charNumber, char *buf);

int FASTCALL XmlUtf16Encode(int charNumber, unsigned short *buf);

int XmlSizeOfUnknownEncoding(void);

-typedef int (*CONVERTER)(void *userData, const char *p);

+typedef int (XMLCALL *CONVERTER) (void *userData, const char *p);

ENCODING *

XmlInitUnknownEncoding(void *mem,

diff --git a/lib/libexpat/lib/xmltok_impl.c b/lib/libexpat/lib/xmltok_impl.c
index 84a32679272..0ee57abb1f4 100644
--- a/lib/libexpat/lib/xmltok_impl.c
+++ b/lib/libexpat/lib/xmltok_impl.c

@@ -882,7 +882,7 @@ PREFIX(scanPercent)(const ENCODING *enc, const char *ptr, const char *end,

const char **nextTokPtr)

{

if (ptr == end)

- return XML_TOK_PARTIAL;

+ return -XML_TOK_PERCENT;

switch (BYTE_TYPE(enc, ptr)) {

CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)

case BT_S: case BT_LF: case BT_CR: case BT_PERCNT:

@@ -1714,7 +1714,7 @@ PREFIX(nameLength)(const ENCODING *enc, const char *ptr)

ptr += MINBPC(enc);

break;

default:

- return ptr - start;

+ return (int)(ptr - start);

}

@@ -1750,7 +1750,7 @@ PREFIX(updatePosition)(const ENCODING *enc,

LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)

#undef LEAD_CASE

case BT_LF:

- pos->columnNumber = (unsigned)-1;

+ pos->columnNumber = (XML_Size)-1;

pos->lineNumber++;

ptr += MINBPC(enc);

break;

@@ -1759,7 +1759,7 @@ PREFIX(updatePosition)(const ENCODING *enc,

ptr += MINBPC(enc);

if (ptr != end && BYTE_TYPE(enc, ptr) == BT_LF)

ptr += MINBPC(enc);

- pos->columnNumber = (unsigned)-1;

+ pos->columnNumber = (XML_Size)-1;

break;

default:

ptr += MINBPC(enc);

diff --git a/lib/libexpat/lib/xmltok_ns.c b/lib/libexpat/lib/xmltok_ns.c
index 5610eb95ba7..d2f893836fb 100644
--- a/lib/libexpat/lib/xmltok_ns.c
+++ b/lib/libexpat/lib/xmltok_ns.c

@@ -19,7 +19,7 @@ NS(XmlGetUtf16InternalEncoding)(void)

#endif

}

-static const ENCODING *NS(encodings)[] = {

+static const ENCODING * const NS(encodings)[] = {

&ns(latin1_encoding).enc,

&ns(ascii_encoding).enc,

&ns(utf8_encoding).enc,

diff --git a/lib/libexpat/shlib_version b/lib/libexpat/shlib_version
index 3066b9771e7..9c1551636c5 100644
--- a/lib/libexpat/shlib_version
+++ b/lib/libexpat/shlib_version

@@ -1,2 +1,2 @@

-major=5

+major=6

minor=0