traverseda
/
cpython
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

closes bpo-38174: Update vendored expat library to 2.2.8. (GH-16346) 

Fixes CVE-2019-15903. See full changelog at https://github.com/libexpat/libexpat/blob/R_2_2_8/expat/Changes.
This commit is contained in:
Benjamin Peterson 2019-09-25 21:33:58 -07:00 committed by GitHub
parent 49d99f01e6
commit 52b9408038
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
24 changed files with 3972 additions and 4841 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Misc/NEWS.d/next/Security/2019-09-23-21-02-46.bpo-38174.MeWuJd.rst Normal file
View File

@ -0,0 +1,2 @@
Update vendorized expat library version to 2.2.8, which resolves
CVE-2019-15903.

137
Modules/expat/expat.h
View File

@ -33,15 +33,6 @@
#ifndef Expat_INCLUDED #ifndef Expat_INCLUDED
#define Expat_INCLUDED 1 #define Expat_INCLUDED 1
#ifdef __VMS
/* 0 1 2 3 0 1 2 3
1234567890123456789012345678901 1234567890123456789012345678901 */
#define XML_SetProcessingInstructionHandler XML_SetProcessingInstrHandler
#define XML_SetUnparsedEntityDeclHandler XML_SetUnparsedEntDeclHandler
#define XML_SetStartNamespaceDeclHandler XML_SetStartNamespcDeclHandler
#define XML_SetExternalEntityRefHandlerArg XML_SetExternalEntRefHandlerArg
#endif
#include <stdlib.h> #include <stdlib.h>
#include "expat_external.h" #include "expat_external.h"
@ -171,7 +162,6 @@ struct XML_cp {
XML_Content *children; XML_Content *children;
}; };
/* This is called for an element declaration. See above for /* This is called for an element declaration. See above for
description of the model argument. It's the caller's responsibility description of the model argument. It's the caller's responsibility
to free model when finished with it. to free model when finished with it.
@ -181,8 +171,7 @@ typedef void (XMLCALL *XML_ElementDeclHandler) (void *userData,
XML_Content *model); XML_Content *model);
XMLPARSEAPI(void) XMLPARSEAPI(void)
XML_SetElementDeclHandler(XML_Parser parser, XML_SetElementDeclHandler(XML_Parser parser, XML_ElementDeclHandler eldecl);
XML_ElementDeclHandler eldecl);
/* The Attlist declaration handler is called for *each* attribute. So /* The Attlist declaration handler is called for *each* attribute. So
a single Attlist declaration with multiple attributes declared will a single Attlist declaration with multiple attributes declared will
@ -193,16 +182,11 @@ XML_SetElementDeclHandler(XML_Parser parser,
true and default is non-NULL, then this is a "#FIXED" default. true and default is non-NULL, then this is a "#FIXED" default.
*/ */
typedef void(XMLCALL *XML_AttlistDeclHandler)( typedef void(XMLCALL *XML_AttlistDeclHandler)(
void *userData, void *userData, const XML_Char *elname, const XML_Char *attname,
const XML_Char *elname, const XML_Char *att_type, const XML_Char *dflt, int isrequired);
const XML_Char *attname,
const XML_Char *att_type,
const XML_Char *dflt,
int isrequired);
XMLPARSEAPI(void) XMLPARSEAPI(void)
XML_SetAttlistDeclHandler(XML_Parser parser, XML_SetAttlistDeclHandler(XML_Parser parser, XML_AttlistDeclHandler attdecl);
XML_AttlistDeclHandler attdecl);
/* The XML declaration handler is called for *both* XML declarations /* The XML declaration handler is called for *both* XML declarations
and text declarations. The way to distinguish is that the version and text declarations. The way to distinguish is that the version
@ -218,9 +202,7 @@ typedef void (XMLCALL *XML_XmlDeclHandler) (void *userData,
int standalone); int standalone);
XMLPARSEAPI(void) XMLPARSEAPI(void)
XML_SetXmlDeclHandler(XML_Parser parser, XML_SetXmlDeclHandler(XML_Parser parser, XML_XmlDeclHandler xmldecl);
XML_XmlDeclHandler xmldecl);
typedef struct { typedef struct {
void *(*malloc_fcn)(size_t size); void *(*malloc_fcn)(size_t size);
@ -248,7 +230,6 @@ XML_ParserCreate(const XML_Char *encoding);
XMLPARSEAPI(XML_Parser) XMLPARSEAPI(XML_Parser)
XML_ParserCreateNS(const XML_Char *encoding, XML_Char namespaceSeparator); XML_ParserCreateNS(const XML_Char *encoding, XML_Char namespaceSeparator);
/* Constructs a new parser using the memory management suite referred to /* Constructs a new parser using the memory management suite referred to
by memsuite. If memsuite is NULL, then use the standard library memory by memsuite. If memsuite is NULL, then use the standard library memory
suite. If namespaceSeparator is non-NULL it creates a parser with suite. If namespaceSeparator is non-NULL it creates a parser with
@ -265,7 +246,7 @@ XML_ParserCreate_MM(const XML_Char *encoding,
/* Prepare a parser object to be re-used. This is particularly /* Prepare a parser object to be re-used. This is particularly
valuable when memory allocation overhead is disproportionately high, valuable when memory allocation overhead is disproportionately high,
such as when a large number of small documents need to be parsed. such as when a large number of small documnents need to be parsed.
All handlers are cleared from the parser, except for the All handlers are cleared from the parser, except for the
unknownEncodingHandler. The parser's external state is re-initialized unknownEncodingHandler. The parser's external state is re-initialized
except for the values of ns and ns_triplets. except for the values of ns and ns_triplets.
@ -285,21 +266,17 @@ typedef void (XMLCALL *XML_StartElementHandler) (void *userData,
typedef void(XMLCALL *XML_EndElementHandler)(void *userData, typedef void(XMLCALL *XML_EndElementHandler)(void *userData,
const XML_Char *name); const XML_Char *name);
/* s is not 0 terminated. */ /* s is not 0 terminated. */
typedef void(XMLCALL *XML_CharacterDataHandler)(void *userData, typedef void(XMLCALL *XML_CharacterDataHandler)(void *userData,
const XML_Char *s, const XML_Char *s, int len);
int len);
/* target and data are 0 terminated */ /* target and data are 0 terminated */
typedef void (XMLCALL *XML_ProcessingInstructionHandler) ( typedef void(XMLCALL *XML_ProcessingInstructionHandler)(void *userData,
void *userData,
const XML_Char *target, const XML_Char *target,
const XML_Char *data); const XML_Char *data);
/* data is 0 terminated */ /* data is 0 terminated */
typedef void (XMLCALL *XML_CommentHandler) (void *userData, typedef void(XMLCALL *XML_CommentHandler)(void *userData, const XML_Char *data);
const XML_Char *data);
typedef void(XMLCALL *XML_StartCdataSectionHandler)(void *userData); typedef void(XMLCALL *XML_StartCdataSectionHandler)(void *userData);
typedef void(XMLCALL *XML_EndCdataSectionHandler)(void *userData); typedef void(XMLCALL *XML_EndCdataSectionHandler)(void *userData);
@ -317,15 +294,13 @@ typedef void (XMLCALL *XML_EndCdataSectionHandler) (void *userData);
default handler: for example, a comment might be split between default handler: for example, a comment might be split between
multiple calls. multiple calls.
*/ */
typedef void (XMLCALL *XML_DefaultHandler) (void *userData, typedef void(XMLCALL *XML_DefaultHandler)(void *userData, const XML_Char *s,
const XML_Char *s,
int len); int len);
/* This is called for the start of the DOCTYPE declaration, before /* This is called for the start of the DOCTYPE declaration, before
any DTD or internal subset is parsed. any DTD or internal subset is parsed.
*/ */
typedef void (XMLCALL *XML_StartDoctypeDeclHandler) ( typedef void(XMLCALL *XML_StartDoctypeDeclHandler)(void *userData,
void *userData,
const XML_Char *doctypeName, const XML_Char *doctypeName,
const XML_Char *sysid, const XML_Char *sysid,
const XML_Char *pubid, const XML_Char *pubid,
@ -356,19 +331,13 @@ typedef void (XMLCALL *XML_EndDoctypeDeclHandler)(void *userData);
that would break binary compatibility. that would break binary compatibility.
*/ */
typedef void(XMLCALL *XML_EntityDeclHandler)( typedef void(XMLCALL *XML_EntityDeclHandler)(
void *userData, void *userData, const XML_Char *entityName, int is_parameter_entity,
const XML_Char *entityName, const XML_Char *value, int value_length, const XML_Char *base,
int is_parameter_entity, const XML_Char *systemId, const XML_Char *publicId,
const XML_Char *value,
int value_length,
const XML_Char *base,
const XML_Char *systemId,
const XML_Char *publicId,
const XML_Char *notationName); const XML_Char *notationName);
XMLPARSEAPI(void) XMLPARSEAPI(void)
XML_SetEntityDeclHandler(XML_Parser parser, XML_SetEntityDeclHandler(XML_Parser parser, XML_EntityDeclHandler handler);
XML_EntityDeclHandler handler);
/* OBSOLETE -- OBSOLETE -- OBSOLETE /* OBSOLETE -- OBSOLETE -- OBSOLETE
This handler has been superseded by the EntityDeclHandler above. This handler has been superseded by the EntityDeclHandler above.
@ -380,19 +349,15 @@ XML_SetEntityDeclHandler(XML_Parser parser,
NULL. The other arguments may be. NULL. The other arguments may be.
*/ */
typedef void(XMLCALL *XML_UnparsedEntityDeclHandler)( typedef void(XMLCALL *XML_UnparsedEntityDeclHandler)(
void *userData, void *userData, const XML_Char *entityName, const XML_Char *base,
const XML_Char *entityName, const XML_Char *systemId, const XML_Char *publicId,
const XML_Char *base,
const XML_Char *systemId,
const XML_Char *publicId,
const XML_Char *notationName); const XML_Char *notationName);
/* This is called for a declaration of notation. The base argument is /* This is called for a declaration of notation. The base argument is
whatever was set by XML_SetBase. The notationName will never be whatever was set by XML_SetBase. The notationName will never be
NULL. The other arguments can be. NULL. The other arguments can be.
*/ */
typedef void (XMLCALL *XML_NotationDeclHandler) ( typedef void(XMLCALL *XML_NotationDeclHandler)(void *userData,
void *userData,
const XML_Char *notationName, const XML_Char *notationName,
const XML_Char *base, const XML_Char *base,
const XML_Char *systemId, const XML_Char *systemId,
@ -404,13 +369,11 @@ typedef void (XMLCALL *XML_NotationDeclHandler) (
declaration handlers. For an xmlns attribute, prefix will be declaration handlers. For an xmlns attribute, prefix will be
NULL. For an xmlns="" attribute, uri will be NULL. NULL. For an xmlns="" attribute, uri will be NULL.
*/ */
typedef void (XMLCALL *XML_StartNamespaceDeclHandler) ( typedef void(XMLCALL *XML_StartNamespaceDeclHandler)(void *userData,
void *userData,
const XML_Char *prefix, const XML_Char *prefix,
const XML_Char *uri); const XML_Char *uri);
typedef void (XMLCALL *XML_EndNamespaceDeclHandler) ( typedef void(XMLCALL *XML_EndNamespaceDeclHandler)(void *userData,
void *userData,
const XML_Char *prefix); const XML_Char *prefix);
/* This is called if the document is not standalone, that is, it has an /* This is called if the document is not standalone, that is, it has an
@ -458,8 +421,7 @@ typedef int (XMLCALL *XML_NotStandaloneHandler) (void *userData);
Note that unlike other handlers the first argument is the parser, Note that unlike other handlers the first argument is the parser,
not userData. not userData.
*/ */
typedef int (XMLCALL *XML_ExternalEntityRefHandler) ( typedef int(XMLCALL *XML_ExternalEntityRefHandler)(XML_Parser parser,
XML_Parser parser,
const XML_Char *context, const XML_Char *context,
const XML_Char *base, const XML_Char *base,
const XML_Char *systemId, const XML_Char *systemId,
@ -475,8 +437,7 @@ typedef int (XMLCALL *XML_ExternalEntityRefHandler) (
the event would be out of sync with the reporting of the the event would be out of sync with the reporting of the
declarations or attribute values declarations or attribute values
*/ */
typedef void (XMLCALL *XML_SkippedEntityHandler) ( typedef void(XMLCALL *XML_SkippedEntityHandler)(void *userData,
void *userData,
const XML_Char *entityName, const XML_Char *entityName,
int is_parameter_entity); int is_parameter_entity);
@ -554,23 +515,19 @@ typedef struct {
If info does not describe a suitable encoding, then the parser will If info does not describe a suitable encoding, then the parser will
return an XML_UNKNOWN_ENCODING error. return an XML_UNKNOWN_ENCODING error.
*/ */
typedef int (XMLCALL *XML_UnknownEncodingHandler) ( typedef int(XMLCALL *XML_UnknownEncodingHandler)(void *encodingHandlerData,
void *encodingHandlerData,
const XML_Char *name, const XML_Char *name,
XML_Encoding *info); XML_Encoding *info);
XMLPARSEAPI(void) XMLPARSEAPI(void)
XML_SetElementHandler(XML_Parser parser, XML_SetElementHandler(XML_Parser parser, XML_StartElementHandler start,
XML_StartElementHandler start,
XML_EndElementHandler end); XML_EndElementHandler end);
XMLPARSEAPI(void) XMLPARSEAPI(void)
XML_SetStartElementHandler(XML_Parser parser, XML_SetStartElementHandler(XML_Parser parser, XML_StartElementHandler handler);
XML_StartElementHandler handler);
XMLPARSEAPI(void) XMLPARSEAPI(void)
XML_SetEndElementHandler(XML_Parser parser, XML_SetEndElementHandler(XML_Parser parser, XML_EndElementHandler handler);
XML_EndElementHandler handler);
XMLPARSEAPI(void) XMLPARSEAPI(void)
XML_SetCharacterDataHandler(XML_Parser parser, XML_SetCharacterDataHandler(XML_Parser parser,
@ -580,8 +537,7 @@ XMLPARSEAPI(void)
XML_SetProcessingInstructionHandler(XML_Parser parser, XML_SetProcessingInstructionHandler(XML_Parser parser,
XML_ProcessingInstructionHandler handler); XML_ProcessingInstructionHandler handler);
XMLPARSEAPI(void) XMLPARSEAPI(void)
XML_SetCommentHandler(XML_Parser parser, XML_SetCommentHandler(XML_Parser parser, XML_CommentHandler handler);
XML_CommentHandler handler);
XMLPARSEAPI(void) XMLPARSEAPI(void)
XML_SetCdataSectionHandler(XML_Parser parser, XML_SetCdataSectionHandler(XML_Parser parser,
@ -601,20 +557,17 @@ XML_SetEndCdataSectionHandler(XML_Parser parser,
default handler, or to the skipped entity handler, if one is set. default handler, or to the skipped entity handler, if one is set.
*/ */
XMLPARSEAPI(void) XMLPARSEAPI(void)
XML_SetDefaultHandler(XML_Parser parser, XML_SetDefaultHandler(XML_Parser parser, XML_DefaultHandler handler);
XML_DefaultHandler handler);
/* This sets the default handler but does not inhibit expansion of /* This sets the default handler but does not inhibit expansion of
internal entities. The entity reference will not be passed to the internal entities. The entity reference will not be passed to the
default handler. default handler.
*/ */
XMLPARSEAPI(void) XMLPARSEAPI(void)
XML_SetDefaultHandlerExpand(XML_Parser parser, XML_SetDefaultHandlerExpand(XML_Parser parser, XML_DefaultHandler handler);
XML_DefaultHandler handler);
XMLPARSEAPI(void) XMLPARSEAPI(void)
XML_SetDoctypeDeclHandler(XML_Parser parser, XML_SetDoctypeDeclHandler(XML_Parser parser, XML_StartDoctypeDeclHandler start,
XML_StartDoctypeDeclHandler start,
XML_EndDoctypeDeclHandler end); XML_EndDoctypeDeclHandler end);
XMLPARSEAPI(void) XMLPARSEAPI(void)
@ -622,16 +575,14 @@ XML_SetStartDoctypeDeclHandler(XML_Parser parser,
XML_StartDoctypeDeclHandler start); XML_StartDoctypeDeclHandler start);
XMLPARSEAPI(void) XMLPARSEAPI(void)
XML_SetEndDoctypeDeclHandler(XML_Parser parser, XML_SetEndDoctypeDeclHandler(XML_Parser parser, XML_EndDoctypeDeclHandler end);
XML_EndDoctypeDeclHandler end);
XMLPARSEAPI(void) XMLPARSEAPI(void)
XML_SetUnparsedEntityDeclHandler(XML_Parser parser, XML_SetUnparsedEntityDeclHandler(XML_Parser parser,
XML_UnparsedEntityDeclHandler handler); XML_UnparsedEntityDeclHandler handler);
XMLPARSEAPI(void) XMLPARSEAPI(void)
XML_SetNotationDeclHandler(XML_Parser parser, XML_SetNotationDeclHandler(XML_Parser parser, XML_NotationDeclHandler handler);
XML_NotationDeclHandler handler);
XMLPARSEAPI(void) XMLPARSEAPI(void)
XML_SetNamespaceDeclHandler(XML_Parser parser, XML_SetNamespaceDeclHandler(XML_Parser parser,
@ -659,8 +610,7 @@ XML_SetExternalEntityRefHandler(XML_Parser parser,
instead of the parser object. instead of the parser object.
*/ */
XMLPARSEAPI(void) XMLPARSEAPI(void)
XML_SetExternalEntityRefHandlerArg(XML_Parser parser, XML_SetExternalEntityRefHandlerArg(XML_Parser parser, void *arg);
void *arg);
XMLPARSEAPI(void) XMLPARSEAPI(void)
XML_SetSkippedEntityHandler(XML_Parser parser, XML_SetSkippedEntityHandler(XML_Parser parser,
@ -740,7 +690,6 @@ XML_UseParserAsHandlerArg(XML_Parser parser);
XMLPARSEAPI(enum XML_Error) XMLPARSEAPI(enum XML_Error)
XML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD); XML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD);
/* Sets the base to be used for resolving relative URIs in system /* Sets the base to be used for resolving relative URIs in system
identifiers in declarations. Resolving relative identifiers is identifiers in declarations. Resolving relative identifiers is
left to the application: this value will be passed through as the left to the application: this value will be passed through as the
@ -863,12 +812,7 @@ XML_StopParser(XML_Parser parser, XML_Bool resumable);
XMLPARSEAPI(enum XML_Status) XMLPARSEAPI(enum XML_Status)
XML_ResumeParser(XML_Parser parser); XML_ResumeParser(XML_Parser parser);
enum XML_Parsing { enum XML_Parsing { XML_INITIALIZED, XML_PARSING, XML_FINISHED, XML_SUSPENDED };
XML_INITIALIZED,
XML_PARSING,
XML_FINISHED,
XML_SUSPENDED
};
typedef struct { typedef struct {
enum XML_Parsing parsing; enum XML_Parsing parsing;
@ -900,8 +844,7 @@ XML_GetParsingStatus(XML_Parser parser, XML_ParsingStatus *status);
Otherwise returns a new XML_Parser object. Otherwise returns a new XML_Parser object.
*/ */
XMLPARSEAPI(XML_Parser) XMLPARSEAPI(XML_Parser)
XML_ExternalEntityParserCreate(XML_Parser parser, XML_ExternalEntityParserCreate(XML_Parser parser, const XML_Char *context,
const XML_Char *context,
const XML_Char *encoding); const XML_Char *encoding);
enum XML_ParamEntityParsing { enum XML_ParamEntityParsing {
@ -945,8 +888,7 @@ XML_SetParamEntityParsing(XML_Parser parser,
Note: If parser == NULL, the function will do nothing and return 0. Note: If parser == NULL, the function will do nothing and return 0.
*/ */
XMLPARSEAPI(int) XMLPARSEAPI(int)
XML_SetHashSalt(XML_Parser parser, XML_SetHashSalt(XML_Parser parser, unsigned long hash_salt);
unsigned long hash_salt);
/* If XML_Parse or XML_ParseBuffer have returned XML_STATUS_ERROR, then /* If XML_Parse or XML_ParseBuffer have returned XML_STATUS_ERROR, then
XML_GetErrorCode returns information about the error. XML_GetErrorCode returns information about the error.
@ -995,9 +937,7 @@ XML_GetCurrentByteCount(XML_Parser parser);
the handler that makes the call. the handler that makes the call.
*/ */
XMLPARSEAPI(const char *) XMLPARSEAPI(const char *)
XML_GetInputContext(XML_Parser parser, XML_GetInputContext(XML_Parser parser, int *offset, int *size);
int *offset,
int *size);
/* For backwards compatibility with previous versions. */ /* For backwards compatibility with previous versions. */
#define XML_GetErrorLineNumber XML_GetCurrentLineNumber #define XML_GetErrorLineNumber XML_GetCurrentLineNumber
@ -1070,13 +1010,12 @@ typedef struct {
XMLPARSEAPI(const XML_Feature *) XMLPARSEAPI(const XML_Feature *)
XML_GetFeatureList(void); XML_GetFeatureList(void);
/* Expat follows the semantic versioning convention. /* Expat follows the semantic versioning convention.
See http://semver.org. See http://semver.org.
*/ */
#define XML_MAJOR_VERSION 2 #define XML_MAJOR_VERSION 2
#define XML_MINOR_VERSION 2 #define XML_MINOR_VERSION 2
#define XML_MICRO_VERSION 7 #define XML_MICRO_VERSION 8
#ifdef __cplusplus #ifdef __cplusplus
} }

27
Modules/expat/expat_external.h
View File

@ -35,10 +35,6 @@
/* External API definitions */ /* 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 /* Expat tries very hard to make the API boundary very specifically
defined. There are two macros defined to control this boundary; defined. There are two macros defined to control this boundary;
each of these can be defined before including this header to each of these can be defined before including this header to
@ -61,6 +57,11 @@
compiled with the cdecl calling convention as the default since compiled with the cdecl calling convention as the default since
system headers may assume the cdecl convention. system headers may assume the cdecl convention.
*/ */
/* Namespace external symbols to allow multiple libexpat version to
co-exist. */
#include "pyexpatns.h"
#ifndef XMLCALL #ifndef XMLCALL
# if defined(_MSC_VER) # if defined(_MSC_VER)
# define XMLCALL __cdecl # define XMLCALL __cdecl
@ -81,16 +82,11 @@
# endif # endif
#endif /* not defined XMLCALL */ #endif /* not defined XMLCALL */
/* Namespace external symbols to allow multiple libexpat version to
co-exist. */
#include "pyexpatns.h"
#if ! defined(XML_STATIC) && ! defined(XMLIMPORT) #if ! defined(XML_STATIC) && ! defined(XMLIMPORT)
# ifndef XML_BUILDING_EXPAT # ifndef XML_BUILDING_EXPAT
/* using Expat from an application */ /* using Expat from an application */
# ifdef XML_USE_MSC_EXTENSIONS # if defined(_MSC_EXTENSIONS) && ! defined(__BEOS__) && ! defined(__CYGWIN__)
# define XMLIMPORT __declspec(dllimport) # define XMLIMPORT __declspec(dllimport)
# endif # endif
@ -110,13 +106,15 @@
# define XMLIMPORT # define XMLIMPORT
#endif #endif
#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96)) #if defined(__GNUC__) \
&& (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 96))
# define XML_ATTR_MALLOC __attribute__((__malloc__)) # define XML_ATTR_MALLOC __attribute__((__malloc__))
#else #else
# define XML_ATTR_MALLOC # define XML_ATTR_MALLOC
#endif #endif
#if defined(__GNUC__) && ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) #if defined(__GNUC__) \
&& ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
# define XML_ATTR_ALLOC_SIZE(x) __attribute__((__alloc_size__(x))) # define XML_ATTR_ALLOC_SIZE(x) __attribute__((__alloc_size__(x)))
#else #else
# define XML_ATTR_ALLOC_SIZE(x) # define XML_ATTR_ALLOC_SIZE(x)
@ -151,13 +149,8 @@ typedef char XML_LChar;
#endif /* XML_UNICODE */ #endif /* XML_UNICODE */
#ifdef XML_LARGE_SIZE /* Use large integers for file/stream positions. */ #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 long long XML_Index;
typedef unsigned long long XML_Size; typedef unsigned long long XML_Size;
# endif
#else #else
typedef long XML_Index; typedef long XML_Index;
typedef unsigned long XML_Size; typedef unsigned long XML_Size;

12
Modules/expat/internal.h
View File

@ -102,27 +102,21 @@
#endif #endif
#ifndef UNUSED_P #ifndef UNUSED_P
# ifdef __GNUC__ # define UNUSED_P(p) (void)p
# define UNUSED_P(p) UNUSED_ ## p __attribute__((__unused__))
# else
# define UNUSED_P(p) UNUSED_ ## p
#endif #endif
#endif
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#ifdef XML_ENABLE_VISIBILITY #ifdef XML_ENABLE_VISIBILITY
# if XML_ENABLE_VISIBILITY # if XML_ENABLE_VISIBILITY
__attribute__((visibility("default"))) __attribute__((visibility("default")))
# endif # endif
#endif #endif
void void
_INTERNAL_trim_to_complete_utf8_characters(const char * from, const char ** fromLimRef); _INTERNAL_trim_to_complete_utf8_characters(const char *from,
const char **fromLimRef);
#ifdef __cplusplus #ifdef __cplusplus
} }

143
Modules/expat/loadlibrary.c
View File

@ -1,143 +0,0 @@
/***************************************************************************
* _ _ ____ _
* Project ___| | | | _ \| |
* / __| | | | |_) | |
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
* Copyright (C) 2016 - 2017, Steve Holme, <steve_holme@hotmail.com>.
* Copyright (C) 2017, Expat development team
*
* All rights reserved.
* Licensed under the MIT license:
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies.
*
* THE SOFTWARE 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 OF
* THIRD PARTY RIGHTS. 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 THE SOFTWARE.
*
* Except as contained in this notice, the name of a copyright holder shall
* not be used in advertising or otherwise to promote the sale, use or other
* dealings in this Software without prior written authorization of the
* copyright holder.
*
***************************************************************************/
#if defined(_WIN32)
#include <windows.h>
#include <tchar.h>
HMODULE _Expat_LoadLibrary(LPCTSTR filename);
#if !defined(LOAD_WITH_ALTERED_SEARCH_PATH)
#define LOAD_WITH_ALTERED_SEARCH_PATH 0x00000008
#endif
#if !defined(LOAD_LIBRARY_SEARCH_SYSTEM32)
#define LOAD_LIBRARY_SEARCH_SYSTEM32 0x00000800
#endif
/* We use our own typedef here since some headers might lack these */
typedef HMODULE (APIENTRY *LOADLIBRARYEX_FN)(LPCTSTR, HANDLE, DWORD);
/* See function definitions in winbase.h */
#ifdef UNICODE
# ifdef _WIN32_WCE
# define LOADLIBRARYEX L"LoadLibraryExW"
# else
# define LOADLIBRARYEX "LoadLibraryExW"
# endif
#else
# define LOADLIBRARYEX "LoadLibraryExA"
#endif
/*
* _Expat_LoadLibrary()
*
* This is used to dynamically load DLLs using the most secure method available
* for the version of Windows that we are running on.
*
* Parameters:
*
* filename [in] - The filename or full path of the DLL to load. If only the
* filename is passed then the DLL will be loaded from the
* Windows system directory.
*
* Returns the handle of the module on success; otherwise NULL.
*/
HMODULE _Expat_LoadLibrary(LPCTSTR filename)
{
HMODULE hModule = NULL;
LOADLIBRARYEX_FN pLoadLibraryEx = NULL;
/* Get a handle to kernel32 so we can access it's functions at runtime */
HMODULE hKernel32 = GetModuleHandle(TEXT("kernel32"));
if(!hKernel32)
return NULL; /* LCOV_EXCL_LINE */
/* Attempt to find LoadLibraryEx() which is only available on Windows 2000
and above */
pLoadLibraryEx = (LOADLIBRARYEX_FN) GetProcAddress(hKernel32, LOADLIBRARYEX);
/* Detect if there's already a path in the filename and load the library if
there is. Note: Both back slashes and forward slashes have been supported
since the earlier days of DOS at an API level although they are not
supported by command prompt */
if(_tcspbrk(filename, TEXT("\\/"))) {
/** !checksrc! disable BANNEDFUNC 1 **/
hModule = pLoadLibraryEx ?
pLoadLibraryEx(filename, NULL, LOAD_WITH_ALTERED_SEARCH_PATH) :
LoadLibrary(filename);
}
/* Detect if KB2533623 is installed, as LOAD_LIBARY_SEARCH_SYSTEM32 is only
supported on Windows Vista, Windows Server 2008, Windows 7 and Windows
Server 2008 R2 with this patch or natively on Windows 8 and above */
else if(pLoadLibraryEx && GetProcAddress(hKernel32, "AddDllDirectory")) {
/* Load the DLL from the Windows system directory */
hModule = pLoadLibraryEx(filename, NULL, LOAD_LIBRARY_SEARCH_SYSTEM32);
}
else {
/* Attempt to get the Windows system path */
UINT systemdirlen = GetSystemDirectory(NULL, 0);
if(systemdirlen) {
/* Allocate space for the full DLL path (Room for the null terminator
is included in systemdirlen) */
size_t filenamelen = _tcslen(filename);
TCHAR *path = malloc(sizeof(TCHAR) * (systemdirlen + 1 + filenamelen));
if(path && GetSystemDirectory(path, systemdirlen)) {
/* Calculate the full DLL path */
_tcscpy(path + _tcslen(path), TEXT("\\"));
_tcscpy(path + _tcslen(path), filename);
/* Load the DLL from the Windows system directory */
/** !checksrc! disable BANNEDFUNC 1 **/
hModule = pLoadLibraryEx ?
pLoadLibraryEx(path, NULL, LOAD_WITH_ALTERED_SEARCH_PATH) :
LoadLibrary(path);
}
free(path);
}
}
return hModule;
}
#else /* defined(_WIN32) */
/* ISO C requires a translation unit to contain at least one declaration
[-Wempty-translation-unit] */
typedef int _TRANSLATION_UNIT_LOAD_LIBRARY_C_NOT_EMTPY;
#endif /* defined(_WIN32) */

242
Modules/expat/nametab.h
View File

@ -31,152 +31,106 @@
*/ */
static const unsigned namingBitmap[] = { static const unsigned namingBitmap[] = {
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x04000000,
0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x87FFFFFE, 0x07FFFFFE, 0x00000000, 0x00000000, 0xFF7FFFFF, 0xFF7FFFFF,
0x00000000, 0x04000000, 0x87FFFFFE, 0x07FFFFFE, 0xFFFFFFFF, 0x7FF3FFFF, 0xFFFFFDFE, 0x7FFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
0x00000000, 0x00000000, 0xFF7FFFFF, 0xFF7FFFFF, 0xFFFFE00F, 0xFC31FFFF, 0x00FFFFFF, 0x00000000, 0xFFFF0000, 0xFFFFFFFF,
0xFFFFFFFF, 0x7FF3FFFF, 0xFFFFFDFE, 0x7FFFFFFF, 0xFFFFFFFF, 0xF80001FF, 0x00000003, 0x00000000, 0x00000000, 0x00000000,
0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFE00F, 0xFC31FFFF, 0x00000000, 0x00000000, 0xFFFFD740, 0xFFFFFFFB, 0x547F7FFF, 0x000FFFFD,
0x00FFFFFF, 0x00000000, 0xFFFF0000, 0xFFFFFFFF, 0xFFFFDFFE, 0xFFFFFFFF, 0xDFFEFFFF, 0xFFFFFFFF, 0xFFFF0003, 0xFFFFFFFF,
0xFFFFFFFF, 0xF80001FF, 0x00000003, 0x00000000, 0xFFFF199F, 0x033FCFFF, 0x00000000, 0xFFFE0000, 0x027FFFFF, 0xFFFFFFFE,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x0000007F, 0x00000000, 0xFFFF0000, 0x000707FF, 0x00000000, 0x07FFFFFE,
0xFFFFD740, 0xFFFFFFFB, 0x547F7FFF, 0x000FFFFD, 0x000007FE, 0xFFFE0000, 0xFFFFFFFF, 0x7CFFFFFF, 0x002F7FFF, 0x00000060,
0xFFFFDFFE, 0xFFFFFFFF, 0xDFFEFFFF, 0xFFFFFFFF, 0xFFFFFFE0, 0x23FFFFFF, 0xFF000000, 0x00000003, 0xFFF99FE0, 0x03C5FDFF,
0xFFFF0003, 0xFFFFFFFF, 0xFFFF199F, 0x033FCFFF, 0xB0000000, 0x00030003, 0xFFF987E0, 0x036DFDFF, 0x5E000000, 0x001C0000,
0x00000000, 0xFFFE0000, 0x027FFFFF, 0xFFFFFFFE, 0xFFFBAFE0, 0x23EDFDFF, 0x00000000, 0x00000001, 0xFFF99FE0, 0x23CDFDFF,
0x0000007F, 0x00000000, 0xFFFF0000, 0x000707FF, 0xB0000000, 0x00000003, 0xD63DC7E0, 0x03BFC718, 0x00000000, 0x00000000,
0x00000000, 0x07FFFFFE, 0x000007FE, 0xFFFE0000, 0xFFFDDFE0, 0x03EFFDFF, 0x00000000, 0x00000003, 0xFFFDDFE0, 0x03EFFDFF,
0xFFFFFFFF, 0x7CFFFFFF, 0x002F7FFF, 0x00000060, 0x40000000, 0x00000003, 0xFFFDDFE0, 0x03FFFDFF, 0x00000000, 0x00000003,
0xFFFFFFE0, 0x23FFFFFF, 0xFF000000, 0x00000003, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFE, 0x000D7FFF,
0xFFF99FE0, 0x03C5FDFF, 0xB0000000, 0x00030003, 0x0000003F, 0x00000000, 0xFEF02596, 0x200D6CAE, 0x0000001F, 0x00000000,
0xFFF987E0, 0x036DFDFF, 0x5E000000, 0x001C0000, 0x00000000, 0x00000000, 0xFFFFFEFF, 0x000003FF, 0x00000000, 0x00000000,
0xFFFBAFE0, 0x23EDFDFF, 0x00000000, 0x00000001, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0xFFF99FE0, 0x23CDFDFF, 0xB0000000, 0x00000003, 0x00000000, 0xFFFFFFFF, 0xFFFF003F, 0x007FFFFF, 0x0007DAED, 0x50000000,
0xD63DC7E0, 0x03BFC718, 0x00000000, 0x00000000, 0x82315001, 0x002C62AB, 0x40000000, 0xF580C900, 0x00000007, 0x02010800,
0xFFFDDFE0, 0x03EFFDFF, 0x00000000, 0x00000003, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x0FFFFFFF, 0xFFFFFFFF,
0xFFFDDFE0, 0x03EFFDFF, 0x40000000, 0x00000003, 0xFFFFFFFF, 0x03FFFFFF, 0x3F3FFFFF, 0xFFFFFFFF, 0xAAFF3F3F, 0x3FFFFFFF,
0xFFFDDFE0, 0x03FFFDFF, 0x00000000, 0x00000003, 0xFFFFFFFF, 0x5FDFFFFF, 0x0FCF1FDC, 0x1FDC1FFF, 0x00000000, 0x00004C40,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000007, 0x00000000, 0x00000000, 0x00000000,
0xFFFFFFFE, 0x000D7FFF, 0x0000003F, 0x00000000, 0x00000080, 0x000003FE, 0xFFFFFFFE, 0xFFFFFFFF, 0x001FFFFF, 0xFFFFFFFE,
0xFEF02596, 0x200D6CAE, 0x0000001F, 0x00000000, 0xFFFFFFFF, 0x07FFFFFF, 0xFFFFFFE0, 0x00001FFF, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0xFFFFFEFF, 0x000003FF, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x0000003F, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x0000000F,
0x00000000, 0xFFFFFFFF, 0xFFFF003F, 0x007FFFFF, 0x00000000, 0x00000000, 0x00000000, 0x07FF6000, 0x87FFFFFE, 0x07FFFFFE,
0x0007DAED, 0x50000000, 0x82315001, 0x002C62AB, 0x00000000, 0x00800000, 0xFF7FFFFF, 0xFF7FFFFF, 0x00FFFFFF, 0x00000000,
0x40000000, 0xF580C900, 0x00000007, 0x02010800, 0xFFFF0000, 0xFFFFFFFF, 0xFFFFFFFF, 0xF80001FF, 0x00030003, 0x00000000,
0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x0000003F, 0x00000003, 0xFFFFD7C0, 0xFFFFFFFB,
0x0FFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x03FFFFFF, 0x547F7FFF, 0x000FFFFD, 0xFFFFDFFE, 0xFFFFFFFF, 0xDFFEFFFF, 0xFFFFFFFF,
0x3F3FFFFF, 0xFFFFFFFF, 0xAAFF3F3F, 0x3FFFFFFF, 0xFFFF007B, 0xFFFFFFFF, 0xFFFF199F, 0x033FCFFF, 0x00000000, 0xFFFE0000,
0xFFFFFFFF, 0x5FDFFFFF, 0x0FCF1FDC, 0x1FDC1FFF, 0x027FFFFF, 0xFFFFFFFE, 0xFFFE007F, 0xBBFFFFFB, 0xFFFF0016, 0x000707FF,
0x00000000, 0x00004C40, 0x00000000, 0x00000000, 0x00000000, 0x07FFFFFE, 0x0007FFFF, 0xFFFF03FF, 0xFFFFFFFF, 0x7CFFFFFF,
0x00000007, 0x00000000, 0x00000000, 0x00000000, 0xFFEF7FFF, 0x03FF3DFF, 0xFFFFFFEE, 0xF3FFFFFF, 0xFF1E3FFF, 0x0000FFCF,
0x00000080, 0x000003FE, 0xFFFFFFFE, 0xFFFFFFFF, 0xFFF99FEE, 0xD3C5FDFF, 0xB080399F, 0x0003FFCF, 0xFFF987E4, 0xD36DFDFF,
0x001FFFFF, 0xFFFFFFFE, 0xFFFFFFFF, 0x07FFFFFF, 0x5E003987, 0x001FFFC0, 0xFFFBAFEE, 0xF3EDFDFF, 0x00003BBF, 0x0000FFC1,
0xFFFFFFE0, 0x00001FFF, 0x00000000, 0x00000000, 0xFFF99FEE, 0xF3CDFDFF, 0xB0C0398F, 0x0000FFC3, 0xD63DC7EC, 0xC3BFC718,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00803DC7, 0x0000FF80, 0xFFFDDFEE, 0xC3EFFDFF, 0x00603DDF, 0x0000FFC3,
0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFDDFEC, 0xC3EFFDFF, 0x40603DDF, 0x0000FFC3, 0xFFFDDFEC, 0xC3FFFDFF,
0xFFFFFFFF, 0x0000003F, 0x00000000, 0x00000000, 0x00803DCF, 0x0000FFC3, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFE, 0x07FF7FFF, 0x03FF7FFF, 0x00000000, 0xFEF02596, 0x3BFF6CAE,
0xFFFFFFFF, 0x0000000F, 0x00000000, 0x00000000, 0x03FF3F5F, 0x00000000, 0x03000000, 0xC2A003FF, 0xFFFFFEFF, 0xFFFE03FF,
0x00000000, 0x07FF6000, 0x87FFFFFE, 0x07FFFFFE, 0xFEBF0FDF, 0x02FE3FFF, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00800000, 0xFF7FFFFF, 0xFF7FFFFF, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x1FFF0000, 0x00000002,
0x00FFFFFF, 0x00000000, 0xFFFF0000, 0xFFFFFFFF, 0x000000A0, 0x003EFFFE, 0xFFFFFFFE, 0xFFFFFFFF, 0x661FFFFF, 0xFFFFFFFE,
0xFFFFFFFF, 0xF80001FF, 0x00030003, 0x00000000, 0xFFFFFFFF, 0x77FFFFFF,
0xFFFFFFFF, 0xFFFFFFFF, 0x0000003F, 0x00000003,
0xFFFFD7C0, 0xFFFFFFFB, 0x547F7FFF, 0x000FFFFD,
0xFFFFDFFE, 0xFFFFFFFF, 0xDFFEFFFF, 0xFFFFFFFF,
0xFFFF007B, 0xFFFFFFFF, 0xFFFF199F, 0x033FCFFF,
0x00000000, 0xFFFE0000, 0x027FFFFF, 0xFFFFFFFE,
0xFFFE007F, 0xBBFFFFFB, 0xFFFF0016, 0x000707FF,
0x00000000, 0x07FFFFFE, 0x0007FFFF, 0xFFFF03FF,
0xFFFFFFFF, 0x7CFFFFFF, 0xFFEF7FFF, 0x03FF3DFF,
0xFFFFFFEE, 0xF3FFFFFF, 0xFF1E3FFF, 0x0000FFCF,
0xFFF99FEE, 0xD3C5FDFF, 0xB080399F, 0x0003FFCF,
0xFFF987E4, 0xD36DFDFF, 0x5E003987, 0x001FFFC0,
0xFFFBAFEE, 0xF3EDFDFF, 0x00003BBF, 0x0000FFC1,
0xFFF99FEE, 0xF3CDFDFF, 0xB0C0398F, 0x0000FFC3,
0xD63DC7EC, 0xC3BFC718, 0x00803DC7, 0x0000FF80,
0xFFFDDFEE, 0xC3EFFDFF, 0x00603DDF, 0x0000FFC3,
0xFFFDDFEC, 0xC3EFFDFF, 0x40603DDF, 0x0000FFC3,
0xFFFDDFEC, 0xC3FFFDFF, 0x00803DCF, 0x0000FFC3,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0xFFFFFFFE, 0x07FF7FFF, 0x03FF7FFF, 0x00000000,
0xFEF02596, 0x3BFF6CAE, 0x03FF3F5F, 0x00000000,
0x03000000, 0xC2A003FF, 0xFFFFFEFF, 0xFFFE03FF,
0xFEBF0FDF, 0x02FE3FFF, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x1FFF0000, 0x00000002,
0x000000A0, 0x003EFFFE, 0xFFFFFFFE, 0xFFFFFFFF,
0x661FFFFF, 0xFFFFFFFE, 0xFFFFFFFF, 0x77FFFFFF,
}; };
static const unsigned char nmstrtPages[] = { static const unsigned char nmstrtPages[] = {
0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x00, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x00, 0x00, 0x09, 0x0A, 0x0B,
0x00, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x0C, 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x10, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x13, 0x00, 0x14, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x13, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x15, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x15, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x18,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x18,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
}; };
static const unsigned char namePages[] = { static const unsigned char namePages[] = {
0x19, 0x03, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x00, 0x19, 0x03, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x00, 0x00, 0x1F, 0x20, 0x21,
0x00, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x22, 0x23, 0x24, 0x25, 0x10, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x10, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x13, 0x26, 0x14, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x13, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x26, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x27, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x27, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x18,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x17, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x18,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
}; };

95
Modules/expat/siphash.h
View File

@ -11,6 +11,10 @@
* -------------------------------------------------------------------------- * --------------------------------------------------------------------------
* HISTORY: * HISTORY:
* *
* 2019-08-03 (Sebastian Pipping)
* - Mark part of sip24_valid as to be excluded from clang-format
* - Re-format code using clang-format 9
*
* 2018-07-08 (Anton Maklakov) * 2018-07-08 (Anton Maklakov)
* - Add "fall through" markers for GCC's -Wimplicit-fallthrough * - Add "fall through" markers for GCC's -Wimplicit-fallthrough
* *
@ -102,7 +106,6 @@
# include <stdint.h> /* uint64_t uint32_t uint8_t */ # include <stdint.h> /* uint64_t uint32_t uint8_t */
#endif #endif
/* /*
* Workaround to not require a C++11 compiler for using ULL suffix * Workaround to not require a C++11 compiler for using ULL suffix
* if this code is included and compiled as C++; related GCC warning is: * if this code is included and compiled as C++; related GCC warning is:
@ -110,29 +113,26 @@
*/ */
#define _SIP_ULL(high, low) (((uint64_t)high << 32) | low) #define _SIP_ULL(high, low) (((uint64_t)high << 32) | low)
#define SIP_ROTL(x, b) (uint64_t)(((x) << (b)) | ((x) >> (64 - (b)))) #define SIP_ROTL(x, b) (uint64_t)(((x) << (b)) | ((x) >> (64 - (b))))
#define SIP_U32TO8_LE(p, v) \ #define SIP_U32TO8_LE(p, v) \
(p)[0] = (uint8_t)((v) >> 0); (p)[1] = (uint8_t)((v) >> 8); \ (p)[0] = (uint8_t)((v) >> 0); \
(p)[2] = (uint8_t)((v) >> 16); (p)[3] = (uint8_t)((v) >> 24); (p)[1] = (uint8_t)((v) >> 8); \
(p)[2] = (uint8_t)((v) >> 16); \
(p)[3] = (uint8_t)((v) >> 24);
#define SIP_U64TO8_LE(p, v) \ #define SIP_U64TO8_LE(p, v) \
SIP_U32TO8_LE((p) + 0, (uint32_t)((v) >> 0)); \ SIP_U32TO8_LE((p) + 0, (uint32_t)((v) >> 0)); \
SIP_U32TO8_LE((p) + 4, (uint32_t)((v) >> 32)); SIP_U32TO8_LE((p) + 4, (uint32_t)((v) >> 32));
#define SIP_U8TO64_LE(p) \ #define SIP_U8TO64_LE(p) \
(((uint64_t)((p)[0]) << 0) | \ (((uint64_t)((p)[0]) << 0) | ((uint64_t)((p)[1]) << 8) \
((uint64_t)((p)[1]) << 8) | \ | ((uint64_t)((p)[2]) << 16) | ((uint64_t)((p)[3]) << 24) \
((uint64_t)((p)[2]) << 16) | \ | ((uint64_t)((p)[4]) << 32) | ((uint64_t)((p)[5]) << 40) \
((uint64_t)((p)[3]) << 24) | \ | ((uint64_t)((p)[6]) << 48) | ((uint64_t)((p)[7]) << 56))
((uint64_t)((p)[4]) << 32) | \
((uint64_t)((p)[5]) << 40) | \
((uint64_t)((p)[6]) << 48) | \
((uint64_t)((p)[7]) << 56))
#define SIPHASH_INITIALIZER \
#define SIPHASH_INITIALIZER { 0, 0, 0, 0, { 0 }, 0, 0 } { 0, 0, 0, 0, {0}, 0, 0 }
struct siphash { struct siphash {
uint64_t v0, v1, v2, v3; uint64_t v0, v1, v2, v3;
@ -141,7 +141,6 @@ struct siphash {
uint64_t c; uint64_t c;
}; /* struct siphash */ }; /* struct siphash */
#define SIP_KEYLEN 16 #define SIP_KEYLEN 16
struct sipkey { struct sipkey {
@ -150,26 +149,27 @@ struct sipkey {
#define sip_keyof(k) sip_tokey(&(struct sipkey){{0}}, (k)) #define sip_keyof(k) sip_tokey(&(struct sipkey){{0}}, (k))
static struct sipkey *sip_tokey(struct sipkey *key, const void *src) { static struct sipkey *
sip_tokey(struct sipkey *key, const void *src) {
key->k[0] = SIP_U8TO64_LE((const unsigned char *)src); key->k[0] = SIP_U8TO64_LE((const unsigned char *)src);
key->k[1] = SIP_U8TO64_LE((const unsigned char *)src + 8); key->k[1] = SIP_U8TO64_LE((const unsigned char *)src + 8);
return key; return key;
} /* sip_tokey() */ } /* sip_tokey() */
#ifdef SIPHASH_TOBIN #ifdef SIPHASH_TOBIN
# define sip_binof(v) sip_tobin((unsigned char[8]){0}, (v)) # define sip_binof(v) sip_tobin((unsigned char[8]){0}, (v))
static void *sip_tobin(void *dst, uint64_t u64) { static void *
sip_tobin(void *dst, uint64_t u64) {
SIP_U64TO8_LE((unsigned char *)dst, u64); SIP_U64TO8_LE((unsigned char *)dst, u64);
return dst; return dst;
} /* sip_tobin() */ } /* sip_tobin() */
#endif /* SIPHASH_TOBIN */ #endif /* SIPHASH_TOBIN */
static void
static void sip_round(struct siphash *H, const int rounds) { sip_round(struct siphash *H, const int rounds) {
int i; int i;
for (i = 0; i < rounds; i++) { for (i = 0; i < rounds; i++) {
@ -193,9 +193,8 @@ static void sip_round(struct siphash *H, const int rounds) {
} }
} /* sip_round() */ } /* sip_round() */
static struct siphash *
static struct siphash *sip24_init(struct siphash *H, sip24_init(struct siphash *H, const struct sipkey *key) {
const struct sipkey *key) {
H->v0 = _SIP_ULL(0x736f6d65U, 0x70736575U) ^ key->k[0]; H->v0 = _SIP_ULL(0x736f6d65U, 0x70736575U) ^ key->k[0];
H->v1 = _SIP_ULL(0x646f7261U, 0x6e646f6dU) ^ key->k[1]; H->v1 = _SIP_ULL(0x646f7261U, 0x6e646f6dU) ^ key->k[1];
H->v2 = _SIP_ULL(0x6c796765U, 0x6e657261U) ^ key->k[0]; H->v2 = _SIP_ULL(0x6c796765U, 0x6e657261U) ^ key->k[0];
@ -207,11 +206,10 @@ static struct siphash *sip24_init(struct siphash *H,
return H; return H;
} /* sip24_init() */ } /* sip24_init() */
#define sip_endof(a) (&(a)[sizeof(a) / sizeof *(a)]) #define sip_endof(a) (&(a)[sizeof(a) / sizeof *(a)])
static struct siphash *sip24_update(struct siphash *H, const void *src, static struct siphash *
size_t len) { sip24_update(struct siphash *H, const void *src, size_t len) {
const unsigned char *p = (const unsigned char *)src, *pe = p + len; const unsigned char *p = (const unsigned char *)src, *pe = p + len;
uint64_t m; uint64_t m;
@ -234,27 +232,35 @@ static struct siphash *sip24_update(struct siphash *H, const void *src,
return H; return H;
} /* sip24_update() */ } /* sip24_update() */
static uint64_t
static uint64_t sip24_final(struct siphash *H) { sip24_final(struct siphash *H) {
const char left = (char)(H->p - H->buf); const char left = (char)(H->p - H->buf);
uint64_t b = (H->c + left) << 56; uint64_t b = (H->c + left) << 56;
switch (left) { switch (left) {
case 7: b |= (uint64_t)H->buf[6] << 48; case 7:
b |= (uint64_t)H->buf[6] << 48;
/* fall through */ /* fall through */
case 6: b |= (uint64_t)H->buf[5] << 40; case 6:
b |= (uint64_t)H->buf[5] << 40;
/* fall through */ /* fall through */
case 5: b |= (uint64_t)H->buf[4] << 32; case 5:
b |= (uint64_t)H->buf[4] << 32;
/* fall through */ /* fall through */
case 4: b |= (uint64_t)H->buf[3] << 24; case 4:
b |= (uint64_t)H->buf[3] << 24;
/* fall through */ /* fall through */
case 3: b |= (uint64_t)H->buf[2] << 16; case 3:
b |= (uint64_t)H->buf[2] << 16;
/* fall through */ /* fall through */
case 2: b |= (uint64_t)H->buf[1] << 8; case 2:
b |= (uint64_t)H->buf[1] << 8;
/* fall through */ /* fall through */
case 1: b |= (uint64_t)H->buf[0] << 0; case 1:
b |= (uint64_t)H->buf[0] << 0;
/* fall through */ /* fall through */
case 0: break; case 0:
break;
} }
H->v3 ^= b; H->v3 ^= b;
@ -266,14 +272,12 @@ static uint64_t sip24_final(struct siphash *H) {
return H->v0 ^ H->v1 ^ H->v2 ^ H->v3; return H->v0 ^ H->v1 ^ H->v2 ^ H->v3;
} /* sip24_final() */ } /* sip24_final() */
static uint64_t
static uint64_t siphash24(const void *src, size_t len, siphash24(const void *src, size_t len, const struct sipkey *key) {
const struct sipkey *key) {
struct siphash state = SIPHASH_INITIALIZER; struct siphash state = SIPHASH_INITIALIZER;
return sip24_final(sip24_update(sip24_init(&state, key), src, len)); return sip24_final(sip24_update(sip24_init(&state, key), src, len));
} /* siphash24() */ } /* siphash24() */
/* /*
* SipHash-2-4 output with * SipHash-2-4 output with
* k = 00 01 02 ... * k = 00 01 02 ...
@ -285,7 +289,9 @@ static uint64_t siphash24(const void *src, size_t len,
* ... * ...
* in = 00 01 02 ... 3e (63 bytes) * in = 00 01 02 ... 3e (63 bytes)
*/ */
static int sip24_valid(void) { static int
sip24_valid(void) {
/* clang-format off */
static const unsigned char vectors[64][8] = { static const unsigned char vectors[64][8] = {
{ 0x31, 0x0e, 0x0e, 0xdd, 0x47, 0xdb, 0x6f, 0x72, }, { 0x31, 0x0e, 0x0e, 0xdd, 0x47, 0xdb, 0x6f, 0x72, },
{ 0xfd, 0x67, 0xdc, 0x93, 0xc5, 0x39, 0xf8, 0x74, }, { 0xfd, 0x67, 0xdc, 0x93, 0xc5, 0x39, 0xf8, 0x74, },
@ -352,6 +358,8 @@ static int sip24_valid(void) {
{ 0x57, 0x5f, 0xf2, 0x8e, 0x60, 0x38, 0x1b, 0xe5, }, { 0x57, 0x5f, 0xf2, 0x8e, 0x60, 0x38, 0x1b, 0xe5, },
{ 0x72, 0x45, 0x06, 0xeb, 0x4c, 0x32, 0x8a, 0x95, } { 0x72, 0x45, 0x06, 0xeb, 0x4c, 0x32, 0x8a, 0x95, }
}; };
/* clang-format on */
unsigned char in[64]; unsigned char in[64];
struct sipkey k; struct sipkey k;
size_t i; size_t i;
@ -369,12 +377,12 @@ static int sip24_valid(void) {
return 1; return 1;
} /* sip24_valid() */ } /* sip24_valid() */
#ifdef SIPHASH_MAIN #ifdef SIPHASH_MAIN
# include <stdio.h> # include <stdio.h>
int main(void) { int
main(void) {
const int ok = sip24_valid(); const int ok = sip24_valid();
if (ok) if (ok)
@ -387,5 +395,4 @@ int main(void) {
#endif /* SIPHASH_MAIN */ #endif /* SIPHASH_MAIN */
#endif /* SIPHASH_H */ #endif /* SIPHASH_H */

3
Modules/expat/winconfig.h
View File

@ -40,12 +40,10 @@
#include <memory.h> #include <memory.h>
#include <string.h> #include <string.h>
#if defined(HAVE_EXPAT_CONFIG_H) /* e.g. MinGW */ #if defined(HAVE_EXPAT_CONFIG_H) /* e.g. MinGW */
# include <expat_config.h> # include <expat_config.h>
#else /* !defined(HAVE_EXPAT_CONFIG_H) */ #else /* !defined(HAVE_EXPAT_CONFIG_H) */
# define XML_NS 1 # define XML_NS 1
# define XML_DTD 1 # define XML_DTD 1
# define XML_CONTEXT_BYTES 1024 # define XML_CONTEXT_BYTES 1024
@ -55,5 +53,4 @@
#endif /* !defined(HAVE_EXPAT_CONFIG_H) */ #endif /* !defined(HAVE_EXPAT_CONFIG_H) */
#endif /* ndef WINCONFIG_H */ #endif /* ndef WINCONFIG_H */

2093
Modules/expat/xmlparse.c
View File

File diff suppressed because it is too large Load Diff

709
Modules/expat/xmlrole.c
View File

File diff suppressed because it is too large Load Diff

7
Modules/expat/xmlrole.h
View File

@ -113,11 +113,8 @@ enum {
}; };
typedef struct prolog_state { typedef struct prolog_state {
int (PTRCALL *handler) (struct prolog_state *state, int(PTRCALL *handler)(struct prolog_state *state, int tok, const char *ptr,
int tok, const char *end, const ENCODING *enc);
const char *ptr,
const char *end,
const ENCODING *enc);
unsigned level; unsigned level;
int role_none; int role_none;
#ifdef XML_DTD #ifdef XML_DTD

730
Modules/expat/xmltok.c
View File

File diff suppressed because it is too large Load Diff

86
Modules/expat/xmltok.h
View File

@ -38,13 +38,15 @@ extern "C" {
#endif #endif
/* The following token may be returned by XmlContentTok */ /* The following token may be returned by XmlContentTok */
#define XML_TOK_TRAILING_RSQB -5 /* ] or ]] at the end of the scan; might be #define XML_TOK_TRAILING_RSQB \
-5 /* ] or ]] at the end of the scan; might be \
start of illegal ]]> sequence */ start of illegal ]]> sequence */
/* The following tokens may be returned by both XmlPrologTok and /* The following tokens may be returned by both XmlPrologTok and
XmlContentTok. XmlContentTok.
*/ */
#define XML_TOK_NONE -4 /* The string to be scanned is empty */ #define XML_TOK_NONE -4 /* The string to be scanned is empty */
#define XML_TOK_TRAILING_CR -3 /* A CR at the end of the scan; #define XML_TOK_TRAILING_CR \
-3 /* A CR at the end of the scan; \
might be part of CRLF sequence */ might be part of CRLF sequence */
#define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */ #define XML_TOK_PARTIAL_CHAR -2 /* only part of a multibyte sequence */
#define XML_TOK_PARTIAL -1 /* only part of a token */ #define XML_TOK_PARTIAL -1 /* only part of a token */
@ -153,46 +155,35 @@ typedef struct {
struct encoding; struct encoding;
typedef struct encoding ENCODING; typedef struct encoding ENCODING;
typedef int (PTRCALL *SCANNER)(const ENCODING *, typedef int(PTRCALL *SCANNER)(const ENCODING *, const char *, const char *,
const char *,
const char *,
const char **); const char **);
enum XML_Convert_Result { enum XML_Convert_Result {
XML_CONVERT_COMPLETED = 0, XML_CONVERT_COMPLETED = 0,
XML_CONVERT_INPUT_INCOMPLETE = 1, XML_CONVERT_INPUT_INCOMPLETE = 1,
XML_CONVERT_OUTPUT_EXHAUSTED = 2 /* and therefore potentially input remaining as well */ XML_CONVERT_OUTPUT_EXHAUSTED
= 2 /* and therefore potentially input remaining as well */
}; };
struct encoding { struct encoding {
SCANNER scanners[XML_N_STATES]; SCANNER scanners[XML_N_STATES];
SCANNER literalScanners[XML_N_LITERAL_TYPES]; SCANNER literalScanners[XML_N_LITERAL_TYPES];
int (PTRCALL *nameMatchesAscii)(const ENCODING *, int(PTRCALL *nameMatchesAscii)(const ENCODING *, const char *, const char *,
const char *,
const char *,
const char *); const char *);
int(PTRFASTCALL *nameLength)(const ENCODING *, const char *); int(PTRFASTCALL *nameLength)(const ENCODING *, const char *);
const char *(PTRFASTCALL *skipS)(const ENCODING *, const char *); const char *(PTRFASTCALL *skipS)(const ENCODING *, const char *);
int (PTRCALL *getAtts)(const ENCODING *enc, int(PTRCALL *getAtts)(const ENCODING *enc, const char *ptr, int attsMax,
const char *ptr,
int attsMax,
ATTRIBUTE *atts); ATTRIBUTE *atts);
int(PTRFASTCALL *charRefNumber)(const ENCODING *enc, const char *ptr); int(PTRFASTCALL *charRefNumber)(const ENCODING *enc, const char *ptr);
int (PTRCALL *predefinedEntityName)(const ENCODING *, int(PTRCALL *predefinedEntityName)(const ENCODING *, const char *,
const char *,
const char *); const char *);
void (PTRCALL *updatePosition)(const ENCODING *, void(PTRCALL *updatePosition)(const ENCODING *, const char *ptr,
const char *ptr, const char *end, POSITION *);
const char *end, int(PTRCALL *isPublicId)(const ENCODING *enc, const char *ptr,
POSITION *); const char *end, const char **badPtr);
int (PTRCALL *isPublicId)(const ENCODING *enc,
const char *ptr,
const char *end,
const char **badPtr);
enum XML_Convert_Result(PTRCALL *utf8Convert)(const ENCODING *enc, enum XML_Convert_Result(PTRCALL *utf8Convert)(const ENCODING *enc,
const char **fromP, const char **fromP,
const char *fromLim, const char *fromLim, char **toP,
char **toP,
const char *toLim); const char *toLim);
enum XML_Convert_Result(PTRCALL *utf16Convert)(const ENCODING *enc, enum XML_Convert_Result(PTRCALL *utf16Convert)(const ENCODING *enc,
const char **fromP, const char **fromP,
@ -225,7 +216,6 @@ struct encoding {
the prolog outside literals, comments and processing instructions. the prolog outside literals, comments and processing instructions.
*/ */
#define XmlTok(enc, state, ptr, end, nextTokPtr) \ #define XmlTok(enc, state, ptr, end, nextTokPtr) \
(((enc)->scanners[state])(enc, ptr, end, nextTokPtr)) (((enc)->scanners[state])(enc, ptr, end, nextTokPtr))
@ -260,17 +250,14 @@ struct encoding {
#define XmlNameMatchesAscii(enc, ptr1, end1, ptr2) \ #define XmlNameMatchesAscii(enc, ptr1, end1, ptr2) \
(((enc)->nameMatchesAscii)(enc, ptr1, end1, ptr2)) (((enc)->nameMatchesAscii)(enc, ptr1, end1, ptr2))
#define XmlNameLength(enc, ptr) \ #define XmlNameLength(enc, ptr) (((enc)->nameLength)(enc, ptr))
(((enc)->nameLength)(enc, ptr))
#define XmlSkipS(enc, ptr) \ #define XmlSkipS(enc, ptr) (((enc)->skipS)(enc, ptr))
(((enc)->skipS)(enc, ptr))
#define XmlGetAttributes(enc, ptr, attsMax, atts) \ #define XmlGetAttributes(enc, ptr, attsMax, atts) \
(((enc)->getAtts)(enc, ptr, attsMax, atts)) (((enc)->getAtts)(enc, ptr, attsMax, atts))
#define XmlCharRefNumber(enc, ptr) \ #define XmlCharRefNumber(enc, ptr) (((enc)->charRefNumber)(enc, ptr))
(((enc)->charRefNumber)(enc, ptr))
#define XmlPredefinedEntityName(enc, ptr, end) \ #define XmlPredefinedEntityName(enc, ptr, end) \
(((enc)->predefinedEntityName)(enc, ptr, end)) (((enc)->predefinedEntityName)(enc, ptr, end))
@ -292,16 +279,11 @@ typedef struct {
const ENCODING **encPtr; const ENCODING **encPtr;
} INIT_ENCODING; } INIT_ENCODING;
int XmlParseXmlDecl(int isGeneralTextEntity, int XmlParseXmlDecl(int isGeneralTextEntity, const ENCODING *enc,
const ENCODING *enc, const char *ptr, const char *end, const char **badPtr,
const char *ptr, const char **versionPtr, const char **versionEndPtr,
const char *end,
const char **badPtr,
const char **versionPtr,
const char **versionEndPtr,
const char **encodingNamePtr, const char **encodingNamePtr,
const ENCODING **namedEncodingPtr, const ENCODING **namedEncodingPtr, int *standalonePtr);
int *standalonePtr);
int XmlInitEncoding(INIT_ENCODING *, const ENCODING **, const char *name); int XmlInitEncoding(INIT_ENCODING *, const ENCODING **, const char *name);
const ENCODING *XmlGetUtf8InternalEncoding(void); const ENCODING *XmlGetUtf8InternalEncoding(void);
@ -310,33 +292,21 @@ int FASTCALL XmlUtf8Encode(int charNumber, char *buf);
int FASTCALL XmlUtf16Encode(int charNumber, unsigned short *buf); int FASTCALL XmlUtf16Encode(int charNumber, unsigned short *buf);
int XmlSizeOfUnknownEncoding(void); int XmlSizeOfUnknownEncoding(void);
typedef int(XMLCALL *CONVERTER)(void *userData, const char *p); typedef int(XMLCALL *CONVERTER)(void *userData, const char *p);
ENCODING * ENCODING *XmlInitUnknownEncoding(void *mem, int *table, CONVERTER convert,
XmlInitUnknownEncoding(void *mem,
int *table,
CONVERTER convert,
void *userData); void *userData);
int XmlParseXmlDeclNS(int isGeneralTextEntity, int XmlParseXmlDeclNS(int isGeneralTextEntity, const ENCODING *enc,
const ENCODING *enc, const char *ptr, const char *end, const char **badPtr,
const char *ptr, const char **versionPtr, const char **versionEndPtr,
const char *end,
const char **badPtr,
const char **versionPtr,
const char **versionEndPtr,
const char **encodingNamePtr, const char **encodingNamePtr,
const ENCODING **namedEncodingPtr, const ENCODING **namedEncodingPtr, int *standalonePtr);
int *standalonePtr);
int XmlInitEncodingNS(INIT_ENCODING *, const ENCODING **, const char *name); int XmlInitEncodingNS(INIT_ENCODING *, const ENCODING **, const char *name);
const ENCODING *XmlGetUtf8InternalEncodingNS(void); const ENCODING *XmlGetUtf8InternalEncodingNS(void);
const ENCODING *XmlGetUtf16InternalEncodingNS(void); const ENCODING *XmlGetUtf16InternalEncodingNS(void);
ENCODING * ENCODING *XmlInitUnknownEncodingNS(void *mem, int *table, CONVERTER convert,
XmlInitUnknownEncodingNS(void *mem,
int *table,
CONVERTER convert,
void *userData); void *userData);
#ifdef __cplusplus #ifdef __cplusplus
} }

337
Modules/expat/xmltok_impl.c
View File

@ -116,12 +116,9 @@
# define PREFIX(ident) ident # define PREFIX(ident) ident
# endif # endif
# define HAS_CHARS(enc, ptr, end, count) (end - ptr >= count * MINBPC(enc))
#define HAS_CHARS(enc, ptr, end, count) \ # define HAS_CHAR(enc, ptr, end) HAS_CHARS(enc, ptr, end, 1)
(end - ptr >= count * MINBPC(enc))
#define HAS_CHAR(enc, ptr, end) \
HAS_CHARS(enc, ptr, end, 1)
# define REQUIRE_CHARS(enc, ptr, end, count) \ # define REQUIRE_CHARS(enc, ptr, end, count) \
{ \ { \
@ -130,16 +127,13 @@
} \ } \
} }
#define REQUIRE_CHAR(enc, ptr, end) \ # define REQUIRE_CHAR(enc, ptr, end) REQUIRE_CHARS(enc, ptr, end, 1)
REQUIRE_CHARS(enc, ptr, end, 1)
/* ptr points to character following "<!-" */ /* ptr points to character following "<!-" */
static int PTRCALL static int PTRCALL
PREFIX(scanComment)(const ENCODING *enc, const char *ptr, PREFIX(scanComment)(const ENCODING *enc, const char *ptr, const char *end,
const char *end, const char **nextTokPtr) const char **nextTokPtr) {
{
if (HAS_CHAR(enc, ptr, end)) { if (HAS_CHAR(enc, ptr, end)) {
if (! CHAR_MATCHES(enc, ptr, ASCII_MINUS)) { if (! CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {
*nextTokPtr = ptr; *nextTokPtr = ptr;
@ -175,9 +169,8 @@ PREFIX(scanComment)(const ENCODING *enc, const char *ptr,
/* ptr points to character following "<!" */ /* ptr points to character following "<!" */
static int PTRCALL static int PTRCALL
PREFIX(scanDecl)(const ENCODING *enc, const char *ptr, PREFIX(scanDecl)(const ENCODING *enc, const char *ptr, const char *end,
const char *end, const char **nextTokPtr) const char **nextTokPtr) {
{
REQUIRE_CHAR(enc, ptr, end); REQUIRE_CHAR(enc, ptr, end);
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
case BT_MINUS: case BT_MINUS:
@ -199,12 +192,17 @@ PREFIX(scanDecl)(const ENCODING *enc, const char *ptr,
REQUIRE_CHARS(enc, ptr, end, 2); REQUIRE_CHARS(enc, ptr, end, 2);
/* don't allow <!ENTITY% foo "whatever"> */ /* don't allow <!ENTITY% foo "whatever"> */
switch (BYTE_TYPE(enc, ptr + MINBPC(enc))) { switch (BYTE_TYPE(enc, ptr + MINBPC(enc))) {
case BT_S: case BT_CR: case BT_LF: case BT_PERCNT: case BT_S:
case BT_CR:
case BT_LF:
case BT_PERCNT:
*nextTokPtr = ptr; *nextTokPtr = ptr;
return XML_TOK_INVALID; return XML_TOK_INVALID;
} }
/* fall through */ /* fall through */
case BT_S: case BT_CR: case BT_LF: case BT_S:
case BT_CR:
case BT_LF:
*nextTokPtr = ptr; *nextTokPtr = ptr;
return XML_TOK_DECL_OPEN; return XML_TOK_DECL_OPEN;
case BT_NMSTRT: case BT_NMSTRT:
@ -220,10 +218,10 @@ PREFIX(scanDecl)(const ENCODING *enc, const char *ptr,
} }
static int PTRCALL static int PTRCALL
PREFIX(checkPiTarget)(const ENCODING *UNUSED_P(enc), const char *ptr, PREFIX(checkPiTarget)(const ENCODING *enc, const char *ptr, const char *end,
const char *end, int *tokPtr) int *tokPtr) {
{
int upper = 0; int upper = 0;
UNUSED_P(enc);
*tokPtr = XML_TOK_PI; *tokPtr = XML_TOK_PI;
if (end - ptr != MINBPC(enc) * 3) if (end - ptr != MINBPC(enc) * 3)
return 1; return 1;
@ -265,9 +263,8 @@ PREFIX(checkPiTarget)(const ENCODING *UNUSED_P(enc), const char *ptr,
/* ptr points to character following "<?" */ /* ptr points to character following "<?" */
static int PTRCALL static int PTRCALL
PREFIX(scanPi)(const ENCODING *enc, const char *ptr, PREFIX(scanPi)(const ENCODING *enc, const char *ptr, const char *end,
const char *end, const char **nextTokPtr) const char **nextTokPtr) {
{
int tok; int tok;
const char *target = ptr; const char *target = ptr;
REQUIRE_CHAR(enc, ptr, end); REQUIRE_CHAR(enc, ptr, end);
@ -280,7 +277,9 @@ PREFIX(scanPi)(const ENCODING *enc, const char *ptr,
while (HAS_CHAR(enc, ptr, end)) { while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
case BT_S: case BT_CR: case BT_LF: case BT_S:
case BT_CR:
case BT_LF:
if (! PREFIX(checkPiTarget)(enc, target, ptr, &tok)) { if (! PREFIX(checkPiTarget)(enc, target, ptr, &tok)) {
*nextTokPtr = ptr; *nextTokPtr = ptr;
return XML_TOK_INVALID; return XML_TOK_INVALID;
@ -324,12 +323,12 @@ PREFIX(scanPi)(const ENCODING *enc, const char *ptr,
} }
static int PTRCALL static int PTRCALL
PREFIX(scanCdataSection)(const ENCODING *UNUSED_P(enc), const char *ptr, PREFIX(scanCdataSection)(const ENCODING *enc, const char *ptr, const char *end,
const char *end, const char **nextTokPtr) const char **nextTokPtr) {
{ static const char CDATA_LSQB[]
static const char CDATA_LSQB[] = { ASCII_C, ASCII_D, ASCII_A, = {ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, ASCII_LSQB};
ASCII_T, ASCII_A, ASCII_LSQB };
int i; int i;
UNUSED_P(enc);
/* CDATA[ */ /* CDATA[ */
REQUIRE_CHARS(enc, ptr, end, 6); REQUIRE_CHARS(enc, ptr, end, 6);
for (i = 0; i < 6; i++, ptr += MINBPC(enc)) { for (i = 0; i < 6; i++, ptr += MINBPC(enc)) {
@ -343,9 +342,8 @@ PREFIX(scanCdataSection)(const ENCODING *UNUSED_P(enc), const char *ptr,
} }
static int PTRCALL static int PTRCALL
PREFIX(cdataSectionTok)(const ENCODING *enc, const char *ptr, PREFIX(cdataSectionTok)(const ENCODING *enc, const char *ptr, const char *end,
const char *end, const char **nextTokPtr) const char **nextTokPtr) {
{
if (ptr >= end) if (ptr >= end)
return XML_TOK_NONE; return XML_TOK_NONE;
if (MINBPC(enc) > 1) { if (MINBPC(enc) > 1) {
@ -396,7 +394,9 @@ PREFIX(cdataSectionTok)(const ENCODING *enc, const char *ptr,
} \ } \
ptr += n; \ ptr += n; \
break; break;
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_NONXML: case BT_NONXML:
case BT_MALFORM: case BT_MALFORM:
@ -418,9 +418,8 @@ PREFIX(cdataSectionTok)(const ENCODING *enc, const char *ptr,
/* ptr points to character following "</" */ /* ptr points to character following "</" */
static int PTRCALL static int PTRCALL
PREFIX(scanEndTag)(const ENCODING *enc, const char *ptr, PREFIX(scanEndTag)(const ENCODING *enc, const char *ptr, const char *end,
const char *end, const char **nextTokPtr) const char **nextTokPtr) {
{
REQUIRE_CHAR(enc, ptr, end); REQUIRE_CHAR(enc, ptr, end);
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
@ -431,10 +430,14 @@ PREFIX(scanEndTag)(const ENCODING *enc, const char *ptr,
while (HAS_CHAR(enc, ptr, end)) { while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
case BT_S: case BT_CR: case BT_LF: case BT_S:
case BT_CR:
case BT_LF:
for (ptr += MINBPC(enc); HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) { for (ptr += MINBPC(enc); HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) {
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
case BT_S: case BT_CR: case BT_LF: case BT_S:
case BT_CR:
case BT_LF:
break; break;
case BT_GT: case BT_GT:
*nextTokPtr = ptr + MINBPC(enc); *nextTokPtr = ptr + MINBPC(enc);
@ -466,9 +469,8 @@ PREFIX(scanEndTag)(const ENCODING *enc, const char *ptr,
/* ptr points to character following "&#X" */ /* ptr points to character following "&#X" */
static int PTRCALL static int PTRCALL
PREFIX(scanHexCharRef)(const ENCODING *enc, const char *ptr, PREFIX(scanHexCharRef)(const ENCODING *enc, const char *ptr, const char *end,
const char *end, const char **nextTokPtr) const char **nextTokPtr) {
{
if (HAS_CHAR(enc, ptr, end)) { if (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
case BT_DIGIT: case BT_DIGIT:
@ -498,9 +500,8 @@ PREFIX(scanHexCharRef)(const ENCODING *enc, const char *ptr,
/* ptr points to character following "&#" */ /* ptr points to character following "&#" */
static int PTRCALL static int PTRCALL
PREFIX(scanCharRef)(const ENCODING *enc, const char *ptr, PREFIX(scanCharRef)(const ENCODING *enc, const char *ptr, const char *end,
const char *end, const char **nextTokPtr) const char **nextTokPtr) {
{
if (HAS_CHAR(enc, ptr, end)) { if (HAS_CHAR(enc, ptr, end)) {
if (CHAR_MATCHES(enc, ptr, ASCII_x)) if (CHAR_MATCHES(enc, ptr, ASCII_x))
return PREFIX(scanHexCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr); return PREFIX(scanHexCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
@ -531,8 +532,7 @@ PREFIX(scanCharRef)(const ENCODING *enc, const char *ptr,
static int PTRCALL static int PTRCALL
PREFIX(scanRef)(const ENCODING *enc, const char *ptr, const char *end, PREFIX(scanRef)(const ENCODING *enc, const char *ptr, const char *end,
const char **nextTokPtr) const char **nextTokPtr) {
{
REQUIRE_CHAR(enc, ptr, end); REQUIRE_CHAR(enc, ptr, end);
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
@ -560,8 +560,7 @@ PREFIX(scanRef)(const ENCODING *enc, const char *ptr, const char *end,
static int PTRCALL static int PTRCALL
PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end, PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
const char **nextTokPtr) const char **nextTokPtr) {
{
# ifdef XML_NS # ifdef XML_NS
int hadColon = 0; int hadColon = 0;
# endif # endif
@ -585,7 +584,9 @@ PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
} }
break; break;
# endif # endif
case BT_S: case BT_CR: case BT_LF: case BT_S:
case BT_CR:
case BT_LF:
for (;;) { for (;;) {
int t; int t;
@ -605,8 +606,7 @@ PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
} }
} }
/* fall through */ /* fall through */
case BT_EQUALS: case BT_EQUALS: {
{
int open; int open;
# ifdef XML_NS # ifdef XML_NS
hadColon = 0; hadColon = 0;
@ -637,8 +637,7 @@ PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
break; break;
switch (t) { switch (t) {
INVALID_CASES(ptr, nextTokPtr) INVALID_CASES(ptr, nextTokPtr)
case BT_AMP: case BT_AMP: {
{
int tok = PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, &ptr); int tok = PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, &ptr);
if (tok <= 0) { if (tok <= 0) {
if (tok == XML_TOK_INVALID) if (tok == XML_TOK_INVALID)
@ -676,7 +675,9 @@ PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
REQUIRE_CHAR(enc, ptr, end); REQUIRE_CHAR(enc, ptr, end);
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
case BT_S: case BT_CR: case BT_LF: case BT_S:
case BT_CR:
case BT_LF:
continue; continue;
case BT_GT: case BT_GT:
gt: gt:
@ -712,8 +713,7 @@ PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
static int PTRCALL static int PTRCALL
PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end, PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
const char **nextTokPtr) const char **nextTokPtr) {
{
# ifdef XML_NS # ifdef XML_NS
int hadColon; int hadColon;
# endif # endif
@ -727,8 +727,7 @@ PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
case BT_MINUS: case BT_MINUS:
return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr); return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr);
case BT_LSQB: case BT_LSQB:
return PREFIX(scanCdataSection)(enc, ptr + MINBPC(enc), return PREFIX(scanCdataSection)(enc, ptr + MINBPC(enc), end, nextTokPtr);
end, nextTokPtr);
} }
*nextTokPtr = ptr; *nextTokPtr = ptr;
return XML_TOK_INVALID; return XML_TOK_INVALID;
@ -764,8 +763,9 @@ PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
} }
break; break;
# endif # endif
case BT_S: case BT_CR: case BT_LF: case BT_S:
{ case BT_CR:
case BT_LF: {
ptr += MINBPC(enc); ptr += MINBPC(enc);
while (HAS_CHAR(enc, ptr, end)) { while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
@ -774,7 +774,9 @@ PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
goto gt; goto gt;
case BT_SOL: case BT_SOL:
goto sol; goto sol;
case BT_S: case BT_CR: case BT_LF: case BT_S:
case BT_CR:
case BT_LF:
ptr += MINBPC(enc); ptr += MINBPC(enc);
continue; continue;
default: default:
@ -809,8 +811,7 @@ PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
static int PTRCALL static int PTRCALL
PREFIX(contentTok)(const ENCODING *enc, const char *ptr, const char *end, PREFIX(contentTok)(const ENCODING *enc, const char *ptr, const char *end,
const char **nextTokPtr) const char **nextTokPtr) {
{
if (ptr >= end) if (ptr >= end)
return XML_TOK_NONE; return XML_TOK_NONE;
if (MINBPC(enc) > 1) { if (MINBPC(enc) > 1) {
@ -868,7 +869,9 @@ PREFIX(contentTok)(const ENCODING *enc, const char *ptr, const char *end,
} \ } \
ptr += n; \ ptr += n; \
break; break;
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_RSQB: case BT_RSQB:
if (HAS_CHARS(enc, ptr, end, 2)) { if (HAS_CHARS(enc, ptr, end, 2)) {
@ -908,12 +911,14 @@ PREFIX(contentTok)(const ENCODING *enc, const char *ptr, const char *end,
static int PTRCALL static int PTRCALL
PREFIX(scanPercent)(const ENCODING *enc, const char *ptr, const char *end, PREFIX(scanPercent)(const ENCODING *enc, const char *ptr, const char *end,
const char **nextTokPtr) const char **nextTokPtr) {
{
REQUIRE_CHAR(enc, ptr, end); REQUIRE_CHAR(enc, ptr, end);
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
case BT_S: case BT_LF: case BT_CR: case BT_PERCNT: case BT_S:
case BT_LF:
case BT_CR:
case BT_PERCNT:
*nextTokPtr = ptr; *nextTokPtr = ptr;
return XML_TOK_PERCENT; return XML_TOK_PERCENT;
default: default:
@ -936,8 +941,7 @@ PREFIX(scanPercent)(const ENCODING *enc, const char *ptr, const char *end,
static int PTRCALL static int PTRCALL
PREFIX(scanPoundName)(const ENCODING *enc, const char *ptr, const char *end, PREFIX(scanPoundName)(const ENCODING *enc, const char *ptr, const char *end,
const char **nextTokPtr) const char **nextTokPtr) {
{
REQUIRE_CHAR(enc, ptr, end); REQUIRE_CHAR(enc, ptr, end);
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
@ -948,8 +952,13 @@ PREFIX(scanPoundName)(const ENCODING *enc, const char *ptr, const char *end,
while (HAS_CHAR(enc, ptr, end)) { while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
case BT_CR: case BT_LF: case BT_S: case BT_CR:
case BT_RPAR: case BT_GT: case BT_PERCNT: case BT_VERBAR: case BT_LF:
case BT_S:
case BT_RPAR:
case BT_GT:
case BT_PERCNT:
case BT_VERBAR:
*nextTokPtr = ptr; *nextTokPtr = ptr;
return XML_TOK_POUND_NAME; return XML_TOK_POUND_NAME;
default: default:
@ -961,10 +970,8 @@ PREFIX(scanPoundName)(const ENCODING *enc, const char *ptr, const char *end,
} }
static int PTRCALL static int PTRCALL
PREFIX(scanLit)(int open, const ENCODING *enc, PREFIX(scanLit)(int open, const ENCODING *enc, const char *ptr, const char *end,
const char *ptr, const char *end, const char **nextTokPtr) {
const char **nextTokPtr)
{
while (HAS_CHAR(enc, ptr, end)) { while (HAS_CHAR(enc, ptr, end)) {
int t = BYTE_TYPE(enc, ptr); int t = BYTE_TYPE(enc, ptr);
switch (t) { switch (t) {
@ -978,8 +985,12 @@ PREFIX(scanLit)(int open, const ENCODING *enc,
return -XML_TOK_LITERAL; return -XML_TOK_LITERAL;
*nextTokPtr = ptr; *nextTokPtr = ptr;
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
case BT_S: case BT_CR: case BT_LF: case BT_S:
case BT_GT: case BT_PERCNT: case BT_LSQB: case BT_CR:
case BT_LF:
case BT_GT:
case BT_PERCNT:
case BT_LSQB:
return XML_TOK_LITERAL; return XML_TOK_LITERAL;
default: default:
return XML_TOK_INVALID; return XML_TOK_INVALID;
@ -994,8 +1005,7 @@ PREFIX(scanLit)(int open, const ENCODING *enc,
static int PTRCALL static int PTRCALL
PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end, PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
const char **nextTokPtr) const char **nextTokPtr) {
{
int tok; int tok;
if (ptr >= end) if (ptr >= end)
return XML_TOK_NONE; return XML_TOK_NONE;
@ -1013,8 +1023,7 @@ PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
return PREFIX(scanLit)(BT_QUOT, enc, ptr + MINBPC(enc), end, nextTokPtr); return PREFIX(scanLit)(BT_QUOT, enc, ptr + MINBPC(enc), end, nextTokPtr);
case BT_APOS: case BT_APOS:
return PREFIX(scanLit)(BT_APOS, enc, ptr + MINBPC(enc), end, nextTokPtr); return PREFIX(scanLit)(BT_APOS, enc, ptr + MINBPC(enc), end, nextTokPtr);
case BT_LT: case BT_LT: {
{
ptr += MINBPC(enc); ptr += MINBPC(enc);
REQUIRE_CHAR(enc, ptr, end); REQUIRE_CHAR(enc, ptr, end);
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
@ -1041,13 +1050,15 @@ PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
return -XML_TOK_PROLOG_S; return -XML_TOK_PROLOG_S;
} }
/* fall through */ /* fall through */
case BT_S: case BT_LF: case BT_S:
case BT_LF:
for (;;) { for (;;) {
ptr += MINBPC(enc); ptr += MINBPC(enc);
if (! HAS_CHAR(enc, ptr, end)) if (! HAS_CHAR(enc, ptr, end))
break; break;
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
case BT_S: case BT_LF: case BT_S:
case BT_LF:
break; break;
case BT_CR: case BT_CR:
/* don't split CR/LF pair */ /* don't split CR/LF pair */
@ -1099,8 +1110,12 @@ PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
case BT_PLUS: case BT_PLUS:
*nextTokPtr = ptr + MINBPC(enc); *nextTokPtr = ptr + MINBPC(enc);
return XML_TOK_CLOSE_PAREN_PLUS; return XML_TOK_CLOSE_PAREN_PLUS;
case BT_CR: case BT_LF: case BT_S: case BT_CR:
case BT_GT: case BT_COMMA: case BT_VERBAR: case BT_LF:
case BT_S:
case BT_GT:
case BT_COMMA:
case BT_VERBAR:
case BT_RPAR: case BT_RPAR:
*nextTokPtr = ptr; *nextTokPtr = ptr;
return XML_TOK_CLOSE_PAREN; return XML_TOK_CLOSE_PAREN;
@ -1131,7 +1146,9 @@ PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
} \ } \
*nextTokPtr = ptr; \ *nextTokPtr = ptr; \
return XML_TOK_INVALID; return XML_TOK_INVALID;
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_NMSTRT: case BT_NMSTRT:
case BT_HEX: case BT_HEX:
@ -1166,9 +1183,15 @@ PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
while (HAS_CHAR(enc, ptr, end)) { while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
case BT_GT: case BT_RPAR: case BT_COMMA: case BT_GT:
case BT_VERBAR: case BT_LSQB: case BT_PERCNT: case BT_RPAR:
case BT_S: case BT_CR: case BT_LF: case BT_COMMA:
case BT_VERBAR:
case BT_LSQB:
case BT_PERCNT:
case BT_S:
case BT_CR:
case BT_LF:
*nextTokPtr = ptr; *nextTokPtr = ptr;
return tok; return tok;
# ifdef XML_NS # ifdef XML_NS
@ -1221,9 +1244,8 @@ PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
} }
static int PTRCALL static int PTRCALL
PREFIX(attributeValueTok)(const ENCODING *enc, const char *ptr, PREFIX(attributeValueTok)(const ENCODING *enc, const char *ptr, const char *end,
const char *end, const char **nextTokPtr) const char **nextTokPtr) {
{
const char *start; const char *start;
if (ptr >= end) if (ptr >= end)
return XML_TOK_NONE; return XML_TOK_NONE;
@ -1239,8 +1261,12 @@ PREFIX(attributeValueTok)(const ENCODING *enc, const char *ptr,
while (HAS_CHAR(enc, ptr, end)) { while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
# define LEAD_CASE(n) \ # define LEAD_CASE(n) \
case BT_LEAD ## n: ptr += n; break; case BT_LEAD##n: \
LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4) ptr += n; \
break;
LEAD_CASE(2)
LEAD_CASE(3)
LEAD_CASE(4)
# undef LEAD_CASE # undef LEAD_CASE
case BT_AMP: case BT_AMP:
if (ptr == start) if (ptr == start)
@ -1287,9 +1313,8 @@ PREFIX(attributeValueTok)(const ENCODING *enc, const char *ptr,
} }
static int PTRCALL static int PTRCALL
PREFIX(entityValueTok)(const ENCODING *enc, const char *ptr, PREFIX(entityValueTok)(const ENCODING *enc, const char *ptr, const char *end,
const char *end, const char **nextTokPtr) const char **nextTokPtr) {
{
const char *start; const char *start;
if (ptr >= end) if (ptr >= end)
return XML_TOK_NONE; return XML_TOK_NONE;
@ -1305,8 +1330,12 @@ PREFIX(entityValueTok)(const ENCODING *enc, const char *ptr,
while (HAS_CHAR(enc, ptr, end)) { while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
# define LEAD_CASE(n) \ # define LEAD_CASE(n) \
case BT_LEAD ## n: ptr += n; break; case BT_LEAD##n: \
LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4) ptr += n; \
break;
LEAD_CASE(2)
LEAD_CASE(3)
LEAD_CASE(4)
# undef LEAD_CASE # undef LEAD_CASE
case BT_AMP: case BT_AMP:
if (ptr == start) if (ptr == start)
@ -1315,8 +1344,7 @@ PREFIX(entityValueTok)(const ENCODING *enc, const char *ptr,
return XML_TOK_DATA_CHARS; return XML_TOK_DATA_CHARS;
case BT_PERCNT: case BT_PERCNT:
if (ptr == start) { if (ptr == start) {
int tok = PREFIX(scanPercent)(enc, ptr + MINBPC(enc), int tok = PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr);
end, nextTokPtr);
return (tok == XML_TOK_PERCENT) ? XML_TOK_INVALID : tok; return (tok == XML_TOK_PERCENT) ? XML_TOK_INVALID : tok;
} }
*nextTokPtr = ptr; *nextTokPtr = ptr;
@ -1352,9 +1380,8 @@ PREFIX(entityValueTok)(const ENCODING *enc, const char *ptr,
# ifdef XML_DTD # ifdef XML_DTD
static int PTRCALL static int PTRCALL
PREFIX(ignoreSectionTok)(const ENCODING *enc, const char *ptr, PREFIX(ignoreSectionTok)(const ENCODING *enc, const char *ptr, const char *end,
const char *end, const char **nextTokPtr) const char **nextTokPtr) {
{
int level = 0; int level = 0;
if (MINBPC(enc) > 1) { if (MINBPC(enc) > 1) {
size_t n = end - ptr; size_t n = end - ptr;
@ -1406,8 +1433,7 @@ PREFIX(ignoreSectionTok)(const ENCODING *enc, const char *ptr,
static int PTRCALL static int PTRCALL
PREFIX(isPublicId)(const ENCODING *enc, const char *ptr, const char *end, PREFIX(isPublicId)(const ENCODING *enc, const char *ptr, const char *end,
const char **badPtr) const char **badPtr) {
{
ptr += MINBPC(enc); ptr += MINBPC(enc);
end -= MINBPC(enc); end -= MINBPC(enc);
for (; HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) { for (; HAS_CHAR(enc, ptr, end); ptr += MINBPC(enc)) {
@ -1466,9 +1492,8 @@ PREFIX(isPublicId)(const ENCODING *enc, const char *ptr, const char *end,
*/ */
static int PTRCALL static int PTRCALL
PREFIX(getAtts)(const ENCODING *enc, const char *ptr, PREFIX(getAtts)(const ENCODING *enc, const char *ptr, int attsMax,
int attsMax, ATTRIBUTE *atts) ATTRIBUTE *atts) {
{
enum { other, inName, inValue } state = inName; enum { other, inName, inValue } state = inName;
int nAtts = 0; int nAtts = 0;
int open = 0; /* defined when state == inValue; int open = 0; /* defined when state == inValue;
@ -1485,8 +1510,12 @@ PREFIX(getAtts)(const ENCODING *enc, const char *ptr,
state = inName; \ state = inName; \
} }
# define LEAD_CASE(n) \ # define LEAD_CASE(n) \
case BT_LEAD ## n: START_NAME ptr += (n - MINBPC(enc)); break; case BT_LEAD##n: \
LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4) START_NAME ptr += (n - MINBPC(enc)); \
break;
LEAD_CASE(2)
LEAD_CASE(3)
LEAD_CASE(4)
# undef LEAD_CASE # undef LEAD_CASE
case BT_NONASCII: case BT_NONASCII:
case BT_NMSTRT: case BT_NMSTRT:
@ -1500,8 +1529,7 @@ PREFIX(getAtts)(const ENCODING *enc, const char *ptr,
atts[nAtts].valuePtr = ptr + MINBPC(enc); atts[nAtts].valuePtr = ptr + MINBPC(enc);
state = inValue; state = inValue;
open = BT_QUOT; open = BT_QUOT;
} } else if (open == BT_QUOT) {
else if (open == BT_QUOT) {
state = other; state = other;
if (nAtts < attsMax) if (nAtts < attsMax)
atts[nAtts].valueEnd = ptr; atts[nAtts].valueEnd = ptr;
@ -1514,8 +1542,7 @@ PREFIX(getAtts)(const ENCODING *enc, const char *ptr,
atts[nAtts].valuePtr = ptr + MINBPC(enc); atts[nAtts].valuePtr = ptr + MINBPC(enc);
state = inValue; state = inValue;
open = BT_APOS; open = BT_APOS;
} } else if (open == BT_APOS) {
else if (open == BT_APOS) {
state = other; state = other;
if (nAtts < attsMax) if (nAtts < attsMax)
atts[nAtts].valueEnd = ptr; atts[nAtts].valueEnd = ptr;
@ -1529,16 +1556,15 @@ PREFIX(getAtts)(const ENCODING *enc, const char *ptr,
case BT_S: case BT_S:
if (state == inName) if (state == inName)
state = other; state = other;
else if (state == inValue else if (state == inValue && nAtts < attsMax && atts[nAtts].normalized
&& nAtts < attsMax
&& atts[nAtts].normalized
&& (ptr == atts[nAtts].valuePtr && (ptr == atts[nAtts].valuePtr
|| BYTE_TO_ASCII(enc, ptr) != ASCII_SPACE || BYTE_TO_ASCII(enc, ptr) != ASCII_SPACE
|| BYTE_TO_ASCII(enc, ptr + MINBPC(enc)) == ASCII_SPACE || BYTE_TO_ASCII(enc, ptr + MINBPC(enc)) == ASCII_SPACE
|| BYTE_TYPE(enc, ptr + MINBPC(enc)) == open)) || BYTE_TYPE(enc, ptr + MINBPC(enc)) == open))
atts[nAtts].normalized = 0; atts[nAtts].normalized = 0;
break; break;
case BT_CR: case BT_LF: case BT_CR:
case BT_LF:
/* This case ensures that the first attribute name is counted /* This case ensures that the first attribute name is counted
Apart from that we could just change state on the quote. */ Apart from that we could just change state on the quote. */
if (state == inName) if (state == inName)
@ -1559,29 +1585,44 @@ PREFIX(getAtts)(const ENCODING *enc, const char *ptr,
} }
static int PTRFASTCALL static int PTRFASTCALL
PREFIX(charRefNumber)(const ENCODING *UNUSED_P(enc), const char *ptr) PREFIX(charRefNumber)(const ENCODING *enc, const char *ptr) {
{
int result = 0; int result = 0;
/* skip &# */ /* skip &# */
UNUSED_P(enc);
ptr += 2 * MINBPC(enc); ptr += 2 * MINBPC(enc);
if (CHAR_MATCHES(enc, ptr, ASCII_x)) { if (CHAR_MATCHES(enc, ptr, ASCII_x)) {
for (ptr += MINBPC(enc); for (ptr += MINBPC(enc); ! CHAR_MATCHES(enc, ptr, ASCII_SEMI);
!CHAR_MATCHES(enc, ptr, ASCII_SEMI);
ptr += MINBPC(enc)) { ptr += MINBPC(enc)) {
int c = BYTE_TO_ASCII(enc, ptr); int c = BYTE_TO_ASCII(enc, ptr);
switch (c) { switch (c) {
case ASCII_0: case ASCII_1: case ASCII_2: case ASCII_3: case ASCII_4: case ASCII_0:
case ASCII_5: case ASCII_6: case ASCII_7: case ASCII_8: case ASCII_9: case ASCII_1:
case ASCII_2:
case ASCII_3:
case ASCII_4:
case ASCII_5:
case ASCII_6:
case ASCII_7:
case ASCII_8:
case ASCII_9:
result <<= 4; result <<= 4;
result |= (c - ASCII_0); result |= (c - ASCII_0);
break; break;
case ASCII_A: case ASCII_B: case ASCII_C: case ASCII_A:
case ASCII_D: case ASCII_E: case ASCII_F: case ASCII_B:
case ASCII_C:
case ASCII_D:
case ASCII_E:
case ASCII_F:
result <<= 4; result <<= 4;
result += 10 + (c - ASCII_A); result += 10 + (c - ASCII_A);
break; break;
case ASCII_a: case ASCII_b: case ASCII_c: case ASCII_a:
case ASCII_d: case ASCII_e: case ASCII_f: case ASCII_b:
case ASCII_c:
case ASCII_d:
case ASCII_e:
case ASCII_f:
result <<= 4; result <<= 4;
result += 10 + (c - ASCII_a); result += 10 + (c - ASCII_a);
break; break;
@ -1589,8 +1630,7 @@ PREFIX(charRefNumber)(const ENCODING *UNUSED_P(enc), const char *ptr)
if (result >= 0x110000) if (result >= 0x110000)
return -1; return -1;
} }
} } else {
else {
for (; ! CHAR_MATCHES(enc, ptr, ASCII_SEMI); ptr += MINBPC(enc)) { for (; ! CHAR_MATCHES(enc, ptr, ASCII_SEMI); ptr += MINBPC(enc)) {
int c = BYTE_TO_ASCII(enc, ptr); int c = BYTE_TO_ASCII(enc, ptr);
result *= 10; result *= 10;
@ -1603,9 +1643,9 @@ PREFIX(charRefNumber)(const ENCODING *UNUSED_P(enc), const char *ptr)
} }
static int PTRCALL static int PTRCALL
PREFIX(predefinedEntityName)(const ENCODING *UNUSED_P(enc), const char *ptr, PREFIX(predefinedEntityName)(const ENCODING *enc, const char *ptr,
const char *end) const char *end) {
{ UNUSED_P(enc);
switch ((end - ptr) / MINBPC(enc)) { switch ((end - ptr) / MINBPC(enc)) {
case 2: case 2:
if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_t)) { if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_t)) {
@ -1657,9 +1697,9 @@ PREFIX(predefinedEntityName)(const ENCODING *UNUSED_P(enc), const char *ptr,
} }
static int PTRCALL static int PTRCALL
PREFIX(nameMatchesAscii)(const ENCODING *UNUSED_P(enc), const char *ptr1, PREFIX(nameMatchesAscii)(const ENCODING *enc, const char *ptr1,
const char *end1, const char *ptr2) const char *end1, const char *ptr2) {
{ UNUSED_P(enc);
for (; *ptr2; ptr1 += MINBPC(enc), ptr2++) { for (; *ptr2; ptr1 += MINBPC(enc), ptr2++) {
if (end1 - ptr1 < MINBPC(enc)) { if (end1 - ptr1 < MINBPC(enc)) {
/* This line cannot be executed. The incoming data has already /* This line cannot be executed. The incoming data has already
@ -1676,14 +1716,17 @@ PREFIX(nameMatchesAscii)(const ENCODING *UNUSED_P(enc), const char *ptr1,
} }
static int PTRFASTCALL static int PTRFASTCALL
PREFIX(nameLength)(const ENCODING *enc, const char *ptr) PREFIX(nameLength)(const ENCODING *enc, const char *ptr) {
{
const char *start = ptr; const char *start = ptr;
for (;;) { for (;;) {
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
# define LEAD_CASE(n) \ # define LEAD_CASE(n) \
case BT_LEAD ## n: ptr += n; break; case BT_LEAD##n: \
LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4) ptr += n; \
break;
LEAD_CASE(2)
LEAD_CASE(3)
LEAD_CASE(4)
# undef LEAD_CASE # undef LEAD_CASE
case BT_NONASCII: case BT_NONASCII:
case BT_NMSTRT: case BT_NMSTRT:
@ -1703,8 +1746,7 @@ PREFIX(nameLength)(const ENCODING *enc, const char *ptr)
} }
static const char *PTRFASTCALL static const char *PTRFASTCALL
PREFIX(skipS)(const ENCODING *enc, const char *ptr) PREFIX(skipS)(const ENCODING *enc, const char *ptr) {
{
for (;;) { for (;;) {
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
case BT_LF: case BT_LF:
@ -1719,18 +1761,17 @@ PREFIX(skipS)(const ENCODING *enc, const char *ptr)
} }
static void PTRCALL static void PTRCALL
PREFIX(updatePosition)(const ENCODING *enc, PREFIX(updatePosition)(const ENCODING *enc, const char *ptr, const char *end,
const char *ptr, POSITION *pos) {
const char *end,
POSITION *pos)
{
while (HAS_CHAR(enc, ptr, end)) { while (HAS_CHAR(enc, ptr, end)) {
switch (BYTE_TYPE(enc, ptr)) { switch (BYTE_TYPE(enc, ptr)) {
# define LEAD_CASE(n) \ # define LEAD_CASE(n) \
case BT_LEAD##n: \ case BT_LEAD##n: \
ptr += n; \ ptr += n; \
break; break;
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 = (XML_Size)-1; pos->columnNumber = (XML_Size)-1;

70
Modules/expat/xmltok_impl.h
View File

@ -31,43 +31,43 @@
*/ */
enum { enum {
BT_NONXML, BT_NONXML, /* e.g. noncharacter-FFFF */
BT_MALFORM, BT_MALFORM, /* illegal, with regard to encoding */
BT_LT, BT_LT, /* less than = "<" */
BT_AMP, BT_AMP, /* ampersand = "&" */
BT_RSQB, BT_RSQB, /* right square bracket = "[" */
BT_LEAD2, BT_LEAD2, /* lead byte of a 2-byte UTF-8 character */
BT_LEAD3, BT_LEAD3, /* lead byte of a 3-byte UTF-8 character */
BT_LEAD4, BT_LEAD4, /* lead byte of a 4-byte UTF-8 character */
BT_TRAIL, BT_TRAIL, /* trailing unit, e.g. second 16-bit unit of a 4-byte char. */
BT_CR, BT_CR, /* carriage return = "\r" */
BT_LF, BT_LF, /* line feed = "\n" */
BT_GT, BT_GT, /* greater than = ">" */
BT_QUOT, BT_QUOT, /* quotation character = "\"" */
BT_APOS, BT_APOS, /* aposthrophe = "'" */
BT_EQUALS, BT_EQUALS, /* equal sign = "=" */
BT_QUEST, BT_QUEST, /* question mark = "?" */
BT_EXCL, BT_EXCL, /* exclamation mark = "!" */
BT_SOL, BT_SOL, /* solidus, slash = "/" */
BT_SEMI, BT_SEMI, /* semicolon = ";" */
BT_NUM, BT_NUM, /* number sign = "#" */
BT_LSQB, BT_LSQB, /* left square bracket = "[" */
BT_S, BT_S, /* white space, e.g. "\t", " "[, "\r"] */
BT_NMSTRT, BT_NMSTRT, /* non-hex name start letter = "G".."Z" + "g".."z" + "_" */
BT_COLON, BT_COLON, /* colon = ":" */
BT_HEX, BT_HEX, /* hex letter = "A".."F" + "a".."f" */
BT_DIGIT, BT_DIGIT, /* digit = "0".."9" */
BT_NAME, BT_NAME, /* dot and middle dot = "." + chr(0xb7) */
BT_MINUS, BT_MINUS, /* minus = "-" */
BT_OTHER, /* known not to be a name or name start character */ BT_OTHER, /* known not to be a name or name start character */
BT_NONASCII, /* might be a name or name start character */ BT_NONASCII, /* might be a name or name start character */
BT_PERCNT, BT_PERCNT, /* percent sign = "%" */
BT_LPAR, BT_LPAR, /* left parenthesis = "(" */
BT_RPAR, BT_RPAR, /* right parenthesis = "(" */
BT_AST, BT_AST, /* asterisk = "*" */
BT_PLUS, BT_PLUS, /* plus sign = "+" */
BT_COMMA, BT_COMMA, /* comma = "," */
BT_VERBAR BT_VERBAR /* vertical bar = "|" */
}; };
#include <stddef.h> #include <stddef.h>

68
Modules/expat/xmltok_ns.c
View File

@ -33,56 +33,47 @@
#ifdef XML_TOK_NS_C #ifdef XML_TOK_NS_C
const ENCODING * const ENCODING *
NS(XmlGetUtf8InternalEncoding)(void) NS(XmlGetUtf8InternalEncoding)(void) {
{
return &ns(internal_utf8_encoding).enc; return &ns(internal_utf8_encoding).enc;
} }
const ENCODING * const ENCODING *
NS(XmlGetUtf16InternalEncoding)(void) NS(XmlGetUtf16InternalEncoding)(void) {
{
# if BYTEORDER == 1234 # if BYTEORDER == 1234
return &ns(internal_little2_encoding).enc; return &ns(internal_little2_encoding).enc;
# elif BYTEORDER == 4321 # elif BYTEORDER == 4321
return &ns(internal_big2_encoding).enc; return &ns(internal_big2_encoding).enc;
# else # else
const short n = 1; const short n = 1;
return (*(const char *)&n return (*(const char *)&n ? &ns(internal_little2_encoding).enc
? &ns(internal_little2_encoding).enc
: &ns(internal_big2_encoding).enc); : &ns(internal_big2_encoding).enc);
# endif # endif
} }
static const ENCODING *const 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(big2_encoding).enc,
&ns(utf8_encoding).enc, &ns(big2_encoding).enc, &ns(little2_encoding).enc,
&ns(big2_encoding).enc,
&ns(big2_encoding).enc,
&ns(little2_encoding).enc,
&ns(utf8_encoding).enc /* NO_ENC */ &ns(utf8_encoding).enc /* NO_ENC */
}; };
static int PTRCALL static int PTRCALL
NS(initScanProlog)(const ENCODING *enc, const char *ptr, const char *end, NS(initScanProlog)(const ENCODING *enc, const char *ptr, const char *end,
const char **nextTokPtr) const char **nextTokPtr) {
{ return initScan(NS(encodings), (const INIT_ENCODING *)enc, XML_PROLOG_STATE,
return initScan(NS(encodings), (const INIT_ENCODING *)enc, ptr, end, nextTokPtr);
XML_PROLOG_STATE, ptr, end, nextTokPtr);
} }
static int PTRCALL static int PTRCALL
NS(initScanContent)(const ENCODING *enc, const char *ptr, const char *end, NS(initScanContent)(const ENCODING *enc, const char *ptr, const char *end,
const char **nextTokPtr) const char **nextTokPtr) {
{ return initScan(NS(encodings), (const INIT_ENCODING *)enc, XML_CONTENT_STATE,
return initScan(NS(encodings), (const INIT_ENCODING *)enc, ptr, end, nextTokPtr);
XML_CONTENT_STATE, ptr, end, nextTokPtr);
} }
int int
NS(XmlInitEncoding)(INIT_ENCODING *p, const ENCODING **encPtr, NS(XmlInitEncoding)(INIT_ENCODING *p, const ENCODING **encPtr,
const char *name) const char *name) {
{
int i = getEncodingIndex(name); int i = getEncodingIndex(name);
if (i == UNKNOWN_ENC) if (i == UNKNOWN_ENC)
return 0; return 0;
@ -96,8 +87,7 @@ NS(XmlInitEncoding)(INIT_ENCODING *p, const ENCODING **encPtr,
} }
static const ENCODING * static const ENCODING *
NS(findEncoding)(const ENCODING *enc, const char *ptr, const char *end) NS(findEncoding)(const ENCODING *enc, const char *ptr, const char *end) {
{
# define ENCODING_MAX 128 # define ENCODING_MAX 128
char buf[ENCODING_MAX]; char buf[ENCODING_MAX];
char *p = buf; char *p = buf;
@ -115,28 +105,14 @@ NS(findEncoding)(const ENCODING *enc, const char *ptr, const char *end)
} }
int int
NS(XmlParseXmlDecl)(int isGeneralTextEntity, NS(XmlParseXmlDecl)(int isGeneralTextEntity, const ENCODING *enc,
const ENCODING *enc, const char *ptr, const char *end, const char **badPtr,
const char *ptr, const char **versionPtr, const char **versionEndPtr,
const char *end, const char **encodingName, const ENCODING **encoding,
const char **badPtr, int *standalone) {
const char **versionPtr, return doParseXmlDecl(NS(findEncoding), isGeneralTextEntity, enc, ptr, end,
const char **versionEndPtr, badPtr, versionPtr, versionEndPtr, encodingName,
const char **encodingName, encoding, standalone);
const ENCODING **encoding,
int *standalone)
{
return doParseXmlDecl(NS(findEncoding),
isGeneralTextEntity,
enc,
ptr,
end,
badPtr,
versionPtr,
versionEndPtr,
encodingName,
encoding,
standalone);
} }
#endif /* XML_TOK_NS_C */ #endif /* XML_TOK_NS_C */

1
PCbuild/_elementtree.vcxproj
View File

@ -116,7 +116,6 @@
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<ClCompile Include="..\Modules\_elementtree.c" /> <ClCompile Include="..\Modules\_elementtree.c" />
<ClCompile Include="..\Modules\expat\loadlibrary.c" />
<ClCompile Include="..\Modules\expat\xmlparse.c" /> <ClCompile Include="..\Modules\expat\xmlparse.c" />
<ClCompile Include="..\Modules\expat\xmlrole.c" /> <ClCompile Include="..\Modules\expat\xmlrole.c" />
<ClCompile Include="..\Modules\expat\xmltok.c" /> <ClCompile Include="..\Modules\expat\xmltok.c" />

3
PCbuild/_elementtree.vcxproj.filters
View File

@ -33,9 +33,6 @@
<ClInclude Include="..\Modules\expat\latin1tab.h"> <ClInclude Include="..\Modules\expat\latin1tab.h">
<Filter>Header Files</Filter> <Filter>Header Files</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="..\Modules\expat\loadlibrary.c">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\Modules\expat\macconfig.h"> <ClInclude Include="..\Modules\expat\macconfig.h">
<Filter>Header Files</Filter> <Filter>Header Files</Filter>
</ClInclude> </ClInclude>

1
PCbuild/pyexpat.vcxproj
View File

@ -100,7 +100,6 @@
</ItemGroup> </ItemGroup>
<ItemGroup> <ItemGroup>
<ClCompile Include="..\Modules\pyexpat.c" /> <ClCompile Include="..\Modules\pyexpat.c" />
<ClCompile Include="..\Modules\expat\loadlibrary.c" />
<ClCompile Include="..\Modules\expat\xmlparse.c" /> <ClCompile Include="..\Modules\expat\xmlparse.c" />
<ClCompile Include="..\Modules\expat\xmlrole.c" /> <ClCompile Include="..\Modules\expat\xmlrole.c" />
<ClCompile Include="..\Modules\expat\xmltok.c" /> <ClCompile Include="..\Modules\expat\xmltok.c" />

3
PCbuild/pyexpat.vcxproj.filters
View File

@ -20,9 +20,6 @@
<ClCompile Include="..\Modules\pyexpat.c"> <ClCompile Include="..\Modules\pyexpat.c">
<Filter>Source Files</Filter> <Filter>Source Files</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="..\Modules\expat\loadlibrary.c">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\Modules\expat\xmlparse.c"> <ClCompile Include="..\Modules\expat\xmlparse.c">
<Filter>Source Files</Filter> <Filter>Source Files</Filter>
</ClCompile> </ClCompile>