Mirror
/
cpython
mirror of https://github.com/python/cpython
4
1
Fork 0
Code Issues Releases Wiki Activity

Upgrade pyexpat to expat 2.0.0 (http://python.org/sf/1462338).

This commit is contained in:
Trent Mick 2006-06-19 23:21:25 +00:00
parent 3dbc8916f5
commit f08d663a2f
12 changed files with 365 additions and 310 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Include/pyexpat.h
View File

@ -16,8 +16,8 @@ struct PyExpat_CAPI
the end, if needed */ the end, if needed */
const XML_LChar * (*ErrorString)(enum XML_Error code); const XML_LChar * (*ErrorString)(enum XML_Error code);
enum XML_Error (*GetErrorCode)(XML_Parser parser); enum XML_Error (*GetErrorCode)(XML_Parser parser);
int (*GetErrorColumnNumber)(XML_Parser parser); XML_Size (*GetErrorColumnNumber)(XML_Parser parser);
int (*GetErrorLineNumber)(XML_Parser parser); XML_Size (*GetErrorLineNumber)(XML_Parser parser);
enum XML_Status (*Parse)( enum XML_Status (*Parse)(
XML_Parser parser, const char *s, int len, int isFinal); XML_Parser parser, const char *s, int len, int isFinal);
XML_Parser (*ParserCreate_MM)( XML_Parser (*ParserCreate_MM)(

4
Modules/_elementtree.c
View File

@ -1989,7 +1989,7 @@ expat_default_handler(XMLParserObject* self, const XML_Char* data_in,
Py_XDECREF(res); Py_XDECREF(res);
} else { } else {
PyErr_Format( PyErr_Format(
PyExc_SyntaxError, "undefined entity &%s;: line %d, column %d", PyExc_SyntaxError, "undefined entity &%s;: line %ld, column %ld",
PyString_AS_STRING(key), PyString_AS_STRING(key),
EXPAT(GetErrorLineNumber)(self->parser), EXPAT(GetErrorLineNumber)(self->parser),
EXPAT(GetErrorColumnNumber)(self->parser) EXPAT(GetErrorColumnNumber)(self->parser)
@ -2350,7 +2350,7 @@ expat_parse(XMLParserObject* self, char* data, int data_len, int final)
if (!ok) { if (!ok) {
PyErr_Format( PyErr_Format(
PyExc_SyntaxError, "%s: line %d, column %d", PyExc_SyntaxError, "%s: line %ld, column %ld",
EXPAT(ErrorString)(EXPAT(GetErrorCode)(self->parser)), EXPAT(ErrorString)(EXPAT(GetErrorCode)(self->parser)),
EXPAT(GetErrorLineNumber)(self->parser), EXPAT(GetErrorLineNumber)(self->parser),
EXPAT(GetErrorColumnNumber)(self->parser) EXPAT(GetErrorColumnNumber)(self->parser)

158
Modules/expat/Makefile.in
View File

@ -1,158 +0,0 @@
################################################################
# Process this file with top-level configure script to produce Makefile
#
# Copyright 2000 Clark Cooper
#
# This file is part of EXPAT.
#
# EXPAT is free software; you can redistribute it and/or modify it
# under the terms of the License (based on the MIT/X license) contained
# in the file COPYING that comes with this distribution.
#
# EXPAT IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
# SOFTWARE OR THE USE OR OTHER DEALINGS IN EXPAT.
#
SHELL = @SHELL@
srcdir = @srcdir@
top_srcdir = @top_srcdir@
VPATH = @srcdir@
prefix = @prefix@
exec_prefix = @exec_prefix@
bindir = @bindir@
sbindir = @sbindir@
libexecdir = @libexecdir@
datadir = @datadir@
sysconfdir = @sysconfdir@
sharedstatedir = @sharedstatedir@
localstatedir = @localstatedir@
libdir = @libdir@
infodir = @infodir@
mandir = @mandir@
includedir = @includedir@
oldincludedir = /usr/include
subdir = lib
top_builddir = ..
INSTALL = @INSTALL@
INSTALL_PROGRAM = @INSTALL_PROGRAM@
INSTALL_SCRIPT = @INSTALL_SCRIPT@
INSTALL_DATA = @INSTALL_DATA@
host_alias = @host_alias@
host_triplet = @host@
AS = @AS@
CC = @CC@
DLLTOOL = @DLLTOOL@
LIBTOOL = @LIBTOOL@
LN_S = @LN_S@
OBJDUMP = @OBJDUMP@
PACKAGE = @PACKAGE@
RANLIB = @RANLIB@
VERSION = @VERSION@
LIBRARY = libexpat.la
SOURCES = xmlparse.c xmltok.c xmlrole.c
OBJECTS = $(SOURCES:.c=.o)
LTOBJECTS = $(SOURCES:.c=.lo)
TEMPLATES = xmltok_impl.c xmltok_ns.c
APIHEADER = expat.h
HEADERS = ascii.h iasciitab.h utf8tab.h xmltok.h asciitab.h latin1tab.h \
nametab.h xmldef.h xmlrole.h xmltok_impl.h
mkinstalldirs = $(SHELL) $(top_srcdir)/conftools/mkinstalldirs
CONFIG_HEADER = ../config.h
CONFIG_CLEAN_FILES =
INCLUDES = -I$(srcdir) -I. -I..
DEFS = @DEFS@ -DPACKAGE='"$(PACKAGE)"' -DVERSION='"$(PACKAGE)_$(VERSION)"'
CPPFLAGS = @CPPFLAGS@
LDFLAGS = @LDFLAGS@
LIBS = @LIBS@
CFLAGS = @CFLAGS@
LIBREVISION = @LIBREVISION@
LIBCURRENT = @LIBCURRENT@
LIBAGE = @LIBAGE@
COMPILE = $(CC) $(DEFS) $(INCLUDES) $(CPPFLAGS) $(CFLAGS)
LTCOMPILE = $(LIBTOOL) --mode=compile $(CC) $(DEFS) $(INCLUDES) $(CPPFLAGS) $(CFLAGS)
CCLD = $(CC)
LINK = $(LIBTOOL) --mode=link $(CCLD) -version-info $(LIBCURRENT):$(LIBREVISION):$(LIBAGE) $(CFLAGS) $(LDFLAGS) -o $@
DIST_COMMON = Makefile.in
DISTFILES = $(DIST_COMMON) $(SOURCES) $(TEMPLATES) $(APIHEADER) $(HEADERS)
TAR = gtar
GZIP_ENV = --best
all: $(LIBRARY)
.SUFFIXES: .c .lo .o
.PHONY: all clean distclean maintainer-clean
.c.o:
$(COMPILE) -c $<
.c.lo:
$(LTCOMPILE) -c $<
Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
cd $(top_builddir) \
&& CONFIG_FILES=$(subdir)/$@ CONFIG_HEADERS= $(SHELL) ./config.status
$(top_builddir)/config.status: $(top_builddir)/configure
cd $(top_builddir) && $(MAKE) config.status
$(top_builddir)/config.h: $(top_builddir)/config.h.in
cd $(top_builddir) && $(MAKE) config.h
clean:
rm -f $(LIBRARY) *.o *.lo *~
rm -rf .libs _libs
distclean: clean
rm -f Makefile
maintainer-clean: distclean
check: $(SUBDIRS)
@echo
@echo This package does not yet have a regression test.
@echo
install: $(LIBRARY) $(APIHEADER)
$(mkinstalldirs) $(libdir) $(includedir)
$(LIBTOOL) --mode=install $(INSTALL) $(LIBRARY) $(libdir)/$(LIBRARY)
$(INSTALL_DATA) $(APIHEADER) $(includedir)
uninstall:
$(LIBTOOL) --mode=uninstall rm -f $(libdir)/$(LIBRARY);
rm -f $(libdir)/$(APIHEADER)
$(LIBRARY): $(LTOBJECTS)
$(LINK) -rpath $(libdir) $(LDFLAGS) $(LTOBJECTS)
xmlparse.o \
xmlparse.lo: xmlparse.c expat.h xmlrole.h xmltok.h $(top_builddir)/config.h
xmlrole.o \
xmlrole.lo: xmlrole.c ascii.h xmlrole.h $(top_builddir)/config.h
xmltok.o \
xmltok.lo: xmltok.c xmltok_impl.c xmltok_ns.c \
ascii.h asciitab.h iasciitab.h latin1tab.h nametab.h utf8tab.h \
xmltok.h xmltok_impl.h $(top_builddir)/config.h

96
Modules/expat/amigaconfig.h Normal file
View File

@ -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 */

35
Modules/expat/expat.h
View File

@ -2,8 +2,8 @@
See the file COPYING for copying permission. See the file COPYING for copying permission.
*/ */
#ifndef XmlParse_INCLUDED #ifndef Expat_INCLUDED
#define XmlParse_INCLUDED 1 #define Expat_INCLUDED 1
#ifdef __VMS #ifdef __VMS
/* 0 1 2 3 0 1 2 3 /* 0 1 2 3 0 1 2 3
@ -17,6 +17,10 @@
#include <stdlib.h> #include <stdlib.h>
#include "expat_external.h" #include "expat_external.h"
#ifdef __cplusplus
extern "C" {
#endif
struct XML_ParserStruct; struct XML_ParserStruct;
typedef struct XML_ParserStruct *XML_Parser; typedef struct XML_ParserStruct *XML_Parser;
@ -87,7 +91,11 @@ enum XML_Error {
XML_ERROR_NOT_SUSPENDED, XML_ERROR_NOT_SUSPENDED,
XML_ERROR_ABORTED, XML_ERROR_ABORTED,
XML_ERROR_FINISHED, XML_ERROR_FINISHED,
XML_ERROR_SUSPEND_PE 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 { enum XML_Content_Type {
@ -205,8 +213,8 @@ XML_ParserCreate(const XML_Char *encoding);
URI, the namespace separator character, and the local part of the URI, the namespace separator character, and the local part of the
name. If the namespace separator is '\0' then the namespace URI name. If the namespace separator is '\0' then the namespace URI
and the local part will be concatenated without any separator. and the local part will be concatenated without any separator.
When a namespace is not declared, the name and prefix will be It is a programming error to use the separator '\0' with namespace
passed through without expansion. triplets (see XML_SetReturnNSTriplet).
*/ */
XMLPARSEAPI(XML_Parser) XMLPARSEAPI(XML_Parser)
XML_ParserCreateNS(const XML_Char *encoding, XML_Char namespaceSeparator); XML_ParserCreateNS(const XML_Char *encoding, XML_Char namespaceSeparator);
@ -897,9 +905,9 @@ XML_GetErrorCode(XML_Parser parser);
was detected; otherwise the location is the location of the last was detected; otherwise the location is the location of the last
parse event, as described above. parse event, as described above.
*/ */
XMLPARSEAPI(int) XML_GetCurrentLineNumber(XML_Parser parser); XMLPARSEAPI(XML_Size) XML_GetCurrentLineNumber(XML_Parser parser);
XMLPARSEAPI(int) XML_GetCurrentColumnNumber(XML_Parser parser); XMLPARSEAPI(XML_Size) XML_GetCurrentColumnNumber(XML_Parser parser);
XMLPARSEAPI(long) XML_GetCurrentByteIndex(XML_Parser parser); XMLPARSEAPI(XML_Index) XML_GetCurrentByteIndex(XML_Parser parser);
/* Return the number of bytes in the current event. /* Return the number of bytes in the current event.
Returns 0 if the event is in an internal entity. Returns 0 if the event is in an internal entity.
@ -974,7 +982,8 @@ enum XML_FeatureEnum {
XML_FEATURE_CONTEXT_BYTES, XML_FEATURE_CONTEXT_BYTES,
XML_FEATURE_MIN_SIZE, XML_FEATURE_MIN_SIZE,
XML_FEATURE_SIZEOF_XML_CHAR, 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. */ /* Additional features must be added to the end of this enum. */
}; };
@ -993,12 +1002,12 @@ XML_GetFeatureList(void);
releases. Micro is bumped with each release, and set to 0 with each releases. Micro is bumped with each release, and set to 0 with each
change to major or minor version. change to major or minor version.
*/ */
#define XML_MAJOR_VERSION 1 #define XML_MAJOR_VERSION 2
#define XML_MINOR_VERSION 95 #define XML_MINOR_VERSION 0
#define XML_MICRO_VERSION 8 #define XML_MICRO_VERSION 0
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* not XmlParse_INCLUDED */ #endif /* not Expat_INCLUDED */

23
Modules/expat/expat_external.h
View File

@ -2,6 +2,9 @@
See the file COPYING for copying permission. See the file COPYING for copying permission.
*/ */
#ifndef Expat_External_INCLUDED
#define Expat_External_INCLUDED 1
/* External API definitions */ /* External API definitions */
#if defined(_MSC_EXTENSIONS) && !defined(__BEOS__) && !defined(__CYGWIN__) #if defined(_MSC_EXTENSIONS) && !defined(__BEOS__) && !defined(__CYGWIN__)
@ -62,6 +65,7 @@
#endif #endif
#endif /* not defined XML_STATIC */ #endif /* not defined XML_STATIC */
/* If we didn't define it above, define it away: */ /* If we didn't define it above, define it away: */
#ifndef XMLIMPORT #ifndef XMLIMPORT
#define XMLIMPORT #define XMLIMPORT
@ -90,3 +94,22 @@ typedef char XML_LChar;
typedef char XML_Char; typedef char XML_Char;
typedef char XML_LChar; typedef char XML_LChar;
#endif /* XML_UNICODE */ #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 */

333
Modules/expat/xmlparse.c
View File

@ -8,6 +8,8 @@
#include "winconfig.h" #include "winconfig.h"
#elif defined(MACOS_CLASSIC) #elif defined(MACOS_CLASSIC)
#include "macconfig.h" #include "macconfig.h"
#elif defined(__amigaos4__)
#include "amigaconfig.h"
#elif defined(HAVE_EXPAT_CONFIG_H) #elif defined(HAVE_EXPAT_CONFIG_H)
#include <expat_config.h> #include <expat_config.h>
#endif /* ndef COMPILED_FROM_DSP */ #endif /* ndef COMPILED_FROM_DSP */
@ -456,7 +458,7 @@ struct XML_ParserStruct {
char *m_bufferEnd; char *m_bufferEnd;
/* allocated end of buffer */ /* allocated end of buffer */
const char *m_bufferLim; const char *m_bufferLim;
long m_parseEndByteIndex; XML_Index m_parseEndByteIndex;
const char *m_parseEndPtr; const char *m_parseEndPtr;
XML_Char *m_dataBuf; XML_Char *m_dataBuf;
XML_Char *m_dataBufEnd; XML_Char *m_dataBufEnd;
@ -640,8 +642,8 @@ struct XML_ParserStruct {
#define groupSize (parser->m_groupSize) #define groupSize (parser->m_groupSize)
#define namespaceSeparator (parser->m_namespaceSeparator) #define namespaceSeparator (parser->m_namespaceSeparator)
#define parentParser (parser->m_parentParser) #define parentParser (parser->m_parentParser)
#define parsing (parser->m_parsingStatus.parsing) #define ps_parsing (parser->m_parsingStatus.parsing)
#define finalBuffer (parser->m_parsingStatus.finalBuffer) #define ps_finalBuffer (parser->m_parsingStatus.finalBuffer)
#ifdef XML_DTD #ifdef XML_DTD
#define isParamEntity (parser->m_isParamEntity) #define isParamEntity (parser->m_isParamEntity)
#define useForeignDTD (parser->m_useForeignDTD) #define useForeignDTD (parser->m_useForeignDTD)
@ -852,7 +854,7 @@ parserInit(XML_Parser parser, const XML_Char *encodingName)
unknownEncodingRelease = NULL; unknownEncodingRelease = NULL;
unknownEncodingData = NULL; unknownEncodingData = NULL;
parentParser = NULL; parentParser = NULL;
parsing = XML_INITIALIZED; ps_parsing = XML_INITIALIZED;
#ifdef XML_DTD #ifdef XML_DTD
isParamEntity = XML_FALSE; isParamEntity = XML_FALSE;
useForeignDTD = XML_FALSE; useForeignDTD = XML_FALSE;
@ -915,7 +917,7 @@ XML_SetEncoding(XML_Parser parser, const XML_Char *encodingName)
XXX There's no way for the caller to determine which of the XXX There's no way for the caller to determine which of the
XXX possible error cases caused the XML_STATUS_ERROR return. XXX possible error cases caused the XML_STATUS_ERROR return.
*/ */
if (parsing == XML_PARSING || parsing == XML_SUSPENDED) if (ps_parsing == XML_PARSING || ps_parsing == XML_SUSPENDED)
return XML_STATUS_ERROR; return XML_STATUS_ERROR;
if (encodingName == NULL) if (encodingName == NULL)
protocolEncodingName = NULL; protocolEncodingName = NULL;
@ -1143,7 +1145,7 @@ XML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD)
{ {
#ifdef XML_DTD #ifdef XML_DTD
/* block after XML_Parse()/XML_ParseBuffer() has been called */ /* block after XML_Parse()/XML_ParseBuffer() has been called */
if (parsing == XML_PARSING || parsing == XML_SUSPENDED) if (ps_parsing == XML_PARSING || ps_parsing == XML_SUSPENDED)
return XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING; return XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING;
useForeignDTD = useDTD; useForeignDTD = useDTD;
return XML_ERROR_NONE; return XML_ERROR_NONE;
@ -1156,7 +1158,7 @@ void XMLCALL
XML_SetReturnNSTriplet(XML_Parser parser, int do_nst) XML_SetReturnNSTriplet(XML_Parser parser, int do_nst)
{ {
/* block after XML_Parse()/XML_ParseBuffer() has been called */ /* block after XML_Parse()/XML_ParseBuffer() has been called */
if (parsing == XML_PARSING || parsing == XML_SUSPENDED) if (ps_parsing == XML_PARSING || ps_parsing == XML_SUSPENDED)
return; return;
ns_triplets = do_nst ? XML_TRUE : XML_FALSE; ns_triplets = do_nst ? XML_TRUE : XML_FALSE;
} }
@ -1408,7 +1410,7 @@ XML_SetParamEntityParsing(XML_Parser parser,
enum XML_ParamEntityParsing peParsing) enum XML_ParamEntityParsing peParsing)
{ {
/* block after XML_Parse()/XML_ParseBuffer() has been called */ /* block after XML_Parse()/XML_ParseBuffer() has been called */
if (parsing == XML_PARSING || parsing == XML_SUSPENDED) if (ps_parsing == XML_PARSING || ps_parsing == XML_SUSPENDED)
return 0; return 0;
#ifdef XML_DTD #ifdef XML_DTD
paramEntityParsing = peParsing; paramEntityParsing = peParsing;
@ -1421,7 +1423,7 @@ XML_SetParamEntityParsing(XML_Parser parser,
enum XML_Status XMLCALL enum XML_Status XMLCALL
XML_Parse(XML_Parser parser, const char *s, int len, int isFinal) XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)
{ {
switch (parsing) { switch (ps_parsing) {
case XML_SUSPENDED: case XML_SUSPENDED:
errorCode = XML_ERROR_SUSPENDED; errorCode = XML_ERROR_SUSPENDED;
return XML_STATUS_ERROR; return XML_STATUS_ERROR;
@ -1429,11 +1431,11 @@ XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)
errorCode = XML_ERROR_FINISHED; errorCode = XML_ERROR_FINISHED;
return XML_STATUS_ERROR; return XML_STATUS_ERROR;
default: default:
parsing = XML_PARSING; ps_parsing = XML_PARSING;
} }
if (len == 0) { if (len == 0) {
finalBuffer = (XML_Bool)isFinal; ps_finalBuffer = (XML_Bool)isFinal;
if (!isFinal) if (!isFinal)
return XML_STATUS_OK; return XML_STATUS_OK;
positionPtr = bufferPtr; positionPtr = bufferPtr;
@ -1441,19 +1443,19 @@ XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)
/* If data are left over from last buffer, and we now know that these /* 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 data are the final chunk of input, then we have to check them again
to detect errors based on this information. to detect errors based on that fact.
*/ */
errorCode = processor(parser, bufferPtr, parseEndPtr, &bufferPtr); errorCode = processor(parser, bufferPtr, parseEndPtr, &bufferPtr);
if (errorCode == XML_ERROR_NONE) { if (errorCode == XML_ERROR_NONE) {
switch (parsing) { switch (ps_parsing) {
case XML_SUSPENDED: case XML_SUSPENDED:
XmlUpdatePosition(encoding, positionPtr, bufferPtr, &position); XmlUpdatePosition(encoding, positionPtr, bufferPtr, &position);
positionPtr = bufferPtr; positionPtr = bufferPtr;
return XML_STATUS_SUSPENDED; return XML_STATUS_SUSPENDED;
case XML_INITIALIZED: case XML_INITIALIZED:
case XML_PARSING: case XML_PARSING:
parsing = XML_FINISHED; ps_parsing = XML_FINISHED;
/* fall through */ /* fall through */
default: default:
return XML_STATUS_OK; return XML_STATUS_OK;
@ -1470,7 +1472,7 @@ XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)
enum XML_Error result; enum XML_Error result;
parseEndByteIndex += len; parseEndByteIndex += len;
positionPtr = s; positionPtr = s;
finalBuffer = (XML_Bool)isFinal; ps_finalBuffer = (XML_Bool)isFinal;
errorCode = processor(parser, s, parseEndPtr = s + len, &end); errorCode = processor(parser, s, parseEndPtr = s + len, &end);
@ -1480,7 +1482,7 @@ XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)
return XML_STATUS_ERROR; return XML_STATUS_ERROR;
} }
else { else {
switch (parsing) { switch (ps_parsing) {
case XML_SUSPENDED: case XML_SUSPENDED:
result = XML_STATUS_SUSPENDED; result = XML_STATUS_SUSPENDED;
break; break;
@ -1488,14 +1490,13 @@ XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)
case XML_PARSING: case XML_PARSING:
result = XML_STATUS_OK; result = XML_STATUS_OK;
if (isFinal) { if (isFinal) {
parsing = XML_FINISHED; ps_parsing = XML_FINISHED;
return result; return result;
} }
} }
} }
XmlUpdatePosition(encoding, positionPtr, end, &position); XmlUpdatePosition(encoding, positionPtr, end, &position);
positionPtr = end;
nLeftOver = s + len - end; nLeftOver = s + len - end;
if (nLeftOver) { if (nLeftOver) {
if (buffer == NULL || nLeftOver > bufferLim - buffer) { if (buffer == NULL || nLeftOver > bufferLim - buffer) {
@ -1518,9 +1519,13 @@ XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)
bufferLim = buffer + len * 2; bufferLim = buffer + len * 2;
} }
memcpy(buffer, end, nLeftOver); memcpy(buffer, end, nLeftOver);
bufferPtr = buffer;
bufferEnd = buffer + nLeftOver;
} }
bufferPtr = buffer;
bufferEnd = buffer + nLeftOver;
positionPtr = bufferPtr;
parseEndPtr = bufferEnd;
eventPtr = bufferPtr;
eventEndPtr = bufferPtr;
return result; return result;
} }
#endif /* not defined XML_CONTEXT_BYTES */ #endif /* not defined XML_CONTEXT_BYTES */
@ -1541,7 +1546,7 @@ XML_ParseBuffer(XML_Parser parser, int len, int isFinal)
const char *start; const char *start;
enum XML_Status result = XML_STATUS_OK; enum XML_Status result = XML_STATUS_OK;
switch (parsing) { switch (ps_parsing) {
case XML_SUSPENDED: case XML_SUSPENDED:
errorCode = XML_ERROR_SUSPENDED; errorCode = XML_ERROR_SUSPENDED;
return XML_STATUS_ERROR; return XML_STATUS_ERROR;
@ -1549,7 +1554,7 @@ XML_ParseBuffer(XML_Parser parser, int len, int isFinal)
errorCode = XML_ERROR_FINISHED; errorCode = XML_ERROR_FINISHED;
return XML_STATUS_ERROR; return XML_STATUS_ERROR;
default: default:
parsing = XML_PARSING; ps_parsing = XML_PARSING;
} }
start = bufferPtr; start = bufferPtr;
@ -1557,7 +1562,7 @@ XML_ParseBuffer(XML_Parser parser, int len, int isFinal)
bufferEnd += len; bufferEnd += len;
parseEndPtr = bufferEnd; parseEndPtr = bufferEnd;
parseEndByteIndex += len; parseEndByteIndex += len;
finalBuffer = (XML_Bool)isFinal; ps_finalBuffer = (XML_Bool)isFinal;
errorCode = processor(parser, start, parseEndPtr, &bufferPtr); errorCode = processor(parser, start, parseEndPtr, &bufferPtr);
@ -1567,14 +1572,14 @@ XML_ParseBuffer(XML_Parser parser, int len, int isFinal)
return XML_STATUS_ERROR; return XML_STATUS_ERROR;
} }
else { else {
switch (parsing) { switch (ps_parsing) {
case XML_SUSPENDED: case XML_SUSPENDED:
result = XML_STATUS_SUSPENDED; result = XML_STATUS_SUSPENDED;
break; break;
case XML_INITIALIZED: case XML_INITIALIZED:
case XML_PARSING: case XML_PARSING:
if (isFinal) { if (isFinal) {
parsing = XML_FINISHED; ps_parsing = XML_FINISHED;
return result; return result;
} }
default: ; /* should not happen */ default: ; /* should not happen */
@ -1589,7 +1594,7 @@ XML_ParseBuffer(XML_Parser parser, int len, int isFinal)
void * XMLCALL void * XMLCALL
XML_GetBuffer(XML_Parser parser, int len) XML_GetBuffer(XML_Parser parser, int len)
{ {
switch (parsing) { switch (ps_parsing) {
case XML_SUSPENDED: case XML_SUSPENDED:
errorCode = XML_ERROR_SUSPENDED; errorCode = XML_ERROR_SUSPENDED;
return NULL; return NULL;
@ -1601,9 +1606,9 @@ XML_GetBuffer(XML_Parser parser, int len)
if (len > bufferLim - bufferEnd) { if (len > bufferLim - bufferEnd) {
/* FIXME avoid integer overflow */ /* FIXME avoid integer overflow */
int neededSize = len + (bufferEnd - bufferPtr); int neededSize = len + (int)(bufferEnd - bufferPtr);
#ifdef XML_CONTEXT_BYTES #ifdef XML_CONTEXT_BYTES
int keep = bufferPtr - buffer; int keep = (int)(bufferPtr - buffer);
if (keep > XML_CONTEXT_BYTES) if (keep > XML_CONTEXT_BYTES)
keep = XML_CONTEXT_BYTES; keep = XML_CONTEXT_BYTES;
@ -1612,7 +1617,7 @@ XML_GetBuffer(XML_Parser parser, int len)
if (neededSize <= bufferLim - buffer) { if (neededSize <= bufferLim - buffer) {
#ifdef XML_CONTEXT_BYTES #ifdef XML_CONTEXT_BYTES
if (keep < bufferPtr - buffer) { if (keep < bufferPtr - buffer) {
int offset = (bufferPtr - buffer) - keep; int offset = (int)(bufferPtr - buffer) - keep;
memmove(buffer, &buffer[offset], bufferEnd - bufferPtr + keep); memmove(buffer, &buffer[offset], bufferEnd - bufferPtr + keep);
bufferEnd -= offset; bufferEnd -= offset;
bufferPtr -= offset; bufferPtr -= offset;
@ -1625,7 +1630,7 @@ XML_GetBuffer(XML_Parser parser, int len)
} }
else { else {
char *newBuf; char *newBuf;
int bufferSize = bufferLim - bufferPtr; int bufferSize = (int)(bufferLim - bufferPtr);
if (bufferSize == 0) if (bufferSize == 0)
bufferSize = INIT_BUFFER_SIZE; bufferSize = INIT_BUFFER_SIZE;
do { do {
@ -1639,7 +1644,7 @@ XML_GetBuffer(XML_Parser parser, int len)
bufferLim = newBuf + bufferSize; bufferLim = newBuf + bufferSize;
#ifdef XML_CONTEXT_BYTES #ifdef XML_CONTEXT_BYTES
if (bufferPtr) { if (bufferPtr) {
int keep = bufferPtr - buffer; int keep = (int)(bufferPtr - buffer);
if (keep > XML_CONTEXT_BYTES) if (keep > XML_CONTEXT_BYTES)
keep = XML_CONTEXT_BYTES; keep = XML_CONTEXT_BYTES;
memcpy(newBuf, &bufferPtr[-keep], bufferEnd - bufferPtr + keep); memcpy(newBuf, &bufferPtr[-keep], bufferEnd - bufferPtr + keep);
@ -1668,13 +1673,13 @@ XML_GetBuffer(XML_Parser parser, int len)
enum XML_Status XMLCALL enum XML_Status XMLCALL
XML_StopParser(XML_Parser parser, XML_Bool resumable) XML_StopParser(XML_Parser parser, XML_Bool resumable)
{ {
switch (parsing) { switch (ps_parsing) {
case XML_SUSPENDED: case XML_SUSPENDED:
if (resumable) { if (resumable) {
errorCode = XML_ERROR_SUSPENDED; errorCode = XML_ERROR_SUSPENDED;
return XML_STATUS_ERROR; return XML_STATUS_ERROR;
} }
parsing = XML_FINISHED; ps_parsing = XML_FINISHED;
break; break;
case XML_FINISHED: case XML_FINISHED:
errorCode = XML_ERROR_FINISHED; errorCode = XML_ERROR_FINISHED;
@ -1687,10 +1692,10 @@ XML_StopParser(XML_Parser parser, XML_Bool resumable)
return XML_STATUS_ERROR; return XML_STATUS_ERROR;
} }
#endif #endif
parsing = XML_SUSPENDED; ps_parsing = XML_SUSPENDED;
} }
else else
parsing = XML_FINISHED; ps_parsing = XML_FINISHED;
} }
return XML_STATUS_OK; return XML_STATUS_OK;
} }
@ -1700,11 +1705,11 @@ XML_ResumeParser(XML_Parser parser)
{ {
enum XML_Status result = XML_STATUS_OK; enum XML_Status result = XML_STATUS_OK;
if (parsing != XML_SUSPENDED) { if (ps_parsing != XML_SUSPENDED) {
errorCode = XML_ERROR_NOT_SUSPENDED; errorCode = XML_ERROR_NOT_SUSPENDED;
return XML_STATUS_ERROR; return XML_STATUS_ERROR;
} }
parsing = XML_PARSING; ps_parsing = XML_PARSING;
errorCode = processor(parser, bufferPtr, parseEndPtr, &bufferPtr); errorCode = processor(parser, bufferPtr, parseEndPtr, &bufferPtr);
@ -1714,14 +1719,14 @@ XML_ResumeParser(XML_Parser parser)
return XML_STATUS_ERROR; return XML_STATUS_ERROR;
} }
else { else {
switch (parsing) { switch (ps_parsing) {
case XML_SUSPENDED: case XML_SUSPENDED:
result = XML_STATUS_SUSPENDED; result = XML_STATUS_SUSPENDED;
break; break;
case XML_INITIALIZED: case XML_INITIALIZED:
case XML_PARSING: case XML_PARSING:
if (finalBuffer) { if (ps_finalBuffer) {
parsing = XML_FINISHED; ps_parsing = XML_FINISHED;
return result; return result;
} }
default: ; default: ;
@ -1746,7 +1751,7 @@ XML_GetErrorCode(XML_Parser parser)
return errorCode; return errorCode;
} }
long XMLCALL XML_Index XMLCALL
XML_GetCurrentByteIndex(XML_Parser parser) XML_GetCurrentByteIndex(XML_Parser parser)
{ {
if (eventPtr) if (eventPtr)
@ -1758,7 +1763,7 @@ int XMLCALL
XML_GetCurrentByteCount(XML_Parser parser) XML_GetCurrentByteCount(XML_Parser parser)
{ {
if (eventEndPtr && eventPtr) if (eventEndPtr && eventPtr)
return eventEndPtr - eventPtr; return (int)(eventEndPtr - eventPtr);
return 0; return 0;
} }
@ -1767,15 +1772,15 @@ XML_GetInputContext(XML_Parser parser, int *offset, int *size)
{ {
#ifdef XML_CONTEXT_BYTES #ifdef XML_CONTEXT_BYTES
if (eventPtr && buffer) { if (eventPtr && buffer) {
*offset = eventPtr - buffer; *offset = (int)(eventPtr - buffer);
*size = bufferEnd - buffer; *size = (int)(bufferEnd - buffer);
return buffer; return buffer;
} }
#endif /* defined XML_CONTEXT_BYTES */ #endif /* defined XML_CONTEXT_BYTES */
return (char *) 0; return (char *) 0;
} }
int XMLCALL XML_Size XMLCALL
XML_GetCurrentLineNumber(XML_Parser parser) XML_GetCurrentLineNumber(XML_Parser parser)
{ {
if (eventPtr && eventPtr >= positionPtr) { if (eventPtr && eventPtr >= positionPtr) {
@ -1785,7 +1790,7 @@ XML_GetCurrentLineNumber(XML_Parser parser)
return position.lineNumber + 1; return position.lineNumber + 1;
} }
int XMLCALL XML_Size XMLCALL
XML_GetCurrentColumnNumber(XML_Parser parser) XML_GetCurrentColumnNumber(XML_Parser parser)
{ {
if (eventPtr && eventPtr >= positionPtr) { if (eventPtr && eventPtr >= positionPtr) {
@ -1836,7 +1841,7 @@ XML_DefaultCurrent(XML_Parser parser)
const XML_LChar * XMLCALL const XML_LChar * XMLCALL
XML_ErrorString(enum XML_Error code) XML_ErrorString(enum XML_Error code)
{ {
static const XML_LChar *message[] = { static const XML_LChar* const message[] = {
0, 0,
XML_L("out of memory"), XML_L("out of memory"),
XML_L("syntax error"), XML_L("syntax error"),
@ -1854,7 +1859,7 @@ XML_ErrorString(enum XML_Error code)
XML_L("reference to invalid character number"), XML_L("reference to invalid character number"),
XML_L("reference to binary entity"), XML_L("reference to binary entity"),
XML_L("reference to external entity in attribute"), 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("unknown encoding"),
XML_L("encoding specified in XML declaration is incorrect"), XML_L("encoding specified in XML declaration is incorrect"),
XML_L("unclosed CDATA section"), XML_L("unclosed CDATA section"),
@ -1874,7 +1879,10 @@ XML_ErrorString(enum XML_Error code)
XML_L("parser not suspended"), XML_L("parser not suspended"),
XML_L("parsing aborted"), XML_L("parsing aborted"),
XML_L("parsing finished"), XML_L("parsing finished"),
XML_L("cannot suspend in external parameter entity") 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])) if (code > 0 && code < sizeof(message)/sizeof(message[0]))
return message[code]; return message[code];
@ -1916,9 +1924,11 @@ XML_ExpatVersionInfo(void)
const XML_Feature * XMLCALL const XML_Feature * XMLCALL
XML_GetFeatureList(void) XML_GetFeatureList(void)
{ {
static XML_Feature features[] = { static const XML_Feature features[] = {
{XML_FEATURE_SIZEOF_XML_CHAR, XML_L("sizeof(XML_Char)"), 0}, {XML_FEATURE_SIZEOF_XML_CHAR, XML_L("sizeof(XML_Char)"),
{XML_FEATURE_SIZEOF_XML_LCHAR, XML_L("sizeof(XML_LChar)"), 0}, sizeof(XML_Char)},
{XML_FEATURE_SIZEOF_XML_LCHAR, XML_L("sizeof(XML_LChar)"),
sizeof(XML_LChar)},
#ifdef XML_UNICODE #ifdef XML_UNICODE
{XML_FEATURE_UNICODE, XML_L("XML_UNICODE"), 0}, {XML_FEATURE_UNICODE, XML_L("XML_UNICODE"), 0},
#endif #endif
@ -1934,12 +1944,13 @@ XML_GetFeatureList(void)
#endif #endif
#ifdef XML_MIN_SIZE #ifdef XML_MIN_SIZE
{XML_FEATURE_MIN_SIZE, XML_L("XML_MIN_SIZE"), 0}, {XML_FEATURE_MIN_SIZE, XML_L("XML_MIN_SIZE"), 0},
#endif
#ifdef XML_NS
{XML_FEATURE_NS, XML_L("XML_NS"), 0},
#endif #endif
{XML_FEATURE_END, NULL, 0} {XML_FEATURE_END, NULL, 0}
}; };
features[0].value = sizeof(XML_Char);
features[1].value = sizeof(XML_LChar);
return features; return features;
} }
@ -2000,7 +2011,7 @@ contentProcessor(XML_Parser parser,
const char **endPtr) const char **endPtr)
{ {
enum XML_Error result = doContent(parser, 0, encoding, start, end, enum XML_Error result = doContent(parser, 0, encoding, start, end,
endPtr, (XML_Bool)!finalBuffer); endPtr, (XML_Bool)!ps_finalBuffer);
if (result == XML_ERROR_NONE) { if (result == XML_ERROR_NONE) {
if (!storeRawNames(parser)) if (!storeRawNames(parser))
return XML_ERROR_NO_MEMORY; return XML_ERROR_NO_MEMORY;
@ -2036,21 +2047,21 @@ externalEntityInitProcessor2(XML_Parser parser,
doContent (by detecting XML_TOK_NONE) without processing any xml text doContent (by detecting XML_TOK_NONE) without processing any xml text
declaration - causing the error XML_ERROR_MISPLACED_XML_PI in doContent. declaration - causing the error XML_ERROR_MISPLACED_XML_PI in doContent.
*/ */
if (next == end && !finalBuffer) { if (next == end && !ps_finalBuffer) {
*endPtr = next; *endPtr = next;
return XML_ERROR_NONE; return XML_ERROR_NONE;
} }
start = next; start = next;
break; break;
case XML_TOK_PARTIAL: case XML_TOK_PARTIAL:
if (!finalBuffer) { if (!ps_finalBuffer) {
*endPtr = start; *endPtr = start;
return XML_ERROR_NONE; return XML_ERROR_NONE;
} }
eventPtr = start; eventPtr = start;
return XML_ERROR_UNCLOSED_TOKEN; return XML_ERROR_UNCLOSED_TOKEN;
case XML_TOK_PARTIAL_CHAR: case XML_TOK_PARTIAL_CHAR:
if (!finalBuffer) { if (!ps_finalBuffer) {
*endPtr = start; *endPtr = start;
return XML_ERROR_NONE; return XML_ERROR_NONE;
} }
@ -2080,7 +2091,7 @@ externalEntityInitProcessor3(XML_Parser parser,
result = processXmlDecl(parser, 1, start, next); result = processXmlDecl(parser, 1, start, next);
if (result != XML_ERROR_NONE) if (result != XML_ERROR_NONE)
return result; return result;
switch (parsing) { switch (ps_parsing) {
case XML_SUSPENDED: case XML_SUSPENDED:
*endPtr = next; *endPtr = next;
return XML_ERROR_NONE; return XML_ERROR_NONE;
@ -2092,13 +2103,13 @@ externalEntityInitProcessor3(XML_Parser parser,
} }
break; break;
case XML_TOK_PARTIAL: case XML_TOK_PARTIAL:
if (!finalBuffer) { if (!ps_finalBuffer) {
*endPtr = start; *endPtr = start;
return XML_ERROR_NONE; return XML_ERROR_NONE;
} }
return XML_ERROR_UNCLOSED_TOKEN; return XML_ERROR_UNCLOSED_TOKEN;
case XML_TOK_PARTIAL_CHAR: case XML_TOK_PARTIAL_CHAR:
if (!finalBuffer) { if (!ps_finalBuffer) {
*endPtr = start; *endPtr = start;
return XML_ERROR_NONE; return XML_ERROR_NONE;
} }
@ -2116,7 +2127,7 @@ externalEntityContentProcessor(XML_Parser parser,
const char **endPtr) const char **endPtr)
{ {
enum XML_Error result = doContent(parser, 1, encoding, start, end, enum XML_Error result = doContent(parser, 1, encoding, start, end,
endPtr, (XML_Bool)!finalBuffer); endPtr, (XML_Bool)!ps_finalBuffer);
if (result == XML_ERROR_NONE) { if (result == XML_ERROR_NONE) {
if (!storeRawNames(parser)) if (!storeRawNames(parser))
return XML_ERROR_NO_MEMORY; return XML_ERROR_NO_MEMORY;
@ -2315,12 +2326,12 @@ doContent(XML_Parser parser,
XmlConvert(enc, XmlConvert(enc,
&fromPtr, rawNameEnd, &fromPtr, rawNameEnd,
(ICHAR **)&toPtr, (ICHAR *)tag->bufEnd - 1); (ICHAR **)&toPtr, (ICHAR *)tag->bufEnd - 1);
convLen = toPtr - (XML_Char *)tag->buf; convLen = (int)(toPtr - (XML_Char *)tag->buf);
if (fromPtr == rawNameEnd) { if (fromPtr == rawNameEnd) {
tag->name.strLen = convLen; tag->name.strLen = convLen;
break; break;
} }
bufSize = (tag->bufEnd - tag->buf) << 1; bufSize = (int)(tag->bufEnd - tag->buf) << 1;
{ {
char *temp = (char *)REALLOC(tag->buf, bufSize); char *temp = (char *)REALLOC(tag->buf, bufSize);
if (temp == NULL) if (temp == NULL)
@ -2508,12 +2519,12 @@ doContent(XML_Parser parser,
ICHAR *dataPtr = (ICHAR *)dataBuf; ICHAR *dataPtr = (ICHAR *)dataBuf;
XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)dataBufEnd); XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)dataBufEnd);
characterDataHandler(handlerArg, dataBuf, characterDataHandler(handlerArg, dataBuf,
dataPtr - (ICHAR *)dataBuf); (int)(dataPtr - (ICHAR *)dataBuf));
} }
else else
characterDataHandler(handlerArg, characterDataHandler(handlerArg,
(XML_Char *)s, (XML_Char *)s,
(XML_Char *)end - (XML_Char *)s); (int)((XML_Char *)end - (XML_Char *)s));
} }
else if (defaultHandler) else if (defaultHandler)
reportDefault(parser, enc, s, end); reportDefault(parser, enc, s, end);
@ -2538,7 +2549,7 @@ doContent(XML_Parser parser,
XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd); XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd);
*eventEndPP = s; *eventEndPP = s;
characterDataHandler(handlerArg, dataBuf, characterDataHandler(handlerArg, dataBuf,
dataPtr - (ICHAR *)dataBuf); (int)(dataPtr - (ICHAR *)dataBuf));
if (s == next) if (s == next)
break; break;
*eventPP = s; *eventPP = s;
@ -2547,7 +2558,7 @@ doContent(XML_Parser parser,
else else
characterDataHandler(handlerArg, characterDataHandler(handlerArg,
(XML_Char *)s, (XML_Char *)s,
(XML_Char *)next - (XML_Char *)s); (int)((XML_Char *)next - (XML_Char *)s));
} }
else if (defaultHandler) else if (defaultHandler)
reportDefault(parser, enc, s, next); reportDefault(parser, enc, s, next);
@ -2566,7 +2577,7 @@ doContent(XML_Parser parser,
break; break;
} }
*eventPP = s = next; *eventPP = s = next;
switch (parsing) { switch (ps_parsing) {
case XML_SUSPENDED: case XML_SUSPENDED:
*nextPtr = next; *nextPtr = next;
return XML_ERROR_NONE; return XML_ERROR_NONE;
@ -2822,7 +2833,7 @@ storeAtts(XML_Parser parser, const ENCODING *enc,
} }
if (!step) if (!step)
step = PROBE_STEP(uriHash, mask, nsAttsPower); step = PROBE_STEP(uriHash, mask, nsAttsPower);
j < step ? ( j += nsAttsSize - step) : (j -= step); j < step ? (j += nsAttsSize - step) : (j -= step);
} }
} }
@ -2845,8 +2856,10 @@ storeAtts(XML_Parser parser, const ENCODING *enc,
nsAtts[j].hash = uriHash; nsAtts[j].hash = uriHash;
nsAtts[j].uriName = s; nsAtts[j].uriName = s;
if (!--nPrefixes) if (!--nPrefixes) {
i += 2;
break; break;
}
} }
else /* not prefixed */ else /* not prefixed */
((XML_Char *)s)[-1] = 0; /* clear flag */ ((XML_Char *)s)[-1] = 0; /* clear flag */
@ -2879,14 +2892,14 @@ storeAtts(XML_Parser parser, const ENCODING *enc,
prefixLen = 0; prefixLen = 0;
if (ns_triplets && binding->prefix->name) { if (ns_triplets && binding->prefix->name) {
for (; binding->prefix->name[prefixLen++];) for (; binding->prefix->name[prefixLen++];)
; ; /* prefixLen includes null terminator */
} }
tagNamePtr->localPart = localPart; tagNamePtr->localPart = localPart;
tagNamePtr->uriLen = binding->uriLen; tagNamePtr->uriLen = binding->uriLen;
tagNamePtr->prefix = binding->prefix->name; tagNamePtr->prefix = binding->prefix->name;
tagNamePtr->prefixLen = prefixLen; tagNamePtr->prefixLen = prefixLen;
for (i = 0; localPart[i++];) for (i = 0; localPart[i++];)
; ; /* i includes null terminator */
n = i + binding->uriLen + prefixLen; n = i + binding->uriLen + prefixLen;
if (n > binding->uriAlloc) { if (n > binding->uriAlloc) {
TAG *p; TAG *p;
@ -2901,12 +2914,13 @@ storeAtts(XML_Parser parser, const ENCODING *enc,
FREE(binding->uri); FREE(binding->uri);
binding->uri = uri; binding->uri = uri;
} }
/* if namespaceSeparator != '\0' then uri includes it already */
uri = binding->uri + binding->uriLen; uri = binding->uri + binding->uriLen;
memcpy(uri, localPart, i * sizeof(XML_Char)); memcpy(uri, localPart, i * sizeof(XML_Char));
/* we always have a namespace separator between localPart and prefix */
if (prefixLen) { if (prefixLen) {
uri = uri + (i - 1); uri += i - 1;
if (namespaceSeparator) *uri = namespaceSeparator; /* replace null terminator */
*uri = namespaceSeparator;
memcpy(uri + 1, binding->prefix->name, prefixLen * sizeof(XML_Char)); memcpy(uri + 1, binding->prefix->name, prefixLen * sizeof(XML_Char));
} }
tagNamePtr->str = binding->uri; tagNamePtr->str = binding->uri;
@ -2920,6 +2934,26 @@ static enum XML_Error
addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId, addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId,
const XML_Char *uri, BINDING **bindingsPtr) 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; BINDING *b;
int len; int len;
@ -2927,8 +2961,39 @@ addBinding(XML_Parser parser, PREFIX *prefix, const ATTRIBUTE_ID *attId,
if (*uri == XML_T('\0') && prefix->name) if (*uri == XML_T('\0') && prefix->name)
return XML_ERROR_UNDECLARING_PREFIX; return XML_ERROR_UNDECLARING_PREFIX;
for (len = 0; uri[len]; len++) 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;
if (namespaceSeparator) if (namespaceSeparator)
len++; len++;
if (freeBindingList) { if (freeBindingList) {
@ -2985,7 +3050,7 @@ cdataSectionProcessor(XML_Parser parser,
const char **endPtr) const char **endPtr)
{ {
enum XML_Error result = doCdataSection(parser, encoding, &start, end, enum XML_Error result = doCdataSection(parser, encoding, &start, end,
endPtr, (XML_Bool)!finalBuffer); endPtr, (XML_Bool)!ps_finalBuffer);
if (result != XML_ERROR_NONE) if (result != XML_ERROR_NONE)
return result; return result;
if (start) { if (start) {
@ -3044,7 +3109,7 @@ doCdataSection(XML_Parser parser,
reportDefault(parser, enc, s, next); reportDefault(parser, enc, s, next);
*startPtr = next; *startPtr = next;
*nextPtr = next; *nextPtr = next;
if (parsing == XML_FINISHED) if (ps_parsing == XML_FINISHED)
return XML_ERROR_ABORTED; return XML_ERROR_ABORTED;
else else
return XML_ERROR_NONE; return XML_ERROR_NONE;
@ -3064,7 +3129,7 @@ doCdataSection(XML_Parser parser,
XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd); XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd);
*eventEndPP = next; *eventEndPP = next;
characterDataHandler(handlerArg, dataBuf, characterDataHandler(handlerArg, dataBuf,
dataPtr - (ICHAR *)dataBuf); (int)(dataPtr - (ICHAR *)dataBuf));
if (s == next) if (s == next)
break; break;
*eventPP = s; *eventPP = s;
@ -3073,7 +3138,7 @@ doCdataSection(XML_Parser parser,
else else
characterDataHandler(handlerArg, characterDataHandler(handlerArg,
(XML_Char *)s, (XML_Char *)s,
(XML_Char *)next - (XML_Char *)s); (int)((XML_Char *)next - (XML_Char *)s));
} }
else if (defaultHandler) else if (defaultHandler)
reportDefault(parser, enc, s, next); reportDefault(parser, enc, s, next);
@ -3100,7 +3165,7 @@ doCdataSection(XML_Parser parser,
} }
*eventPP = s = next; *eventPP = s = next;
switch (parsing) { switch (ps_parsing) {
case XML_SUSPENDED: case XML_SUSPENDED:
*nextPtr = next; *nextPtr = next;
return XML_ERROR_NONE; return XML_ERROR_NONE;
@ -3124,7 +3189,7 @@ ignoreSectionProcessor(XML_Parser parser,
const char **endPtr) const char **endPtr)
{ {
enum XML_Error result = doIgnoreSection(parser, encoding, &start, end, enum XML_Error result = doIgnoreSection(parser, encoding, &start, end,
endPtr, (XML_Bool)!finalBuffer); endPtr, (XML_Bool)!ps_finalBuffer);
if (result != XML_ERROR_NONE) if (result != XML_ERROR_NONE)
return result; return result;
if (start) { if (start) {
@ -3169,7 +3234,7 @@ doIgnoreSection(XML_Parser parser,
reportDefault(parser, enc, s, next); reportDefault(parser, enc, s, next);
*startPtr = next; *startPtr = next;
*nextPtr = next; *nextPtr = next;
if (parsing == XML_FINISHED) if (ps_parsing == XML_FINISHED)
return XML_ERROR_ABORTED; return XML_ERROR_ABORTED;
else else
return XML_ERROR_NONE; return XML_ERROR_NONE;
@ -3409,7 +3474,7 @@ entityValueInitProcessor(XML_Parser parser,
tok = XmlPrologTok(encoding, start, end, &next); tok = XmlPrologTok(encoding, start, end, &next);
eventEndPtr = next; eventEndPtr = next;
if (tok <= 0) { if (tok <= 0) {
if (!finalBuffer && tok != XML_TOK_INVALID) { if (!ps_finalBuffer && tok != XML_TOK_INVALID) {
*nextPtr = s; *nextPtr = s;
return XML_ERROR_NONE; return XML_ERROR_NONE;
} }
@ -3432,7 +3497,7 @@ entityValueInitProcessor(XML_Parser parser,
result = processXmlDecl(parser, 0, start, next); result = processXmlDecl(parser, 0, start, next);
if (result != XML_ERROR_NONE) if (result != XML_ERROR_NONE)
return result; return result;
switch (parsing) { switch (ps_parsing) {
case XML_SUSPENDED: case XML_SUSPENDED:
*nextPtr = next; *nextPtr = next;
return XML_ERROR_NONE; return XML_ERROR_NONE;
@ -3452,7 +3517,7 @@ entityValueInitProcessor(XML_Parser parser,
then, when this routine is entered the next time, XmlPrologTok will then, when this routine is entered the next time, XmlPrologTok will
return XML_TOK_INVALID, since the BOM is still in the buffer return XML_TOK_INVALID, since the BOM is still in the buffer
*/ */
else if (tok == XML_TOK_BOM && next == end && !finalBuffer) { else if (tok == XML_TOK_BOM && next == end && !ps_finalBuffer) {
*nextPtr = next; *nextPtr = next;
return XML_ERROR_NONE; return XML_ERROR_NONE;
} }
@ -3472,7 +3537,7 @@ externalParEntProcessor(XML_Parser parser,
tok = XmlPrologTok(encoding, s, end, &next); tok = XmlPrologTok(encoding, s, end, &next);
if (tok <= 0) { if (tok <= 0) {
if (!finalBuffer && tok != XML_TOK_INVALID) { if (!ps_finalBuffer && tok != XML_TOK_INVALID) {
*nextPtr = s; *nextPtr = s;
return XML_ERROR_NONE; return XML_ERROR_NONE;
} }
@ -3499,7 +3564,7 @@ externalParEntProcessor(XML_Parser parser,
processor = prologProcessor; processor = prologProcessor;
return doProlog(parser, encoding, s, end, tok, next, return doProlog(parser, encoding, s, end, tok, next,
nextPtr, (XML_Bool)!finalBuffer); nextPtr, (XML_Bool)!ps_finalBuffer);
} }
static enum XML_Error PTRCALL static enum XML_Error PTRCALL
@ -3516,7 +3581,7 @@ entityValueProcessor(XML_Parser parser,
for (;;) { for (;;) {
tok = XmlPrologTok(enc, start, end, &next); tok = XmlPrologTok(enc, start, end, &next);
if (tok <= 0) { if (tok <= 0) {
if (!finalBuffer && tok != XML_TOK_INVALID) { if (!ps_finalBuffer && tok != XML_TOK_INVALID) {
*nextPtr = s; *nextPtr = s;
return XML_ERROR_NONE; return XML_ERROR_NONE;
} }
@ -3549,7 +3614,7 @@ prologProcessor(XML_Parser parser,
const char *next = s; const char *next = s;
int tok = XmlPrologTok(encoding, s, end, &next); int tok = XmlPrologTok(encoding, s, end, &next);
return doProlog(parser, encoding, s, end, tok, next, return doProlog(parser, encoding, s, end, tok, next,
nextPtr, (XML_Bool)!finalBuffer); nextPtr, (XML_Bool)!ps_finalBuffer);
} }
static enum XML_Error static enum XML_Error
@ -3738,7 +3803,8 @@ doProlog(XML_Parser parser,
*/ */
#ifdef XML_DTD #ifdef XML_DTD
if (doctypeSysid || useForeignDTD) { if (doctypeSysid || useForeignDTD) {
dtd->hasParamEntityRefs = XML_TRUE; /* when docTypeSysid == NULL */ XML_Bool hadParamEntityRefs = dtd->hasParamEntityRefs;
dtd->hasParamEntityRefs = XML_TRUE;
if (paramEntityParsing && externalEntityRefHandler) { if (paramEntityParsing && externalEntityRefHandler) {
ENTITY *entity = (ENTITY *)lookup(&dtd->paramEntities, ENTITY *entity = (ENTITY *)lookup(&dtd->paramEntities,
externalSubsetName, externalSubsetName,
@ -3754,11 +3820,17 @@ doProlog(XML_Parser parser,
entity->systemId, entity->systemId,
entity->publicId)) entity->publicId))
return XML_ERROR_EXTERNAL_ENTITY_HANDLING; return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
if (dtd->paramEntityRead && if (dtd->paramEntityRead) {
!dtd->standalone && if (!dtd->standalone &&
notStandaloneHandler && notStandaloneHandler &&
!notStandaloneHandler(handlerArg)) !notStandaloneHandler(handlerArg))
return XML_ERROR_NOT_STANDALONE; 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 */ /* end of DTD - no need to update dtd->keepProcessing */
} }
useForeignDTD = XML_FALSE; useForeignDTD = XML_FALSE;
@ -3775,6 +3847,7 @@ doProlog(XML_Parser parser,
last chance to read the foreign DTD last chance to read the foreign DTD
*/ */
if (useForeignDTD) { if (useForeignDTD) {
XML_Bool hadParamEntityRefs = dtd->hasParamEntityRefs;
dtd->hasParamEntityRefs = XML_TRUE; dtd->hasParamEntityRefs = XML_TRUE;
if (paramEntityParsing && externalEntityRefHandler) { if (paramEntityParsing && externalEntityRefHandler) {
ENTITY *entity = (ENTITY *)lookup(&dtd->paramEntities, ENTITY *entity = (ENTITY *)lookup(&dtd->paramEntities,
@ -3790,11 +3863,17 @@ doProlog(XML_Parser parser,
entity->systemId, entity->systemId,
entity->publicId)) entity->publicId))
return XML_ERROR_EXTERNAL_ENTITY_HANDLING; return XML_ERROR_EXTERNAL_ENTITY_HANDLING;
if (dtd->paramEntityRead && if (dtd->paramEntityRead) {
!dtd->standalone && if (!dtd->standalone &&
notStandaloneHandler && notStandaloneHandler &&
!notStandaloneHandler(handlerArg)) !notStandaloneHandler(handlerArg))
return XML_ERROR_NOT_STANDALONE; 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 */ /* end of DTD - no need to update dtd->keepProcessing */
} }
} }
@ -3935,7 +4014,7 @@ doProlog(XML_Parser parser,
next - enc->minBytesPerChar); next - enc->minBytesPerChar);
if (declEntity) { if (declEntity) {
declEntity->textPtr = poolStart(&dtd->entityValuePool); declEntity->textPtr = poolStart(&dtd->entityValuePool);
declEntity->textLen = poolLength(&dtd->entityValuePool); declEntity->textLen = (int)(poolLength(&dtd->entityValuePool));
poolFinish(&dtd->entityValuePool); poolFinish(&dtd->entityValuePool);
if (entityDeclHandler) { if (entityDeclHandler) {
*eventEndPP = s; *eventEndPP = s;
@ -4496,7 +4575,7 @@ doProlog(XML_Parser parser,
if (handleDefault && defaultHandler) if (handleDefault && defaultHandler)
reportDefault(parser, enc, s, next); reportDefault(parser, enc, s, next);
switch (parsing) { switch (ps_parsing) {
case XML_SUSPENDED: case XML_SUSPENDED:
*nextPtr = next; *nextPtr = next;
return XML_ERROR_NONE; return XML_ERROR_NONE;
@ -4527,7 +4606,7 @@ epilogProcessor(XML_Parser parser,
case -XML_TOK_PROLOG_S: case -XML_TOK_PROLOG_S:
if (defaultHandler) { if (defaultHandler) {
reportDefault(parser, encoding, s, next); reportDefault(parser, encoding, s, next);
if (parsing == XML_FINISHED) if (ps_parsing == XML_FINISHED)
return XML_ERROR_ABORTED; return XML_ERROR_ABORTED;
} }
*nextPtr = next; *nextPtr = next;
@ -4551,13 +4630,13 @@ epilogProcessor(XML_Parser parser,
eventPtr = next; eventPtr = next;
return XML_ERROR_INVALID_TOKEN; return XML_ERROR_INVALID_TOKEN;
case XML_TOK_PARTIAL: case XML_TOK_PARTIAL:
if (!finalBuffer) { if (!ps_finalBuffer) {
*nextPtr = s; *nextPtr = s;
return XML_ERROR_NONE; return XML_ERROR_NONE;
} }
return XML_ERROR_UNCLOSED_TOKEN; return XML_ERROR_UNCLOSED_TOKEN;
case XML_TOK_PARTIAL_CHAR: case XML_TOK_PARTIAL_CHAR:
if (!finalBuffer) { if (!ps_finalBuffer) {
*nextPtr = s; *nextPtr = s;
return XML_ERROR_NONE; return XML_ERROR_NONE;
} }
@ -4566,7 +4645,7 @@ epilogProcessor(XML_Parser parser,
return XML_ERROR_JUNK_AFTER_DOC_ELEMENT; return XML_ERROR_JUNK_AFTER_DOC_ELEMENT;
} }
eventPtr = s = next; eventPtr = s = next;
switch (parsing) { switch (ps_parsing) {
case XML_SUSPENDED: case XML_SUSPENDED:
*nextPtr = next; *nextPtr = next;
return XML_ERROR_NONE; return XML_ERROR_NONE;
@ -4619,8 +4698,8 @@ processInternalEntity(XML_Parser parser, ENTITY *entity,
textEnd, &next, XML_FALSE); textEnd, &next, XML_FALSE);
if (result == XML_ERROR_NONE) { if (result == XML_ERROR_NONE) {
if (textEnd != next && parsing == XML_SUSPENDED) { if (textEnd != next && ps_parsing == XML_SUSPENDED) {
entity->processed = next - textStart; entity->processed = (int)(next - textStart);
processor = internalEntityProcessor; processor = internalEntityProcessor;
} }
else { else {
@ -4665,8 +4744,8 @@ internalEntityProcessor(XML_Parser parser,
if (result != XML_ERROR_NONE) if (result != XML_ERROR_NONE)
return result; return result;
else if (textEnd != next && parsing == XML_SUSPENDED) { else if (textEnd != next && ps_parsing == XML_SUSPENDED) {
entity->processed = next - (char *)entity->textPtr; entity->processed = (int)(next - (char *)entity->textPtr);
return result; return result;
} }
else { else {
@ -4683,7 +4762,7 @@ internalEntityProcessor(XML_Parser parser,
processor = prologProcessor; processor = prologProcessor;
tok = XmlPrologTok(encoding, s, end, &next); 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)!finalBuffer); (XML_Bool)!ps_finalBuffer);
} }
else else
#endif /* XML_DTD */ #endif /* XML_DTD */
@ -4691,7 +4770,7 @@ internalEntityProcessor(XML_Parser parser,
processor = contentProcessor; processor = contentProcessor;
/* see externalEntityContentProcessor vs contentProcessor */ /* see externalEntityContentProcessor vs contentProcessor */
return doContent(parser, parentParser ? 1 : 0, encoding, s, end, return doContent(parser, parentParser ? 1 : 0, encoding, s, end,
nextPtr, (XML_Bool)!finalBuffer); nextPtr, (XML_Bool)!ps_finalBuffer);
} }
} }
@ -4800,9 +4879,8 @@ appendAttributeValue(XML_Parser parser, const ENCODING *enc, XML_Bool isCdata,
return XML_ERROR_NO_MEMORY; return XML_ERROR_NO_MEMORY;
entity = (ENTITY *)lookup(&dtd->generalEntities, name, 0); entity = (ENTITY *)lookup(&dtd->generalEntities, name, 0);
poolDiscard(&temp2Pool); poolDiscard(&temp2Pool);
/* first, determine if a check for an existing declaration is needed; /* First, determine if a check for an existing declaration is needed;
if yes, check that the entity exists, and that it is internal, if yes, check that the entity exists, and that it is internal.
otherwise call the default handler (if called from content)
*/ */
if (pool == &dtd->pool) /* are we called from prolog? */ if (pool == &dtd->pool) /* are we called from prolog? */
checkEntityDecl = checkEntityDecl =
@ -4821,13 +4899,16 @@ appendAttributeValue(XML_Parser parser, const ENCODING *enc, XML_Bool isCdata,
return XML_ERROR_ENTITY_DECLARED_IN_PE; return XML_ERROR_ENTITY_DECLARED_IN_PE;
} }
else if (!entity) { else if (!entity) {
/* cannot report skipped entity here - see comments on /* Cannot report skipped entity here - see comments on
skippedEntityHandler skippedEntityHandler.
if (skippedEntityHandler) if (skippedEntityHandler)
skippedEntityHandler(handlerArg, name, 0); 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) if ((pool == &tempPool) && defaultHandler)
reportDefault(parser, enc, ptr, next); reportDefault(parser, enc, ptr, next);
*/
break; break;
} }
if (entity->open) { if (entity->open) {
@ -5127,12 +5208,12 @@ reportDefault(XML_Parser parser, const ENCODING *enc,
ICHAR *dataPtr = (ICHAR *)dataBuf; ICHAR *dataPtr = (ICHAR *)dataBuf;
XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)dataBufEnd); XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)dataBufEnd);
*eventEndPP = s; *eventEndPP = s;
defaultHandler(handlerArg, dataBuf, dataPtr - (ICHAR *)dataBuf); defaultHandler(handlerArg, dataBuf, (int)(dataPtr - (ICHAR *)dataBuf));
*eventPP = s; *eventPP = s;
} while (s != end); } while (s != end);
} }
else else
defaultHandler(handlerArg, (XML_Char *)s, (XML_Char *)end - (XML_Char *)s); defaultHandler(handlerArg, (XML_Char *)s, (int)((XML_Char *)end - (XML_Char *)s));
} }
@ -5286,7 +5367,7 @@ getContext(XML_Parser parser)
if (!poolAppendChar(&tempPool, XML_T('='))) if (!poolAppendChar(&tempPool, XML_T('=')))
return NULL; return NULL;
len = dtd->defaultPrefix.binding->uriLen; len = dtd->defaultPrefix.binding->uriLen;
if (namespaceSeparator != XML_T('\0')) if (namespaceSeparator)
len--; len--;
for (i = 0; i < len; i++) for (i = 0; i < len; i++)
if (!poolAppendChar(&tempPool, dtd->defaultPrefix.binding->uri[i])) if (!poolAppendChar(&tempPool, dtd->defaultPrefix.binding->uri[i]))
@ -5312,7 +5393,7 @@ getContext(XML_Parser parser)
if (!poolAppendChar(&tempPool, XML_T('='))) if (!poolAppendChar(&tempPool, XML_T('=')))
return NULL; return NULL;
len = prefix->binding->uriLen; len = prefix->binding->uriLen;
if (namespaceSeparator != XML_T('\0')) if (namespaceSeparator)
len--; len--;
for (i = 0; i < len; i++) for (i = 0; i < len; i++)
if (!poolAppendChar(&tempPool, prefix->binding->uri[i])) if (!poolAppendChar(&tempPool, prefix->binding->uri[i]))
@ -6014,7 +6095,7 @@ poolGrow(STRING_POOL *pool)
} }
} }
if (pool->blocks && pool->start == pool->blocks->s) { 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->blocks = (BLOCK *)
pool->mem->realloc_fcn(pool->blocks, pool->mem->realloc_fcn(pool->blocks,
(offsetof(BLOCK, s) (offsetof(BLOCK, s)
@ -6028,7 +6109,7 @@ poolGrow(STRING_POOL *pool)
} }
else { else {
BLOCK *tem; BLOCK *tem;
int blockSize = pool->end - pool->start; int blockSize = (int)(pool->end - pool->start);
if (blockSize < INIT_BLOCK_SIZE) if (blockSize < INIT_BLOCK_SIZE)
blockSize = INIT_BLOCK_SIZE; blockSize = INIT_BLOCK_SIZE;
else else

4
Modules/expat/xmlrole.c
View File

@ -6,6 +6,8 @@
#include "winconfig.h" #include "winconfig.h"
#elif defined(MACOS_CLASSIC) #elif defined(MACOS_CLASSIC)
#include "macconfig.h" #include "macconfig.h"
#elif defined(__amigaos4__)
#include "amigaconfig.h"
#else #else
#ifdef HAVE_EXPAT_CONFIG_H #ifdef HAVE_EXPAT_CONFIG_H
#include <expat_config.h> #include <expat_config.h>
@ -793,7 +795,7 @@ attlist2(PROLOG_STATE *state,
return XML_ROLE_ATTLIST_NONE; return XML_ROLE_ATTLIST_NONE;
case XML_TOK_NAME: case XML_TOK_NAME:
{ {
static const char *types[] = { static const char * const types[] = {
KW_CDATA, KW_CDATA,
KW_ID, KW_ID,
KW_IDREF, KW_IDREF,

6
Modules/expat/xmltok.c
View File

@ -6,6 +6,8 @@
#include "winconfig.h" #include "winconfig.h"
#elif defined(MACOS_CLASSIC) #elif defined(MACOS_CLASSIC)
#include "macconfig.h" #include "macconfig.h"
#elif defined(__amigaos4__)
#include "amigaconfig.h"
#else #else
#ifdef HAVE_EXPAT_CONFIG_H #ifdef HAVE_EXPAT_CONFIG_H
#include <expat_config.h> #include <expat_config.h>
@ -1451,7 +1453,7 @@ static const char KW_UTF_16LE[] = {
static int FASTCALL static int FASTCALL
getEncodingIndex(const char *name) getEncodingIndex(const char *name)
{ {
static const char *encodingNames[] = { static const char * const encodingNames[] = {
KW_ISO_8859_1, KW_ISO_8859_1,
KW_US_ASCII, KW_US_ASCII,
KW_UTF_8, KW_UTF_8,
@ -1484,7 +1486,7 @@ getEncodingIndex(const char *name)
static int static int
initScan(const ENCODING **encodingTable, initScan(const ENCODING * const *encodingTable,
const INIT_ENCODING *enc, const INIT_ENCODING *enc,
int state, int state,
const char *ptr, const char *ptr,

4
Modules/expat/xmltok.h
View File

@ -111,8 +111,8 @@ extern "C" {
typedef struct position { typedef struct position {
/* first line and first column are 0 not 1 */ /* first line and first column are 0 not 1 */
unsigned long lineNumber; XML_Size lineNumber;
unsigned long columnNumber; XML_Size columnNumber;
} POSITION; } POSITION;
typedef struct { typedef struct {

6
Modules/expat/xmltok_impl.c
View File

@ -1714,7 +1714,7 @@ PREFIX(nameLength)(const ENCODING *enc, const char *ptr)
ptr += MINBPC(enc); ptr += MINBPC(enc);
break; break;
default: 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) LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
#undef LEAD_CASE #undef LEAD_CASE
case BT_LF: case BT_LF:
pos->columnNumber = (unsigned)-1; pos->columnNumber = (XML_Size)-1;
pos->lineNumber++; pos->lineNumber++;
ptr += MINBPC(enc); ptr += MINBPC(enc);
break; break;
@ -1759,7 +1759,7 @@ PREFIX(updatePosition)(const ENCODING *enc,
ptr += MINBPC(enc); ptr += MINBPC(enc);
if (ptr != end && BYTE_TYPE(enc, ptr) == BT_LF) if (ptr != end && BYTE_TYPE(enc, ptr) == BT_LF)
ptr += MINBPC(enc); ptr += MINBPC(enc);
pos->columnNumber = (unsigned)-1; pos->columnNumber = (XML_Size)-1;
break; break;
default: default:
ptr += MINBPC(enc); ptr += MINBPC(enc);

2
Modules/expat/xmltok_ns.c
View File

@ -19,7 +19,7 @@ NS(XmlGetUtf16InternalEncoding)(void)
#endif #endif
} }
static const ENCODING *NS(encodings)[] = { static const ENCODING * const NS(encodings)[] = {
&ns(latin1_encoding).enc, &ns(latin1_encoding).enc,
&ns(ascii_encoding).enc, &ns(ascii_encoding).enc,
&ns(utf8_encoding).enc, &ns(utf8_encoding).enc,