mirror of
https://gitlab.kitware.com/cmake/cmake.git
synced 2026-09-28 04:09:35 +03:00
Merge branch 'upstream-expat' into update-expat
* upstream-expat: expat 2016-05-01 (379213ca)
This commit is contained in:
Brad King
@@ -0,0 +1,121 @@
|
||||
# This file is copyrighted under the BSD-license for buildsystem files of KDE
|
||||
# copyright 2010, Patrick Spendrin <ps_ml@gmx.de>
|
||||
|
||||
project(expat)
|
||||
|
||||
cmake_minimum_required(VERSION 2.6)
|
||||
set(PACKAGE_BUGREPORT "expat-bugs@libexpat.org")
|
||||
set(PACKAGE_NAME "expat")
|
||||
set(PACKAGE_VERSION "2.1.1")
|
||||
set(PACKAGE_STRING "${PACKAGE_NAME} ${PACKAGE_VERSION}")
|
||||
set(PACKAGE_TARNAME "${PACKAGE_NAME}")
|
||||
|
||||
option(BUILD_tools "build the xmlwf tool for expat library" ON)
|
||||
option(BUILD_examples "build the examples for expat library" ON)
|
||||
option(BUILD_tests "build the tests for expat library" ON)
|
||||
option(BUILD_shared "build a shared expat library" ON)
|
||||
|
||||
# configuration options
|
||||
set(XML_CONTEXT_BYTES 1024 CACHE STRING "Define to specify how much context to retain around the current parse point")
|
||||
option(XML_DTD "Define to make parameter entity parsing functionality available" ON)
|
||||
option(XML_NS "Define to make XML Namespaces functionality available" ON)
|
||||
|
||||
if(XML_DTD)
|
||||
set(XML_DTD 1)
|
||||
else(XML_DTD)
|
||||
set(XML_DTD 0)
|
||||
endif(XML_DTD)
|
||||
if(XML_NS)
|
||||
set(XML_NS 1)
|
||||
else(XML_NS)
|
||||
set(XML_NS 0)
|
||||
endif(XML_NS)
|
||||
|
||||
if(BUILD_tests)
|
||||
enable_testing()
|
||||
endif(BUILD_tests)
|
||||
|
||||
include(ConfigureChecks.cmake)
|
||||
|
||||
include_directories(${CMAKE_BINARY_DIR} ${CMAKE_SOURCE_DIR}/lib)
|
||||
if(MSVC)
|
||||
add_definitions(-D_CRT_SECURE_NO_WARNINGS -wd4996)
|
||||
endif(MSVC)
|
||||
if(WIN32)
|
||||
add_definitions(-DCOMPILING_FOR_WINDOWS)
|
||||
endif(WIN32)
|
||||
|
||||
set(expat_SRCS
|
||||
lib/xmlparse.c
|
||||
lib/xmlrole.c
|
||||
lib/xmltok.c
|
||||
lib/xmltok_impl.c
|
||||
lib/xmltok_ns.c
|
||||
)
|
||||
|
||||
if(BUILD_shared)
|
||||
set(_SHARED SHARED)
|
||||
if(WIN32)
|
||||
set(expat_SRCS ${expat_SRCS} lib/libexpat.def)
|
||||
endif(WIN32)
|
||||
else(BUILD_shared)
|
||||
set(_SHARED STATIC)
|
||||
if(WIN32)
|
||||
add_definitions(-DXML_STATIC)
|
||||
endif(WIN32)
|
||||
endif(BUILD_shared)
|
||||
|
||||
add_library(expat ${_SHARED} ${expat_SRCS})
|
||||
|
||||
install(TARGETS expat RUNTIME DESTINATION bin
|
||||
LIBRARY DESTINATION lib
|
||||
ARCHIVE DESTINATION lib)
|
||||
|
||||
set(prefix ${CMAKE_INSTALL_PREFIX})
|
||||
set(exec_prefix "\${prefix}/bin")
|
||||
set(libdir "\${prefix}/lib")
|
||||
set(includedir "\${prefix}/include")
|
||||
configure_file(expat.pc.in ${CMAKE_CURRENT_BINARY_DIR}/expat.pc)
|
||||
|
||||
install(FILES lib/expat.h lib/expat_external.h DESTINATION include)
|
||||
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/expat.pc DESTINATION lib/pkgconfig)
|
||||
|
||||
|
||||
|
||||
if(BUILD_tools AND NOT WINCE)
|
||||
set(xmlwf_SRCS
|
||||
xmlwf/xmlwf.c
|
||||
xmlwf/xmlfile.c
|
||||
xmlwf/codepage.c
|
||||
xmlwf/readfilemap.c
|
||||
)
|
||||
|
||||
add_executable(xmlwf ${xmlwf_SRCS})
|
||||
set_property(TARGET xmlwf PROPERTY RUNTIME_OUTPUT_DIRECTORY xmlwf)
|
||||
target_link_libraries(xmlwf expat)
|
||||
install(TARGETS xmlwf DESTINATION bin)
|
||||
install(FILES doc/xmlwf.1 DESTINATION share/man/man1)
|
||||
endif(BUILD_tools AND NOT WINCE)
|
||||
|
||||
if(BUILD_examples)
|
||||
add_executable(elements examples/elements.c)
|
||||
set_property(TARGET elements PROPERTY RUNTIME_OUTPUT_DIRECTORY examples)
|
||||
target_link_libraries(elements expat)
|
||||
|
||||
add_executable(outline examples/outline.c)
|
||||
set_property(TARGET outline PROPERTY RUNTIME_OUTPUT_DIRECTORY examples)
|
||||
target_link_libraries(outline expat)
|
||||
endif(BUILD_examples)
|
||||
|
||||
if(BUILD_tests)
|
||||
## these are unittests that can be run on any platform
|
||||
add_executable(runtests tests/runtests.c tests/chardata.c tests/minicheck.c)
|
||||
set_property(TARGET runtests PROPERTY RUNTIME_OUTPUT_DIRECTORY tests)
|
||||
target_link_libraries(runtests expat)
|
||||
add_test(runtests tests/runtests)
|
||||
|
||||
add_executable(runtestspp tests/runtestspp.cpp tests/chardata.c tests/minicheck.c)
|
||||
set_property(TARGET runtestspp PROPERTY RUNTIME_OUTPUT_DIRECTORY tests)
|
||||
target_link_libraries(runtestspp expat)
|
||||
add_test(runtestspp tests/runtestspp)
|
||||
endif(BUILD_tests)
|
||||
@@ -0,0 +1,22 @@
|
||||
Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd
|
||||
and Clark Cooper
|
||||
Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006 Expat maintainers.
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining
|
||||
a copy of this software and associated documentation files (the
|
||||
"Software"), to deal in the Software without restriction, including
|
||||
without limitation the rights to use, copy, modify, merge, publish,
|
||||
distribute, sublicense, and/or sell copies of the Software, and to
|
||||
permit persons to whom the Software is furnished to do so, subject to
|
||||
the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included
|
||||
in all copies or substantial portions of the Software.
|
||||
|
||||
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.
|
||||
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.
|
||||
@@ -0,0 +1,44 @@
|
||||
include(CheckIncludeFile)
|
||||
include(CheckIncludeFiles)
|
||||
include(CheckFunctionExists)
|
||||
include(CheckSymbolExists)
|
||||
include(TestBigEndian)
|
||||
|
||||
check_include_file("dlfcn.h" HAVE_DLFCN_H)
|
||||
check_include_file("fcntl.h" HAVE_FCNTL_H)
|
||||
check_include_file("inttypes.h" HAVE_INTTYPES_H)
|
||||
check_include_file("memory.h" HAVE_MEMORY_H)
|
||||
check_include_file("stdint.h" HAVE_STDINT_H)
|
||||
check_include_file("stdlib.h" HAVE_STDLIB_H)
|
||||
check_include_file("strings.h" HAVE_STRINGS_H)
|
||||
check_include_file("string.h" HAVE_STRING_H)
|
||||
check_include_file("sys/stat.h" HAVE_SYS_STAT_H)
|
||||
check_include_file("sys/types.h" HAVE_SYS_TYPES_H)
|
||||
check_include_file("unistd.h" HAVE_UNISTD_H)
|
||||
|
||||
check_function_exists("getpagesize" HAVE_GETPAGESIZE)
|
||||
check_function_exists("bcopy" HAVE_BCOPY)
|
||||
check_symbol_exists("memmove" "string.h" HAVE_MEMMOVE)
|
||||
check_function_exists("mmap" HAVE_MMAP)
|
||||
|
||||
#/* Define to 1 if you have the ANSI C header files. */
|
||||
check_include_files("stdlib.h;stdarg.h;string.h;float.h" STDC_HEADERS)
|
||||
|
||||
test_big_endian(WORDS_BIGENDIAN)
|
||||
#/* 1234 = LIL_ENDIAN, 4321 = BIGENDIAN */
|
||||
if(WORDS_BIGENDIAN)
|
||||
set(BYTEORDER 4321)
|
||||
else(WORDS_BIGENDIAN)
|
||||
set(BYTEORDER 1234)
|
||||
endif(WORDS_BIGENDIAN)
|
||||
|
||||
if(HAVE_SYS_TYPES_H)
|
||||
check_symbol_exists("off_t" "sys/types.h" OFF_T)
|
||||
check_symbol_exists("size_t" "sys/types.h" SIZE_T)
|
||||
else(HAVE_SYS_TYPES_H)
|
||||
set(OFF_T "long")
|
||||
set(SIZE_T "unsigned")
|
||||
endif(HAVE_SYS_TYPES_H)
|
||||
|
||||
configure_file(expat_config.h.cmake expat_config.h)
|
||||
add_definitions(-DHAVE_EXPAT_CONFIG_H)
|
||||
@@ -0,0 +1,139 @@
|
||||
|
||||
Expat, Release 2.1.1
|
||||
|
||||
This is Expat, a C library for parsing XML, written by James Clark.
|
||||
Expat is a stream-oriented XML parser. This means that you register
|
||||
handlers with the parser before starting the parse. These handlers
|
||||
are called when the parser discovers the associated structures in the
|
||||
document being parsed. A start tag is an example of the kind of
|
||||
structures for which you may register handlers.
|
||||
|
||||
Windows users should use the expat_win32bin package, which includes
|
||||
both precompiled libraries and executables, and source code for
|
||||
developers.
|
||||
|
||||
Expat is free software. You may copy, distribute, and modify it under
|
||||
the terms of the License contained in the file COPYING distributed
|
||||
with this package. This license is the same as the MIT/X Consortium
|
||||
license.
|
||||
|
||||
Versions of Expat that have an odd minor version (the middle number in
|
||||
the release above), are development releases and should be considered
|
||||
as beta software. Releases with even minor version numbers are
|
||||
intended to be production grade software.
|
||||
|
||||
If you are building Expat from a check-out from the CVS repository,
|
||||
you need to run a script that generates the configure script using the
|
||||
GNU autoconf and libtool tools. To do this, you need to have
|
||||
autoconf 2.58 or newer. Run the script like this:
|
||||
|
||||
./buildconf.sh
|
||||
|
||||
Once this has been done, follow the same instructions as for building
|
||||
from a source distribution.
|
||||
|
||||
To build Expat from a source distribution, you first run the
|
||||
configuration shell script in the top level distribution directory:
|
||||
|
||||
./configure
|
||||
|
||||
There are many options which you may provide to configure (which you
|
||||
can discover by running configure with the --help option). But the
|
||||
one of most interest is the one that sets the installation directory.
|
||||
By default, the configure script will set things up to install
|
||||
libexpat into /usr/local/lib, expat.h into /usr/local/include, and
|
||||
xmlwf into /usr/local/bin. If, for example, you'd prefer to install
|
||||
into /home/me/mystuff/lib, /home/me/mystuff/include, and
|
||||
/home/me/mystuff/bin, you can tell configure about that with:
|
||||
|
||||
./configure --prefix=/home/me/mystuff
|
||||
|
||||
Another interesting option is to enable 64-bit integer support for
|
||||
line and column numbers and the over-all byte index:
|
||||
|
||||
./configure CPPFLAGS=-DXML_LARGE_SIZE
|
||||
|
||||
However, such a modification would be a breaking change to the ABI
|
||||
and is therefore not recommended for general use - e.g. as part of
|
||||
a Linux distribution - but rather for builds with special requirements.
|
||||
|
||||
After running the configure script, the "make" command will build
|
||||
things and "make install" will install things into their proper
|
||||
location. Have a look at the "Makefile" to learn about additional
|
||||
"make" options. Note that you need to have write permission into
|
||||
the directories into which things will be installed.
|
||||
|
||||
If you are interested in building Expat to provide document
|
||||
information in UTF-16 encoding rather than the default UTF-8, follow
|
||||
these instructions (after having run "make distclean"):
|
||||
|
||||
1. For UTF-16 output as unsigned short (and version/error
|
||||
strings as char), run:
|
||||
|
||||
./configure CPPFLAGS=-DXML_UNICODE
|
||||
|
||||
For UTF-16 output as wchar_t (incl. version/error strings),
|
||||
run:
|
||||
|
||||
./configure CFLAGS="-g -O2 -fshort-wchar" \
|
||||
CPPFLAGS=-DXML_UNICODE_WCHAR_T
|
||||
|
||||
2. Edit the MakeFile, changing:
|
||||
|
||||
LIBRARY = libexpat.la
|
||||
|
||||
to:
|
||||
|
||||
LIBRARY = libexpatw.la
|
||||
|
||||
(Note the additional "w" in the library name.)
|
||||
|
||||
3. Run "make buildlib" (which builds the library only).
|
||||
Or, to save step 2, run "make buildlib LIBRARY=libexpatw.la".
|
||||
|
||||
4. Run "make installlib" (which installs the library only).
|
||||
Or, if step 2 was omitted, run "make installlib LIBRARY=libexpatw.la".
|
||||
|
||||
Using DESTDIR or INSTALL_ROOT is enabled, with INSTALL_ROOT being the default
|
||||
value for DESTDIR, and the rest of the make file using only DESTDIR.
|
||||
It works as follows:
|
||||
$ make install DESTDIR=/path/to/image
|
||||
overrides the in-makefile set DESTDIR, while both
|
||||
$ INSTALL_ROOT=/path/to/image make install
|
||||
$ make install INSTALL_ROOT=/path/to/image
|
||||
use DESTDIR=$(INSTALL_ROOT), even if DESTDIR eventually is defined in the
|
||||
environment, because variable-setting priority is
|
||||
1) commandline
|
||||
2) in-makefile
|
||||
3) environment
|
||||
|
||||
Note: This only applies to the Expat library itself, building UTF-16 versions
|
||||
of xmlwf and the tests is currently not supported.
|
||||
|
||||
Note for Solaris users: The "ar" command is usually located in
|
||||
"/usr/ccs/bin", which is not in the default PATH. You will need to
|
||||
add this to your path for the "make" command, and probably also switch
|
||||
to GNU make (the "make" found in /usr/ccs/bin does not seem to work
|
||||
properly -- appearantly it does not understand .PHONY directives). If
|
||||
you're using ksh or bash, use this command to build:
|
||||
|
||||
PATH=/usr/ccs/bin:$PATH make
|
||||
|
||||
When using Expat with a project using autoconf for configuration, you
|
||||
can use the probing macro in conftools/expat.m4 to determine how to
|
||||
include Expat. See the comments at the top of that file for more
|
||||
information.
|
||||
|
||||
A reference manual is available in the file doc/reference.html in this
|
||||
distribution.
|
||||
|
||||
The homepage for this project is http://www.libexpat.org/. There
|
||||
are links there to connect you to the bug reports page. If you need
|
||||
to report a bug when you don't have access to a browser, you may also
|
||||
send a bug report by email to expat-bugs@mail.libexpat.org.
|
||||
|
||||
Discussion related to the direction of future expat development takes
|
||||
place on expat-discuss@mail.libexpat.org. Archives of this list and
|
||||
other Expat-related lists may be found at:
|
||||
|
||||
http://mail.libexpat.org/mailman/listinfo/
|
||||
@@ -0,0 +1,91 @@
|
||||
/* expat_config.h.in. Generated from configure.in by autoheader. */
|
||||
|
||||
/* 1234 = LIL_ENDIAN, 4321 = BIGENDIAN */
|
||||
#cmakedefine BYTEORDER @BYTEORDER@
|
||||
|
||||
/* Define to 1 if you have the `bcopy' function. */
|
||||
#cmakedefine HAVE_BCOPY
|
||||
|
||||
/* Define to 1 if you have the <dlfcn.h> header file. */
|
||||
#cmakedefine HAVE_DLFCN_H
|
||||
|
||||
/* Define to 1 if you have the <fcntl.h> header file. */
|
||||
#cmakedefine HAVE_FCNTL_H
|
||||
|
||||
/* Define to 1 if you have the `getpagesize' function. */
|
||||
#cmakedefine HAVE_GETPAGESIZE
|
||||
|
||||
/* Define to 1 if you have the <inttypes.h> header file. */
|
||||
#cmakedefine HAVE_INTTYPES_H
|
||||
|
||||
/* Define to 1 if you have the `memmove' function. */
|
||||
#cmakedefine HAVE_MEMMOVE
|
||||
|
||||
/* Define to 1 if you have the <memory.h> header file. */
|
||||
#cmakedefine HAVE_MEMORY_H
|
||||
|
||||
/* Define to 1 if you have a working `mmap' system call. */
|
||||
#cmakedefine HAVE_MMAP
|
||||
|
||||
/* Define to 1 if you have the <stdint.h> header file. */
|
||||
#cmakedefine HAVE_STDINT_H
|
||||
|
||||
/* Define to 1 if you have the <stdlib.h> header file. */
|
||||
#cmakedefine HAVE_STDLIB_H
|
||||
|
||||
/* Define to 1 if you have the <strings.h> header file. */
|
||||
#cmakedefine HAVE_STRINGS_H
|
||||
|
||||
/* Define to 1 if you have the <string.h> header file. */
|
||||
#cmakedefine HAVE_STRING_H
|
||||
|
||||
/* Define to 1 if you have the <sys/stat.h> header file. */
|
||||
#cmakedefine HAVE_SYS_STAT_H
|
||||
|
||||
/* Define to 1 if you have the <sys/types.h> header file. */
|
||||
#cmakedefine HAVE_SYS_TYPES_H
|
||||
|
||||
/* Define to 1 if you have the <unistd.h> header file. */
|
||||
#cmakedefine HAVE_UNISTD_H
|
||||
|
||||
/* Define to the address where bug reports for this package should be sent. */
|
||||
#cmakedefine PACKAGE_BUGREPORT
|
||||
|
||||
/* Define to the full name of this package. */
|
||||
#cmakedefine PACKAGE_NAME
|
||||
|
||||
/* Define to the full name and version of this package. */
|
||||
#cmakedefine PACKAGE_STRING
|
||||
|
||||
/* Define to the one symbol short name of this package. */
|
||||
#cmakedefine PACKAGE_TARNAME
|
||||
|
||||
/* Define to the version of this package. */
|
||||
#cmakedefine PACKAGE_VERSION
|
||||
|
||||
/* Define to 1 if you have the ANSI C header files. */
|
||||
#cmakedefine STDC_HEADERS
|
||||
|
||||
/* whether byteorder is bigendian */
|
||||
#cmakedefine WORDS_BIGENDIAN
|
||||
|
||||
/* Define to specify how much context to retain around the current parse
|
||||
point. */
|
||||
#cmakedefine XML_CONTEXT_BYTES @XML_CONTEXT_BYTES@
|
||||
|
||||
/* Define to make parameter entity parsing functionality available. */
|
||||
#cmakedefine XML_DTD
|
||||
|
||||
/* Define to make XML Namespaces functionality available. */
|
||||
#cmakedefine XML_NS
|
||||
|
||||
/* Define to __FUNCTION__ or "" if `__func__' does not conform to ANSI C. */
|
||||
#ifdef _MSC_VER
|
||||
# define __func__ __FUNCTION__
|
||||
#endif
|
||||
|
||||
/* Define to `long' if <sys/types.h> does not define. */
|
||||
#cmakedefine off_t @OFF_T@
|
||||
|
||||
/* Define to `unsigned' if <sys/types.h> does not define. */
|
||||
#cmakedefine size_t @SIZE_T@
|
||||
@@ -0,0 +1,92 @@
|
||||
/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
|
||||
See the file COPYING for copying permission.
|
||||
*/
|
||||
|
||||
#define ASCII_A 0x41
|
||||
#define ASCII_B 0x42
|
||||
#define ASCII_C 0x43
|
||||
#define ASCII_D 0x44
|
||||
#define ASCII_E 0x45
|
||||
#define ASCII_F 0x46
|
||||
#define ASCII_G 0x47
|
||||
#define ASCII_H 0x48
|
||||
#define ASCII_I 0x49
|
||||
#define ASCII_J 0x4A
|
||||
#define ASCII_K 0x4B
|
||||
#define ASCII_L 0x4C
|
||||
#define ASCII_M 0x4D
|
||||
#define ASCII_N 0x4E
|
||||
#define ASCII_O 0x4F
|
||||
#define ASCII_P 0x50
|
||||
#define ASCII_Q 0x51
|
||||
#define ASCII_R 0x52
|
||||
#define ASCII_S 0x53
|
||||
#define ASCII_T 0x54
|
||||
#define ASCII_U 0x55
|
||||
#define ASCII_V 0x56
|
||||
#define ASCII_W 0x57
|
||||
#define ASCII_X 0x58
|
||||
#define ASCII_Y 0x59
|
||||
#define ASCII_Z 0x5A
|
||||
|
||||
#define ASCII_a 0x61
|
||||
#define ASCII_b 0x62
|
||||
#define ASCII_c 0x63
|
||||
#define ASCII_d 0x64
|
||||
#define ASCII_e 0x65
|
||||
#define ASCII_f 0x66
|
||||
#define ASCII_g 0x67
|
||||
#define ASCII_h 0x68
|
||||
#define ASCII_i 0x69
|
||||
#define ASCII_j 0x6A
|
||||
#define ASCII_k 0x6B
|
||||
#define ASCII_l 0x6C
|
||||
#define ASCII_m 0x6D
|
||||
#define ASCII_n 0x6E
|
||||
#define ASCII_o 0x6F
|
||||
#define ASCII_p 0x70
|
||||
#define ASCII_q 0x71
|
||||
#define ASCII_r 0x72
|
||||
#define ASCII_s 0x73
|
||||
#define ASCII_t 0x74
|
||||
#define ASCII_u 0x75
|
||||
#define ASCII_v 0x76
|
||||
#define ASCII_w 0x77
|
||||
#define ASCII_x 0x78
|
||||
#define ASCII_y 0x79
|
||||
#define ASCII_z 0x7A
|
||||
|
||||
#define ASCII_0 0x30
|
||||
#define ASCII_1 0x31
|
||||
#define ASCII_2 0x32
|
||||
#define ASCII_3 0x33
|
||||
#define ASCII_4 0x34
|
||||
#define ASCII_5 0x35
|
||||
#define ASCII_6 0x36
|
||||
#define ASCII_7 0x37
|
||||
#define ASCII_8 0x38
|
||||
#define ASCII_9 0x39
|
||||
|
||||
#define ASCII_TAB 0x09
|
||||
#define ASCII_SPACE 0x20
|
||||
#define ASCII_EXCL 0x21
|
||||
#define ASCII_QUOT 0x22
|
||||
#define ASCII_AMP 0x26
|
||||
#define ASCII_APOS 0x27
|
||||
#define ASCII_MINUS 0x2D
|
||||
#define ASCII_PERIOD 0x2E
|
||||
#define ASCII_COLON 0x3A
|
||||
#define ASCII_SEMI 0x3B
|
||||
#define ASCII_LT 0x3C
|
||||
#define ASCII_EQUALS 0x3D
|
||||
#define ASCII_GT 0x3E
|
||||
#define ASCII_LSQB 0x5B
|
||||
#define ASCII_RSQB 0x5D
|
||||
#define ASCII_UNDERSCORE 0x5F
|
||||
#define ASCII_LPAREN 0x28
|
||||
#define ASCII_RPAREN 0x29
|
||||
#define ASCII_FF 0x0C
|
||||
#define ASCII_SLASH 0x2F
|
||||
#define ASCII_HASH 0x23
|
||||
#define ASCII_PIPE 0x7C
|
||||
#define ASCII_COMMA 0x2C
|
||||
@@ -0,0 +1,36 @@
|
||||
/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
|
||||
See the file COPYING for copying permission.
|
||||
*/
|
||||
|
||||
/* 0x00 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
|
||||
/* 0x04 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
|
||||
/* 0x08 */ BT_NONXML, BT_S, BT_LF, BT_NONXML,
|
||||
/* 0x0C */ BT_NONXML, BT_CR, BT_NONXML, BT_NONXML,
|
||||
/* 0x10 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
|
||||
/* 0x14 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
|
||||
/* 0x18 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
|
||||
/* 0x1C */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
|
||||
/* 0x20 */ BT_S, BT_EXCL, BT_QUOT, BT_NUM,
|
||||
/* 0x24 */ BT_OTHER, BT_PERCNT, BT_AMP, BT_APOS,
|
||||
/* 0x28 */ BT_LPAR, BT_RPAR, BT_AST, BT_PLUS,
|
||||
/* 0x2C */ BT_COMMA, BT_MINUS, BT_NAME, BT_SOL,
|
||||
/* 0x30 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
|
||||
/* 0x34 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
|
||||
/* 0x38 */ BT_DIGIT, BT_DIGIT, BT_COLON, BT_SEMI,
|
||||
/* 0x3C */ BT_LT, BT_EQUALS, BT_GT, BT_QUEST,
|
||||
/* 0x40 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
|
||||
/* 0x44 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
|
||||
/* 0x48 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
|
||||
/* 0x4C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
|
||||
/* 0x50 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
|
||||
/* 0x54 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
|
||||
/* 0x58 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_LSQB,
|
||||
/* 0x5C */ BT_OTHER, BT_RSQB, BT_OTHER, BT_NMSTRT,
|
||||
/* 0x60 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
|
||||
/* 0x64 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
|
||||
/* 0x68 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
|
||||
/* 0x6C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
|
||||
/* 0x70 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
|
||||
/* 0x74 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
|
||||
/* 0x78 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
|
||||
/* 0x7C */ BT_VERBAR, BT_OTHER, BT_OTHER, BT_OTHER,
|
||||
@@ -0,0 +1,1047 @@
|
||||
/* Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd
|
||||
See the file COPYING for copying permission.
|
||||
*/
|
||||
|
||||
#ifndef Expat_INCLUDED
|
||||
#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 "expat_external.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
struct XML_ParserStruct;
|
||||
typedef struct XML_ParserStruct *XML_Parser;
|
||||
|
||||
/* Should this be defined using stdbool.h when C99 is available? */
|
||||
typedef unsigned char XML_Bool;
|
||||
#define XML_TRUE ((XML_Bool) 1)
|
||||
#define XML_FALSE ((XML_Bool) 0)
|
||||
|
||||
/* The XML_Status enum gives the possible return values for several
|
||||
API functions. The preprocessor #defines are included so this
|
||||
stanza can be added to code that still needs to support older
|
||||
versions of Expat 1.95.x:
|
||||
|
||||
#ifndef XML_STATUS_OK
|
||||
#define XML_STATUS_OK 1
|
||||
#define XML_STATUS_ERROR 0
|
||||
#endif
|
||||
|
||||
Otherwise, the #define hackery is quite ugly and would have been
|
||||
dropped.
|
||||
*/
|
||||
enum XML_Status {
|
||||
XML_STATUS_ERROR = 0,
|
||||
#define XML_STATUS_ERROR XML_STATUS_ERROR
|
||||
XML_STATUS_OK = 1,
|
||||
#define XML_STATUS_OK XML_STATUS_OK
|
||||
XML_STATUS_SUSPENDED = 2
|
||||
#define XML_STATUS_SUSPENDED XML_STATUS_SUSPENDED
|
||||
};
|
||||
|
||||
enum XML_Error {
|
||||
XML_ERROR_NONE,
|
||||
XML_ERROR_NO_MEMORY,
|
||||
XML_ERROR_SYNTAX,
|
||||
XML_ERROR_NO_ELEMENTS,
|
||||
XML_ERROR_INVALID_TOKEN,
|
||||
XML_ERROR_UNCLOSED_TOKEN,
|
||||
XML_ERROR_PARTIAL_CHAR,
|
||||
XML_ERROR_TAG_MISMATCH,
|
||||
XML_ERROR_DUPLICATE_ATTRIBUTE,
|
||||
XML_ERROR_JUNK_AFTER_DOC_ELEMENT,
|
||||
XML_ERROR_PARAM_ENTITY_REF,
|
||||
XML_ERROR_UNDEFINED_ENTITY,
|
||||
XML_ERROR_RECURSIVE_ENTITY_REF,
|
||||
XML_ERROR_ASYNC_ENTITY,
|
||||
XML_ERROR_BAD_CHAR_REF,
|
||||
XML_ERROR_BINARY_ENTITY_REF,
|
||||
XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF,
|
||||
XML_ERROR_MISPLACED_XML_PI,
|
||||
XML_ERROR_UNKNOWN_ENCODING,
|
||||
XML_ERROR_INCORRECT_ENCODING,
|
||||
XML_ERROR_UNCLOSED_CDATA_SECTION,
|
||||
XML_ERROR_EXTERNAL_ENTITY_HANDLING,
|
||||
XML_ERROR_NOT_STANDALONE,
|
||||
XML_ERROR_UNEXPECTED_STATE,
|
||||
XML_ERROR_ENTITY_DECLARED_IN_PE,
|
||||
XML_ERROR_FEATURE_REQUIRES_XML_DTD,
|
||||
XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING,
|
||||
/* Added in 1.95.7. */
|
||||
XML_ERROR_UNBOUND_PREFIX,
|
||||
/* Added in 1.95.8. */
|
||||
XML_ERROR_UNDECLARING_PREFIX,
|
||||
XML_ERROR_INCOMPLETE_PE,
|
||||
XML_ERROR_XML_DECL,
|
||||
XML_ERROR_TEXT_DECL,
|
||||
XML_ERROR_PUBLICID,
|
||||
XML_ERROR_SUSPENDED,
|
||||
XML_ERROR_NOT_SUSPENDED,
|
||||
XML_ERROR_ABORTED,
|
||||
XML_ERROR_FINISHED,
|
||||
XML_ERROR_SUSPEND_PE,
|
||||
/* Added in 2.0. */
|
||||
XML_ERROR_RESERVED_PREFIX_XML,
|
||||
XML_ERROR_RESERVED_PREFIX_XMLNS,
|
||||
XML_ERROR_RESERVED_NAMESPACE_URI
|
||||
};
|
||||
|
||||
enum XML_Content_Type {
|
||||
XML_CTYPE_EMPTY = 1,
|
||||
XML_CTYPE_ANY,
|
||||
XML_CTYPE_MIXED,
|
||||
XML_CTYPE_NAME,
|
||||
XML_CTYPE_CHOICE,
|
||||
XML_CTYPE_SEQ
|
||||
};
|
||||
|
||||
enum XML_Content_Quant {
|
||||
XML_CQUANT_NONE,
|
||||
XML_CQUANT_OPT,
|
||||
XML_CQUANT_REP,
|
||||
XML_CQUANT_PLUS
|
||||
};
|
||||
|
||||
/* If type == XML_CTYPE_EMPTY or XML_CTYPE_ANY, then quant will be
|
||||
XML_CQUANT_NONE, and the other fields will be zero or NULL.
|
||||
If type == XML_CTYPE_MIXED, then quant will be NONE or REP and
|
||||
numchildren will contain number of elements that may be mixed in
|
||||
and children point to an array of XML_Content cells that will be
|
||||
all of XML_CTYPE_NAME type with no quantification.
|
||||
|
||||
If type == XML_CTYPE_NAME, then the name points to the name, and
|
||||
the numchildren field will be zero and children will be NULL. The
|
||||
quant fields indicates any quantifiers placed on the name.
|
||||
|
||||
CHOICE and SEQ will have name NULL, the number of children in
|
||||
numchildren and children will point, recursively, to an array
|
||||
of XML_Content cells.
|
||||
|
||||
The EMPTY, ANY, and MIXED types will only occur at top level.
|
||||
*/
|
||||
|
||||
typedef struct XML_cp XML_Content;
|
||||
|
||||
struct XML_cp {
|
||||
enum XML_Content_Type type;
|
||||
enum XML_Content_Quant quant;
|
||||
XML_Char * name;
|
||||
unsigned int numchildren;
|
||||
XML_Content * children;
|
||||
};
|
||||
|
||||
|
||||
/* This is called for an element declaration. See above for
|
||||
description of the model argument. It's the caller's responsibility
|
||||
to free model when finished with it.
|
||||
*/
|
||||
typedef void (XMLCALL *XML_ElementDeclHandler) (void *userData,
|
||||
const XML_Char *name,
|
||||
XML_Content *model);
|
||||
|
||||
XMLPARSEAPI(void)
|
||||
XML_SetElementDeclHandler(XML_Parser parser,
|
||||
XML_ElementDeclHandler eldecl);
|
||||
|
||||
/* The Attlist declaration handler is called for *each* attribute. So
|
||||
a single Attlist declaration with multiple attributes declared will
|
||||
generate multiple calls to this handler. The "default" parameter
|
||||
may be NULL in the case of the "#IMPLIED" or "#REQUIRED"
|
||||
keyword. The "isrequired" parameter will be true and the default
|
||||
value will be NULL in the case of "#REQUIRED". If "isrequired" is
|
||||
true and default is non-NULL, then this is a "#FIXED" default.
|
||||
*/
|
||||
typedef void (XMLCALL *XML_AttlistDeclHandler) (
|
||||
void *userData,
|
||||
const XML_Char *elname,
|
||||
const XML_Char *attname,
|
||||
const XML_Char *att_type,
|
||||
const XML_Char *dflt,
|
||||
int isrequired);
|
||||
|
||||
XMLPARSEAPI(void)
|
||||
XML_SetAttlistDeclHandler(XML_Parser parser,
|
||||
XML_AttlistDeclHandler attdecl);
|
||||
|
||||
/* The XML declaration handler is called for *both* XML declarations
|
||||
and text declarations. The way to distinguish is that the version
|
||||
parameter will be NULL for text declarations. The encoding
|
||||
parameter may be NULL for XML declarations. The standalone
|
||||
parameter will be -1, 0, or 1 indicating respectively that there
|
||||
was no standalone parameter in the declaration, that it was given
|
||||
as no, or that it was given as yes.
|
||||
*/
|
||||
typedef void (XMLCALL *XML_XmlDeclHandler) (void *userData,
|
||||
const XML_Char *version,
|
||||
const XML_Char *encoding,
|
||||
int standalone);
|
||||
|
||||
XMLPARSEAPI(void)
|
||||
XML_SetXmlDeclHandler(XML_Parser parser,
|
||||
XML_XmlDeclHandler xmldecl);
|
||||
|
||||
|
||||
typedef struct {
|
||||
void *(*malloc_fcn)(size_t size);
|
||||
void *(*realloc_fcn)(void *ptr, size_t size);
|
||||
void (*free_fcn)(void *ptr);
|
||||
} XML_Memory_Handling_Suite;
|
||||
|
||||
/* Constructs a new parser; encoding is the encoding specified by the
|
||||
external protocol or NULL if there is none specified.
|
||||
*/
|
||||
XMLPARSEAPI(XML_Parser)
|
||||
XML_ParserCreate(const XML_Char *encoding);
|
||||
|
||||
/* Constructs a new parser and namespace processor. Element type
|
||||
names and attribute names that belong to a namespace will be
|
||||
expanded; unprefixed attribute names are never expanded; unprefixed
|
||||
element type names are expanded only if there is a default
|
||||
namespace. The expanded name is the concatenation of the namespace
|
||||
URI, the namespace separator character, and the local part of the
|
||||
name. If the namespace separator is '\0' then the namespace URI
|
||||
and the local part will be concatenated without any separator.
|
||||
It is a programming error to use the separator '\0' with namespace
|
||||
triplets (see XML_SetReturnNSTriplet).
|
||||
*/
|
||||
XMLPARSEAPI(XML_Parser)
|
||||
XML_ParserCreateNS(const XML_Char *encoding, XML_Char namespaceSeparator);
|
||||
|
||||
|
||||
/* Constructs a new parser using the memory management suite referred to
|
||||
by memsuite. If memsuite is NULL, then use the standard library memory
|
||||
suite. If namespaceSeparator is non-NULL it creates a parser with
|
||||
namespace processing as described above. The character pointed at
|
||||
will serve as the namespace separator.
|
||||
|
||||
All further memory operations used for the created parser will come from
|
||||
the given suite.
|
||||
*/
|
||||
XMLPARSEAPI(XML_Parser)
|
||||
XML_ParserCreate_MM(const XML_Char *encoding,
|
||||
const XML_Memory_Handling_Suite *memsuite,
|
||||
const XML_Char *namespaceSeparator);
|
||||
|
||||
/* Prepare a parser object to be re-used. This is particularly
|
||||
valuable when memory allocation overhead is disproportionatly high,
|
||||
such as when a large number of small documnents need to be parsed.
|
||||
All handlers are cleared from the parser, except for the
|
||||
unknownEncodingHandler. The parser's external state is re-initialized
|
||||
except for the values of ns and ns_triplets.
|
||||
|
||||
Added in Expat 1.95.3.
|
||||
*/
|
||||
XMLPARSEAPI(XML_Bool)
|
||||
XML_ParserReset(XML_Parser parser, const XML_Char *encoding);
|
||||
|
||||
/* atts is array of name/value pairs, terminated by 0;
|
||||
names and values are 0 terminated.
|
||||
*/
|
||||
typedef void (XMLCALL *XML_StartElementHandler) (void *userData,
|
||||
const XML_Char *name,
|
||||
const XML_Char **atts);
|
||||
|
||||
typedef void (XMLCALL *XML_EndElementHandler) (void *userData,
|
||||
const XML_Char *name);
|
||||
|
||||
|
||||
/* s is not 0 terminated. */
|
||||
typedef void (XMLCALL *XML_CharacterDataHandler) (void *userData,
|
||||
const XML_Char *s,
|
||||
int len);
|
||||
|
||||
/* target and data are 0 terminated */
|
||||
typedef void (XMLCALL *XML_ProcessingInstructionHandler) (
|
||||
void *userData,
|
||||
const XML_Char *target,
|
||||
const XML_Char *data);
|
||||
|
||||
/* data is 0 terminated */
|
||||
typedef void (XMLCALL *XML_CommentHandler) (void *userData,
|
||||
const XML_Char *data);
|
||||
|
||||
typedef void (XMLCALL *XML_StartCdataSectionHandler) (void *userData);
|
||||
typedef void (XMLCALL *XML_EndCdataSectionHandler) (void *userData);
|
||||
|
||||
/* This is called for any characters in the XML document for which
|
||||
there is no applicable handler. This includes both characters that
|
||||
are part of markup which is of a kind that is not reported
|
||||
(comments, markup declarations), or characters that are part of a
|
||||
construct which could be reported but for which no handler has been
|
||||
supplied. The characters are passed exactly as they were in the XML
|
||||
document except that they will be encoded in UTF-8 or UTF-16.
|
||||
Line boundaries are not normalized. Note that a byte order mark
|
||||
character is not passed to the default handler. There are no
|
||||
guarantees about how characters are divided between calls to the
|
||||
default handler: for example, a comment might be split between
|
||||
multiple calls.
|
||||
*/
|
||||
typedef void (XMLCALL *XML_DefaultHandler) (void *userData,
|
||||
const XML_Char *s,
|
||||
int len);
|
||||
|
||||
/* This is called for the start of the DOCTYPE declaration, before
|
||||
any DTD or internal subset is parsed.
|
||||
*/
|
||||
typedef void (XMLCALL *XML_StartDoctypeDeclHandler) (
|
||||
void *userData,
|
||||
const XML_Char *doctypeName,
|
||||
const XML_Char *sysid,
|
||||
const XML_Char *pubid,
|
||||
int has_internal_subset);
|
||||
|
||||
/* This is called for the start of the DOCTYPE declaration when the
|
||||
closing > is encountered, but after processing any external
|
||||
subset.
|
||||
*/
|
||||
typedef void (XMLCALL *XML_EndDoctypeDeclHandler)(void *userData);
|
||||
|
||||
/* This is called for entity declarations. The is_parameter_entity
|
||||
argument will be non-zero if the entity is a parameter entity, zero
|
||||
otherwise.
|
||||
|
||||
For internal entities (<!ENTITY foo "bar">), value will
|
||||
be non-NULL and systemId, publicID, and notationName will be NULL.
|
||||
The value string is NOT nul-terminated; the length is provided in
|
||||
the value_length argument. Since it is legal to have zero-length
|
||||
values, do not use this argument to test for internal entities.
|
||||
|
||||
For external entities, value will be NULL and systemId will be
|
||||
non-NULL. The publicId argument will be NULL unless a public
|
||||
identifier was provided. The notationName argument will have a
|
||||
non-NULL value only for unparsed entity declarations.
|
||||
|
||||
Note that is_parameter_entity can't be changed to XML_Bool, since
|
||||
that would break binary compatibility.
|
||||
*/
|
||||
typedef void (XMLCALL *XML_EntityDeclHandler) (
|
||||
void *userData,
|
||||
const XML_Char *entityName,
|
||||
int is_parameter_entity,
|
||||
const XML_Char *value,
|
||||
int value_length,
|
||||
const XML_Char *base,
|
||||
const XML_Char *systemId,
|
||||
const XML_Char *publicId,
|
||||
const XML_Char *notationName);
|
||||
|
||||
XMLPARSEAPI(void)
|
||||
XML_SetEntityDeclHandler(XML_Parser parser,
|
||||
XML_EntityDeclHandler handler);
|
||||
|
||||
/* OBSOLETE -- OBSOLETE -- OBSOLETE
|
||||
This handler has been superceded by the EntityDeclHandler above.
|
||||
It is provided here for backward compatibility.
|
||||
|
||||
This is called for a declaration of an unparsed (NDATA) entity.
|
||||
The base argument is whatever was set by XML_SetBase. The
|
||||
entityName, systemId and notationName arguments will never be
|
||||
NULL. The other arguments may be.
|
||||
*/
|
||||
typedef void (XMLCALL *XML_UnparsedEntityDeclHandler) (
|
||||
void *userData,
|
||||
const XML_Char *entityName,
|
||||
const XML_Char *base,
|
||||
const XML_Char *systemId,
|
||||
const XML_Char *publicId,
|
||||
const XML_Char *notationName);
|
||||
|
||||
/* This is called for a declaration of notation. The base argument is
|
||||
whatever was set by XML_SetBase. The notationName will never be
|
||||
NULL. The other arguments can be.
|
||||
*/
|
||||
typedef void (XMLCALL *XML_NotationDeclHandler) (
|
||||
void *userData,
|
||||
const XML_Char *notationName,
|
||||
const XML_Char *base,
|
||||
const XML_Char *systemId,
|
||||
const XML_Char *publicId);
|
||||
|
||||
/* When namespace processing is enabled, these are called once for
|
||||
each namespace declaration. The call to the start and end element
|
||||
handlers occur between the calls to the start and end namespace
|
||||
declaration handlers. For an xmlns attribute, prefix will be
|
||||
NULL. For an xmlns="" attribute, uri will be NULL.
|
||||
*/
|
||||
typedef void (XMLCALL *XML_StartNamespaceDeclHandler) (
|
||||
void *userData,
|
||||
const XML_Char *prefix,
|
||||
const XML_Char *uri);
|
||||
|
||||
typedef void (XMLCALL *XML_EndNamespaceDeclHandler) (
|
||||
void *userData,
|
||||
const XML_Char *prefix);
|
||||
|
||||
/* This is called if the document is not standalone, that is, it has an
|
||||
external subset or a reference to a parameter entity, but does not
|
||||
have standalone="yes". If this handler returns XML_STATUS_ERROR,
|
||||
then processing will not continue, and the parser will return a
|
||||
XML_ERROR_NOT_STANDALONE error.
|
||||
If parameter entity parsing is enabled, then in addition to the
|
||||
conditions above this handler will only be called if the referenced
|
||||
entity was actually read.
|
||||
*/
|
||||
typedef int (XMLCALL *XML_NotStandaloneHandler) (void *userData);
|
||||
|
||||
/* This is called for a reference to an external parsed general
|
||||
entity. The referenced entity is not automatically parsed. The
|
||||
application can parse it immediately or later using
|
||||
XML_ExternalEntityParserCreate.
|
||||
|
||||
The parser argument is the parser parsing the entity containing the
|
||||
reference; it can be passed as the parser argument to
|
||||
XML_ExternalEntityParserCreate. The systemId argument is the
|
||||
system identifier as specified in the entity declaration; it will
|
||||
not be NULL.
|
||||
|
||||
The base argument is the system identifier that should be used as
|
||||
the base for resolving systemId if systemId was relative; this is
|
||||
set by XML_SetBase; it may be NULL.
|
||||
|
||||
The publicId argument is the public identifier as specified in the
|
||||
entity declaration, or NULL if none was specified; the whitespace
|
||||
in the public identifier will have been normalized as required by
|
||||
the XML spec.
|
||||
|
||||
The context argument specifies the parsing context in the format
|
||||
expected by the context argument to XML_ExternalEntityParserCreate;
|
||||
context is valid only until the handler returns, so if the
|
||||
referenced entity is to be parsed later, it must be copied.
|
||||
context is NULL only when the entity is a parameter entity.
|
||||
|
||||
The handler should return XML_STATUS_ERROR if processing should not
|
||||
continue because of a fatal error in the handling of the external
|
||||
entity. In this case the calling parser will return an
|
||||
XML_ERROR_EXTERNAL_ENTITY_HANDLING error.
|
||||
|
||||
Note that unlike other handlers the first argument is the parser,
|
||||
not userData.
|
||||
*/
|
||||
typedef int (XMLCALL *XML_ExternalEntityRefHandler) (
|
||||
XML_Parser parser,
|
||||
const XML_Char *context,
|
||||
const XML_Char *base,
|
||||
const XML_Char *systemId,
|
||||
const XML_Char *publicId);
|
||||
|
||||
/* This is called in two situations:
|
||||
1) An entity reference is encountered for which no declaration
|
||||
has been read *and* this is not an error.
|
||||
2) An internal entity reference is read, but not expanded, because
|
||||
XML_SetDefaultHandler has been called.
|
||||
Note: skipped parameter entities in declarations and skipped general
|
||||
entities in attribute values cannot be reported, because
|
||||
the event would be out of sync with the reporting of the
|
||||
declarations or attribute values
|
||||
*/
|
||||
typedef void (XMLCALL *XML_SkippedEntityHandler) (
|
||||
void *userData,
|
||||
const XML_Char *entityName,
|
||||
int is_parameter_entity);
|
||||
|
||||
/* This structure is filled in by the XML_UnknownEncodingHandler to
|
||||
provide information to the parser about encodings that are unknown
|
||||
to the parser.
|
||||
|
||||
The map[b] member gives information about byte sequences whose
|
||||
first byte is b.
|
||||
|
||||
If map[b] is c where c is >= 0, then b by itself encodes the
|
||||
Unicode scalar value c.
|
||||
|
||||
If map[b] is -1, then the byte sequence is malformed.
|
||||
|
||||
If map[b] is -n, where n >= 2, then b is the first byte of an
|
||||
n-byte sequence that encodes a single Unicode scalar value.
|
||||
|
||||
The data member will be passed as the first argument to the convert
|
||||
function.
|
||||
|
||||
The convert function is used to convert multibyte sequences; s will
|
||||
point to a n-byte sequence where map[(unsigned char)*s] == -n. The
|
||||
convert function must return the Unicode scalar value represented
|
||||
by this byte sequence or -1 if the byte sequence is malformed.
|
||||
|
||||
The convert function may be NULL if the encoding is a single-byte
|
||||
encoding, that is if map[b] >= -1 for all bytes b.
|
||||
|
||||
When the parser is finished with the encoding, then if release is
|
||||
not NULL, it will call release passing it the data member; once
|
||||
release has been called, the convert function will not be called
|
||||
again.
|
||||
|
||||
Expat places certain restrictions on the encodings that are supported
|
||||
using this mechanism.
|
||||
|
||||
1. Every ASCII character that can appear in a well-formed XML document,
|
||||
other than the characters
|
||||
|
||||
$@\^`{}~
|
||||
|
||||
must be represented by a single byte, and that byte must be the
|
||||
same byte that represents that character in ASCII.
|
||||
|
||||
2. No character may require more than 4 bytes to encode.
|
||||
|
||||
3. All characters encoded must have Unicode scalar values <=
|
||||
0xFFFF, (i.e., characters that would be encoded by surrogates in
|
||||
UTF-16 are not allowed). Note that this restriction doesn't
|
||||
apply to the built-in support for UTF-8 and UTF-16.
|
||||
|
||||
4. No Unicode character may be encoded by more than one distinct
|
||||
sequence of bytes.
|
||||
*/
|
||||
typedef struct {
|
||||
int map[256];
|
||||
void *data;
|
||||
int (XMLCALL *convert)(void *data, const char *s);
|
||||
void (XMLCALL *release)(void *data);
|
||||
} XML_Encoding;
|
||||
|
||||
/* This is called for an encoding that is unknown to the parser.
|
||||
|
||||
The encodingHandlerData argument is that which was passed as the
|
||||
second argument to XML_SetUnknownEncodingHandler.
|
||||
|
||||
The name argument gives the name of the encoding as specified in
|
||||
the encoding declaration.
|
||||
|
||||
If the callback can provide information about the encoding, it must
|
||||
fill in the XML_Encoding structure, and return XML_STATUS_OK.
|
||||
Otherwise it must return XML_STATUS_ERROR.
|
||||
|
||||
If info does not describe a suitable encoding, then the parser will
|
||||
return an XML_UNKNOWN_ENCODING error.
|
||||
*/
|
||||
typedef int (XMLCALL *XML_UnknownEncodingHandler) (
|
||||
void *encodingHandlerData,
|
||||
const XML_Char *name,
|
||||
XML_Encoding *info);
|
||||
|
||||
XMLPARSEAPI(void)
|
||||
XML_SetElementHandler(XML_Parser parser,
|
||||
XML_StartElementHandler start,
|
||||
XML_EndElementHandler end);
|
||||
|
||||
XMLPARSEAPI(void)
|
||||
XML_SetStartElementHandler(XML_Parser parser,
|
||||
XML_StartElementHandler handler);
|
||||
|
||||
XMLPARSEAPI(void)
|
||||
XML_SetEndElementHandler(XML_Parser parser,
|
||||
XML_EndElementHandler handler);
|
||||
|
||||
XMLPARSEAPI(void)
|
||||
XML_SetCharacterDataHandler(XML_Parser parser,
|
||||
XML_CharacterDataHandler handler);
|
||||
|
||||
XMLPARSEAPI(void)
|
||||
XML_SetProcessingInstructionHandler(XML_Parser parser,
|
||||
XML_ProcessingInstructionHandler handler);
|
||||
XMLPARSEAPI(void)
|
||||
XML_SetCommentHandler(XML_Parser parser,
|
||||
XML_CommentHandler handler);
|
||||
|
||||
XMLPARSEAPI(void)
|
||||
XML_SetCdataSectionHandler(XML_Parser parser,
|
||||
XML_StartCdataSectionHandler start,
|
||||
XML_EndCdataSectionHandler end);
|
||||
|
||||
XMLPARSEAPI(void)
|
||||
XML_SetStartCdataSectionHandler(XML_Parser parser,
|
||||
XML_StartCdataSectionHandler start);
|
||||
|
||||
XMLPARSEAPI(void)
|
||||
XML_SetEndCdataSectionHandler(XML_Parser parser,
|
||||
XML_EndCdataSectionHandler end);
|
||||
|
||||
/* This sets the default handler and also inhibits expansion of
|
||||
internal entities. These entity references will be passed to the
|
||||
default handler, or to the skipped entity handler, if one is set.
|
||||
*/
|
||||
XMLPARSEAPI(void)
|
||||
XML_SetDefaultHandler(XML_Parser parser,
|
||||
XML_DefaultHandler handler);
|
||||
|
||||
/* This sets the default handler but does not inhibit expansion of
|
||||
internal entities. The entity reference will not be passed to the
|
||||
default handler.
|
||||
*/
|
||||
XMLPARSEAPI(void)
|
||||
XML_SetDefaultHandlerExpand(XML_Parser parser,
|
||||
XML_DefaultHandler handler);
|
||||
|
||||
XMLPARSEAPI(void)
|
||||
XML_SetDoctypeDeclHandler(XML_Parser parser,
|
||||
XML_StartDoctypeDeclHandler start,
|
||||
XML_EndDoctypeDeclHandler end);
|
||||
|
||||
XMLPARSEAPI(void)
|
||||
XML_SetStartDoctypeDeclHandler(XML_Parser parser,
|
||||
XML_StartDoctypeDeclHandler start);
|
||||
|
||||
XMLPARSEAPI(void)
|
||||
XML_SetEndDoctypeDeclHandler(XML_Parser parser,
|
||||
XML_EndDoctypeDeclHandler end);
|
||||
|
||||
XMLPARSEAPI(void)
|
||||
XML_SetUnparsedEntityDeclHandler(XML_Parser parser,
|
||||
XML_UnparsedEntityDeclHandler handler);
|
||||
|
||||
XMLPARSEAPI(void)
|
||||
XML_SetNotationDeclHandler(XML_Parser parser,
|
||||
XML_NotationDeclHandler handler);
|
||||
|
||||
XMLPARSEAPI(void)
|
||||
XML_SetNamespaceDeclHandler(XML_Parser parser,
|
||||
XML_StartNamespaceDeclHandler start,
|
||||
XML_EndNamespaceDeclHandler end);
|
||||
|
||||
XMLPARSEAPI(void)
|
||||
XML_SetStartNamespaceDeclHandler(XML_Parser parser,
|
||||
XML_StartNamespaceDeclHandler start);
|
||||
|
||||
XMLPARSEAPI(void)
|
||||
XML_SetEndNamespaceDeclHandler(XML_Parser parser,
|
||||
XML_EndNamespaceDeclHandler end);
|
||||
|
||||
XMLPARSEAPI(void)
|
||||
XML_SetNotStandaloneHandler(XML_Parser parser,
|
||||
XML_NotStandaloneHandler handler);
|
||||
|
||||
XMLPARSEAPI(void)
|
||||
XML_SetExternalEntityRefHandler(XML_Parser parser,
|
||||
XML_ExternalEntityRefHandler handler);
|
||||
|
||||
/* If a non-NULL value for arg is specified here, then it will be
|
||||
passed as the first argument to the external entity ref handler
|
||||
instead of the parser object.
|
||||
*/
|
||||
XMLPARSEAPI(void)
|
||||
XML_SetExternalEntityRefHandlerArg(XML_Parser parser,
|
||||
void *arg);
|
||||
|
||||
XMLPARSEAPI(void)
|
||||
XML_SetSkippedEntityHandler(XML_Parser parser,
|
||||
XML_SkippedEntityHandler handler);
|
||||
|
||||
XMLPARSEAPI(void)
|
||||
XML_SetUnknownEncodingHandler(XML_Parser parser,
|
||||
XML_UnknownEncodingHandler handler,
|
||||
void *encodingHandlerData);
|
||||
|
||||
/* This can be called within a handler for a start element, end
|
||||
element, processing instruction or character data. It causes the
|
||||
corresponding markup to be passed to the default handler.
|
||||
*/
|
||||
XMLPARSEAPI(void)
|
||||
XML_DefaultCurrent(XML_Parser parser);
|
||||
|
||||
/* If do_nst is non-zero, and namespace processing is in effect, and
|
||||
a name has a prefix (i.e. an explicit namespace qualifier) then
|
||||
that name is returned as a triplet in a single string separated by
|
||||
the separator character specified when the parser was created: URI
|
||||
+ sep + local_name + sep + prefix.
|
||||
|
||||
If do_nst is zero, then namespace information is returned in the
|
||||
default manner (URI + sep + local_name) whether or not the name
|
||||
has a prefix.
|
||||
|
||||
Note: Calling XML_SetReturnNSTriplet after XML_Parse or
|
||||
XML_ParseBuffer has no effect.
|
||||
*/
|
||||
|
||||
XMLPARSEAPI(void)
|
||||
XML_SetReturnNSTriplet(XML_Parser parser, int do_nst);
|
||||
|
||||
/* This value is passed as the userData argument to callbacks. */
|
||||
XMLPARSEAPI(void)
|
||||
XML_SetUserData(XML_Parser parser, void *userData);
|
||||
|
||||
/* Returns the last value set by XML_SetUserData or NULL. */
|
||||
#define XML_GetUserData(parser) (*(void **)(parser))
|
||||
|
||||
/* This is equivalent to supplying an encoding argument to
|
||||
XML_ParserCreate. On success XML_SetEncoding returns non-zero,
|
||||
zero otherwise.
|
||||
Note: Calling XML_SetEncoding after XML_Parse or XML_ParseBuffer
|
||||
has no effect and returns XML_STATUS_ERROR.
|
||||
*/
|
||||
XMLPARSEAPI(enum XML_Status)
|
||||
XML_SetEncoding(XML_Parser parser, const XML_Char *encoding);
|
||||
|
||||
/* If this function is called, then the parser will be passed as the
|
||||
first argument to callbacks instead of userData. The userData will
|
||||
still be accessible using XML_GetUserData.
|
||||
*/
|
||||
XMLPARSEAPI(void)
|
||||
XML_UseParserAsHandlerArg(XML_Parser parser);
|
||||
|
||||
/* If useDTD == XML_TRUE is passed to this function, then the parser
|
||||
will assume that there is an external subset, even if none is
|
||||
specified in the document. In such a case the parser will call the
|
||||
externalEntityRefHandler with a value of NULL for the systemId
|
||||
argument (the publicId and context arguments will be NULL as well).
|
||||
Note: For the purpose of checking WFC: Entity Declared, passing
|
||||
useDTD == XML_TRUE will make the parser behave as if the document
|
||||
had a DTD with an external subset.
|
||||
Note: If this function is called, then this must be done before
|
||||
the first call to XML_Parse or XML_ParseBuffer, since it will
|
||||
have no effect after that. Returns
|
||||
XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING.
|
||||
Note: If the document does not have a DOCTYPE declaration at all,
|
||||
then startDoctypeDeclHandler and endDoctypeDeclHandler will not
|
||||
be called, despite an external subset being parsed.
|
||||
Note: If XML_DTD is not defined when Expat is compiled, returns
|
||||
XML_ERROR_FEATURE_REQUIRES_XML_DTD.
|
||||
*/
|
||||
XMLPARSEAPI(enum XML_Error)
|
||||
XML_UseForeignDTD(XML_Parser parser, XML_Bool useDTD);
|
||||
|
||||
|
||||
/* Sets the base to be used for resolving relative URIs in system
|
||||
identifiers in declarations. Resolving relative identifiers is
|
||||
left to the application: this value will be passed through as the
|
||||
base argument to the XML_ExternalEntityRefHandler,
|
||||
XML_NotationDeclHandler and XML_UnparsedEntityDeclHandler. The base
|
||||
argument will be copied. Returns XML_STATUS_ERROR if out of memory,
|
||||
XML_STATUS_OK otherwise.
|
||||
*/
|
||||
XMLPARSEAPI(enum XML_Status)
|
||||
XML_SetBase(XML_Parser parser, const XML_Char *base);
|
||||
|
||||
XMLPARSEAPI(const XML_Char *)
|
||||
XML_GetBase(XML_Parser parser);
|
||||
|
||||
/* Returns the number of the attribute/value pairs passed in last call
|
||||
to the XML_StartElementHandler that were specified in the start-tag
|
||||
rather than defaulted. Each attribute/value pair counts as 2; thus
|
||||
this correspondds to an index into the atts array passed to the
|
||||
XML_StartElementHandler.
|
||||
*/
|
||||
XMLPARSEAPI(int)
|
||||
XML_GetSpecifiedAttributeCount(XML_Parser parser);
|
||||
|
||||
/* Returns the index of the ID attribute passed in the last call to
|
||||
XML_StartElementHandler, or -1 if there is no ID attribute. Each
|
||||
attribute/value pair counts as 2; thus this correspondds to an
|
||||
index into the atts array passed to the XML_StartElementHandler.
|
||||
*/
|
||||
XMLPARSEAPI(int)
|
||||
XML_GetIdAttributeIndex(XML_Parser parser);
|
||||
|
||||
#ifdef XML_ATTR_INFO
|
||||
/* Source file byte offsets for the start and end of attribute names and values.
|
||||
The value indices are exclusive of surrounding quotes; thus in a UTF-8 source
|
||||
file an attribute value of "blah" will yield:
|
||||
info->valueEnd - info->valueStart = 4 bytes.
|
||||
*/
|
||||
typedef struct {
|
||||
XML_Index nameStart; /* Offset to beginning of the attribute name. */
|
||||
XML_Index nameEnd; /* Offset after the attribute name's last byte. */
|
||||
XML_Index valueStart; /* Offset to beginning of the attribute value. */
|
||||
XML_Index valueEnd; /* Offset after the attribute value's last byte. */
|
||||
} XML_AttrInfo;
|
||||
|
||||
/* Returns an array of XML_AttrInfo structures for the attribute/value pairs
|
||||
passed in last call to the XML_StartElementHandler that were specified
|
||||
in the start-tag rather than defaulted. Each attribute/value pair counts
|
||||
as 1; thus the number of entries in the array is
|
||||
XML_GetSpecifiedAttributeCount(parser) / 2.
|
||||
*/
|
||||
XMLPARSEAPI(const XML_AttrInfo *)
|
||||
XML_GetAttributeInfo(XML_Parser parser);
|
||||
#endif
|
||||
|
||||
/* Parses some input. Returns XML_STATUS_ERROR if a fatal error is
|
||||
detected. The last call to XML_Parse must have isFinal true; len
|
||||
may be zero for this call (or any other).
|
||||
|
||||
Though the return values for these functions has always been
|
||||
described as a Boolean value, the implementation, at least for the
|
||||
1.95.x series, has always returned exactly one of the XML_Status
|
||||
values.
|
||||
*/
|
||||
XMLPARSEAPI(enum XML_Status)
|
||||
XML_Parse(XML_Parser parser, const char *s, int len, int isFinal);
|
||||
|
||||
XMLPARSEAPI(void *)
|
||||
XML_GetBuffer(XML_Parser parser, int len);
|
||||
|
||||
XMLPARSEAPI(enum XML_Status)
|
||||
XML_ParseBuffer(XML_Parser parser, int len, int isFinal);
|
||||
|
||||
/* Stops parsing, causing XML_Parse() or XML_ParseBuffer() to return.
|
||||
Must be called from within a call-back handler, except when aborting
|
||||
(resumable = 0) an already suspended parser. Some call-backs may
|
||||
still follow because they would otherwise get lost. Examples:
|
||||
- endElementHandler() for empty elements when stopped in
|
||||
startElementHandler(),
|
||||
- endNameSpaceDeclHandler() when stopped in endElementHandler(),
|
||||
and possibly others.
|
||||
|
||||
Can be called from most handlers, including DTD related call-backs,
|
||||
except when parsing an external parameter entity and resumable != 0.
|
||||
Returns XML_STATUS_OK when successful, XML_STATUS_ERROR otherwise.
|
||||
Possible error codes:
|
||||
- XML_ERROR_SUSPENDED: when suspending an already suspended parser.
|
||||
- XML_ERROR_FINISHED: when the parser has already finished.
|
||||
- XML_ERROR_SUSPEND_PE: when suspending while parsing an external PE.
|
||||
|
||||
When resumable != 0 (true) then parsing is suspended, that is,
|
||||
XML_Parse() and XML_ParseBuffer() return XML_STATUS_SUSPENDED.
|
||||
Otherwise, parsing is aborted, that is, XML_Parse() and XML_ParseBuffer()
|
||||
return XML_STATUS_ERROR with error code XML_ERROR_ABORTED.
|
||||
|
||||
*Note*:
|
||||
This will be applied to the current parser instance only, that is, if
|
||||
there is a parent parser then it will continue parsing when the
|
||||
externalEntityRefHandler() returns. It is up to the implementation of
|
||||
the externalEntityRefHandler() to call XML_StopParser() on the parent
|
||||
parser (recursively), if one wants to stop parsing altogether.
|
||||
|
||||
When suspended, parsing can be resumed by calling XML_ResumeParser().
|
||||
*/
|
||||
XMLPARSEAPI(enum XML_Status)
|
||||
XML_StopParser(XML_Parser parser, XML_Bool resumable);
|
||||
|
||||
/* Resumes parsing after it has been suspended with XML_StopParser().
|
||||
Must not be called from within a handler call-back. Returns same
|
||||
status codes as XML_Parse() or XML_ParseBuffer().
|
||||
Additional error code XML_ERROR_NOT_SUSPENDED possible.
|
||||
|
||||
*Note*:
|
||||
This must be called on the most deeply nested child parser instance
|
||||
first, and on its parent parser only after the child parser has finished,
|
||||
to be applied recursively until the document entity's parser is restarted.
|
||||
That is, the parent parser will not resume by itself and it is up to the
|
||||
application to call XML_ResumeParser() on it at the appropriate moment.
|
||||
*/
|
||||
XMLPARSEAPI(enum XML_Status)
|
||||
XML_ResumeParser(XML_Parser parser);
|
||||
|
||||
enum XML_Parsing {
|
||||
XML_INITIALIZED,
|
||||
XML_PARSING,
|
||||
XML_FINISHED,
|
||||
XML_SUSPENDED
|
||||
};
|
||||
|
||||
typedef struct {
|
||||
enum XML_Parsing parsing;
|
||||
XML_Bool finalBuffer;
|
||||
} XML_ParsingStatus;
|
||||
|
||||
/* Returns status of parser with respect to being initialized, parsing,
|
||||
finished, or suspended and processing the final buffer.
|
||||
XXX XML_Parse() and XML_ParseBuffer() should return XML_ParsingStatus,
|
||||
XXX with XML_FINISHED_OK or XML_FINISHED_ERROR replacing XML_FINISHED
|
||||
*/
|
||||
XMLPARSEAPI(void)
|
||||
XML_GetParsingStatus(XML_Parser parser, XML_ParsingStatus *status);
|
||||
|
||||
/* Creates an XML_Parser object that can parse an external general
|
||||
entity; context is a '\0'-terminated string specifying the parse
|
||||
context; encoding is a '\0'-terminated string giving the name of
|
||||
the externally specified encoding, or NULL if there is no
|
||||
externally specified encoding. The context string consists of a
|
||||
sequence of tokens separated by formfeeds (\f); a token consisting
|
||||
of a name specifies that the general entity of the name is open; a
|
||||
token of the form prefix=uri specifies the namespace for a
|
||||
particular prefix; a token of the form =uri specifies the default
|
||||
namespace. This can be called at any point after the first call to
|
||||
an ExternalEntityRefHandler so longer as the parser has not yet
|
||||
been freed. The new parser is completely independent and may
|
||||
safely be used in a separate thread. The handlers and userData are
|
||||
initialized from the parser argument. Returns NULL if out of memory.
|
||||
Otherwise returns a new XML_Parser object.
|
||||
*/
|
||||
XMLPARSEAPI(XML_Parser)
|
||||
XML_ExternalEntityParserCreate(XML_Parser parser,
|
||||
const XML_Char *context,
|
||||
const XML_Char *encoding);
|
||||
|
||||
enum XML_ParamEntityParsing {
|
||||
XML_PARAM_ENTITY_PARSING_NEVER,
|
||||
XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE,
|
||||
XML_PARAM_ENTITY_PARSING_ALWAYS
|
||||
};
|
||||
|
||||
/* Controls parsing of parameter entities (including the external DTD
|
||||
subset). If parsing of parameter entities is enabled, then
|
||||
references to external parameter entities (including the external
|
||||
DTD subset) will be passed to the handler set with
|
||||
XML_SetExternalEntityRefHandler. The context passed will be 0.
|
||||
|
||||
Unlike external general entities, external parameter entities can
|
||||
only be parsed synchronously. If the external parameter entity is
|
||||
to be parsed, it must be parsed during the call to the external
|
||||
entity ref handler: the complete sequence of
|
||||
XML_ExternalEntityParserCreate, XML_Parse/XML_ParseBuffer and
|
||||
XML_ParserFree calls must be made during this call. After
|
||||
XML_ExternalEntityParserCreate has been called to create the parser
|
||||
for the external parameter entity (context must be 0 for this
|
||||
call), it is illegal to make any calls on the old parser until
|
||||
XML_ParserFree has been called on the newly created parser.
|
||||
If the library has been compiled without support for parameter
|
||||
entity parsing (ie without XML_DTD being defined), then
|
||||
XML_SetParamEntityParsing will return 0 if parsing of parameter
|
||||
entities is requested; otherwise it will return non-zero.
|
||||
Note: If XML_SetParamEntityParsing is called after XML_Parse or
|
||||
XML_ParseBuffer, then it has no effect and will always return 0.
|
||||
*/
|
||||
XMLPARSEAPI(int)
|
||||
XML_SetParamEntityParsing(XML_Parser parser,
|
||||
enum XML_ParamEntityParsing parsing);
|
||||
|
||||
/* Sets the hash salt to use for internal hash calculations.
|
||||
Helps in preventing DoS attacks based on predicting hash
|
||||
function behavior. This must be called before parsing is started.
|
||||
Returns 1 if successful, 0 when called after parsing has started.
|
||||
*/
|
||||
XMLPARSEAPI(int)
|
||||
XML_SetHashSalt(XML_Parser parser,
|
||||
unsigned long hash_salt);
|
||||
|
||||
/* If XML_Parse or XML_ParseBuffer have returned XML_STATUS_ERROR, then
|
||||
XML_GetErrorCode returns information about the error.
|
||||
*/
|
||||
XMLPARSEAPI(enum XML_Error)
|
||||
XML_GetErrorCode(XML_Parser parser);
|
||||
|
||||
/* These functions return information about the current parse
|
||||
location. They may be called from any callback called to report
|
||||
some parse event; in this case the location is the location of the
|
||||
first of the sequence of characters that generated the event. When
|
||||
called from callbacks generated by declarations in the document
|
||||
prologue, the location identified isn't as neatly defined, but will
|
||||
be within the relevant markup. When called outside of the callback
|
||||
functions, the position indicated will be just past the last parse
|
||||
event (regardless of whether there was an associated callback).
|
||||
|
||||
They may also be called after returning from a call to XML_Parse
|
||||
or XML_ParseBuffer. If the return value is XML_STATUS_ERROR then
|
||||
the location is the location of the character at which the error
|
||||
was detected; otherwise the location is the location of the last
|
||||
parse event, as described above.
|
||||
*/
|
||||
XMLPARSEAPI(XML_Size) XML_GetCurrentLineNumber(XML_Parser parser);
|
||||
XMLPARSEAPI(XML_Size) XML_GetCurrentColumnNumber(XML_Parser parser);
|
||||
XMLPARSEAPI(XML_Index) XML_GetCurrentByteIndex(XML_Parser parser);
|
||||
|
||||
/* Return the number of bytes in the current event.
|
||||
Returns 0 if the event is in an internal entity.
|
||||
*/
|
||||
XMLPARSEAPI(int)
|
||||
XML_GetCurrentByteCount(XML_Parser parser);
|
||||
|
||||
/* If XML_CONTEXT_BYTES is defined, returns the input buffer, sets
|
||||
the integer pointed to by offset to the offset within this buffer
|
||||
of the current parse position, and sets the integer pointed to by size
|
||||
to the size of this buffer (the number of input bytes). Otherwise
|
||||
returns a NULL pointer. Also returns a NULL pointer if a parse isn't
|
||||
active.
|
||||
|
||||
NOTE: The character pointer returned should not be used outside
|
||||
the handler that makes the call.
|
||||
*/
|
||||
XMLPARSEAPI(const char *)
|
||||
XML_GetInputContext(XML_Parser parser,
|
||||
int *offset,
|
||||
int *size);
|
||||
|
||||
/* For backwards compatibility with previous versions. */
|
||||
#define XML_GetErrorLineNumber XML_GetCurrentLineNumber
|
||||
#define XML_GetErrorColumnNumber XML_GetCurrentColumnNumber
|
||||
#define XML_GetErrorByteIndex XML_GetCurrentByteIndex
|
||||
|
||||
/* Frees the content model passed to the element declaration handler */
|
||||
XMLPARSEAPI(void)
|
||||
XML_FreeContentModel(XML_Parser parser, XML_Content *model);
|
||||
|
||||
/* Exposing the memory handling functions used in Expat */
|
||||
XMLPARSEAPI(void *)
|
||||
XML_MemMalloc(XML_Parser parser, size_t size);
|
||||
|
||||
XMLPARSEAPI(void *)
|
||||
XML_MemRealloc(XML_Parser parser, void *ptr, size_t size);
|
||||
|
||||
XMLPARSEAPI(void)
|
||||
XML_MemFree(XML_Parser parser, void *ptr);
|
||||
|
||||
/* Frees memory used by the parser. */
|
||||
XMLPARSEAPI(void)
|
||||
XML_ParserFree(XML_Parser parser);
|
||||
|
||||
/* Returns a string describing the error. */
|
||||
XMLPARSEAPI(const XML_LChar *)
|
||||
XML_ErrorString(enum XML_Error code);
|
||||
|
||||
/* Return a string containing the version number of this expat */
|
||||
XMLPARSEAPI(const XML_LChar *)
|
||||
XML_ExpatVersion(void);
|
||||
|
||||
typedef struct {
|
||||
int major;
|
||||
int minor;
|
||||
int micro;
|
||||
} XML_Expat_Version;
|
||||
|
||||
/* Return an XML_Expat_Version structure containing numeric version
|
||||
number information for this version of expat.
|
||||
*/
|
||||
XMLPARSEAPI(XML_Expat_Version)
|
||||
XML_ExpatVersionInfo(void);
|
||||
|
||||
/* Added in Expat 1.95.5. */
|
||||
enum XML_FeatureEnum {
|
||||
XML_FEATURE_END = 0,
|
||||
XML_FEATURE_UNICODE,
|
||||
XML_FEATURE_UNICODE_WCHAR_T,
|
||||
XML_FEATURE_DTD,
|
||||
XML_FEATURE_CONTEXT_BYTES,
|
||||
XML_FEATURE_MIN_SIZE,
|
||||
XML_FEATURE_SIZEOF_XML_CHAR,
|
||||
XML_FEATURE_SIZEOF_XML_LCHAR,
|
||||
XML_FEATURE_NS,
|
||||
XML_FEATURE_LARGE_SIZE,
|
||||
XML_FEATURE_ATTR_INFO
|
||||
/* Additional features must be added to the end of this enum. */
|
||||
};
|
||||
|
||||
typedef struct {
|
||||
enum XML_FeatureEnum feature;
|
||||
const XML_LChar *name;
|
||||
long int value;
|
||||
} XML_Feature;
|
||||
|
||||
XMLPARSEAPI(const XML_Feature *)
|
||||
XML_GetFeatureList(void);
|
||||
|
||||
|
||||
/* Expat follows the GNU/Linux convention of odd number minor version for
|
||||
beta/development releases and even number minor version for stable
|
||||
releases. Micro is bumped with each release, and set to 0 with each
|
||||
change to major or minor version.
|
||||
*/
|
||||
#define XML_MAJOR_VERSION 2
|
||||
#define XML_MINOR_VERSION 1
|
||||
#define XML_MICRO_VERSION 1
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* not Expat_INCLUDED */
|
||||
@@ -0,0 +1,115 @@
|
||||
/* Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd
|
||||
See the file COPYING for copying permission.
|
||||
*/
|
||||
|
||||
#ifndef Expat_External_INCLUDED
|
||||
#define Expat_External_INCLUDED 1
|
||||
|
||||
/* External API definitions */
|
||||
|
||||
#if defined(_MSC_EXTENSIONS) && !defined(__BEOS__) && !defined(__CYGWIN__)
|
||||
#define XML_USE_MSC_EXTENSIONS 1
|
||||
#endif
|
||||
|
||||
/* Expat tries very hard to make the API boundary very specifically
|
||||
defined. There are two macros defined to control this boundary;
|
||||
each of these can be defined before including this header to
|
||||
achieve some different behavior, but doing so it not recommended or
|
||||
tested frequently.
|
||||
|
||||
XMLCALL - The calling convention to use for all calls across the
|
||||
"library boundary." This will default to cdecl, and
|
||||
try really hard to tell the compiler that's what we
|
||||
want.
|
||||
|
||||
XMLIMPORT - Whatever magic is needed to note that a function is
|
||||
to be imported from a dynamically loaded library
|
||||
(.dll, .so, or .sl, depending on your platform).
|
||||
|
||||
The XMLCALL macro was added in Expat 1.95.7. The only one which is
|
||||
expected to be directly useful in client code is XMLCALL.
|
||||
|
||||
Note that on at least some Unix versions, the Expat library must be
|
||||
compiled with the cdecl calling convention as the default since
|
||||
system headers may assume the cdecl convention.
|
||||
*/
|
||||
#ifndef XMLCALL
|
||||
#if defined(_MSC_VER)
|
||||
#define XMLCALL __cdecl
|
||||
#elif defined(__GNUC__) && defined(__i386) && !defined(__INTEL_COMPILER)
|
||||
#define XMLCALL __attribute__((cdecl))
|
||||
#else
|
||||
/* For any platform which uses this definition and supports more than
|
||||
one calling convention, we need to extend this definition to
|
||||
declare the convention used on that platform, if it's possible to
|
||||
do so.
|
||||
|
||||
If this is the case for your platform, please file a bug report
|
||||
with information on how to identify your platform via the C
|
||||
pre-processor and how to specify the same calling convention as the
|
||||
platform's malloc() implementation.
|
||||
*/
|
||||
#define XMLCALL
|
||||
#endif
|
||||
#endif /* not defined XMLCALL */
|
||||
|
||||
|
||||
#if !defined(XML_STATIC) && !defined(XMLIMPORT)
|
||||
#ifndef XML_BUILDING_EXPAT
|
||||
/* using Expat from an application */
|
||||
|
||||
#ifdef XML_USE_MSC_EXTENSIONS
|
||||
#define XMLIMPORT __declspec(dllimport)
|
||||
#endif
|
||||
|
||||
#endif
|
||||
#endif /* not defined XML_STATIC */
|
||||
|
||||
|
||||
/* If we didn't define it above, define it away: */
|
||||
#ifndef XMLIMPORT
|
||||
#define XMLIMPORT
|
||||
#endif
|
||||
|
||||
|
||||
#define XMLPARSEAPI(type) XMLIMPORT type XMLCALL
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#ifdef XML_UNICODE_WCHAR_T
|
||||
#define XML_UNICODE
|
||||
#endif
|
||||
|
||||
#ifdef XML_UNICODE /* Information is UTF-16 encoded. */
|
||||
#ifdef XML_UNICODE_WCHAR_T
|
||||
typedef wchar_t XML_Char;
|
||||
typedef wchar_t XML_LChar;
|
||||
#else
|
||||
typedef unsigned short XML_Char;
|
||||
typedef char XML_LChar;
|
||||
#endif /* XML_UNICODE_WCHAR_T */
|
||||
#else /* Information is UTF-8 encoded. */
|
||||
typedef char XML_Char;
|
||||
typedef char XML_LChar;
|
||||
#endif /* XML_UNICODE */
|
||||
|
||||
#ifdef XML_LARGE_SIZE /* Use large integers for file/stream positions. */
|
||||
#if defined(XML_USE_MSC_EXTENSIONS) && _MSC_VER < 1400
|
||||
typedef __int64 XML_Index;
|
||||
typedef unsigned __int64 XML_Size;
|
||||
#else
|
||||
typedef long long XML_Index;
|
||||
typedef unsigned long long XML_Size;
|
||||
#endif
|
||||
#else
|
||||
typedef long XML_Index;
|
||||
typedef unsigned long XML_Size;
|
||||
#endif /* XML_LARGE_SIZE */
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* not Expat_External_INCLUDED */
|
||||
@@ -0,0 +1,37 @@
|
||||
/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
|
||||
See the file COPYING for copying permission.
|
||||
*/
|
||||
|
||||
/* Like asciitab.h, except that 0xD has code BT_S rather than BT_CR */
|
||||
/* 0x00 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
|
||||
/* 0x04 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
|
||||
/* 0x08 */ BT_NONXML, BT_S, BT_LF, BT_NONXML,
|
||||
/* 0x0C */ BT_NONXML, BT_S, BT_NONXML, BT_NONXML,
|
||||
/* 0x10 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
|
||||
/* 0x14 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
|
||||
/* 0x18 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
|
||||
/* 0x1C */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
|
||||
/* 0x20 */ BT_S, BT_EXCL, BT_QUOT, BT_NUM,
|
||||
/* 0x24 */ BT_OTHER, BT_PERCNT, BT_AMP, BT_APOS,
|
||||
/* 0x28 */ BT_LPAR, BT_RPAR, BT_AST, BT_PLUS,
|
||||
/* 0x2C */ BT_COMMA, BT_MINUS, BT_NAME, BT_SOL,
|
||||
/* 0x30 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
|
||||
/* 0x34 */ BT_DIGIT, BT_DIGIT, BT_DIGIT, BT_DIGIT,
|
||||
/* 0x38 */ BT_DIGIT, BT_DIGIT, BT_COLON, BT_SEMI,
|
||||
/* 0x3C */ BT_LT, BT_EQUALS, BT_GT, BT_QUEST,
|
||||
/* 0x40 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
|
||||
/* 0x44 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
|
||||
/* 0x48 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
|
||||
/* 0x4C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
|
||||
/* 0x50 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
|
||||
/* 0x54 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
|
||||
/* 0x58 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_LSQB,
|
||||
/* 0x5C */ BT_OTHER, BT_RSQB, BT_OTHER, BT_NMSTRT,
|
||||
/* 0x60 */ BT_OTHER, BT_HEX, BT_HEX, BT_HEX,
|
||||
/* 0x64 */ BT_HEX, BT_HEX, BT_HEX, BT_NMSTRT,
|
||||
/* 0x68 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
|
||||
/* 0x6C */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
|
||||
/* 0x70 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
|
||||
/* 0x74 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
|
||||
/* 0x78 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
|
||||
/* 0x7C */ BT_VERBAR, BT_OTHER, BT_OTHER, BT_OTHER,
|
||||
@@ -0,0 +1,73 @@
|
||||
/* internal.h
|
||||
|
||||
Internal definitions used by Expat. This is not needed to compile
|
||||
client code.
|
||||
|
||||
The following calling convention macros are defined for frequently
|
||||
called functions:
|
||||
|
||||
FASTCALL - Used for those internal functions that have a simple
|
||||
body and a low number of arguments and local variables.
|
||||
|
||||
PTRCALL - Used for functions called though function pointers.
|
||||
|
||||
PTRFASTCALL - Like PTRCALL, but for low number of arguments.
|
||||
|
||||
inline - Used for selected internal functions for which inlining
|
||||
may improve performance on some platforms.
|
||||
|
||||
Note: Use of these macros is based on judgement, not hard rules,
|
||||
and therefore subject to change.
|
||||
*/
|
||||
|
||||
#if defined(__GNUC__) && defined(__i386__) && !defined(__MINGW32__)
|
||||
/* We'll use this version by default only where we know it helps.
|
||||
|
||||
regparm() generates warnings on Solaris boxes. See SF bug #692878.
|
||||
|
||||
Instability reported with egcs on a RedHat Linux 7.3.
|
||||
Let's comment out:
|
||||
#define FASTCALL __attribute__((stdcall, regparm(3)))
|
||||
and let's try this:
|
||||
*/
|
||||
#define FASTCALL __attribute__((regparm(3)))
|
||||
#define PTRFASTCALL __attribute__((regparm(3)))
|
||||
#endif
|
||||
|
||||
/* Using __fastcall seems to have an unexpected negative effect under
|
||||
MS VC++, especially for function pointers, so we won't use it for
|
||||
now on that platform. It may be reconsidered for a future release
|
||||
if it can be made more effective.
|
||||
Likely reason: __fastcall on Windows is like stdcall, therefore
|
||||
the compiler cannot perform stack optimizations for call clusters.
|
||||
*/
|
||||
|
||||
/* Make sure all of these are defined if they aren't already. */
|
||||
|
||||
#ifndef FASTCALL
|
||||
#define FASTCALL
|
||||
#endif
|
||||
|
||||
#ifndef PTRCALL
|
||||
#define PTRCALL
|
||||
#endif
|
||||
|
||||
#ifndef PTRFASTCALL
|
||||
#define PTRFASTCALL
|
||||
#endif
|
||||
|
||||
#ifndef XML_MIN_SIZE
|
||||
#if !defined(__cplusplus) && !defined(inline)
|
||||
#ifdef __GNUC__
|
||||
#define inline __inline
|
||||
#endif /* __GNUC__ */
|
||||
#endif
|
||||
#endif /* XML_MIN_SIZE */
|
||||
|
||||
#ifdef __cplusplus
|
||||
#define inline inline
|
||||
#else
|
||||
#ifndef inline
|
||||
#define inline
|
||||
#endif
|
||||
#endif
|
||||
@@ -0,0 +1,36 @@
|
||||
/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
|
||||
See the file COPYING for copying permission.
|
||||
*/
|
||||
|
||||
/* 0x80 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
|
||||
/* 0x84 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
|
||||
/* 0x88 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
|
||||
/* 0x8C */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
|
||||
/* 0x90 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
|
||||
/* 0x94 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
|
||||
/* 0x98 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
|
||||
/* 0x9C */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
|
||||
/* 0xA0 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
|
||||
/* 0xA4 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
|
||||
/* 0xA8 */ BT_OTHER, BT_OTHER, BT_NMSTRT, BT_OTHER,
|
||||
/* 0xAC */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
|
||||
/* 0xB0 */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
|
||||
/* 0xB4 */ BT_OTHER, BT_NMSTRT, BT_OTHER, BT_NAME,
|
||||
/* 0xB8 */ BT_OTHER, BT_OTHER, BT_NMSTRT, BT_OTHER,
|
||||
/* 0xBC */ BT_OTHER, BT_OTHER, BT_OTHER, BT_OTHER,
|
||||
/* 0xC0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
|
||||
/* 0xC4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
|
||||
/* 0xC8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
|
||||
/* 0xCC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
|
||||
/* 0xD0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
|
||||
/* 0xD4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
|
||||
/* 0xD8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
|
||||
/* 0xDC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
|
||||
/* 0xE0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
|
||||
/* 0xE4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
|
||||
/* 0xE8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
|
||||
/* 0xEC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
|
||||
/* 0xF0 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
|
||||
/* 0xF4 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_OTHER,
|
||||
/* 0xF8 */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
|
||||
/* 0xFC */ BT_NMSTRT, BT_NMSTRT, BT_NMSTRT, BT_NMSTRT,
|
||||
@@ -0,0 +1,150 @@
|
||||
static const unsigned namingBitmap[] = {
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000,
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000,
|
||||
0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
|
||||
0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
|
||||
0x00000000, 0x04000000, 0x87FFFFFE, 0x07FFFFFE,
|
||||
0x00000000, 0x00000000, 0xFF7FFFFF, 0xFF7FFFFF,
|
||||
0xFFFFFFFF, 0x7FF3FFFF, 0xFFFFFDFE, 0x7FFFFFFF,
|
||||
0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFE00F, 0xFC31FFFF,
|
||||
0x00FFFFFF, 0x00000000, 0xFFFF0000, 0xFFFFFFFF,
|
||||
0xFFFFFFFF, 0xF80001FF, 0x00000003, 0x00000000,
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000,
|
||||
0xFFFFD740, 0xFFFFFFFB, 0x547F7FFF, 0x000FFFFD,
|
||||
0xFFFFDFFE, 0xFFFFFFFF, 0xDFFEFFFF, 0xFFFFFFFF,
|
||||
0xFFFF0003, 0xFFFFFFFF, 0xFFFF199F, 0x033FCFFF,
|
||||
0x00000000, 0xFFFE0000, 0x027FFFFF, 0xFFFFFFFE,
|
||||
0x0000007F, 0x00000000, 0xFFFF0000, 0x000707FF,
|
||||
0x00000000, 0x07FFFFFE, 0x000007FE, 0xFFFE0000,
|
||||
0xFFFFFFFF, 0x7CFFFFFF, 0x002F7FFF, 0x00000060,
|
||||
0xFFFFFFE0, 0x23FFFFFF, 0xFF000000, 0x00000003,
|
||||
0xFFF99FE0, 0x03C5FDFF, 0xB0000000, 0x00030003,
|
||||
0xFFF987E0, 0x036DFDFF, 0x5E000000, 0x001C0000,
|
||||
0xFFFBAFE0, 0x23EDFDFF, 0x00000000, 0x00000001,
|
||||
0xFFF99FE0, 0x23CDFDFF, 0xB0000000, 0x00000003,
|
||||
0xD63DC7E0, 0x03BFC718, 0x00000000, 0x00000000,
|
||||
0xFFFDDFE0, 0x03EFFDFF, 0x00000000, 0x00000003,
|
||||
0xFFFDDFE0, 0x03EFFDFF, 0x40000000, 0x00000003,
|
||||
0xFFFDDFE0, 0x03FFFDFF, 0x00000000, 0x00000003,
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000,
|
||||
0xFFFFFFFE, 0x000D7FFF, 0x0000003F, 0x00000000,
|
||||
0xFEF02596, 0x200D6CAE, 0x0000001F, 0x00000000,
|
||||
0x00000000, 0x00000000, 0xFFFFFEFF, 0x000003FF,
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000,
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000,
|
||||
0x00000000, 0xFFFFFFFF, 0xFFFF003F, 0x007FFFFF,
|
||||
0x0007DAED, 0x50000000, 0x82315001, 0x002C62AB,
|
||||
0x40000000, 0xF580C900, 0x00000007, 0x02010800,
|
||||
0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
|
||||
0x0FFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x03FFFFFF,
|
||||
0x3F3FFFFF, 0xFFFFFFFF, 0xAAFF3F3F, 0x3FFFFFFF,
|
||||
0xFFFFFFFF, 0x5FDFFFFF, 0x0FCF1FDC, 0x1FDC1FFF,
|
||||
0x00000000, 0x00004C40, 0x00000000, 0x00000000,
|
||||
0x00000007, 0x00000000, 0x00000000, 0x00000000,
|
||||
0x00000080, 0x000003FE, 0xFFFFFFFE, 0xFFFFFFFF,
|
||||
0x001FFFFF, 0xFFFFFFFE, 0xFFFFFFFF, 0x07FFFFFF,
|
||||
0xFFFFFFE0, 0x00001FFF, 0x00000000, 0x00000000,
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000,
|
||||
0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
|
||||
0xFFFFFFFF, 0x0000003F, 0x00000000, 0x00000000,
|
||||
0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
|
||||
0xFFFFFFFF, 0x0000000F, 0x00000000, 0x00000000,
|
||||
0x00000000, 0x07FF6000, 0x87FFFFFE, 0x07FFFFFE,
|
||||
0x00000000, 0x00800000, 0xFF7FFFFF, 0xFF7FFFFF,
|
||||
0x00FFFFFF, 0x00000000, 0xFFFF0000, 0xFFFFFFFF,
|
||||
0xFFFFFFFF, 0xF80001FF, 0x00030003, 0x00000000,
|
||||
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[] = {
|
||||
0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x00,
|
||||
0x00, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
|
||||
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, 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, 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,
|
||||
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, 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[] = {
|
||||
0x19, 0x03, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x00,
|
||||
0x00, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25,
|
||||
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, 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, 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,
|
||||
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, 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,
|
||||
};
|
||||
@@ -0,0 +1,37 @@
|
||||
/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
|
||||
See the file COPYING for copying permission.
|
||||
*/
|
||||
|
||||
|
||||
/* 0x80 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
|
||||
/* 0x84 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
|
||||
/* 0x88 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
|
||||
/* 0x8C */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
|
||||
/* 0x90 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
|
||||
/* 0x94 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
|
||||
/* 0x98 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
|
||||
/* 0x9C */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
|
||||
/* 0xA0 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
|
||||
/* 0xA4 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
|
||||
/* 0xA8 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
|
||||
/* 0xAC */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
|
||||
/* 0xB0 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
|
||||
/* 0xB4 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
|
||||
/* 0xB8 */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
|
||||
/* 0xBC */ BT_TRAIL, BT_TRAIL, BT_TRAIL, BT_TRAIL,
|
||||
/* 0xC0 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
|
||||
/* 0xC4 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
|
||||
/* 0xC8 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
|
||||
/* 0xCC */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
|
||||
/* 0xD0 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
|
||||
/* 0xD4 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
|
||||
/* 0xD8 */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
|
||||
/* 0xDC */ BT_LEAD2, BT_LEAD2, BT_LEAD2, BT_LEAD2,
|
||||
/* 0xE0 */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
|
||||
/* 0xE4 */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
|
||||
/* 0xE8 */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
|
||||
/* 0xEC */ BT_LEAD3, BT_LEAD3, BT_LEAD3, BT_LEAD3,
|
||||
/* 0xF0 */ BT_LEAD4, BT_LEAD4, BT_LEAD4, BT_LEAD4,
|
||||
/* 0xF4 */ BT_LEAD4, BT_NONXML, BT_NONXML, BT_NONXML,
|
||||
/* 0xF8 */ BT_NONXML, BT_NONXML, BT_NONXML, BT_NONXML,
|
||||
/* 0xFC */ BT_NONXML, BT_NONXML, BT_MALFORM, BT_MALFORM,
|
||||
@@ -0,0 +1,30 @@
|
||||
/*================================================================
|
||||
** Copyright 2000, Clark Cooper
|
||||
** All rights reserved.
|
||||
**
|
||||
** This is free software. You are permitted to copy, distribute, or modify
|
||||
** it under the terms of the MIT/X license (contained in the COPYING file
|
||||
** with this distribution.)
|
||||
*/
|
||||
|
||||
#ifndef WINCONFIG_H
|
||||
#define WINCONFIG_H
|
||||
|
||||
#define WIN32_LEAN_AND_MEAN
|
||||
#include <windows.h>
|
||||
#undef WIN32_LEAN_AND_MEAN
|
||||
|
||||
#include <memory.h>
|
||||
#include <string.h>
|
||||
|
||||
#define XML_NS 1
|
||||
#define XML_DTD 1
|
||||
#define XML_CONTEXT_BYTES 1024
|
||||
|
||||
/* we will assume all Windows platforms are little endian */
|
||||
#define BYTEORDER 1234
|
||||
|
||||
/* Windows has memmove() available. */
|
||||
#define HAVE_MEMMOVE
|
||||
|
||||
#endif /* ndef WINCONFIG_H */
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,1336 @@
|
||||
/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
|
||||
See the file COPYING for copying permission.
|
||||
*/
|
||||
|
||||
#include <stddef.h>
|
||||
|
||||
#ifdef COMPILING_FOR_WINDOWS
|
||||
#include "winconfig.h"
|
||||
#elif defined(MACOS_CLASSIC)
|
||||
#include "macconfig.h"
|
||||
#elif defined(__amigaos__)
|
||||
#include "amigaconfig.h"
|
||||
#elif defined(__WATCOMC__)
|
||||
#include "watcomconfig.h"
|
||||
#else
|
||||
#ifdef HAVE_EXPAT_CONFIG_H
|
||||
#include <expat_config.h>
|
||||
#endif
|
||||
#endif /* ndef COMPILING_FOR_WINDOWS */
|
||||
|
||||
#include "expat_external.h"
|
||||
#include "internal.h"
|
||||
#include "xmlrole.h"
|
||||
#include "ascii.h"
|
||||
|
||||
/* Doesn't check:
|
||||
|
||||
that ,| are not mixed in a model group
|
||||
content of literals
|
||||
|
||||
*/
|
||||
|
||||
static const char KW_ANY[] = {
|
||||
ASCII_A, ASCII_N, ASCII_Y, '\0' };
|
||||
static const char KW_ATTLIST[] = {
|
||||
ASCII_A, ASCII_T, ASCII_T, ASCII_L, ASCII_I, ASCII_S, ASCII_T, '\0' };
|
||||
static const char KW_CDATA[] = {
|
||||
ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' };
|
||||
static const char KW_DOCTYPE[] = {
|
||||
ASCII_D, ASCII_O, ASCII_C, ASCII_T, ASCII_Y, ASCII_P, ASCII_E, '\0' };
|
||||
static const char KW_ELEMENT[] = {
|
||||
ASCII_E, ASCII_L, ASCII_E, ASCII_M, ASCII_E, ASCII_N, ASCII_T, '\0' };
|
||||
static const char KW_EMPTY[] = {
|
||||
ASCII_E, ASCII_M, ASCII_P, ASCII_T, ASCII_Y, '\0' };
|
||||
static const char KW_ENTITIES[] = {
|
||||
ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_I, ASCII_E, ASCII_S,
|
||||
'\0' };
|
||||
static const char KW_ENTITY[] = {
|
||||
ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_Y, '\0' };
|
||||
static const char KW_FIXED[] = {
|
||||
ASCII_F, ASCII_I, ASCII_X, ASCII_E, ASCII_D, '\0' };
|
||||
static const char KW_ID[] = {
|
||||
ASCII_I, ASCII_D, '\0' };
|
||||
static const char KW_IDREF[] = {
|
||||
ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, '\0' };
|
||||
static const char KW_IDREFS[] = {
|
||||
ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, ASCII_S, '\0' };
|
||||
#ifdef XML_DTD
|
||||
static const char KW_IGNORE[] = {
|
||||
ASCII_I, ASCII_G, ASCII_N, ASCII_O, ASCII_R, ASCII_E, '\0' };
|
||||
#endif
|
||||
static const char KW_IMPLIED[] = {
|
||||
ASCII_I, ASCII_M, ASCII_P, ASCII_L, ASCII_I, ASCII_E, ASCII_D, '\0' };
|
||||
#ifdef XML_DTD
|
||||
static const char KW_INCLUDE[] = {
|
||||
ASCII_I, ASCII_N, ASCII_C, ASCII_L, ASCII_U, ASCII_D, ASCII_E, '\0' };
|
||||
#endif
|
||||
static const char KW_NDATA[] = {
|
||||
ASCII_N, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' };
|
||||
static const char KW_NMTOKEN[] = {
|
||||
ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, '\0' };
|
||||
static const char KW_NMTOKENS[] = {
|
||||
ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, ASCII_S,
|
||||
'\0' };
|
||||
static const char KW_NOTATION[] =
|
||||
{ ASCII_N, ASCII_O, ASCII_T, ASCII_A, ASCII_T, ASCII_I, ASCII_O, ASCII_N,
|
||||
'\0' };
|
||||
static const char KW_PCDATA[] = {
|
||||
ASCII_P, ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' };
|
||||
static const char KW_PUBLIC[] = {
|
||||
ASCII_P, ASCII_U, ASCII_B, ASCII_L, ASCII_I, ASCII_C, '\0' };
|
||||
static const char KW_REQUIRED[] = {
|
||||
ASCII_R, ASCII_E, ASCII_Q, ASCII_U, ASCII_I, ASCII_R, ASCII_E, ASCII_D,
|
||||
'\0' };
|
||||
static const char KW_SYSTEM[] = {
|
||||
ASCII_S, ASCII_Y, ASCII_S, ASCII_T, ASCII_E, ASCII_M, '\0' };
|
||||
|
||||
#ifndef MIN_BYTES_PER_CHAR
|
||||
#define MIN_BYTES_PER_CHAR(enc) ((enc)->minBytesPerChar)
|
||||
#endif
|
||||
|
||||
#ifdef XML_DTD
|
||||
#define setTopLevel(state) \
|
||||
((state)->handler = ((state)->documentEntity \
|
||||
? internalSubset \
|
||||
: externalSubset1))
|
||||
#else /* not XML_DTD */
|
||||
#define setTopLevel(state) ((state)->handler = internalSubset)
|
||||
#endif /* not XML_DTD */
|
||||
|
||||
typedef int PTRCALL PROLOG_HANDLER(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc);
|
||||
|
||||
static PROLOG_HANDLER
|
||||
prolog0, prolog1, prolog2,
|
||||
doctype0, doctype1, doctype2, doctype3, doctype4, doctype5,
|
||||
internalSubset,
|
||||
entity0, entity1, entity2, entity3, entity4, entity5, entity6,
|
||||
entity7, entity8, entity9, entity10,
|
||||
notation0, notation1, notation2, notation3, notation4,
|
||||
attlist0, attlist1, attlist2, attlist3, attlist4, attlist5, attlist6,
|
||||
attlist7, attlist8, attlist9,
|
||||
element0, element1, element2, element3, element4, element5, element6,
|
||||
element7,
|
||||
#ifdef XML_DTD
|
||||
externalSubset0, externalSubset1,
|
||||
condSect0, condSect1, condSect2,
|
||||
#endif /* XML_DTD */
|
||||
declClose,
|
||||
error;
|
||||
|
||||
static int FASTCALL common(PROLOG_STATE *state, int tok);
|
||||
|
||||
static int PTRCALL
|
||||
prolog0(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
state->handler = prolog1;
|
||||
return XML_ROLE_NONE;
|
||||
case XML_TOK_XML_DECL:
|
||||
state->handler = prolog1;
|
||||
return XML_ROLE_XML_DECL;
|
||||
case XML_TOK_PI:
|
||||
state->handler = prolog1;
|
||||
return XML_ROLE_PI;
|
||||
case XML_TOK_COMMENT:
|
||||
state->handler = prolog1;
|
||||
return XML_ROLE_COMMENT;
|
||||
case XML_TOK_BOM:
|
||||
return XML_ROLE_NONE;
|
||||
case XML_TOK_DECL_OPEN:
|
||||
if (!XmlNameMatchesAscii(enc,
|
||||
ptr + 2 * MIN_BYTES_PER_CHAR(enc),
|
||||
end,
|
||||
KW_DOCTYPE))
|
||||
break;
|
||||
state->handler = doctype0;
|
||||
return XML_ROLE_DOCTYPE_NONE;
|
||||
case XML_TOK_INSTANCE_START:
|
||||
state->handler = error;
|
||||
return XML_ROLE_INSTANCE_START;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
prolog1(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_NONE;
|
||||
case XML_TOK_PI:
|
||||
return XML_ROLE_PI;
|
||||
case XML_TOK_COMMENT:
|
||||
return XML_ROLE_COMMENT;
|
||||
case XML_TOK_BOM:
|
||||
return XML_ROLE_NONE;
|
||||
case XML_TOK_DECL_OPEN:
|
||||
if (!XmlNameMatchesAscii(enc,
|
||||
ptr + 2 * MIN_BYTES_PER_CHAR(enc),
|
||||
end,
|
||||
KW_DOCTYPE))
|
||||
break;
|
||||
state->handler = doctype0;
|
||||
return XML_ROLE_DOCTYPE_NONE;
|
||||
case XML_TOK_INSTANCE_START:
|
||||
state->handler = error;
|
||||
return XML_ROLE_INSTANCE_START;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
prolog2(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_NONE;
|
||||
case XML_TOK_PI:
|
||||
return XML_ROLE_PI;
|
||||
case XML_TOK_COMMENT:
|
||||
return XML_ROLE_COMMENT;
|
||||
case XML_TOK_INSTANCE_START:
|
||||
state->handler = error;
|
||||
return XML_ROLE_INSTANCE_START;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
doctype0(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_DOCTYPE_NONE;
|
||||
case XML_TOK_NAME:
|
||||
case XML_TOK_PREFIXED_NAME:
|
||||
state->handler = doctype1;
|
||||
return XML_ROLE_DOCTYPE_NAME;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
doctype1(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_DOCTYPE_NONE;
|
||||
case XML_TOK_OPEN_BRACKET:
|
||||
state->handler = internalSubset;
|
||||
return XML_ROLE_DOCTYPE_INTERNAL_SUBSET;
|
||||
case XML_TOK_DECL_CLOSE:
|
||||
state->handler = prolog2;
|
||||
return XML_ROLE_DOCTYPE_CLOSE;
|
||||
case XML_TOK_NAME:
|
||||
if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
|
||||
state->handler = doctype3;
|
||||
return XML_ROLE_DOCTYPE_NONE;
|
||||
}
|
||||
if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
|
||||
state->handler = doctype2;
|
||||
return XML_ROLE_DOCTYPE_NONE;
|
||||
}
|
||||
break;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
doctype2(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_DOCTYPE_NONE;
|
||||
case XML_TOK_LITERAL:
|
||||
state->handler = doctype3;
|
||||
return XML_ROLE_DOCTYPE_PUBLIC_ID;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
doctype3(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_DOCTYPE_NONE;
|
||||
case XML_TOK_LITERAL:
|
||||
state->handler = doctype4;
|
||||
return XML_ROLE_DOCTYPE_SYSTEM_ID;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
doctype4(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_DOCTYPE_NONE;
|
||||
case XML_TOK_OPEN_BRACKET:
|
||||
state->handler = internalSubset;
|
||||
return XML_ROLE_DOCTYPE_INTERNAL_SUBSET;
|
||||
case XML_TOK_DECL_CLOSE:
|
||||
state->handler = prolog2;
|
||||
return XML_ROLE_DOCTYPE_CLOSE;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
doctype5(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_DOCTYPE_NONE;
|
||||
case XML_TOK_DECL_CLOSE:
|
||||
state->handler = prolog2;
|
||||
return XML_ROLE_DOCTYPE_CLOSE;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
internalSubset(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_NONE;
|
||||
case XML_TOK_DECL_OPEN:
|
||||
if (XmlNameMatchesAscii(enc,
|
||||
ptr + 2 * MIN_BYTES_PER_CHAR(enc),
|
||||
end,
|
||||
KW_ENTITY)) {
|
||||
state->handler = entity0;
|
||||
return XML_ROLE_ENTITY_NONE;
|
||||
}
|
||||
if (XmlNameMatchesAscii(enc,
|
||||
ptr + 2 * MIN_BYTES_PER_CHAR(enc),
|
||||
end,
|
||||
KW_ATTLIST)) {
|
||||
state->handler = attlist0;
|
||||
return XML_ROLE_ATTLIST_NONE;
|
||||
}
|
||||
if (XmlNameMatchesAscii(enc,
|
||||
ptr + 2 * MIN_BYTES_PER_CHAR(enc),
|
||||
end,
|
||||
KW_ELEMENT)) {
|
||||
state->handler = element0;
|
||||
return XML_ROLE_ELEMENT_NONE;
|
||||
}
|
||||
if (XmlNameMatchesAscii(enc,
|
||||
ptr + 2 * MIN_BYTES_PER_CHAR(enc),
|
||||
end,
|
||||
KW_NOTATION)) {
|
||||
state->handler = notation0;
|
||||
return XML_ROLE_NOTATION_NONE;
|
||||
}
|
||||
break;
|
||||
case XML_TOK_PI:
|
||||
return XML_ROLE_PI;
|
||||
case XML_TOK_COMMENT:
|
||||
return XML_ROLE_COMMENT;
|
||||
case XML_TOK_PARAM_ENTITY_REF:
|
||||
return XML_ROLE_PARAM_ENTITY_REF;
|
||||
case XML_TOK_CLOSE_BRACKET:
|
||||
state->handler = doctype5;
|
||||
return XML_ROLE_DOCTYPE_NONE;
|
||||
case XML_TOK_NONE:
|
||||
return XML_ROLE_NONE;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
#ifdef XML_DTD
|
||||
|
||||
static int PTRCALL
|
||||
externalSubset0(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
state->handler = externalSubset1;
|
||||
if (tok == XML_TOK_XML_DECL)
|
||||
return XML_ROLE_TEXT_DECL;
|
||||
return externalSubset1(state, tok, ptr, end, enc);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
externalSubset1(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_COND_SECT_OPEN:
|
||||
state->handler = condSect0;
|
||||
return XML_ROLE_NONE;
|
||||
case XML_TOK_COND_SECT_CLOSE:
|
||||
if (state->includeLevel == 0)
|
||||
break;
|
||||
state->includeLevel -= 1;
|
||||
return XML_ROLE_NONE;
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_NONE;
|
||||
case XML_TOK_CLOSE_BRACKET:
|
||||
break;
|
||||
case XML_TOK_NONE:
|
||||
if (state->includeLevel)
|
||||
break;
|
||||
return XML_ROLE_NONE;
|
||||
default:
|
||||
return internalSubset(state, tok, ptr, end, enc);
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
#endif /* XML_DTD */
|
||||
|
||||
static int PTRCALL
|
||||
entity0(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_ENTITY_NONE;
|
||||
case XML_TOK_PERCENT:
|
||||
state->handler = entity1;
|
||||
return XML_ROLE_ENTITY_NONE;
|
||||
case XML_TOK_NAME:
|
||||
state->handler = entity2;
|
||||
return XML_ROLE_GENERAL_ENTITY_NAME;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
entity1(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_ENTITY_NONE;
|
||||
case XML_TOK_NAME:
|
||||
state->handler = entity7;
|
||||
return XML_ROLE_PARAM_ENTITY_NAME;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
entity2(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_ENTITY_NONE;
|
||||
case XML_TOK_NAME:
|
||||
if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
|
||||
state->handler = entity4;
|
||||
return XML_ROLE_ENTITY_NONE;
|
||||
}
|
||||
if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
|
||||
state->handler = entity3;
|
||||
return XML_ROLE_ENTITY_NONE;
|
||||
}
|
||||
break;
|
||||
case XML_TOK_LITERAL:
|
||||
state->handler = declClose;
|
||||
state->role_none = XML_ROLE_ENTITY_NONE;
|
||||
return XML_ROLE_ENTITY_VALUE;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
entity3(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_ENTITY_NONE;
|
||||
case XML_TOK_LITERAL:
|
||||
state->handler = entity4;
|
||||
return XML_ROLE_ENTITY_PUBLIC_ID;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
entity4(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_ENTITY_NONE;
|
||||
case XML_TOK_LITERAL:
|
||||
state->handler = entity5;
|
||||
return XML_ROLE_ENTITY_SYSTEM_ID;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
entity5(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_ENTITY_NONE;
|
||||
case XML_TOK_DECL_CLOSE:
|
||||
setTopLevel(state);
|
||||
return XML_ROLE_ENTITY_COMPLETE;
|
||||
case XML_TOK_NAME:
|
||||
if (XmlNameMatchesAscii(enc, ptr, end, KW_NDATA)) {
|
||||
state->handler = entity6;
|
||||
return XML_ROLE_ENTITY_NONE;
|
||||
}
|
||||
break;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
entity6(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_ENTITY_NONE;
|
||||
case XML_TOK_NAME:
|
||||
state->handler = declClose;
|
||||
state->role_none = XML_ROLE_ENTITY_NONE;
|
||||
return XML_ROLE_ENTITY_NOTATION_NAME;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
entity7(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_ENTITY_NONE;
|
||||
case XML_TOK_NAME:
|
||||
if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
|
||||
state->handler = entity9;
|
||||
return XML_ROLE_ENTITY_NONE;
|
||||
}
|
||||
if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
|
||||
state->handler = entity8;
|
||||
return XML_ROLE_ENTITY_NONE;
|
||||
}
|
||||
break;
|
||||
case XML_TOK_LITERAL:
|
||||
state->handler = declClose;
|
||||
state->role_none = XML_ROLE_ENTITY_NONE;
|
||||
return XML_ROLE_ENTITY_VALUE;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
entity8(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_ENTITY_NONE;
|
||||
case XML_TOK_LITERAL:
|
||||
state->handler = entity9;
|
||||
return XML_ROLE_ENTITY_PUBLIC_ID;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
entity9(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_ENTITY_NONE;
|
||||
case XML_TOK_LITERAL:
|
||||
state->handler = entity10;
|
||||
return XML_ROLE_ENTITY_SYSTEM_ID;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
entity10(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_ENTITY_NONE;
|
||||
case XML_TOK_DECL_CLOSE:
|
||||
setTopLevel(state);
|
||||
return XML_ROLE_ENTITY_COMPLETE;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
notation0(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_NOTATION_NONE;
|
||||
case XML_TOK_NAME:
|
||||
state->handler = notation1;
|
||||
return XML_ROLE_NOTATION_NAME;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
notation1(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_NOTATION_NONE;
|
||||
case XML_TOK_NAME:
|
||||
if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
|
||||
state->handler = notation3;
|
||||
return XML_ROLE_NOTATION_NONE;
|
||||
}
|
||||
if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
|
||||
state->handler = notation2;
|
||||
return XML_ROLE_NOTATION_NONE;
|
||||
}
|
||||
break;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
notation2(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_NOTATION_NONE;
|
||||
case XML_TOK_LITERAL:
|
||||
state->handler = notation4;
|
||||
return XML_ROLE_NOTATION_PUBLIC_ID;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
notation3(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_NOTATION_NONE;
|
||||
case XML_TOK_LITERAL:
|
||||
state->handler = declClose;
|
||||
state->role_none = XML_ROLE_NOTATION_NONE;
|
||||
return XML_ROLE_NOTATION_SYSTEM_ID;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
notation4(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_NOTATION_NONE;
|
||||
case XML_TOK_LITERAL:
|
||||
state->handler = declClose;
|
||||
state->role_none = XML_ROLE_NOTATION_NONE;
|
||||
return XML_ROLE_NOTATION_SYSTEM_ID;
|
||||
case XML_TOK_DECL_CLOSE:
|
||||
setTopLevel(state);
|
||||
return XML_ROLE_NOTATION_NO_SYSTEM_ID;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
attlist0(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_ATTLIST_NONE;
|
||||
case XML_TOK_NAME:
|
||||
case XML_TOK_PREFIXED_NAME:
|
||||
state->handler = attlist1;
|
||||
return XML_ROLE_ATTLIST_ELEMENT_NAME;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
attlist1(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_ATTLIST_NONE;
|
||||
case XML_TOK_DECL_CLOSE:
|
||||
setTopLevel(state);
|
||||
return XML_ROLE_ATTLIST_NONE;
|
||||
case XML_TOK_NAME:
|
||||
case XML_TOK_PREFIXED_NAME:
|
||||
state->handler = attlist2;
|
||||
return XML_ROLE_ATTRIBUTE_NAME;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
attlist2(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_ATTLIST_NONE;
|
||||
case XML_TOK_NAME:
|
||||
{
|
||||
static const char * const types[] = {
|
||||
KW_CDATA,
|
||||
KW_ID,
|
||||
KW_IDREF,
|
||||
KW_IDREFS,
|
||||
KW_ENTITY,
|
||||
KW_ENTITIES,
|
||||
KW_NMTOKEN,
|
||||
KW_NMTOKENS,
|
||||
};
|
||||
int i;
|
||||
for (i = 0; i < (int)(sizeof(types)/sizeof(types[0])); i++)
|
||||
if (XmlNameMatchesAscii(enc, ptr, end, types[i])) {
|
||||
state->handler = attlist8;
|
||||
return XML_ROLE_ATTRIBUTE_TYPE_CDATA + i;
|
||||
}
|
||||
}
|
||||
if (XmlNameMatchesAscii(enc, ptr, end, KW_NOTATION)) {
|
||||
state->handler = attlist5;
|
||||
return XML_ROLE_ATTLIST_NONE;
|
||||
}
|
||||
break;
|
||||
case XML_TOK_OPEN_PAREN:
|
||||
state->handler = attlist3;
|
||||
return XML_ROLE_ATTLIST_NONE;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
attlist3(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_ATTLIST_NONE;
|
||||
case XML_TOK_NMTOKEN:
|
||||
case XML_TOK_NAME:
|
||||
case XML_TOK_PREFIXED_NAME:
|
||||
state->handler = attlist4;
|
||||
return XML_ROLE_ATTRIBUTE_ENUM_VALUE;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
attlist4(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_ATTLIST_NONE;
|
||||
case XML_TOK_CLOSE_PAREN:
|
||||
state->handler = attlist8;
|
||||
return XML_ROLE_ATTLIST_NONE;
|
||||
case XML_TOK_OR:
|
||||
state->handler = attlist3;
|
||||
return XML_ROLE_ATTLIST_NONE;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
attlist5(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_ATTLIST_NONE;
|
||||
case XML_TOK_OPEN_PAREN:
|
||||
state->handler = attlist6;
|
||||
return XML_ROLE_ATTLIST_NONE;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
attlist6(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_ATTLIST_NONE;
|
||||
case XML_TOK_NAME:
|
||||
state->handler = attlist7;
|
||||
return XML_ROLE_ATTRIBUTE_NOTATION_VALUE;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
attlist7(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_ATTLIST_NONE;
|
||||
case XML_TOK_CLOSE_PAREN:
|
||||
state->handler = attlist8;
|
||||
return XML_ROLE_ATTLIST_NONE;
|
||||
case XML_TOK_OR:
|
||||
state->handler = attlist6;
|
||||
return XML_ROLE_ATTLIST_NONE;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
/* default value */
|
||||
static int PTRCALL
|
||||
attlist8(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_ATTLIST_NONE;
|
||||
case XML_TOK_POUND_NAME:
|
||||
if (XmlNameMatchesAscii(enc,
|
||||
ptr + MIN_BYTES_PER_CHAR(enc),
|
||||
end,
|
||||
KW_IMPLIED)) {
|
||||
state->handler = attlist1;
|
||||
return XML_ROLE_IMPLIED_ATTRIBUTE_VALUE;
|
||||
}
|
||||
if (XmlNameMatchesAscii(enc,
|
||||
ptr + MIN_BYTES_PER_CHAR(enc),
|
||||
end,
|
||||
KW_REQUIRED)) {
|
||||
state->handler = attlist1;
|
||||
return XML_ROLE_REQUIRED_ATTRIBUTE_VALUE;
|
||||
}
|
||||
if (XmlNameMatchesAscii(enc,
|
||||
ptr + MIN_BYTES_PER_CHAR(enc),
|
||||
end,
|
||||
KW_FIXED)) {
|
||||
state->handler = attlist9;
|
||||
return XML_ROLE_ATTLIST_NONE;
|
||||
}
|
||||
break;
|
||||
case XML_TOK_LITERAL:
|
||||
state->handler = attlist1;
|
||||
return XML_ROLE_DEFAULT_ATTRIBUTE_VALUE;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
attlist9(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_ATTLIST_NONE;
|
||||
case XML_TOK_LITERAL:
|
||||
state->handler = attlist1;
|
||||
return XML_ROLE_FIXED_ATTRIBUTE_VALUE;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
element0(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_ELEMENT_NONE;
|
||||
case XML_TOK_NAME:
|
||||
case XML_TOK_PREFIXED_NAME:
|
||||
state->handler = element1;
|
||||
return XML_ROLE_ELEMENT_NAME;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
element1(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_ELEMENT_NONE;
|
||||
case XML_TOK_NAME:
|
||||
if (XmlNameMatchesAscii(enc, ptr, end, KW_EMPTY)) {
|
||||
state->handler = declClose;
|
||||
state->role_none = XML_ROLE_ELEMENT_NONE;
|
||||
return XML_ROLE_CONTENT_EMPTY;
|
||||
}
|
||||
if (XmlNameMatchesAscii(enc, ptr, end, KW_ANY)) {
|
||||
state->handler = declClose;
|
||||
state->role_none = XML_ROLE_ELEMENT_NONE;
|
||||
return XML_ROLE_CONTENT_ANY;
|
||||
}
|
||||
break;
|
||||
case XML_TOK_OPEN_PAREN:
|
||||
state->handler = element2;
|
||||
state->level = 1;
|
||||
return XML_ROLE_GROUP_OPEN;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
element2(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_ELEMENT_NONE;
|
||||
case XML_TOK_POUND_NAME:
|
||||
if (XmlNameMatchesAscii(enc,
|
||||
ptr + MIN_BYTES_PER_CHAR(enc),
|
||||
end,
|
||||
KW_PCDATA)) {
|
||||
state->handler = element3;
|
||||
return XML_ROLE_CONTENT_PCDATA;
|
||||
}
|
||||
break;
|
||||
case XML_TOK_OPEN_PAREN:
|
||||
state->level = 2;
|
||||
state->handler = element6;
|
||||
return XML_ROLE_GROUP_OPEN;
|
||||
case XML_TOK_NAME:
|
||||
case XML_TOK_PREFIXED_NAME:
|
||||
state->handler = element7;
|
||||
return XML_ROLE_CONTENT_ELEMENT;
|
||||
case XML_TOK_NAME_QUESTION:
|
||||
state->handler = element7;
|
||||
return XML_ROLE_CONTENT_ELEMENT_OPT;
|
||||
case XML_TOK_NAME_ASTERISK:
|
||||
state->handler = element7;
|
||||
return XML_ROLE_CONTENT_ELEMENT_REP;
|
||||
case XML_TOK_NAME_PLUS:
|
||||
state->handler = element7;
|
||||
return XML_ROLE_CONTENT_ELEMENT_PLUS;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
element3(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_ELEMENT_NONE;
|
||||
case XML_TOK_CLOSE_PAREN:
|
||||
state->handler = declClose;
|
||||
state->role_none = XML_ROLE_ELEMENT_NONE;
|
||||
return XML_ROLE_GROUP_CLOSE;
|
||||
case XML_TOK_CLOSE_PAREN_ASTERISK:
|
||||
state->handler = declClose;
|
||||
state->role_none = XML_ROLE_ELEMENT_NONE;
|
||||
return XML_ROLE_GROUP_CLOSE_REP;
|
||||
case XML_TOK_OR:
|
||||
state->handler = element4;
|
||||
return XML_ROLE_ELEMENT_NONE;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
element4(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_ELEMENT_NONE;
|
||||
case XML_TOK_NAME:
|
||||
case XML_TOK_PREFIXED_NAME:
|
||||
state->handler = element5;
|
||||
return XML_ROLE_CONTENT_ELEMENT;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
element5(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_ELEMENT_NONE;
|
||||
case XML_TOK_CLOSE_PAREN_ASTERISK:
|
||||
state->handler = declClose;
|
||||
state->role_none = XML_ROLE_ELEMENT_NONE;
|
||||
return XML_ROLE_GROUP_CLOSE_REP;
|
||||
case XML_TOK_OR:
|
||||
state->handler = element4;
|
||||
return XML_ROLE_ELEMENT_NONE;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
element6(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_ELEMENT_NONE;
|
||||
case XML_TOK_OPEN_PAREN:
|
||||
state->level += 1;
|
||||
return XML_ROLE_GROUP_OPEN;
|
||||
case XML_TOK_NAME:
|
||||
case XML_TOK_PREFIXED_NAME:
|
||||
state->handler = element7;
|
||||
return XML_ROLE_CONTENT_ELEMENT;
|
||||
case XML_TOK_NAME_QUESTION:
|
||||
state->handler = element7;
|
||||
return XML_ROLE_CONTENT_ELEMENT_OPT;
|
||||
case XML_TOK_NAME_ASTERISK:
|
||||
state->handler = element7;
|
||||
return XML_ROLE_CONTENT_ELEMENT_REP;
|
||||
case XML_TOK_NAME_PLUS:
|
||||
state->handler = element7;
|
||||
return XML_ROLE_CONTENT_ELEMENT_PLUS;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
element7(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_ELEMENT_NONE;
|
||||
case XML_TOK_CLOSE_PAREN:
|
||||
state->level -= 1;
|
||||
if (state->level == 0) {
|
||||
state->handler = declClose;
|
||||
state->role_none = XML_ROLE_ELEMENT_NONE;
|
||||
}
|
||||
return XML_ROLE_GROUP_CLOSE;
|
||||
case XML_TOK_CLOSE_PAREN_ASTERISK:
|
||||
state->level -= 1;
|
||||
if (state->level == 0) {
|
||||
state->handler = declClose;
|
||||
state->role_none = XML_ROLE_ELEMENT_NONE;
|
||||
}
|
||||
return XML_ROLE_GROUP_CLOSE_REP;
|
||||
case XML_TOK_CLOSE_PAREN_QUESTION:
|
||||
state->level -= 1;
|
||||
if (state->level == 0) {
|
||||
state->handler = declClose;
|
||||
state->role_none = XML_ROLE_ELEMENT_NONE;
|
||||
}
|
||||
return XML_ROLE_GROUP_CLOSE_OPT;
|
||||
case XML_TOK_CLOSE_PAREN_PLUS:
|
||||
state->level -= 1;
|
||||
if (state->level == 0) {
|
||||
state->handler = declClose;
|
||||
state->role_none = XML_ROLE_ELEMENT_NONE;
|
||||
}
|
||||
return XML_ROLE_GROUP_CLOSE_PLUS;
|
||||
case XML_TOK_COMMA:
|
||||
state->handler = element6;
|
||||
return XML_ROLE_GROUP_SEQUENCE;
|
||||
case XML_TOK_OR:
|
||||
state->handler = element6;
|
||||
return XML_ROLE_GROUP_CHOICE;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
#ifdef XML_DTD
|
||||
|
||||
static int PTRCALL
|
||||
condSect0(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_NONE;
|
||||
case XML_TOK_NAME:
|
||||
if (XmlNameMatchesAscii(enc, ptr, end, KW_INCLUDE)) {
|
||||
state->handler = condSect1;
|
||||
return XML_ROLE_NONE;
|
||||
}
|
||||
if (XmlNameMatchesAscii(enc, ptr, end, KW_IGNORE)) {
|
||||
state->handler = condSect2;
|
||||
return XML_ROLE_NONE;
|
||||
}
|
||||
break;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
condSect1(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_NONE;
|
||||
case XML_TOK_OPEN_BRACKET:
|
||||
state->handler = externalSubset1;
|
||||
state->includeLevel += 1;
|
||||
return XML_ROLE_NONE;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
condSect2(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return XML_ROLE_NONE;
|
||||
case XML_TOK_OPEN_BRACKET:
|
||||
state->handler = externalSubset1;
|
||||
return XML_ROLE_IGNORE_SECT;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
#endif /* XML_DTD */
|
||||
|
||||
static int PTRCALL
|
||||
declClose(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
switch (tok) {
|
||||
case XML_TOK_PROLOG_S:
|
||||
return state->role_none;
|
||||
case XML_TOK_DECL_CLOSE:
|
||||
setTopLevel(state);
|
||||
return state->role_none;
|
||||
}
|
||||
return common(state, tok);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
error(PROLOG_STATE *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc)
|
||||
{
|
||||
return XML_ROLE_NONE;
|
||||
}
|
||||
|
||||
static int FASTCALL
|
||||
common(PROLOG_STATE *state, int tok)
|
||||
{
|
||||
#ifdef XML_DTD
|
||||
if (!state->documentEntity && tok == XML_TOK_PARAM_ENTITY_REF)
|
||||
return XML_ROLE_INNER_PARAM_ENTITY_REF;
|
||||
#endif
|
||||
state->handler = error;
|
||||
return XML_ROLE_ERROR;
|
||||
}
|
||||
|
||||
void
|
||||
XmlPrologStateInit(PROLOG_STATE *state)
|
||||
{
|
||||
state->handler = prolog0;
|
||||
#ifdef XML_DTD
|
||||
state->documentEntity = 1;
|
||||
state->includeLevel = 0;
|
||||
state->inEntityValue = 0;
|
||||
#endif /* XML_DTD */
|
||||
}
|
||||
|
||||
#ifdef XML_DTD
|
||||
|
||||
void
|
||||
XmlPrologStateInitExternalEntity(PROLOG_STATE *state)
|
||||
{
|
||||
state->handler = externalSubset0;
|
||||
state->documentEntity = 0;
|
||||
state->includeLevel = 0;
|
||||
}
|
||||
|
||||
#endif /* XML_DTD */
|
||||
@@ -0,0 +1,114 @@
|
||||
/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
|
||||
See the file COPYING for copying permission.
|
||||
*/
|
||||
|
||||
#ifndef XmlRole_INCLUDED
|
||||
#define XmlRole_INCLUDED 1
|
||||
|
||||
#ifdef __VMS
|
||||
/* 0 1 2 3 0 1 2 3
|
||||
1234567890123456789012345678901 1234567890123456789012345678901 */
|
||||
#define XmlPrologStateInitExternalEntity XmlPrologStateInitExternalEnt
|
||||
#endif
|
||||
|
||||
#include "xmltok.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
enum {
|
||||
XML_ROLE_ERROR = -1,
|
||||
XML_ROLE_NONE = 0,
|
||||
XML_ROLE_XML_DECL,
|
||||
XML_ROLE_INSTANCE_START,
|
||||
XML_ROLE_DOCTYPE_NONE,
|
||||
XML_ROLE_DOCTYPE_NAME,
|
||||
XML_ROLE_DOCTYPE_SYSTEM_ID,
|
||||
XML_ROLE_DOCTYPE_PUBLIC_ID,
|
||||
XML_ROLE_DOCTYPE_INTERNAL_SUBSET,
|
||||
XML_ROLE_DOCTYPE_CLOSE,
|
||||
XML_ROLE_GENERAL_ENTITY_NAME,
|
||||
XML_ROLE_PARAM_ENTITY_NAME,
|
||||
XML_ROLE_ENTITY_NONE,
|
||||
XML_ROLE_ENTITY_VALUE,
|
||||
XML_ROLE_ENTITY_SYSTEM_ID,
|
||||
XML_ROLE_ENTITY_PUBLIC_ID,
|
||||
XML_ROLE_ENTITY_COMPLETE,
|
||||
XML_ROLE_ENTITY_NOTATION_NAME,
|
||||
XML_ROLE_NOTATION_NONE,
|
||||
XML_ROLE_NOTATION_NAME,
|
||||
XML_ROLE_NOTATION_SYSTEM_ID,
|
||||
XML_ROLE_NOTATION_NO_SYSTEM_ID,
|
||||
XML_ROLE_NOTATION_PUBLIC_ID,
|
||||
XML_ROLE_ATTRIBUTE_NAME,
|
||||
XML_ROLE_ATTRIBUTE_TYPE_CDATA,
|
||||
XML_ROLE_ATTRIBUTE_TYPE_ID,
|
||||
XML_ROLE_ATTRIBUTE_TYPE_IDREF,
|
||||
XML_ROLE_ATTRIBUTE_TYPE_IDREFS,
|
||||
XML_ROLE_ATTRIBUTE_TYPE_ENTITY,
|
||||
XML_ROLE_ATTRIBUTE_TYPE_ENTITIES,
|
||||
XML_ROLE_ATTRIBUTE_TYPE_NMTOKEN,
|
||||
XML_ROLE_ATTRIBUTE_TYPE_NMTOKENS,
|
||||
XML_ROLE_ATTRIBUTE_ENUM_VALUE,
|
||||
XML_ROLE_ATTRIBUTE_NOTATION_VALUE,
|
||||
XML_ROLE_ATTLIST_NONE,
|
||||
XML_ROLE_ATTLIST_ELEMENT_NAME,
|
||||
XML_ROLE_IMPLIED_ATTRIBUTE_VALUE,
|
||||
XML_ROLE_REQUIRED_ATTRIBUTE_VALUE,
|
||||
XML_ROLE_DEFAULT_ATTRIBUTE_VALUE,
|
||||
XML_ROLE_FIXED_ATTRIBUTE_VALUE,
|
||||
XML_ROLE_ELEMENT_NONE,
|
||||
XML_ROLE_ELEMENT_NAME,
|
||||
XML_ROLE_CONTENT_ANY,
|
||||
XML_ROLE_CONTENT_EMPTY,
|
||||
XML_ROLE_CONTENT_PCDATA,
|
||||
XML_ROLE_GROUP_OPEN,
|
||||
XML_ROLE_GROUP_CLOSE,
|
||||
XML_ROLE_GROUP_CLOSE_REP,
|
||||
XML_ROLE_GROUP_CLOSE_OPT,
|
||||
XML_ROLE_GROUP_CLOSE_PLUS,
|
||||
XML_ROLE_GROUP_CHOICE,
|
||||
XML_ROLE_GROUP_SEQUENCE,
|
||||
XML_ROLE_CONTENT_ELEMENT,
|
||||
XML_ROLE_CONTENT_ELEMENT_REP,
|
||||
XML_ROLE_CONTENT_ELEMENT_OPT,
|
||||
XML_ROLE_CONTENT_ELEMENT_PLUS,
|
||||
XML_ROLE_PI,
|
||||
XML_ROLE_COMMENT,
|
||||
#ifdef XML_DTD
|
||||
XML_ROLE_TEXT_DECL,
|
||||
XML_ROLE_IGNORE_SECT,
|
||||
XML_ROLE_INNER_PARAM_ENTITY_REF,
|
||||
#endif /* XML_DTD */
|
||||
XML_ROLE_PARAM_ENTITY_REF
|
||||
};
|
||||
|
||||
typedef struct prolog_state {
|
||||
int (PTRCALL *handler) (struct prolog_state *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc);
|
||||
unsigned level;
|
||||
int role_none;
|
||||
#ifdef XML_DTD
|
||||
unsigned includeLevel;
|
||||
int documentEntity;
|
||||
int inEntityValue;
|
||||
#endif /* XML_DTD */
|
||||
} PROLOG_STATE;
|
||||
|
||||
void XmlPrologStateInit(PROLOG_STATE *);
|
||||
#ifdef XML_DTD
|
||||
void XmlPrologStateInitExternalEntity(PROLOG_STATE *);
|
||||
#endif /* XML_DTD */
|
||||
|
||||
#define XmlTokenRole(state, tok, ptr, end, enc) \
|
||||
(((state)->handler)(state, tok, ptr, end, enc))
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* not XmlRole_INCLUDED */
|
||||
@@ -0,0 +1,1662 @@
|
||||
/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
|
||||
See the file COPYING for copying permission.
|
||||
*/
|
||||
|
||||
#include <stddef.h>
|
||||
|
||||
#ifdef COMPILING_FOR_WINDOWS
|
||||
#include "winconfig.h"
|
||||
#elif defined(MACOS_CLASSIC)
|
||||
#include "macconfig.h"
|
||||
#elif defined(__amigaos__)
|
||||
#include "amigaconfig.h"
|
||||
#elif defined(__WATCOMC__)
|
||||
#include "watcomconfig.h"
|
||||
#else
|
||||
#ifdef HAVE_EXPAT_CONFIG_H
|
||||
#include <expat_config.h>
|
||||
#endif
|
||||
#endif /* ndef COMPILING_FOR_WINDOWS */
|
||||
|
||||
#include "expat_external.h"
|
||||
#include "internal.h"
|
||||
#include "xmltok.h"
|
||||
#include "nametab.h"
|
||||
|
||||
#ifdef XML_DTD
|
||||
#define IGNORE_SECTION_TOK_VTABLE , PREFIX(ignoreSectionTok)
|
||||
#else
|
||||
#define IGNORE_SECTION_TOK_VTABLE /* as nothing */
|
||||
#endif
|
||||
|
||||
#define VTABLE1 \
|
||||
{ PREFIX(prologTok), PREFIX(contentTok), \
|
||||
PREFIX(cdataSectionTok) IGNORE_SECTION_TOK_VTABLE }, \
|
||||
{ PREFIX(attributeValueTok), PREFIX(entityValueTok) }, \
|
||||
PREFIX(sameName), \
|
||||
PREFIX(nameMatchesAscii), \
|
||||
PREFIX(nameLength), \
|
||||
PREFIX(skipS), \
|
||||
PREFIX(getAtts), \
|
||||
PREFIX(charRefNumber), \
|
||||
PREFIX(predefinedEntityName), \
|
||||
PREFIX(updatePosition), \
|
||||
PREFIX(isPublicId)
|
||||
|
||||
#define VTABLE VTABLE1, PREFIX(toUtf8), PREFIX(toUtf16)
|
||||
|
||||
#define UCS2_GET_NAMING(pages, hi, lo) \
|
||||
(namingBitmap[(pages[hi] << 3) + ((lo) >> 5)] & (1 << ((lo) & 0x1F)))
|
||||
|
||||
/* A 2 byte UTF-8 representation splits the characters 11 bits between
|
||||
the bottom 5 and 6 bits of the bytes. We need 8 bits to index into
|
||||
pages, 3 bits to add to that index and 5 bits to generate the mask.
|
||||
*/
|
||||
#define UTF8_GET_NAMING2(pages, byte) \
|
||||
(namingBitmap[((pages)[(((byte)[0]) >> 2) & 7] << 3) \
|
||||
+ ((((byte)[0]) & 3) << 1) \
|
||||
+ ((((byte)[1]) >> 5) & 1)] \
|
||||
& (1 << (((byte)[1]) & 0x1F)))
|
||||
|
||||
/* A 3 byte UTF-8 representation splits the characters 16 bits between
|
||||
the bottom 4, 6 and 6 bits of the bytes. We need 8 bits to index
|
||||
into pages, 3 bits to add to that index and 5 bits to generate the
|
||||
mask.
|
||||
*/
|
||||
#define UTF8_GET_NAMING3(pages, byte) \
|
||||
(namingBitmap[((pages)[((((byte)[0]) & 0xF) << 4) \
|
||||
+ ((((byte)[1]) >> 2) & 0xF)] \
|
||||
<< 3) \
|
||||
+ ((((byte)[1]) & 3) << 1) \
|
||||
+ ((((byte)[2]) >> 5) & 1)] \
|
||||
& (1 << (((byte)[2]) & 0x1F)))
|
||||
|
||||
#define UTF8_GET_NAMING(pages, p, n) \
|
||||
((n) == 2 \
|
||||
? UTF8_GET_NAMING2(pages, (const unsigned char *)(p)) \
|
||||
: ((n) == 3 \
|
||||
? UTF8_GET_NAMING3(pages, (const unsigned char *)(p)) \
|
||||
: 0))
|
||||
|
||||
/* Detection of invalid UTF-8 sequences is based on Table 3.1B
|
||||
of Unicode 3.2: http://www.unicode.org/unicode/reports/tr28/
|
||||
with the additional restriction of not allowing the Unicode
|
||||
code points 0xFFFF and 0xFFFE (sequences EF,BF,BF and EF,BF,BE).
|
||||
Implementation details:
|
||||
(A & 0x80) == 0 means A < 0x80
|
||||
and
|
||||
(A & 0xC0) == 0xC0 means A > 0xBF
|
||||
*/
|
||||
|
||||
#define UTF8_INVALID2(p) \
|
||||
((*p) < 0xC2 || ((p)[1] & 0x80) == 0 || ((p)[1] & 0xC0) == 0xC0)
|
||||
|
||||
#define UTF8_INVALID3(p) \
|
||||
(((p)[2] & 0x80) == 0 \
|
||||
|| \
|
||||
((*p) == 0xEF && (p)[1] == 0xBF \
|
||||
? \
|
||||
(p)[2] > 0xBD \
|
||||
: \
|
||||
((p)[2] & 0xC0) == 0xC0) \
|
||||
|| \
|
||||
((*p) == 0xE0 \
|
||||
? \
|
||||
(p)[1] < 0xA0 || ((p)[1] & 0xC0) == 0xC0 \
|
||||
: \
|
||||
((p)[1] & 0x80) == 0 \
|
||||
|| \
|
||||
((*p) == 0xED ? (p)[1] > 0x9F : ((p)[1] & 0xC0) == 0xC0)))
|
||||
|
||||
#define UTF8_INVALID4(p) \
|
||||
(((p)[3] & 0x80) == 0 || ((p)[3] & 0xC0) == 0xC0 \
|
||||
|| \
|
||||
((p)[2] & 0x80) == 0 || ((p)[2] & 0xC0) == 0xC0 \
|
||||
|| \
|
||||
((*p) == 0xF0 \
|
||||
? \
|
||||
(p)[1] < 0x90 || ((p)[1] & 0xC0) == 0xC0 \
|
||||
: \
|
||||
((p)[1] & 0x80) == 0 \
|
||||
|| \
|
||||
((*p) == 0xF4 ? (p)[1] > 0x8F : ((p)[1] & 0xC0) == 0xC0)))
|
||||
|
||||
static int PTRFASTCALL
|
||||
isNever(const ENCODING *enc, const char *p)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int PTRFASTCALL
|
||||
utf8_isName2(const ENCODING *enc, const char *p)
|
||||
{
|
||||
return UTF8_GET_NAMING2(namePages, (const unsigned char *)p);
|
||||
}
|
||||
|
||||
static int PTRFASTCALL
|
||||
utf8_isName3(const ENCODING *enc, const char *p)
|
||||
{
|
||||
return UTF8_GET_NAMING3(namePages, (const unsigned char *)p);
|
||||
}
|
||||
|
||||
#define utf8_isName4 isNever
|
||||
|
||||
static int PTRFASTCALL
|
||||
utf8_isNmstrt2(const ENCODING *enc, const char *p)
|
||||
{
|
||||
return UTF8_GET_NAMING2(nmstrtPages, (const unsigned char *)p);
|
||||
}
|
||||
|
||||
static int PTRFASTCALL
|
||||
utf8_isNmstrt3(const ENCODING *enc, const char *p)
|
||||
{
|
||||
return UTF8_GET_NAMING3(nmstrtPages, (const unsigned char *)p);
|
||||
}
|
||||
|
||||
#define utf8_isNmstrt4 isNever
|
||||
|
||||
static int PTRFASTCALL
|
||||
utf8_isInvalid2(const ENCODING *enc, const char *p)
|
||||
{
|
||||
return UTF8_INVALID2((const unsigned char *)p);
|
||||
}
|
||||
|
||||
static int PTRFASTCALL
|
||||
utf8_isInvalid3(const ENCODING *enc, const char *p)
|
||||
{
|
||||
return UTF8_INVALID3((const unsigned char *)p);
|
||||
}
|
||||
|
||||
static int PTRFASTCALL
|
||||
utf8_isInvalid4(const ENCODING *enc, const char *p)
|
||||
{
|
||||
return UTF8_INVALID4((const unsigned char *)p);
|
||||
}
|
||||
|
||||
struct normal_encoding {
|
||||
ENCODING enc;
|
||||
unsigned char type[256];
|
||||
#ifdef XML_MIN_SIZE
|
||||
int (PTRFASTCALL *byteType)(const ENCODING *, const char *);
|
||||
int (PTRFASTCALL *isNameMin)(const ENCODING *, const char *);
|
||||
int (PTRFASTCALL *isNmstrtMin)(const ENCODING *, const char *);
|
||||
int (PTRFASTCALL *byteToAscii)(const ENCODING *, const char *);
|
||||
int (PTRCALL *charMatches)(const ENCODING *, const char *, int);
|
||||
#endif /* XML_MIN_SIZE */
|
||||
int (PTRFASTCALL *isName2)(const ENCODING *, const char *);
|
||||
int (PTRFASTCALL *isName3)(const ENCODING *, const char *);
|
||||
int (PTRFASTCALL *isName4)(const ENCODING *, const char *);
|
||||
int (PTRFASTCALL *isNmstrt2)(const ENCODING *, const char *);
|
||||
int (PTRFASTCALL *isNmstrt3)(const ENCODING *, const char *);
|
||||
int (PTRFASTCALL *isNmstrt4)(const ENCODING *, const char *);
|
||||
int (PTRFASTCALL *isInvalid2)(const ENCODING *, const char *);
|
||||
int (PTRFASTCALL *isInvalid3)(const ENCODING *, const char *);
|
||||
int (PTRFASTCALL *isInvalid4)(const ENCODING *, const char *);
|
||||
};
|
||||
|
||||
#define AS_NORMAL_ENCODING(enc) ((const struct normal_encoding *) (enc))
|
||||
|
||||
#ifdef XML_MIN_SIZE
|
||||
|
||||
#define STANDARD_VTABLE(E) \
|
||||
E ## byteType, \
|
||||
E ## isNameMin, \
|
||||
E ## isNmstrtMin, \
|
||||
E ## byteToAscii, \
|
||||
E ## charMatches,
|
||||
|
||||
#else
|
||||
|
||||
#define STANDARD_VTABLE(E) /* as nothing */
|
||||
|
||||
#endif
|
||||
|
||||
#define NORMAL_VTABLE(E) \
|
||||
E ## isName2, \
|
||||
E ## isName3, \
|
||||
E ## isName4, \
|
||||
E ## isNmstrt2, \
|
||||
E ## isNmstrt3, \
|
||||
E ## isNmstrt4, \
|
||||
E ## isInvalid2, \
|
||||
E ## isInvalid3, \
|
||||
E ## isInvalid4
|
||||
|
||||
#define NULL_VTABLE \
|
||||
/* isName2 */ NULL, \
|
||||
/* isName3 */ NULL, \
|
||||
/* isName4 */ NULL, \
|
||||
/* isNmstrt2 */ NULL, \
|
||||
/* isNmstrt3 */ NULL, \
|
||||
/* isNmstrt4 */ NULL, \
|
||||
/* isInvalid2 */ NULL, \
|
||||
/* isInvalid3 */ NULL, \
|
||||
/* isInvalid4 */ NULL
|
||||
|
||||
static int FASTCALL checkCharRefNumber(int);
|
||||
|
||||
#include "xmltok_impl.h"
|
||||
#include "ascii.h"
|
||||
|
||||
#ifdef XML_MIN_SIZE
|
||||
#define sb_isNameMin isNever
|
||||
#define sb_isNmstrtMin isNever
|
||||
#endif
|
||||
|
||||
#ifdef XML_MIN_SIZE
|
||||
#define MINBPC(enc) ((enc)->minBytesPerChar)
|
||||
#else
|
||||
/* minimum bytes per character */
|
||||
#define MINBPC(enc) 1
|
||||
#endif
|
||||
|
||||
#define SB_BYTE_TYPE(enc, p) \
|
||||
(((struct normal_encoding *)(enc))->type[(unsigned char)*(p)])
|
||||
|
||||
#ifdef XML_MIN_SIZE
|
||||
static int PTRFASTCALL
|
||||
sb_byteType(const ENCODING *enc, const char *p)
|
||||
{
|
||||
return SB_BYTE_TYPE(enc, p);
|
||||
}
|
||||
#define BYTE_TYPE(enc, p) \
|
||||
(AS_NORMAL_ENCODING(enc)->byteType(enc, p))
|
||||
#else
|
||||
#define BYTE_TYPE(enc, p) SB_BYTE_TYPE(enc, p)
|
||||
#endif
|
||||
|
||||
#ifdef XML_MIN_SIZE
|
||||
#define BYTE_TO_ASCII(enc, p) \
|
||||
(AS_NORMAL_ENCODING(enc)->byteToAscii(enc, p))
|
||||
static int PTRFASTCALL
|
||||
sb_byteToAscii(const ENCODING *enc, const char *p)
|
||||
{
|
||||
return *p;
|
||||
}
|
||||
#else
|
||||
#define BYTE_TO_ASCII(enc, p) (*(p))
|
||||
#endif
|
||||
|
||||
#define IS_NAME_CHAR(enc, p, n) \
|
||||
(AS_NORMAL_ENCODING(enc)->isName ## n(enc, p))
|
||||
#define IS_NMSTRT_CHAR(enc, p, n) \
|
||||
(AS_NORMAL_ENCODING(enc)->isNmstrt ## n(enc, p))
|
||||
#define IS_INVALID_CHAR(enc, p, n) \
|
||||
(AS_NORMAL_ENCODING(enc)->isInvalid ## n(enc, p))
|
||||
|
||||
#ifdef XML_MIN_SIZE
|
||||
#define IS_NAME_CHAR_MINBPC(enc, p) \
|
||||
(AS_NORMAL_ENCODING(enc)->isNameMin(enc, p))
|
||||
#define IS_NMSTRT_CHAR_MINBPC(enc, p) \
|
||||
(AS_NORMAL_ENCODING(enc)->isNmstrtMin(enc, p))
|
||||
#else
|
||||
#define IS_NAME_CHAR_MINBPC(enc, p) (0)
|
||||
#define IS_NMSTRT_CHAR_MINBPC(enc, p) (0)
|
||||
#endif
|
||||
|
||||
#ifdef XML_MIN_SIZE
|
||||
#define CHAR_MATCHES(enc, p, c) \
|
||||
(AS_NORMAL_ENCODING(enc)->charMatches(enc, p, c))
|
||||
static int PTRCALL
|
||||
sb_charMatches(const ENCODING *enc, const char *p, int c)
|
||||
{
|
||||
return *p == c;
|
||||
}
|
||||
#else
|
||||
/* c is an ASCII character */
|
||||
#define CHAR_MATCHES(enc, p, c) (*(p) == c)
|
||||
#endif
|
||||
|
||||
#define PREFIX(ident) normal_ ## ident
|
||||
#define XML_TOK_IMPL_C
|
||||
#include "xmltok_impl.c"
|
||||
#undef XML_TOK_IMPL_C
|
||||
|
||||
#undef MINBPC
|
||||
#undef BYTE_TYPE
|
||||
#undef BYTE_TO_ASCII
|
||||
#undef CHAR_MATCHES
|
||||
#undef IS_NAME_CHAR
|
||||
#undef IS_NAME_CHAR_MINBPC
|
||||
#undef IS_NMSTRT_CHAR
|
||||
#undef IS_NMSTRT_CHAR_MINBPC
|
||||
#undef IS_INVALID_CHAR
|
||||
|
||||
enum { /* UTF8_cvalN is value of masked first byte of N byte sequence */
|
||||
UTF8_cval1 = 0x00,
|
||||
UTF8_cval2 = 0xc0,
|
||||
UTF8_cval3 = 0xe0,
|
||||
UTF8_cval4 = 0xf0
|
||||
};
|
||||
|
||||
static void PTRCALL
|
||||
utf8_toUtf8(const ENCODING *enc,
|
||||
const char **fromP, const char *fromLim,
|
||||
char **toP, const char *toLim)
|
||||
{
|
||||
char *to;
|
||||
const char *from;
|
||||
if (fromLim - *fromP > toLim - *toP) {
|
||||
/* Avoid copying partial characters. */
|
||||
for (fromLim = *fromP + (toLim - *toP); fromLim > *fromP; fromLim--)
|
||||
if (((unsigned char)fromLim[-1] & 0xc0) != 0x80)
|
||||
break;
|
||||
}
|
||||
for (to = *toP, from = *fromP; from != fromLim; from++, to++)
|
||||
*to = *from;
|
||||
*fromP = from;
|
||||
*toP = to;
|
||||
}
|
||||
|
||||
static void PTRCALL
|
||||
utf8_toUtf16(const ENCODING *enc,
|
||||
const char **fromP, const char *fromLim,
|
||||
unsigned short **toP, const unsigned short *toLim)
|
||||
{
|
||||
unsigned short *to = *toP;
|
||||
const char *from = *fromP;
|
||||
while (from != fromLim && to != toLim) {
|
||||
switch (((struct normal_encoding *)enc)->type[(unsigned char)*from]) {
|
||||
case BT_LEAD2:
|
||||
*to++ = (unsigned short)(((from[0] & 0x1f) << 6) | (from[1] & 0x3f));
|
||||
from += 2;
|
||||
break;
|
||||
case BT_LEAD3:
|
||||
*to++ = (unsigned short)(((from[0] & 0xf) << 12)
|
||||
| ((from[1] & 0x3f) << 6) | (from[2] & 0x3f));
|
||||
from += 3;
|
||||
break;
|
||||
case BT_LEAD4:
|
||||
{
|
||||
unsigned long n;
|
||||
if (to + 1 == toLim)
|
||||
goto after;
|
||||
n = ((from[0] & 0x7) << 18) | ((from[1] & 0x3f) << 12)
|
||||
| ((from[2] & 0x3f) << 6) | (from[3] & 0x3f);
|
||||
n -= 0x10000;
|
||||
to[0] = (unsigned short)((n >> 10) | 0xD800);
|
||||
to[1] = (unsigned short)((n & 0x3FF) | 0xDC00);
|
||||
to += 2;
|
||||
from += 4;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
*to++ = *from++;
|
||||
break;
|
||||
}
|
||||
}
|
||||
after:
|
||||
*fromP = from;
|
||||
*toP = to;
|
||||
}
|
||||
|
||||
#ifdef XML_NS
|
||||
static const struct normal_encoding utf8_encoding_ns = {
|
||||
{ VTABLE1, utf8_toUtf8, utf8_toUtf16, 1, 1, 0 },
|
||||
{
|
||||
#include "asciitab.h"
|
||||
#include "utf8tab.h"
|
||||
},
|
||||
STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_)
|
||||
};
|
||||
#endif
|
||||
|
||||
static const struct normal_encoding utf8_encoding = {
|
||||
{ VTABLE1, utf8_toUtf8, utf8_toUtf16, 1, 1, 0 },
|
||||
{
|
||||
#define BT_COLON BT_NMSTRT
|
||||
#include "asciitab.h"
|
||||
#undef BT_COLON
|
||||
#include "utf8tab.h"
|
||||
},
|
||||
STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_)
|
||||
};
|
||||
|
||||
#ifdef XML_NS
|
||||
|
||||
static const struct normal_encoding internal_utf8_encoding_ns = {
|
||||
{ VTABLE1, utf8_toUtf8, utf8_toUtf16, 1, 1, 0 },
|
||||
{
|
||||
#include "iasciitab.h"
|
||||
#include "utf8tab.h"
|
||||
},
|
||||
STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_)
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
static const struct normal_encoding internal_utf8_encoding = {
|
||||
{ VTABLE1, utf8_toUtf8, utf8_toUtf16, 1, 1, 0 },
|
||||
{
|
||||
#define BT_COLON BT_NMSTRT
|
||||
#include "iasciitab.h"
|
||||
#undef BT_COLON
|
||||
#include "utf8tab.h"
|
||||
},
|
||||
STANDARD_VTABLE(sb_) NORMAL_VTABLE(utf8_)
|
||||
};
|
||||
|
||||
static void PTRCALL
|
||||
latin1_toUtf8(const ENCODING *enc,
|
||||
const char **fromP, const char *fromLim,
|
||||
char **toP, const char *toLim)
|
||||
{
|
||||
for (;;) {
|
||||
unsigned char c;
|
||||
if (*fromP == fromLim)
|
||||
break;
|
||||
c = (unsigned char)**fromP;
|
||||
if (c & 0x80) {
|
||||
if (toLim - *toP < 2)
|
||||
break;
|
||||
*(*toP)++ = (char)((c >> 6) | UTF8_cval2);
|
||||
*(*toP)++ = (char)((c & 0x3f) | 0x80);
|
||||
(*fromP)++;
|
||||
}
|
||||
else {
|
||||
if (*toP == toLim)
|
||||
break;
|
||||
*(*toP)++ = *(*fromP)++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void PTRCALL
|
||||
latin1_toUtf16(const ENCODING *enc,
|
||||
const char **fromP, const char *fromLim,
|
||||
unsigned short **toP, const unsigned short *toLim)
|
||||
{
|
||||
while (*fromP != fromLim && *toP != toLim)
|
||||
*(*toP)++ = (unsigned char)*(*fromP)++;
|
||||
}
|
||||
|
||||
#ifdef XML_NS
|
||||
|
||||
static const struct normal_encoding latin1_encoding_ns = {
|
||||
{ VTABLE1, latin1_toUtf8, latin1_toUtf16, 1, 0, 0 },
|
||||
{
|
||||
#include "asciitab.h"
|
||||
#include "latin1tab.h"
|
||||
},
|
||||
STANDARD_VTABLE(sb_) NULL_VTABLE
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
static const struct normal_encoding latin1_encoding = {
|
||||
{ VTABLE1, latin1_toUtf8, latin1_toUtf16, 1, 0, 0 },
|
||||
{
|
||||
#define BT_COLON BT_NMSTRT
|
||||
#include "asciitab.h"
|
||||
#undef BT_COLON
|
||||
#include "latin1tab.h"
|
||||
},
|
||||
STANDARD_VTABLE(sb_) NULL_VTABLE
|
||||
};
|
||||
|
||||
static void PTRCALL
|
||||
ascii_toUtf8(const ENCODING *enc,
|
||||
const char **fromP, const char *fromLim,
|
||||
char **toP, const char *toLim)
|
||||
{
|
||||
while (*fromP != fromLim && *toP != toLim)
|
||||
*(*toP)++ = *(*fromP)++;
|
||||
}
|
||||
|
||||
#ifdef XML_NS
|
||||
|
||||
static const struct normal_encoding ascii_encoding_ns = {
|
||||
{ VTABLE1, ascii_toUtf8, latin1_toUtf16, 1, 1, 0 },
|
||||
{
|
||||
#include "asciitab.h"
|
||||
/* BT_NONXML == 0 */
|
||||
},
|
||||
STANDARD_VTABLE(sb_) NULL_VTABLE
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
static const struct normal_encoding ascii_encoding = {
|
||||
{ VTABLE1, ascii_toUtf8, latin1_toUtf16, 1, 1, 0 },
|
||||
{
|
||||
#define BT_COLON BT_NMSTRT
|
||||
#include "asciitab.h"
|
||||
#undef BT_COLON
|
||||
/* BT_NONXML == 0 */
|
||||
},
|
||||
STANDARD_VTABLE(sb_) NULL_VTABLE
|
||||
};
|
||||
|
||||
static int PTRFASTCALL
|
||||
unicode_byte_type(char hi, char lo)
|
||||
{
|
||||
switch ((unsigned char)hi) {
|
||||
case 0xD8: case 0xD9: case 0xDA: case 0xDB:
|
||||
return BT_LEAD4;
|
||||
case 0xDC: case 0xDD: case 0xDE: case 0xDF:
|
||||
return BT_TRAIL;
|
||||
case 0xFF:
|
||||
switch ((unsigned char)lo) {
|
||||
case 0xFF:
|
||||
case 0xFE:
|
||||
return BT_NONXML;
|
||||
}
|
||||
break;
|
||||
}
|
||||
return BT_NONASCII;
|
||||
}
|
||||
|
||||
#define DEFINE_UTF16_TO_UTF8(E) \
|
||||
static void PTRCALL \
|
||||
E ## toUtf8(const ENCODING *enc, \
|
||||
const char **fromP, const char *fromLim, \
|
||||
char **toP, const char *toLim) \
|
||||
{ \
|
||||
const char *from; \
|
||||
for (from = *fromP; from != fromLim; from += 2) { \
|
||||
int plane; \
|
||||
unsigned char lo2; \
|
||||
unsigned char lo = GET_LO(from); \
|
||||
unsigned char hi = GET_HI(from); \
|
||||
switch (hi) { \
|
||||
case 0: \
|
||||
if (lo < 0x80) { \
|
||||
if (*toP == toLim) { \
|
||||
*fromP = from; \
|
||||
return; \
|
||||
} \
|
||||
*(*toP)++ = lo; \
|
||||
break; \
|
||||
} \
|
||||
/* fall through */ \
|
||||
case 0x1: case 0x2: case 0x3: \
|
||||
case 0x4: case 0x5: case 0x6: case 0x7: \
|
||||
if (toLim - *toP < 2) { \
|
||||
*fromP = from; \
|
||||
return; \
|
||||
} \
|
||||
*(*toP)++ = ((lo >> 6) | (hi << 2) | UTF8_cval2); \
|
||||
*(*toP)++ = ((lo & 0x3f) | 0x80); \
|
||||
break; \
|
||||
default: \
|
||||
if (toLim - *toP < 3) { \
|
||||
*fromP = from; \
|
||||
return; \
|
||||
} \
|
||||
/* 16 bits divided 4, 6, 6 amongst 3 bytes */ \
|
||||
*(*toP)++ = ((hi >> 4) | UTF8_cval3); \
|
||||
*(*toP)++ = (((hi & 0xf) << 2) | (lo >> 6) | 0x80); \
|
||||
*(*toP)++ = ((lo & 0x3f) | 0x80); \
|
||||
break; \
|
||||
case 0xD8: case 0xD9: case 0xDA: case 0xDB: \
|
||||
if (toLim - *toP < 4) { \
|
||||
*fromP = from; \
|
||||
return; \
|
||||
} \
|
||||
plane = (((hi & 0x3) << 2) | ((lo >> 6) & 0x3)) + 1; \
|
||||
*(*toP)++ = ((plane >> 2) | UTF8_cval4); \
|
||||
*(*toP)++ = (((lo >> 2) & 0xF) | ((plane & 0x3) << 4) | 0x80); \
|
||||
from += 2; \
|
||||
lo2 = GET_LO(from); \
|
||||
*(*toP)++ = (((lo & 0x3) << 4) \
|
||||
| ((GET_HI(from) & 0x3) << 2) \
|
||||
| (lo2 >> 6) \
|
||||
| 0x80); \
|
||||
*(*toP)++ = ((lo2 & 0x3f) | 0x80); \
|
||||
break; \
|
||||
} \
|
||||
} \
|
||||
*fromP = from; \
|
||||
}
|
||||
|
||||
#define DEFINE_UTF16_TO_UTF16(E) \
|
||||
static void PTRCALL \
|
||||
E ## toUtf16(const ENCODING *enc, \
|
||||
const char **fromP, const char *fromLim, \
|
||||
unsigned short **toP, const unsigned short *toLim) \
|
||||
{ \
|
||||
/* Avoid copying first half only of surrogate */ \
|
||||
if (fromLim - *fromP > ((toLim - *toP) << 1) \
|
||||
&& (GET_HI(fromLim - 2) & 0xF8) == 0xD8) \
|
||||
fromLim -= 2; \
|
||||
for (; *fromP != fromLim && *toP != toLim; *fromP += 2) \
|
||||
*(*toP)++ = (GET_HI(*fromP) << 8) | GET_LO(*fromP); \
|
||||
}
|
||||
|
||||
#define SET2(ptr, ch) \
|
||||
(((ptr)[0] = ((ch) & 0xff)), ((ptr)[1] = ((ch) >> 8)))
|
||||
#define GET_LO(ptr) ((unsigned char)(ptr)[0])
|
||||
#define GET_HI(ptr) ((unsigned char)(ptr)[1])
|
||||
|
||||
DEFINE_UTF16_TO_UTF8(little2_)
|
||||
DEFINE_UTF16_TO_UTF16(little2_)
|
||||
|
||||
#undef SET2
|
||||
#undef GET_LO
|
||||
#undef GET_HI
|
||||
|
||||
#define SET2(ptr, ch) \
|
||||
(((ptr)[0] = ((ch) >> 8)), ((ptr)[1] = ((ch) & 0xFF)))
|
||||
#define GET_LO(ptr) ((unsigned char)(ptr)[1])
|
||||
#define GET_HI(ptr) ((unsigned char)(ptr)[0])
|
||||
|
||||
DEFINE_UTF16_TO_UTF8(big2_)
|
||||
DEFINE_UTF16_TO_UTF16(big2_)
|
||||
|
||||
#undef SET2
|
||||
#undef GET_LO
|
||||
#undef GET_HI
|
||||
|
||||
#define LITTLE2_BYTE_TYPE(enc, p) \
|
||||
((p)[1] == 0 \
|
||||
? ((struct normal_encoding *)(enc))->type[(unsigned char)*(p)] \
|
||||
: unicode_byte_type((p)[1], (p)[0]))
|
||||
#define LITTLE2_BYTE_TO_ASCII(enc, p) ((p)[1] == 0 ? (p)[0] : -1)
|
||||
#define LITTLE2_CHAR_MATCHES(enc, p, c) ((p)[1] == 0 && (p)[0] == c)
|
||||
#define LITTLE2_IS_NAME_CHAR_MINBPC(enc, p) \
|
||||
UCS2_GET_NAMING(namePages, (unsigned char)p[1], (unsigned char)p[0])
|
||||
#define LITTLE2_IS_NMSTRT_CHAR_MINBPC(enc, p) \
|
||||
UCS2_GET_NAMING(nmstrtPages, (unsigned char)p[1], (unsigned char)p[0])
|
||||
|
||||
#ifdef XML_MIN_SIZE
|
||||
|
||||
static int PTRFASTCALL
|
||||
little2_byteType(const ENCODING *enc, const char *p)
|
||||
{
|
||||
return LITTLE2_BYTE_TYPE(enc, p);
|
||||
}
|
||||
|
||||
static int PTRFASTCALL
|
||||
little2_byteToAscii(const ENCODING *enc, const char *p)
|
||||
{
|
||||
return LITTLE2_BYTE_TO_ASCII(enc, p);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
little2_charMatches(const ENCODING *enc, const char *p, int c)
|
||||
{
|
||||
return LITTLE2_CHAR_MATCHES(enc, p, c);
|
||||
}
|
||||
|
||||
static int PTRFASTCALL
|
||||
little2_isNameMin(const ENCODING *enc, const char *p)
|
||||
{
|
||||
return LITTLE2_IS_NAME_CHAR_MINBPC(enc, p);
|
||||
}
|
||||
|
||||
static int PTRFASTCALL
|
||||
little2_isNmstrtMin(const ENCODING *enc, const char *p)
|
||||
{
|
||||
return LITTLE2_IS_NMSTRT_CHAR_MINBPC(enc, p);
|
||||
}
|
||||
|
||||
#undef VTABLE
|
||||
#define VTABLE VTABLE1, little2_toUtf8, little2_toUtf16
|
||||
|
||||
#else /* not XML_MIN_SIZE */
|
||||
|
||||
#undef PREFIX
|
||||
#define PREFIX(ident) little2_ ## ident
|
||||
#define MINBPC(enc) 2
|
||||
/* CHAR_MATCHES is guaranteed to have MINBPC bytes available. */
|
||||
#define BYTE_TYPE(enc, p) LITTLE2_BYTE_TYPE(enc, p)
|
||||
#define BYTE_TO_ASCII(enc, p) LITTLE2_BYTE_TO_ASCII(enc, p)
|
||||
#define CHAR_MATCHES(enc, p, c) LITTLE2_CHAR_MATCHES(enc, p, c)
|
||||
#define IS_NAME_CHAR(enc, p, n) 0
|
||||
#define IS_NAME_CHAR_MINBPC(enc, p) LITTLE2_IS_NAME_CHAR_MINBPC(enc, p)
|
||||
#define IS_NMSTRT_CHAR(enc, p, n) (0)
|
||||
#define IS_NMSTRT_CHAR_MINBPC(enc, p) LITTLE2_IS_NMSTRT_CHAR_MINBPC(enc, p)
|
||||
|
||||
#define XML_TOK_IMPL_C
|
||||
#include "xmltok_impl.c"
|
||||
#undef XML_TOK_IMPL_C
|
||||
|
||||
#undef MINBPC
|
||||
#undef BYTE_TYPE
|
||||
#undef BYTE_TO_ASCII
|
||||
#undef CHAR_MATCHES
|
||||
#undef IS_NAME_CHAR
|
||||
#undef IS_NAME_CHAR_MINBPC
|
||||
#undef IS_NMSTRT_CHAR
|
||||
#undef IS_NMSTRT_CHAR_MINBPC
|
||||
#undef IS_INVALID_CHAR
|
||||
|
||||
#endif /* not XML_MIN_SIZE */
|
||||
|
||||
#ifdef XML_NS
|
||||
|
||||
static const struct normal_encoding little2_encoding_ns = {
|
||||
{ VTABLE, 2, 0,
|
||||
#if BYTEORDER == 1234
|
||||
1
|
||||
#else
|
||||
0
|
||||
#endif
|
||||
},
|
||||
{
|
||||
#include "asciitab.h"
|
||||
#include "latin1tab.h"
|
||||
},
|
||||
STANDARD_VTABLE(little2_) NULL_VTABLE
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
static const struct normal_encoding little2_encoding = {
|
||||
{ VTABLE, 2, 0,
|
||||
#if BYTEORDER == 1234
|
||||
1
|
||||
#else
|
||||
0
|
||||
#endif
|
||||
},
|
||||
{
|
||||
#define BT_COLON BT_NMSTRT
|
||||
#include "asciitab.h"
|
||||
#undef BT_COLON
|
||||
#include "latin1tab.h"
|
||||
},
|
||||
STANDARD_VTABLE(little2_) NULL_VTABLE
|
||||
};
|
||||
|
||||
#if BYTEORDER != 4321
|
||||
|
||||
#ifdef XML_NS
|
||||
|
||||
static const struct normal_encoding internal_little2_encoding_ns = {
|
||||
{ VTABLE, 2, 0, 1 },
|
||||
{
|
||||
#include "iasciitab.h"
|
||||
#include "latin1tab.h"
|
||||
},
|
||||
STANDARD_VTABLE(little2_) NULL_VTABLE
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
static const struct normal_encoding internal_little2_encoding = {
|
||||
{ VTABLE, 2, 0, 1 },
|
||||
{
|
||||
#define BT_COLON BT_NMSTRT
|
||||
#include "iasciitab.h"
|
||||
#undef BT_COLON
|
||||
#include "latin1tab.h"
|
||||
},
|
||||
STANDARD_VTABLE(little2_) NULL_VTABLE
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
#define BIG2_BYTE_TYPE(enc, p) \
|
||||
((p)[0] == 0 \
|
||||
? ((struct normal_encoding *)(enc))->type[(unsigned char)(p)[1]] \
|
||||
: unicode_byte_type((p)[0], (p)[1]))
|
||||
#define BIG2_BYTE_TO_ASCII(enc, p) ((p)[0] == 0 ? (p)[1] : -1)
|
||||
#define BIG2_CHAR_MATCHES(enc, p, c) ((p)[0] == 0 && (p)[1] == c)
|
||||
#define BIG2_IS_NAME_CHAR_MINBPC(enc, p) \
|
||||
UCS2_GET_NAMING(namePages, (unsigned char)p[0], (unsigned char)p[1])
|
||||
#define BIG2_IS_NMSTRT_CHAR_MINBPC(enc, p) \
|
||||
UCS2_GET_NAMING(nmstrtPages, (unsigned char)p[0], (unsigned char)p[1])
|
||||
|
||||
#ifdef XML_MIN_SIZE
|
||||
|
||||
static int PTRFASTCALL
|
||||
big2_byteType(const ENCODING *enc, const char *p)
|
||||
{
|
||||
return BIG2_BYTE_TYPE(enc, p);
|
||||
}
|
||||
|
||||
static int PTRFASTCALL
|
||||
big2_byteToAscii(const ENCODING *enc, const char *p)
|
||||
{
|
||||
return BIG2_BYTE_TO_ASCII(enc, p);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
big2_charMatches(const ENCODING *enc, const char *p, int c)
|
||||
{
|
||||
return BIG2_CHAR_MATCHES(enc, p, c);
|
||||
}
|
||||
|
||||
static int PTRFASTCALL
|
||||
big2_isNameMin(const ENCODING *enc, const char *p)
|
||||
{
|
||||
return BIG2_IS_NAME_CHAR_MINBPC(enc, p);
|
||||
}
|
||||
|
||||
static int PTRFASTCALL
|
||||
big2_isNmstrtMin(const ENCODING *enc, const char *p)
|
||||
{
|
||||
return BIG2_IS_NMSTRT_CHAR_MINBPC(enc, p);
|
||||
}
|
||||
|
||||
#undef VTABLE
|
||||
#define VTABLE VTABLE1, big2_toUtf8, big2_toUtf16
|
||||
|
||||
#else /* not XML_MIN_SIZE */
|
||||
|
||||
#undef PREFIX
|
||||
#define PREFIX(ident) big2_ ## ident
|
||||
#define MINBPC(enc) 2
|
||||
/* CHAR_MATCHES is guaranteed to have MINBPC bytes available. */
|
||||
#define BYTE_TYPE(enc, p) BIG2_BYTE_TYPE(enc, p)
|
||||
#define BYTE_TO_ASCII(enc, p) BIG2_BYTE_TO_ASCII(enc, p)
|
||||
#define CHAR_MATCHES(enc, p, c) BIG2_CHAR_MATCHES(enc, p, c)
|
||||
#define IS_NAME_CHAR(enc, p, n) 0
|
||||
#define IS_NAME_CHAR_MINBPC(enc, p) BIG2_IS_NAME_CHAR_MINBPC(enc, p)
|
||||
#define IS_NMSTRT_CHAR(enc, p, n) (0)
|
||||
#define IS_NMSTRT_CHAR_MINBPC(enc, p) BIG2_IS_NMSTRT_CHAR_MINBPC(enc, p)
|
||||
|
||||
#define XML_TOK_IMPL_C
|
||||
#include "xmltok_impl.c"
|
||||
#undef XML_TOK_IMPL_C
|
||||
|
||||
#undef MINBPC
|
||||
#undef BYTE_TYPE
|
||||
#undef BYTE_TO_ASCII
|
||||
#undef CHAR_MATCHES
|
||||
#undef IS_NAME_CHAR
|
||||
#undef IS_NAME_CHAR_MINBPC
|
||||
#undef IS_NMSTRT_CHAR
|
||||
#undef IS_NMSTRT_CHAR_MINBPC
|
||||
#undef IS_INVALID_CHAR
|
||||
|
||||
#endif /* not XML_MIN_SIZE */
|
||||
|
||||
#ifdef XML_NS
|
||||
|
||||
static const struct normal_encoding big2_encoding_ns = {
|
||||
{ VTABLE, 2, 0,
|
||||
#if BYTEORDER == 4321
|
||||
1
|
||||
#else
|
||||
0
|
||||
#endif
|
||||
},
|
||||
{
|
||||
#include "asciitab.h"
|
||||
#include "latin1tab.h"
|
||||
},
|
||||
STANDARD_VTABLE(big2_) NULL_VTABLE
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
static const struct normal_encoding big2_encoding = {
|
||||
{ VTABLE, 2, 0,
|
||||
#if BYTEORDER == 4321
|
||||
1
|
||||
#else
|
||||
0
|
||||
#endif
|
||||
},
|
||||
{
|
||||
#define BT_COLON BT_NMSTRT
|
||||
#include "asciitab.h"
|
||||
#undef BT_COLON
|
||||
#include "latin1tab.h"
|
||||
},
|
||||
STANDARD_VTABLE(big2_) NULL_VTABLE
|
||||
};
|
||||
|
||||
#if BYTEORDER != 1234
|
||||
|
||||
#ifdef XML_NS
|
||||
|
||||
static const struct normal_encoding internal_big2_encoding_ns = {
|
||||
{ VTABLE, 2, 0, 1 },
|
||||
{
|
||||
#include "iasciitab.h"
|
||||
#include "latin1tab.h"
|
||||
},
|
||||
STANDARD_VTABLE(big2_) NULL_VTABLE
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
static const struct normal_encoding internal_big2_encoding = {
|
||||
{ VTABLE, 2, 0, 1 },
|
||||
{
|
||||
#define BT_COLON BT_NMSTRT
|
||||
#include "iasciitab.h"
|
||||
#undef BT_COLON
|
||||
#include "latin1tab.h"
|
||||
},
|
||||
STANDARD_VTABLE(big2_) NULL_VTABLE
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
#undef PREFIX
|
||||
|
||||
static int FASTCALL
|
||||
streqci(const char *s1, const char *s2)
|
||||
{
|
||||
for (;;) {
|
||||
char c1 = *s1++;
|
||||
char c2 = *s2++;
|
||||
if (ASCII_a <= c1 && c1 <= ASCII_z)
|
||||
c1 += ASCII_A - ASCII_a;
|
||||
if (ASCII_a <= c2 && c2 <= ASCII_z)
|
||||
c2 += ASCII_A - ASCII_a;
|
||||
if (c1 != c2)
|
||||
return 0;
|
||||
if (!c1)
|
||||
break;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
static void PTRCALL
|
||||
initUpdatePosition(const ENCODING *enc, const char *ptr,
|
||||
const char *end, POSITION *pos)
|
||||
{
|
||||
normal_updatePosition(&utf8_encoding.enc, ptr, end, pos);
|
||||
}
|
||||
|
||||
static int
|
||||
toAscii(const ENCODING *enc, const char *ptr, const char *end)
|
||||
{
|
||||
char buf[1];
|
||||
char *p = buf;
|
||||
XmlUtf8Convert(enc, &ptr, end, &p, p + 1);
|
||||
if (p == buf)
|
||||
return -1;
|
||||
else
|
||||
return buf[0];
|
||||
}
|
||||
|
||||
static int FASTCALL
|
||||
isSpace(int c)
|
||||
{
|
||||
switch (c) {
|
||||
case 0x20:
|
||||
case 0xD:
|
||||
case 0xA:
|
||||
case 0x9:
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Return 1 if there's just optional white space or there's an S
|
||||
followed by name=val.
|
||||
*/
|
||||
static int
|
||||
parsePseudoAttribute(const ENCODING *enc,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const char **namePtr,
|
||||
const char **nameEndPtr,
|
||||
const char **valPtr,
|
||||
const char **nextTokPtr)
|
||||
{
|
||||
int c;
|
||||
char open;
|
||||
if (ptr == end) {
|
||||
*namePtr = NULL;
|
||||
return 1;
|
||||
}
|
||||
if (!isSpace(toAscii(enc, ptr, end))) {
|
||||
*nextTokPtr = ptr;
|
||||
return 0;
|
||||
}
|
||||
do {
|
||||
ptr += enc->minBytesPerChar;
|
||||
} while (isSpace(toAscii(enc, ptr, end)));
|
||||
if (ptr == end) {
|
||||
*namePtr = NULL;
|
||||
return 1;
|
||||
}
|
||||
*namePtr = ptr;
|
||||
for (;;) {
|
||||
c = toAscii(enc, ptr, end);
|
||||
if (c == -1) {
|
||||
*nextTokPtr = ptr;
|
||||
return 0;
|
||||
}
|
||||
if (c == ASCII_EQUALS) {
|
||||
*nameEndPtr = ptr;
|
||||
break;
|
||||
}
|
||||
if (isSpace(c)) {
|
||||
*nameEndPtr = ptr;
|
||||
do {
|
||||
ptr += enc->minBytesPerChar;
|
||||
} while (isSpace(c = toAscii(enc, ptr, end)));
|
||||
if (c != ASCII_EQUALS) {
|
||||
*nextTokPtr = ptr;
|
||||
return 0;
|
||||
}
|
||||
break;
|
||||
}
|
||||
ptr += enc->minBytesPerChar;
|
||||
}
|
||||
if (ptr == *namePtr) {
|
||||
*nextTokPtr = ptr;
|
||||
return 0;
|
||||
}
|
||||
ptr += enc->minBytesPerChar;
|
||||
c = toAscii(enc, ptr, end);
|
||||
while (isSpace(c)) {
|
||||
ptr += enc->minBytesPerChar;
|
||||
c = toAscii(enc, ptr, end);
|
||||
}
|
||||
if (c != ASCII_QUOT && c != ASCII_APOS) {
|
||||
*nextTokPtr = ptr;
|
||||
return 0;
|
||||
}
|
||||
open = (char)c;
|
||||
ptr += enc->minBytesPerChar;
|
||||
*valPtr = ptr;
|
||||
for (;; ptr += enc->minBytesPerChar) {
|
||||
c = toAscii(enc, ptr, end);
|
||||
if (c == open)
|
||||
break;
|
||||
if (!(ASCII_a <= c && c <= ASCII_z)
|
||||
&& !(ASCII_A <= c && c <= ASCII_Z)
|
||||
&& !(ASCII_0 <= c && c <= ASCII_9)
|
||||
&& c != ASCII_PERIOD
|
||||
&& c != ASCII_MINUS
|
||||
&& c != ASCII_UNDERSCORE) {
|
||||
*nextTokPtr = ptr;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
*nextTokPtr = ptr + enc->minBytesPerChar;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static const char KW_version[] = {
|
||||
ASCII_v, ASCII_e, ASCII_r, ASCII_s, ASCII_i, ASCII_o, ASCII_n, '\0'
|
||||
};
|
||||
|
||||
static const char KW_encoding[] = {
|
||||
ASCII_e, ASCII_n, ASCII_c, ASCII_o, ASCII_d, ASCII_i, ASCII_n, ASCII_g, '\0'
|
||||
};
|
||||
|
||||
static const char KW_standalone[] = {
|
||||
ASCII_s, ASCII_t, ASCII_a, ASCII_n, ASCII_d, ASCII_a, ASCII_l, ASCII_o,
|
||||
ASCII_n, ASCII_e, '\0'
|
||||
};
|
||||
|
||||
static const char KW_yes[] = {
|
||||
ASCII_y, ASCII_e, ASCII_s, '\0'
|
||||
};
|
||||
|
||||
static const char KW_no[] = {
|
||||
ASCII_n, ASCII_o, '\0'
|
||||
};
|
||||
|
||||
static int
|
||||
doParseXmlDecl(const ENCODING *(*encodingFinder)(const ENCODING *,
|
||||
const char *,
|
||||
const char *),
|
||||
int isGeneralTextEntity,
|
||||
const ENCODING *enc,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const char **badPtr,
|
||||
const char **versionPtr,
|
||||
const char **versionEndPtr,
|
||||
const char **encodingName,
|
||||
const ENCODING **encoding,
|
||||
int *standalone)
|
||||
{
|
||||
const char *val = NULL;
|
||||
const char *name = NULL;
|
||||
const char *nameEnd = NULL;
|
||||
ptr += 5 * enc->minBytesPerChar;
|
||||
end -= 2 * enc->minBytesPerChar;
|
||||
if (!parsePseudoAttribute(enc, ptr, end, &name, &nameEnd, &val, &ptr)
|
||||
|| !name) {
|
||||
*badPtr = ptr;
|
||||
return 0;
|
||||
}
|
||||
if (!XmlNameMatchesAscii(enc, name, nameEnd, KW_version)) {
|
||||
if (!isGeneralTextEntity) {
|
||||
*badPtr = name;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (versionPtr)
|
||||
*versionPtr = val;
|
||||
if (versionEndPtr)
|
||||
*versionEndPtr = ptr;
|
||||
if (!parsePseudoAttribute(enc, ptr, end, &name, &nameEnd, &val, &ptr)) {
|
||||
*badPtr = ptr;
|
||||
return 0;
|
||||
}
|
||||
if (!name) {
|
||||
if (isGeneralTextEntity) {
|
||||
/* a TextDecl must have an EncodingDecl */
|
||||
*badPtr = ptr;
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
if (XmlNameMatchesAscii(enc, name, nameEnd, KW_encoding)) {
|
||||
int c = toAscii(enc, val, end);
|
||||
if (!(ASCII_a <= c && c <= ASCII_z) && !(ASCII_A <= c && c <= ASCII_Z)) {
|
||||
*badPtr = val;
|
||||
return 0;
|
||||
}
|
||||
if (encodingName)
|
||||
*encodingName = val;
|
||||
if (encoding)
|
||||
*encoding = encodingFinder(enc, val, ptr - enc->minBytesPerChar);
|
||||
if (!parsePseudoAttribute(enc, ptr, end, &name, &nameEnd, &val, &ptr)) {
|
||||
*badPtr = ptr;
|
||||
return 0;
|
||||
}
|
||||
if (!name)
|
||||
return 1;
|
||||
}
|
||||
if (!XmlNameMatchesAscii(enc, name, nameEnd, KW_standalone)
|
||||
|| isGeneralTextEntity) {
|
||||
*badPtr = name;
|
||||
return 0;
|
||||
}
|
||||
if (XmlNameMatchesAscii(enc, val, ptr - enc->minBytesPerChar, KW_yes)) {
|
||||
if (standalone)
|
||||
*standalone = 1;
|
||||
}
|
||||
else if (XmlNameMatchesAscii(enc, val, ptr - enc->minBytesPerChar, KW_no)) {
|
||||
if (standalone)
|
||||
*standalone = 0;
|
||||
}
|
||||
else {
|
||||
*badPtr = val;
|
||||
return 0;
|
||||
}
|
||||
while (isSpace(toAscii(enc, ptr, end)))
|
||||
ptr += enc->minBytesPerChar;
|
||||
if (ptr != end) {
|
||||
*badPtr = ptr;
|
||||
return 0;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int FASTCALL
|
||||
checkCharRefNumber(int result)
|
||||
{
|
||||
switch (result >> 8) {
|
||||
case 0xD8: case 0xD9: case 0xDA: case 0xDB:
|
||||
case 0xDC: case 0xDD: case 0xDE: case 0xDF:
|
||||
return -1;
|
||||
case 0:
|
||||
if (latin1_encoding.type[result] == BT_NONXML)
|
||||
return -1;
|
||||
break;
|
||||
case 0xFF:
|
||||
if (result == 0xFFFE || result == 0xFFFF)
|
||||
return -1;
|
||||
break;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
int FASTCALL
|
||||
XmlUtf8Encode(int c, char *buf)
|
||||
{
|
||||
enum {
|
||||
/* minN is minimum legal resulting value for N byte sequence */
|
||||
min2 = 0x80,
|
||||
min3 = 0x800,
|
||||
min4 = 0x10000
|
||||
};
|
||||
|
||||
if (c < 0)
|
||||
return 0;
|
||||
if (c < min2) {
|
||||
buf[0] = (char)(c | UTF8_cval1);
|
||||
return 1;
|
||||
}
|
||||
if (c < min3) {
|
||||
buf[0] = (char)((c >> 6) | UTF8_cval2);
|
||||
buf[1] = (char)((c & 0x3f) | 0x80);
|
||||
return 2;
|
||||
}
|
||||
if (c < min4) {
|
||||
buf[0] = (char)((c >> 12) | UTF8_cval3);
|
||||
buf[1] = (char)(((c >> 6) & 0x3f) | 0x80);
|
||||
buf[2] = (char)((c & 0x3f) | 0x80);
|
||||
return 3;
|
||||
}
|
||||
if (c < 0x110000) {
|
||||
buf[0] = (char)((c >> 18) | UTF8_cval4);
|
||||
buf[1] = (char)(((c >> 12) & 0x3f) | 0x80);
|
||||
buf[2] = (char)(((c >> 6) & 0x3f) | 0x80);
|
||||
buf[3] = (char)((c & 0x3f) | 0x80);
|
||||
return 4;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int FASTCALL
|
||||
XmlUtf16Encode(int charNum, unsigned short *buf)
|
||||
{
|
||||
if (charNum < 0)
|
||||
return 0;
|
||||
if (charNum < 0x10000) {
|
||||
buf[0] = (unsigned short)charNum;
|
||||
return 1;
|
||||
}
|
||||
if (charNum < 0x110000) {
|
||||
charNum -= 0x10000;
|
||||
buf[0] = (unsigned short)((charNum >> 10) + 0xD800);
|
||||
buf[1] = (unsigned short)((charNum & 0x3FF) + 0xDC00);
|
||||
return 2;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
struct unknown_encoding {
|
||||
struct normal_encoding normal;
|
||||
CONVERTER convert;
|
||||
void *userData;
|
||||
unsigned short utf16[256];
|
||||
char utf8[256][4];
|
||||
};
|
||||
|
||||
#define AS_UNKNOWN_ENCODING(enc) ((const struct unknown_encoding *) (enc))
|
||||
|
||||
int
|
||||
XmlSizeOfUnknownEncoding(void)
|
||||
{
|
||||
return sizeof(struct unknown_encoding);
|
||||
}
|
||||
|
||||
static int PTRFASTCALL
|
||||
unknown_isName(const ENCODING *enc, const char *p)
|
||||
{
|
||||
const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
|
||||
int c = uenc->convert(uenc->userData, p);
|
||||
if (c & ~0xFFFF)
|
||||
return 0;
|
||||
return UCS2_GET_NAMING(namePages, c >> 8, c & 0xFF);
|
||||
}
|
||||
|
||||
static int PTRFASTCALL
|
||||
unknown_isNmstrt(const ENCODING *enc, const char *p)
|
||||
{
|
||||
const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
|
||||
int c = uenc->convert(uenc->userData, p);
|
||||
if (c & ~0xFFFF)
|
||||
return 0;
|
||||
return UCS2_GET_NAMING(nmstrtPages, c >> 8, c & 0xFF);
|
||||
}
|
||||
|
||||
static int PTRFASTCALL
|
||||
unknown_isInvalid(const ENCODING *enc, const char *p)
|
||||
{
|
||||
const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
|
||||
int c = uenc->convert(uenc->userData, p);
|
||||
return (c & ~0xFFFF) || checkCharRefNumber(c) < 0;
|
||||
}
|
||||
|
||||
static void PTRCALL
|
||||
unknown_toUtf8(const ENCODING *enc,
|
||||
const char **fromP, const char *fromLim,
|
||||
char **toP, const char *toLim)
|
||||
{
|
||||
const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
|
||||
char buf[XML_UTF8_ENCODE_MAX];
|
||||
for (;;) {
|
||||
const char *utf8;
|
||||
int n;
|
||||
if (*fromP == fromLim)
|
||||
break;
|
||||
utf8 = uenc->utf8[(unsigned char)**fromP];
|
||||
n = *utf8++;
|
||||
if (n == 0) {
|
||||
int c = uenc->convert(uenc->userData, *fromP);
|
||||
n = XmlUtf8Encode(c, buf);
|
||||
if (n > toLim - *toP)
|
||||
break;
|
||||
utf8 = buf;
|
||||
*fromP += (AS_NORMAL_ENCODING(enc)->type[(unsigned char)**fromP]
|
||||
- (BT_LEAD2 - 2));
|
||||
}
|
||||
else {
|
||||
if (n > toLim - *toP)
|
||||
break;
|
||||
(*fromP)++;
|
||||
}
|
||||
do {
|
||||
*(*toP)++ = *utf8++;
|
||||
} while (--n != 0);
|
||||
}
|
||||
}
|
||||
|
||||
static void PTRCALL
|
||||
unknown_toUtf16(const ENCODING *enc,
|
||||
const char **fromP, const char *fromLim,
|
||||
unsigned short **toP, const unsigned short *toLim)
|
||||
{
|
||||
const struct unknown_encoding *uenc = AS_UNKNOWN_ENCODING(enc);
|
||||
while (*fromP != fromLim && *toP != toLim) {
|
||||
unsigned short c = uenc->utf16[(unsigned char)**fromP];
|
||||
if (c == 0) {
|
||||
c = (unsigned short)
|
||||
uenc->convert(uenc->userData, *fromP);
|
||||
*fromP += (AS_NORMAL_ENCODING(enc)->type[(unsigned char)**fromP]
|
||||
- (BT_LEAD2 - 2));
|
||||
}
|
||||
else
|
||||
(*fromP)++;
|
||||
*(*toP)++ = c;
|
||||
}
|
||||
}
|
||||
|
||||
ENCODING *
|
||||
XmlInitUnknownEncoding(void *mem,
|
||||
int *table,
|
||||
CONVERTER convert,
|
||||
void *userData)
|
||||
{
|
||||
int i;
|
||||
struct unknown_encoding *e = (struct unknown_encoding *)mem;
|
||||
for (i = 0; i < (int)sizeof(struct normal_encoding); i++)
|
||||
((char *)mem)[i] = ((char *)&latin1_encoding)[i];
|
||||
for (i = 0; i < 128; i++)
|
||||
if (latin1_encoding.type[i] != BT_OTHER
|
||||
&& latin1_encoding.type[i] != BT_NONXML
|
||||
&& table[i] != i)
|
||||
return 0;
|
||||
for (i = 0; i < 256; i++) {
|
||||
int c = table[i];
|
||||
if (c == -1) {
|
||||
e->normal.type[i] = BT_MALFORM;
|
||||
/* This shouldn't really get used. */
|
||||
e->utf16[i] = 0xFFFF;
|
||||
e->utf8[i][0] = 1;
|
||||
e->utf8[i][1] = 0;
|
||||
}
|
||||
else if (c < 0) {
|
||||
if (c < -4)
|
||||
return 0;
|
||||
e->normal.type[i] = (unsigned char)(BT_LEAD2 - (c + 2));
|
||||
e->utf8[i][0] = 0;
|
||||
e->utf16[i] = 0;
|
||||
}
|
||||
else if (c < 0x80) {
|
||||
if (latin1_encoding.type[c] != BT_OTHER
|
||||
&& latin1_encoding.type[c] != BT_NONXML
|
||||
&& c != i)
|
||||
return 0;
|
||||
e->normal.type[i] = latin1_encoding.type[c];
|
||||
e->utf8[i][0] = 1;
|
||||
e->utf8[i][1] = (char)c;
|
||||
e->utf16[i] = (unsigned short)(c == 0 ? 0xFFFF : c);
|
||||
}
|
||||
else if (checkCharRefNumber(c) < 0) {
|
||||
e->normal.type[i] = BT_NONXML;
|
||||
/* This shouldn't really get used. */
|
||||
e->utf16[i] = 0xFFFF;
|
||||
e->utf8[i][0] = 1;
|
||||
e->utf8[i][1] = 0;
|
||||
}
|
||||
else {
|
||||
if (c > 0xFFFF)
|
||||
return 0;
|
||||
if (UCS2_GET_NAMING(nmstrtPages, c >> 8, c & 0xff))
|
||||
e->normal.type[i] = BT_NMSTRT;
|
||||
else if (UCS2_GET_NAMING(namePages, c >> 8, c & 0xff))
|
||||
e->normal.type[i] = BT_NAME;
|
||||
else
|
||||
e->normal.type[i] = BT_OTHER;
|
||||
e->utf8[i][0] = (char)XmlUtf8Encode(c, e->utf8[i] + 1);
|
||||
e->utf16[i] = (unsigned short)c;
|
||||
}
|
||||
}
|
||||
e->userData = userData;
|
||||
e->convert = convert;
|
||||
if (convert) {
|
||||
e->normal.isName2 = unknown_isName;
|
||||
e->normal.isName3 = unknown_isName;
|
||||
e->normal.isName4 = unknown_isName;
|
||||
e->normal.isNmstrt2 = unknown_isNmstrt;
|
||||
e->normal.isNmstrt3 = unknown_isNmstrt;
|
||||
e->normal.isNmstrt4 = unknown_isNmstrt;
|
||||
e->normal.isInvalid2 = unknown_isInvalid;
|
||||
e->normal.isInvalid3 = unknown_isInvalid;
|
||||
e->normal.isInvalid4 = unknown_isInvalid;
|
||||
}
|
||||
e->normal.enc.utf8Convert = unknown_toUtf8;
|
||||
e->normal.enc.utf16Convert = unknown_toUtf16;
|
||||
return &(e->normal.enc);
|
||||
}
|
||||
|
||||
/* If this enumeration is changed, getEncodingIndex and encodings
|
||||
must also be changed. */
|
||||
enum {
|
||||
UNKNOWN_ENC = -1,
|
||||
ISO_8859_1_ENC = 0,
|
||||
US_ASCII_ENC,
|
||||
UTF_8_ENC,
|
||||
UTF_16_ENC,
|
||||
UTF_16BE_ENC,
|
||||
UTF_16LE_ENC,
|
||||
/* must match encodingNames up to here */
|
||||
NO_ENC
|
||||
};
|
||||
|
||||
static const char KW_ISO_8859_1[] = {
|
||||
ASCII_I, ASCII_S, ASCII_O, ASCII_MINUS, ASCII_8, ASCII_8, ASCII_5, ASCII_9,
|
||||
ASCII_MINUS, ASCII_1, '\0'
|
||||
};
|
||||
static const char KW_US_ASCII[] = {
|
||||
ASCII_U, ASCII_S, ASCII_MINUS, ASCII_A, ASCII_S, ASCII_C, ASCII_I, ASCII_I,
|
||||
'\0'
|
||||
};
|
||||
static const char KW_UTF_8[] = {
|
||||
ASCII_U, ASCII_T, ASCII_F, ASCII_MINUS, ASCII_8, '\0'
|
||||
};
|
||||
static const char KW_UTF_16[] = {
|
||||
ASCII_U, ASCII_T, ASCII_F, ASCII_MINUS, ASCII_1, ASCII_6, '\0'
|
||||
};
|
||||
static const char KW_UTF_16BE[] = {
|
||||
ASCII_U, ASCII_T, ASCII_F, ASCII_MINUS, ASCII_1, ASCII_6, ASCII_B, ASCII_E,
|
||||
'\0'
|
||||
};
|
||||
static const char KW_UTF_16LE[] = {
|
||||
ASCII_U, ASCII_T, ASCII_F, ASCII_MINUS, ASCII_1, ASCII_6, ASCII_L, ASCII_E,
|
||||
'\0'
|
||||
};
|
||||
|
||||
static int FASTCALL
|
||||
getEncodingIndex(const char *name)
|
||||
{
|
||||
static const char * const encodingNames[] = {
|
||||
KW_ISO_8859_1,
|
||||
KW_US_ASCII,
|
||||
KW_UTF_8,
|
||||
KW_UTF_16,
|
||||
KW_UTF_16BE,
|
||||
KW_UTF_16LE,
|
||||
};
|
||||
int i;
|
||||
if (name == NULL)
|
||||
return NO_ENC;
|
||||
for (i = 0; i < (int)(sizeof(encodingNames)/sizeof(encodingNames[0])); i++)
|
||||
if (streqci(name, encodingNames[i]))
|
||||
return i;
|
||||
return UNKNOWN_ENC;
|
||||
}
|
||||
|
||||
/* For binary compatibility, we store the index of the encoding
|
||||
specified at initialization in the isUtf16 member.
|
||||
*/
|
||||
|
||||
#define INIT_ENC_INDEX(enc) ((int)(enc)->initEnc.isUtf16)
|
||||
#define SET_INIT_ENC_INDEX(enc, i) ((enc)->initEnc.isUtf16 = (char)i)
|
||||
|
||||
/* This is what detects the encoding. encodingTable maps from
|
||||
encoding indices to encodings; INIT_ENC_INDEX(enc) is the index of
|
||||
the external (protocol) specified encoding; state is
|
||||
XML_CONTENT_STATE if we're parsing an external text entity, and
|
||||
XML_PROLOG_STATE otherwise.
|
||||
*/
|
||||
|
||||
|
||||
static int
|
||||
initScan(const ENCODING * const *encodingTable,
|
||||
const INIT_ENCODING *enc,
|
||||
int state,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const char **nextTokPtr)
|
||||
{
|
||||
const ENCODING **encPtr;
|
||||
|
||||
if (ptr == end)
|
||||
return XML_TOK_NONE;
|
||||
encPtr = enc->encPtr;
|
||||
if (ptr + 1 == end) {
|
||||
/* only a single byte available for auto-detection */
|
||||
#ifndef XML_DTD /* FIXME */
|
||||
/* a well-formed document entity must have more than one byte */
|
||||
if (state != XML_CONTENT_STATE)
|
||||
return XML_TOK_PARTIAL;
|
||||
#endif
|
||||
/* so we're parsing an external text entity... */
|
||||
/* if UTF-16 was externally specified, then we need at least 2 bytes */
|
||||
switch (INIT_ENC_INDEX(enc)) {
|
||||
case UTF_16_ENC:
|
||||
case UTF_16LE_ENC:
|
||||
case UTF_16BE_ENC:
|
||||
return XML_TOK_PARTIAL;
|
||||
}
|
||||
switch ((unsigned char)*ptr) {
|
||||
case 0xFE:
|
||||
case 0xFF:
|
||||
case 0xEF: /* possibly first byte of UTF-8 BOM */
|
||||
if (INIT_ENC_INDEX(enc) == ISO_8859_1_ENC
|
||||
&& state == XML_CONTENT_STATE)
|
||||
break;
|
||||
/* fall through */
|
||||
case 0x00:
|
||||
case 0x3C:
|
||||
return XML_TOK_PARTIAL;
|
||||
}
|
||||
}
|
||||
else {
|
||||
switch (((unsigned char)ptr[0] << 8) | (unsigned char)ptr[1]) {
|
||||
case 0xFEFF:
|
||||
if (INIT_ENC_INDEX(enc) == ISO_8859_1_ENC
|
||||
&& state == XML_CONTENT_STATE)
|
||||
break;
|
||||
*nextTokPtr = ptr + 2;
|
||||
*encPtr = encodingTable[UTF_16BE_ENC];
|
||||
return XML_TOK_BOM;
|
||||
/* 00 3C is handled in the default case */
|
||||
case 0x3C00:
|
||||
if ((INIT_ENC_INDEX(enc) == UTF_16BE_ENC
|
||||
|| INIT_ENC_INDEX(enc) == UTF_16_ENC)
|
||||
&& state == XML_CONTENT_STATE)
|
||||
break;
|
||||
*encPtr = encodingTable[UTF_16LE_ENC];
|
||||
return XmlTok(*encPtr, state, ptr, end, nextTokPtr);
|
||||
case 0xFFFE:
|
||||
if (INIT_ENC_INDEX(enc) == ISO_8859_1_ENC
|
||||
&& state == XML_CONTENT_STATE)
|
||||
break;
|
||||
*nextTokPtr = ptr + 2;
|
||||
*encPtr = encodingTable[UTF_16LE_ENC];
|
||||
return XML_TOK_BOM;
|
||||
case 0xEFBB:
|
||||
/* Maybe a UTF-8 BOM (EF BB BF) */
|
||||
/* If there's an explicitly specified (external) encoding
|
||||
of ISO-8859-1 or some flavour of UTF-16
|
||||
and this is an external text entity,
|
||||
don't look for the BOM,
|
||||
because it might be a legal data.
|
||||
*/
|
||||
if (state == XML_CONTENT_STATE) {
|
||||
int e = INIT_ENC_INDEX(enc);
|
||||
if (e == ISO_8859_1_ENC || e == UTF_16BE_ENC
|
||||
|| e == UTF_16LE_ENC || e == UTF_16_ENC)
|
||||
break;
|
||||
}
|
||||
if (ptr + 2 == end)
|
||||
return XML_TOK_PARTIAL;
|
||||
if ((unsigned char)ptr[2] == 0xBF) {
|
||||
*nextTokPtr = ptr + 3;
|
||||
*encPtr = encodingTable[UTF_8_ENC];
|
||||
return XML_TOK_BOM;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
if (ptr[0] == '\0') {
|
||||
/* 0 isn't a legal data character. Furthermore a document
|
||||
entity can only start with ASCII characters. So the only
|
||||
way this can fail to be big-endian UTF-16 if it it's an
|
||||
external parsed general entity that's labelled as
|
||||
UTF-16LE.
|
||||
*/
|
||||
if (state == XML_CONTENT_STATE && INIT_ENC_INDEX(enc) == UTF_16LE_ENC)
|
||||
break;
|
||||
*encPtr = encodingTable[UTF_16BE_ENC];
|
||||
return XmlTok(*encPtr, state, ptr, end, nextTokPtr);
|
||||
}
|
||||
else if (ptr[1] == '\0') {
|
||||
/* We could recover here in the case:
|
||||
- parsing an external entity
|
||||
- second byte is 0
|
||||
- no externally specified encoding
|
||||
- no encoding declaration
|
||||
by assuming UTF-16LE. But we don't, because this would mean when
|
||||
presented just with a single byte, we couldn't reliably determine
|
||||
whether we needed further bytes.
|
||||
*/
|
||||
if (state == XML_CONTENT_STATE)
|
||||
break;
|
||||
*encPtr = encodingTable[UTF_16LE_ENC];
|
||||
return XmlTok(*encPtr, state, ptr, end, nextTokPtr);
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
*encPtr = encodingTable[INIT_ENC_INDEX(enc)];
|
||||
return XmlTok(*encPtr, state, ptr, end, nextTokPtr);
|
||||
}
|
||||
|
||||
|
||||
#define NS(x) x
|
||||
#define ns(x) x
|
||||
#define XML_TOK_NS_C
|
||||
#include "xmltok_ns.c"
|
||||
#undef XML_TOK_NS_C
|
||||
#undef NS
|
||||
#undef ns
|
||||
|
||||
#ifdef XML_NS
|
||||
|
||||
#define NS(x) x ## NS
|
||||
#define ns(x) x ## _ns
|
||||
|
||||
#define XML_TOK_NS_C
|
||||
#include "xmltok_ns.c"
|
||||
#undef XML_TOK_NS_C
|
||||
|
||||
#undef NS
|
||||
#undef ns
|
||||
|
||||
ENCODING *
|
||||
XmlInitUnknownEncodingNS(void *mem,
|
||||
int *table,
|
||||
CONVERTER convert,
|
||||
void *userData)
|
||||
{
|
||||
ENCODING *enc = XmlInitUnknownEncoding(mem, table, convert, userData);
|
||||
if (enc)
|
||||
((struct normal_encoding *)enc)->type[ASCII_COLON] = BT_COLON;
|
||||
return enc;
|
||||
}
|
||||
|
||||
#endif /* XML_NS */
|
||||
@@ -0,0 +1,316 @@
|
||||
/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
|
||||
See the file COPYING for copying permission.
|
||||
*/
|
||||
|
||||
#ifndef XmlTok_INCLUDED
|
||||
#define XmlTok_INCLUDED 1
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* The following token may be returned by XmlContentTok */
|
||||
#define XML_TOK_TRAILING_RSQB -5 /* ] or ]] at the end of the scan; might be
|
||||
start of illegal ]]> sequence */
|
||||
/* The following tokens may be returned by both XmlPrologTok and
|
||||
XmlContentTok.
|
||||
*/
|
||||
#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;
|
||||
might be part of CRLF 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_INVALID 0
|
||||
|
||||
/* The following tokens are returned by XmlContentTok; some are also
|
||||
returned by XmlAttributeValueTok, XmlEntityTok, XmlCdataSectionTok.
|
||||
*/
|
||||
#define XML_TOK_START_TAG_WITH_ATTS 1
|
||||
#define XML_TOK_START_TAG_NO_ATTS 2
|
||||
#define XML_TOK_EMPTY_ELEMENT_WITH_ATTS 3 /* empty element tag <e/> */
|
||||
#define XML_TOK_EMPTY_ELEMENT_NO_ATTS 4
|
||||
#define XML_TOK_END_TAG 5
|
||||
#define XML_TOK_DATA_CHARS 6
|
||||
#define XML_TOK_DATA_NEWLINE 7
|
||||
#define XML_TOK_CDATA_SECT_OPEN 8
|
||||
#define XML_TOK_ENTITY_REF 9
|
||||
#define XML_TOK_CHAR_REF 10 /* numeric character reference */
|
||||
|
||||
/* The following tokens may be returned by both XmlPrologTok and
|
||||
XmlContentTok.
|
||||
*/
|
||||
#define XML_TOK_PI 11 /* processing instruction */
|
||||
#define XML_TOK_XML_DECL 12 /* XML decl or text decl */
|
||||
#define XML_TOK_COMMENT 13
|
||||
#define XML_TOK_BOM 14 /* Byte order mark */
|
||||
|
||||
/* The following tokens are returned only by XmlPrologTok */
|
||||
#define XML_TOK_PROLOG_S 15
|
||||
#define XML_TOK_DECL_OPEN 16 /* <!foo */
|
||||
#define XML_TOK_DECL_CLOSE 17 /* > */
|
||||
#define XML_TOK_NAME 18
|
||||
#define XML_TOK_NMTOKEN 19
|
||||
#define XML_TOK_POUND_NAME 20 /* #name */
|
||||
#define XML_TOK_OR 21 /* | */
|
||||
#define XML_TOK_PERCENT 22
|
||||
#define XML_TOK_OPEN_PAREN 23
|
||||
#define XML_TOK_CLOSE_PAREN 24
|
||||
#define XML_TOK_OPEN_BRACKET 25
|
||||
#define XML_TOK_CLOSE_BRACKET 26
|
||||
#define XML_TOK_LITERAL 27
|
||||
#define XML_TOK_PARAM_ENTITY_REF 28
|
||||
#define XML_TOK_INSTANCE_START 29
|
||||
|
||||
/* The following occur only in element type declarations */
|
||||
#define XML_TOK_NAME_QUESTION 30 /* name? */
|
||||
#define XML_TOK_NAME_ASTERISK 31 /* name* */
|
||||
#define XML_TOK_NAME_PLUS 32 /* name+ */
|
||||
#define XML_TOK_COND_SECT_OPEN 33 /* <![ */
|
||||
#define XML_TOK_COND_SECT_CLOSE 34 /* ]]> */
|
||||
#define XML_TOK_CLOSE_PAREN_QUESTION 35 /* )? */
|
||||
#define XML_TOK_CLOSE_PAREN_ASTERISK 36 /* )* */
|
||||
#define XML_TOK_CLOSE_PAREN_PLUS 37 /* )+ */
|
||||
#define XML_TOK_COMMA 38
|
||||
|
||||
/* The following token is returned only by XmlAttributeValueTok */
|
||||
#define XML_TOK_ATTRIBUTE_VALUE_S 39
|
||||
|
||||
/* The following token is returned only by XmlCdataSectionTok */
|
||||
#define XML_TOK_CDATA_SECT_CLOSE 40
|
||||
|
||||
/* With namespace processing this is returned by XmlPrologTok for a
|
||||
name with a colon.
|
||||
*/
|
||||
#define XML_TOK_PREFIXED_NAME 41
|
||||
|
||||
#ifdef XML_DTD
|
||||
#define XML_TOK_IGNORE_SECT 42
|
||||
#endif /* XML_DTD */
|
||||
|
||||
#ifdef XML_DTD
|
||||
#define XML_N_STATES 4
|
||||
#else /* not XML_DTD */
|
||||
#define XML_N_STATES 3
|
||||
#endif /* not XML_DTD */
|
||||
|
||||
#define XML_PROLOG_STATE 0
|
||||
#define XML_CONTENT_STATE 1
|
||||
#define XML_CDATA_SECTION_STATE 2
|
||||
#ifdef XML_DTD
|
||||
#define XML_IGNORE_SECTION_STATE 3
|
||||
#endif /* XML_DTD */
|
||||
|
||||
#define XML_N_LITERAL_TYPES 2
|
||||
#define XML_ATTRIBUTE_VALUE_LITERAL 0
|
||||
#define XML_ENTITY_VALUE_LITERAL 1
|
||||
|
||||
/* The size of the buffer passed to XmlUtf8Encode must be at least this. */
|
||||
#define XML_UTF8_ENCODE_MAX 4
|
||||
/* The size of the buffer passed to XmlUtf16Encode must be at least this. */
|
||||
#define XML_UTF16_ENCODE_MAX 2
|
||||
|
||||
typedef struct position {
|
||||
/* first line and first column are 0 not 1 */
|
||||
XML_Size lineNumber;
|
||||
XML_Size columnNumber;
|
||||
} POSITION;
|
||||
|
||||
typedef struct {
|
||||
const char *name;
|
||||
const char *valuePtr;
|
||||
const char *valueEnd;
|
||||
char normalized;
|
||||
} ATTRIBUTE;
|
||||
|
||||
struct encoding;
|
||||
typedef struct encoding ENCODING;
|
||||
|
||||
typedef int (PTRCALL *SCANNER)(const ENCODING *,
|
||||
const char *,
|
||||
const char *,
|
||||
const char **);
|
||||
|
||||
struct encoding {
|
||||
SCANNER scanners[XML_N_STATES];
|
||||
SCANNER literalScanners[XML_N_LITERAL_TYPES];
|
||||
int (PTRCALL *sameName)(const ENCODING *,
|
||||
const char *,
|
||||
const char *);
|
||||
int (PTRCALL *nameMatchesAscii)(const ENCODING *,
|
||||
const char *,
|
||||
const char *,
|
||||
const char *);
|
||||
int (PTRFASTCALL *nameLength)(const ENCODING *, const char *);
|
||||
const char *(PTRFASTCALL *skipS)(const ENCODING *, const char *);
|
||||
int (PTRCALL *getAtts)(const ENCODING *enc,
|
||||
const char *ptr,
|
||||
int attsMax,
|
||||
ATTRIBUTE *atts);
|
||||
int (PTRFASTCALL *charRefNumber)(const ENCODING *enc, const char *ptr);
|
||||
int (PTRCALL *predefinedEntityName)(const ENCODING *,
|
||||
const char *,
|
||||
const char *);
|
||||
void (PTRCALL *updatePosition)(const ENCODING *,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
POSITION *);
|
||||
int (PTRCALL *isPublicId)(const ENCODING *enc,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const char **badPtr);
|
||||
void (PTRCALL *utf8Convert)(const ENCODING *enc,
|
||||
const char **fromP,
|
||||
const char *fromLim,
|
||||
char **toP,
|
||||
const char *toLim);
|
||||
void (PTRCALL *utf16Convert)(const ENCODING *enc,
|
||||
const char **fromP,
|
||||
const char *fromLim,
|
||||
unsigned short **toP,
|
||||
const unsigned short *toLim);
|
||||
int minBytesPerChar;
|
||||
char isUtf8;
|
||||
char isUtf16;
|
||||
};
|
||||
|
||||
/* Scan the string starting at ptr until the end of the next complete
|
||||
token, but do not scan past eptr. Return an integer giving the
|
||||
type of token.
|
||||
|
||||
Return XML_TOK_NONE when ptr == eptr; nextTokPtr will not be set.
|
||||
|
||||
Return XML_TOK_PARTIAL when the string does not contain a complete
|
||||
token; nextTokPtr will not be set.
|
||||
|
||||
Return XML_TOK_INVALID when the string does not start a valid
|
||||
token; nextTokPtr will be set to point to the character which made
|
||||
the token invalid.
|
||||
|
||||
Otherwise the string starts with a valid token; nextTokPtr will be
|
||||
set to point to the character following the end of that token.
|
||||
|
||||
Each data character counts as a single token, but adjacent data
|
||||
characters may be returned together. Similarly for characters in
|
||||
the prolog outside literals, comments and processing instructions.
|
||||
*/
|
||||
|
||||
|
||||
#define XmlTok(enc, state, ptr, end, nextTokPtr) \
|
||||
(((enc)->scanners[state])(enc, ptr, end, nextTokPtr))
|
||||
|
||||
#define XmlPrologTok(enc, ptr, end, nextTokPtr) \
|
||||
XmlTok(enc, XML_PROLOG_STATE, ptr, end, nextTokPtr)
|
||||
|
||||
#define XmlContentTok(enc, ptr, end, nextTokPtr) \
|
||||
XmlTok(enc, XML_CONTENT_STATE, ptr, end, nextTokPtr)
|
||||
|
||||
#define XmlCdataSectionTok(enc, ptr, end, nextTokPtr) \
|
||||
XmlTok(enc, XML_CDATA_SECTION_STATE, ptr, end, nextTokPtr)
|
||||
|
||||
#ifdef XML_DTD
|
||||
|
||||
#define XmlIgnoreSectionTok(enc, ptr, end, nextTokPtr) \
|
||||
XmlTok(enc, XML_IGNORE_SECTION_STATE, ptr, end, nextTokPtr)
|
||||
|
||||
#endif /* XML_DTD */
|
||||
|
||||
/* This is used for performing a 2nd-level tokenization on the content
|
||||
of a literal that has already been returned by XmlTok.
|
||||
*/
|
||||
#define XmlLiteralTok(enc, literalType, ptr, end, nextTokPtr) \
|
||||
(((enc)->literalScanners[literalType])(enc, ptr, end, nextTokPtr))
|
||||
|
||||
#define XmlAttributeValueTok(enc, ptr, end, nextTokPtr) \
|
||||
XmlLiteralTok(enc, XML_ATTRIBUTE_VALUE_LITERAL, ptr, end, nextTokPtr)
|
||||
|
||||
#define XmlEntityValueTok(enc, ptr, end, nextTokPtr) \
|
||||
XmlLiteralTok(enc, XML_ENTITY_VALUE_LITERAL, ptr, end, nextTokPtr)
|
||||
|
||||
#define XmlSameName(enc, ptr1, ptr2) (((enc)->sameName)(enc, ptr1, ptr2))
|
||||
|
||||
#define XmlNameMatchesAscii(enc, ptr1, end1, ptr2) \
|
||||
(((enc)->nameMatchesAscii)(enc, ptr1, end1, ptr2))
|
||||
|
||||
#define XmlNameLength(enc, ptr) \
|
||||
(((enc)->nameLength)(enc, ptr))
|
||||
|
||||
#define XmlSkipS(enc, ptr) \
|
||||
(((enc)->skipS)(enc, ptr))
|
||||
|
||||
#define XmlGetAttributes(enc, ptr, attsMax, atts) \
|
||||
(((enc)->getAtts)(enc, ptr, attsMax, atts))
|
||||
|
||||
#define XmlCharRefNumber(enc, ptr) \
|
||||
(((enc)->charRefNumber)(enc, ptr))
|
||||
|
||||
#define XmlPredefinedEntityName(enc, ptr, end) \
|
||||
(((enc)->predefinedEntityName)(enc, ptr, end))
|
||||
|
||||
#define XmlUpdatePosition(enc, ptr, end, pos) \
|
||||
(((enc)->updatePosition)(enc, ptr, end, pos))
|
||||
|
||||
#define XmlIsPublicId(enc, ptr, end, badPtr) \
|
||||
(((enc)->isPublicId)(enc, ptr, end, badPtr))
|
||||
|
||||
#define XmlUtf8Convert(enc, fromP, fromLim, toP, toLim) \
|
||||
(((enc)->utf8Convert)(enc, fromP, fromLim, toP, toLim))
|
||||
|
||||
#define XmlUtf16Convert(enc, fromP, fromLim, toP, toLim) \
|
||||
(((enc)->utf16Convert)(enc, fromP, fromLim, toP, toLim))
|
||||
|
||||
typedef struct {
|
||||
ENCODING initEnc;
|
||||
const ENCODING **encPtr;
|
||||
} INIT_ENCODING;
|
||||
|
||||
int XmlParseXmlDecl(int isGeneralTextEntity,
|
||||
const ENCODING *enc,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const char **badPtr,
|
||||
const char **versionPtr,
|
||||
const char **versionEndPtr,
|
||||
const char **encodingNamePtr,
|
||||
const ENCODING **namedEncodingPtr,
|
||||
int *standalonePtr);
|
||||
|
||||
int XmlInitEncoding(INIT_ENCODING *, const ENCODING **, const char *name);
|
||||
const ENCODING *XmlGetUtf8InternalEncoding(void);
|
||||
const ENCODING *XmlGetUtf16InternalEncoding(void);
|
||||
int FASTCALL XmlUtf8Encode(int charNumber, char *buf);
|
||||
int FASTCALL XmlUtf16Encode(int charNumber, unsigned short *buf);
|
||||
int XmlSizeOfUnknownEncoding(void);
|
||||
|
||||
|
||||
typedef int (XMLCALL *CONVERTER) (void *userData, const char *p);
|
||||
|
||||
ENCODING *
|
||||
XmlInitUnknownEncoding(void *mem,
|
||||
int *table,
|
||||
CONVERTER convert,
|
||||
void *userData);
|
||||
|
||||
int XmlParseXmlDeclNS(int isGeneralTextEntity,
|
||||
const ENCODING *enc,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const char **badPtr,
|
||||
const char **versionPtr,
|
||||
const char **versionEndPtr,
|
||||
const char **encodingNamePtr,
|
||||
const ENCODING **namedEncodingPtr,
|
||||
int *standalonePtr);
|
||||
|
||||
int XmlInitEncodingNS(INIT_ENCODING *, const ENCODING **, const char *name);
|
||||
const ENCODING *XmlGetUtf8InternalEncodingNS(void);
|
||||
const ENCODING *XmlGetUtf16InternalEncodingNS(void);
|
||||
ENCODING *
|
||||
XmlInitUnknownEncodingNS(void *mem,
|
||||
int *table,
|
||||
CONVERTER convert,
|
||||
void *userData);
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* not XmlTok_INCLUDED */
|
||||
@@ -0,0 +1,1783 @@
|
||||
/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
|
||||
See the file COPYING for copying permission.
|
||||
*/
|
||||
|
||||
/* This file is included! */
|
||||
#ifdef XML_TOK_IMPL_C
|
||||
|
||||
#ifndef IS_INVALID_CHAR
|
||||
#define IS_INVALID_CHAR(enc, ptr, n) (0)
|
||||
#endif
|
||||
|
||||
#define INVALID_LEAD_CASE(n, ptr, nextTokPtr) \
|
||||
case BT_LEAD ## n: \
|
||||
if (end - ptr < n) \
|
||||
return XML_TOK_PARTIAL_CHAR; \
|
||||
if (IS_INVALID_CHAR(enc, ptr, n)) { \
|
||||
*(nextTokPtr) = (ptr); \
|
||||
return XML_TOK_INVALID; \
|
||||
} \
|
||||
ptr += n; \
|
||||
break;
|
||||
|
||||
#define INVALID_CASES(ptr, nextTokPtr) \
|
||||
INVALID_LEAD_CASE(2, ptr, nextTokPtr) \
|
||||
INVALID_LEAD_CASE(3, ptr, nextTokPtr) \
|
||||
INVALID_LEAD_CASE(4, ptr, nextTokPtr) \
|
||||
case BT_NONXML: \
|
||||
case BT_MALFORM: \
|
||||
case BT_TRAIL: \
|
||||
*(nextTokPtr) = (ptr); \
|
||||
return XML_TOK_INVALID;
|
||||
|
||||
#define CHECK_NAME_CASE(n, enc, ptr, end, nextTokPtr) \
|
||||
case BT_LEAD ## n: \
|
||||
if (end - ptr < n) \
|
||||
return XML_TOK_PARTIAL_CHAR; \
|
||||
if (!IS_NAME_CHAR(enc, ptr, n)) { \
|
||||
*nextTokPtr = ptr; \
|
||||
return XML_TOK_INVALID; \
|
||||
} \
|
||||
ptr += n; \
|
||||
break;
|
||||
|
||||
#define CHECK_NAME_CASES(enc, ptr, end, nextTokPtr) \
|
||||
case BT_NONASCII: \
|
||||
if (!IS_NAME_CHAR_MINBPC(enc, ptr)) { \
|
||||
*nextTokPtr = ptr; \
|
||||
return XML_TOK_INVALID; \
|
||||
} \
|
||||
case BT_NMSTRT: \
|
||||
case BT_HEX: \
|
||||
case BT_DIGIT: \
|
||||
case BT_NAME: \
|
||||
case BT_MINUS: \
|
||||
ptr += MINBPC(enc); \
|
||||
break; \
|
||||
CHECK_NAME_CASE(2, enc, ptr, end, nextTokPtr) \
|
||||
CHECK_NAME_CASE(3, enc, ptr, end, nextTokPtr) \
|
||||
CHECK_NAME_CASE(4, enc, ptr, end, nextTokPtr)
|
||||
|
||||
#define CHECK_NMSTRT_CASE(n, enc, ptr, end, nextTokPtr) \
|
||||
case BT_LEAD ## n: \
|
||||
if (end - ptr < n) \
|
||||
return XML_TOK_PARTIAL_CHAR; \
|
||||
if (!IS_NMSTRT_CHAR(enc, ptr, n)) { \
|
||||
*nextTokPtr = ptr; \
|
||||
return XML_TOK_INVALID; \
|
||||
} \
|
||||
ptr += n; \
|
||||
break;
|
||||
|
||||
#define CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr) \
|
||||
case BT_NONASCII: \
|
||||
if (!IS_NMSTRT_CHAR_MINBPC(enc, ptr)) { \
|
||||
*nextTokPtr = ptr; \
|
||||
return XML_TOK_INVALID; \
|
||||
} \
|
||||
case BT_NMSTRT: \
|
||||
case BT_HEX: \
|
||||
ptr += MINBPC(enc); \
|
||||
break; \
|
||||
CHECK_NMSTRT_CASE(2, enc, ptr, end, nextTokPtr) \
|
||||
CHECK_NMSTRT_CASE(3, enc, ptr, end, nextTokPtr) \
|
||||
CHECK_NMSTRT_CASE(4, enc, ptr, end, nextTokPtr)
|
||||
|
||||
#ifndef PREFIX
|
||||
#define PREFIX(ident) ident
|
||||
#endif
|
||||
|
||||
/* ptr points to character following "<!-" */
|
||||
|
||||
static int PTRCALL
|
||||
PREFIX(scanComment)(const ENCODING *enc, const char *ptr,
|
||||
const char *end, const char **nextTokPtr)
|
||||
{
|
||||
if (ptr != end) {
|
||||
if (!CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
ptr += MINBPC(enc);
|
||||
while (ptr != end) {
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
INVALID_CASES(ptr, nextTokPtr)
|
||||
case BT_MINUS:
|
||||
if ((ptr += MINBPC(enc)) == end)
|
||||
return XML_TOK_PARTIAL;
|
||||
if (CHAR_MATCHES(enc, ptr, ASCII_MINUS)) {
|
||||
if ((ptr += MINBPC(enc)) == end)
|
||||
return XML_TOK_PARTIAL;
|
||||
if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
*nextTokPtr = ptr + MINBPC(enc);
|
||||
return XML_TOK_COMMENT;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
ptr += MINBPC(enc);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return XML_TOK_PARTIAL;
|
||||
}
|
||||
|
||||
/* ptr points to character following "<!" */
|
||||
|
||||
static int PTRCALL
|
||||
PREFIX(scanDecl)(const ENCODING *enc, const char *ptr,
|
||||
const char *end, const char **nextTokPtr)
|
||||
{
|
||||
if (ptr == end)
|
||||
return XML_TOK_PARTIAL;
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
case BT_MINUS:
|
||||
return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr);
|
||||
case BT_LSQB:
|
||||
*nextTokPtr = ptr + MINBPC(enc);
|
||||
return XML_TOK_COND_SECT_OPEN;
|
||||
case BT_NMSTRT:
|
||||
case BT_HEX:
|
||||
ptr += MINBPC(enc);
|
||||
break;
|
||||
default:
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
while (ptr != end) {
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
case BT_PERCNT:
|
||||
if (ptr + MINBPC(enc) == end)
|
||||
return XML_TOK_PARTIAL;
|
||||
/* don't allow <!ENTITY% foo "whatever"> */
|
||||
switch (BYTE_TYPE(enc, ptr + MINBPC(enc))) {
|
||||
case BT_S: case BT_CR: case BT_LF: case BT_PERCNT:
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
/* fall through */
|
||||
case BT_S: case BT_CR: case BT_LF:
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_DECL_OPEN;
|
||||
case BT_NMSTRT:
|
||||
case BT_HEX:
|
||||
ptr += MINBPC(enc);
|
||||
break;
|
||||
default:
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
}
|
||||
return XML_TOK_PARTIAL;
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
PREFIX(checkPiTarget)(const ENCODING *enc, const char *ptr,
|
||||
const char *end, int *tokPtr)
|
||||
{
|
||||
int upper = 0;
|
||||
*tokPtr = XML_TOK_PI;
|
||||
if (end - ptr != MINBPC(enc)*3)
|
||||
return 1;
|
||||
switch (BYTE_TO_ASCII(enc, ptr)) {
|
||||
case ASCII_x:
|
||||
break;
|
||||
case ASCII_X:
|
||||
upper = 1;
|
||||
break;
|
||||
default:
|
||||
return 1;
|
||||
}
|
||||
ptr += MINBPC(enc);
|
||||
switch (BYTE_TO_ASCII(enc, ptr)) {
|
||||
case ASCII_m:
|
||||
break;
|
||||
case ASCII_M:
|
||||
upper = 1;
|
||||
break;
|
||||
default:
|
||||
return 1;
|
||||
}
|
||||
ptr += MINBPC(enc);
|
||||
switch (BYTE_TO_ASCII(enc, ptr)) {
|
||||
case ASCII_l:
|
||||
break;
|
||||
case ASCII_L:
|
||||
upper = 1;
|
||||
break;
|
||||
default:
|
||||
return 1;
|
||||
}
|
||||
if (upper)
|
||||
return 0;
|
||||
*tokPtr = XML_TOK_XML_DECL;
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* ptr points to character following "<?" */
|
||||
|
||||
static int PTRCALL
|
||||
PREFIX(scanPi)(const ENCODING *enc, const char *ptr,
|
||||
const char *end, const char **nextTokPtr)
|
||||
{
|
||||
int tok;
|
||||
const char *target = ptr;
|
||||
if (ptr == end)
|
||||
return XML_TOK_PARTIAL;
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
|
||||
default:
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
while (ptr != end) {
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
|
||||
case BT_S: case BT_CR: case BT_LF:
|
||||
if (!PREFIX(checkPiTarget)(enc, target, ptr, &tok)) {
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
ptr += MINBPC(enc);
|
||||
while (ptr != end) {
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
INVALID_CASES(ptr, nextTokPtr)
|
||||
case BT_QUEST:
|
||||
ptr += MINBPC(enc);
|
||||
if (ptr == end)
|
||||
return XML_TOK_PARTIAL;
|
||||
if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
|
||||
*nextTokPtr = ptr + MINBPC(enc);
|
||||
return tok;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
ptr += MINBPC(enc);
|
||||
break;
|
||||
}
|
||||
}
|
||||
return XML_TOK_PARTIAL;
|
||||
case BT_QUEST:
|
||||
if (!PREFIX(checkPiTarget)(enc, target, ptr, &tok)) {
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
ptr += MINBPC(enc);
|
||||
if (ptr == end)
|
||||
return XML_TOK_PARTIAL;
|
||||
if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
|
||||
*nextTokPtr = ptr + MINBPC(enc);
|
||||
return tok;
|
||||
}
|
||||
/* fall through */
|
||||
default:
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
}
|
||||
return XML_TOK_PARTIAL;
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
PREFIX(scanCdataSection)(const ENCODING *enc, const char *ptr,
|
||||
const char *end, const char **nextTokPtr)
|
||||
{
|
||||
static const char CDATA_LSQB[] = { ASCII_C, ASCII_D, ASCII_A,
|
||||
ASCII_T, ASCII_A, ASCII_LSQB };
|
||||
int i;
|
||||
/* CDATA[ */
|
||||
if (end - ptr < 6 * MINBPC(enc))
|
||||
return XML_TOK_PARTIAL;
|
||||
for (i = 0; i < 6; i++, ptr += MINBPC(enc)) {
|
||||
if (!CHAR_MATCHES(enc, ptr, CDATA_LSQB[i])) {
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
}
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_CDATA_SECT_OPEN;
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
PREFIX(cdataSectionTok)(const ENCODING *enc, const char *ptr,
|
||||
const char *end, const char **nextTokPtr)
|
||||
{
|
||||
if (ptr == end)
|
||||
return XML_TOK_NONE;
|
||||
if (MINBPC(enc) > 1) {
|
||||
size_t n = end - ptr;
|
||||
if (n & (MINBPC(enc) - 1)) {
|
||||
n &= ~(MINBPC(enc) - 1);
|
||||
if (n == 0)
|
||||
return XML_TOK_PARTIAL;
|
||||
end = ptr + n;
|
||||
}
|
||||
}
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
case BT_RSQB:
|
||||
ptr += MINBPC(enc);
|
||||
if (ptr == end)
|
||||
return XML_TOK_PARTIAL;
|
||||
if (!CHAR_MATCHES(enc, ptr, ASCII_RSQB))
|
||||
break;
|
||||
ptr += MINBPC(enc);
|
||||
if (ptr == end)
|
||||
return XML_TOK_PARTIAL;
|
||||
if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
|
||||
ptr -= MINBPC(enc);
|
||||
break;
|
||||
}
|
||||
*nextTokPtr = ptr + MINBPC(enc);
|
||||
return XML_TOK_CDATA_SECT_CLOSE;
|
||||
case BT_CR:
|
||||
ptr += MINBPC(enc);
|
||||
if (ptr == end)
|
||||
return XML_TOK_PARTIAL;
|
||||
if (BYTE_TYPE(enc, ptr) == BT_LF)
|
||||
ptr += MINBPC(enc);
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_DATA_NEWLINE;
|
||||
case BT_LF:
|
||||
*nextTokPtr = ptr + MINBPC(enc);
|
||||
return XML_TOK_DATA_NEWLINE;
|
||||
INVALID_CASES(ptr, nextTokPtr)
|
||||
default:
|
||||
ptr += MINBPC(enc);
|
||||
break;
|
||||
}
|
||||
while (ptr != end) {
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
#define LEAD_CASE(n) \
|
||||
case BT_LEAD ## n: \
|
||||
if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \
|
||||
*nextTokPtr = ptr; \
|
||||
return XML_TOK_DATA_CHARS; \
|
||||
} \
|
||||
ptr += n; \
|
||||
break;
|
||||
LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
|
||||
#undef LEAD_CASE
|
||||
case BT_NONXML:
|
||||
case BT_MALFORM:
|
||||
case BT_TRAIL:
|
||||
case BT_CR:
|
||||
case BT_LF:
|
||||
case BT_RSQB:
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_DATA_CHARS;
|
||||
default:
|
||||
ptr += MINBPC(enc);
|
||||
break;
|
||||
}
|
||||
}
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_DATA_CHARS;
|
||||
}
|
||||
|
||||
/* ptr points to character following "</" */
|
||||
|
||||
static int PTRCALL
|
||||
PREFIX(scanEndTag)(const ENCODING *enc, const char *ptr,
|
||||
const char *end, const char **nextTokPtr)
|
||||
{
|
||||
if (ptr == end)
|
||||
return XML_TOK_PARTIAL;
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
|
||||
default:
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
while (ptr != end) {
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
|
||||
case BT_S: case BT_CR: case BT_LF:
|
||||
for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) {
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
case BT_S: case BT_CR: case BT_LF:
|
||||
break;
|
||||
case BT_GT:
|
||||
*nextTokPtr = ptr + MINBPC(enc);
|
||||
return XML_TOK_END_TAG;
|
||||
default:
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
}
|
||||
return XML_TOK_PARTIAL;
|
||||
#ifdef XML_NS
|
||||
case BT_COLON:
|
||||
/* no need to check qname syntax here,
|
||||
since end-tag must match exactly */
|
||||
ptr += MINBPC(enc);
|
||||
break;
|
||||
#endif
|
||||
case BT_GT:
|
||||
*nextTokPtr = ptr + MINBPC(enc);
|
||||
return XML_TOK_END_TAG;
|
||||
default:
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
}
|
||||
return XML_TOK_PARTIAL;
|
||||
}
|
||||
|
||||
/* ptr points to character following "&#X" */
|
||||
|
||||
static int PTRCALL
|
||||
PREFIX(scanHexCharRef)(const ENCODING *enc, const char *ptr,
|
||||
const char *end, const char **nextTokPtr)
|
||||
{
|
||||
if (ptr != end) {
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
case BT_DIGIT:
|
||||
case BT_HEX:
|
||||
break;
|
||||
default:
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) {
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
case BT_DIGIT:
|
||||
case BT_HEX:
|
||||
break;
|
||||
case BT_SEMI:
|
||||
*nextTokPtr = ptr + MINBPC(enc);
|
||||
return XML_TOK_CHAR_REF;
|
||||
default:
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
}
|
||||
}
|
||||
return XML_TOK_PARTIAL;
|
||||
}
|
||||
|
||||
/* ptr points to character following "&#" */
|
||||
|
||||
static int PTRCALL
|
||||
PREFIX(scanCharRef)(const ENCODING *enc, const char *ptr,
|
||||
const char *end, const char **nextTokPtr)
|
||||
{
|
||||
if (ptr != end) {
|
||||
if (CHAR_MATCHES(enc, ptr, ASCII_x))
|
||||
return PREFIX(scanHexCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
case BT_DIGIT:
|
||||
break;
|
||||
default:
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
for (ptr += MINBPC(enc); ptr != end; ptr += MINBPC(enc)) {
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
case BT_DIGIT:
|
||||
break;
|
||||
case BT_SEMI:
|
||||
*nextTokPtr = ptr + MINBPC(enc);
|
||||
return XML_TOK_CHAR_REF;
|
||||
default:
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
}
|
||||
}
|
||||
return XML_TOK_PARTIAL;
|
||||
}
|
||||
|
||||
/* ptr points to character following "&" */
|
||||
|
||||
static int PTRCALL
|
||||
PREFIX(scanRef)(const ENCODING *enc, const char *ptr, const char *end,
|
||||
const char **nextTokPtr)
|
||||
{
|
||||
if (ptr == end)
|
||||
return XML_TOK_PARTIAL;
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
|
||||
case BT_NUM:
|
||||
return PREFIX(scanCharRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
|
||||
default:
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
while (ptr != end) {
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
|
||||
case BT_SEMI:
|
||||
*nextTokPtr = ptr + MINBPC(enc);
|
||||
return XML_TOK_ENTITY_REF;
|
||||
default:
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
}
|
||||
return XML_TOK_PARTIAL;
|
||||
}
|
||||
|
||||
/* ptr points to character following first character of attribute name */
|
||||
|
||||
static int PTRCALL
|
||||
PREFIX(scanAtts)(const ENCODING *enc, const char *ptr, const char *end,
|
||||
const char **nextTokPtr)
|
||||
{
|
||||
#ifdef XML_NS
|
||||
int hadColon = 0;
|
||||
#endif
|
||||
while (ptr != end) {
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
|
||||
#ifdef XML_NS
|
||||
case BT_COLON:
|
||||
if (hadColon) {
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
hadColon = 1;
|
||||
ptr += MINBPC(enc);
|
||||
if (ptr == end)
|
||||
return XML_TOK_PARTIAL;
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
|
||||
default:
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
break;
|
||||
#endif
|
||||
case BT_S: case BT_CR: case BT_LF:
|
||||
for (;;) {
|
||||
int t;
|
||||
|
||||
ptr += MINBPC(enc);
|
||||
if (ptr == end)
|
||||
return XML_TOK_PARTIAL;
|
||||
t = BYTE_TYPE(enc, ptr);
|
||||
if (t == BT_EQUALS)
|
||||
break;
|
||||
switch (t) {
|
||||
case BT_S:
|
||||
case BT_LF:
|
||||
case BT_CR:
|
||||
break;
|
||||
default:
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
}
|
||||
/* fall through */
|
||||
case BT_EQUALS:
|
||||
{
|
||||
int open;
|
||||
#ifdef XML_NS
|
||||
hadColon = 0;
|
||||
#endif
|
||||
for (;;) {
|
||||
ptr += MINBPC(enc);
|
||||
if (ptr == end)
|
||||
return XML_TOK_PARTIAL;
|
||||
open = BYTE_TYPE(enc, ptr);
|
||||
if (open == BT_QUOT || open == BT_APOS)
|
||||
break;
|
||||
switch (open) {
|
||||
case BT_S:
|
||||
case BT_LF:
|
||||
case BT_CR:
|
||||
break;
|
||||
default:
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
}
|
||||
ptr += MINBPC(enc);
|
||||
/* in attribute value */
|
||||
for (;;) {
|
||||
int t;
|
||||
if (ptr == end)
|
||||
return XML_TOK_PARTIAL;
|
||||
t = BYTE_TYPE(enc, ptr);
|
||||
if (t == open)
|
||||
break;
|
||||
switch (t) {
|
||||
INVALID_CASES(ptr, nextTokPtr)
|
||||
case BT_AMP:
|
||||
{
|
||||
int tok = PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, &ptr);
|
||||
if (tok <= 0) {
|
||||
if (tok == XML_TOK_INVALID)
|
||||
*nextTokPtr = ptr;
|
||||
return tok;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case BT_LT:
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
default:
|
||||
ptr += MINBPC(enc);
|
||||
break;
|
||||
}
|
||||
}
|
||||
ptr += MINBPC(enc);
|
||||
if (ptr == end)
|
||||
return XML_TOK_PARTIAL;
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
case BT_S:
|
||||
case BT_CR:
|
||||
case BT_LF:
|
||||
break;
|
||||
case BT_SOL:
|
||||
goto sol;
|
||||
case BT_GT:
|
||||
goto gt;
|
||||
default:
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
/* ptr points to closing quote */
|
||||
for (;;) {
|
||||
ptr += MINBPC(enc);
|
||||
if (ptr == end)
|
||||
return XML_TOK_PARTIAL;
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
|
||||
case BT_S: case BT_CR: case BT_LF:
|
||||
continue;
|
||||
case BT_GT:
|
||||
gt:
|
||||
*nextTokPtr = ptr + MINBPC(enc);
|
||||
return XML_TOK_START_TAG_WITH_ATTS;
|
||||
case BT_SOL:
|
||||
sol:
|
||||
ptr += MINBPC(enc);
|
||||
if (ptr == end)
|
||||
return XML_TOK_PARTIAL;
|
||||
if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
*nextTokPtr = ptr + MINBPC(enc);
|
||||
return XML_TOK_EMPTY_ELEMENT_WITH_ATTS;
|
||||
default:
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
default:
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
}
|
||||
return XML_TOK_PARTIAL;
|
||||
}
|
||||
|
||||
/* ptr points to character following "<" */
|
||||
|
||||
static int PTRCALL
|
||||
PREFIX(scanLt)(const ENCODING *enc, const char *ptr, const char *end,
|
||||
const char **nextTokPtr)
|
||||
{
|
||||
#ifdef XML_NS
|
||||
int hadColon;
|
||||
#endif
|
||||
if (ptr == end)
|
||||
return XML_TOK_PARTIAL;
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
|
||||
case BT_EXCL:
|
||||
if ((ptr += MINBPC(enc)) == end)
|
||||
return XML_TOK_PARTIAL;
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
case BT_MINUS:
|
||||
return PREFIX(scanComment)(enc, ptr + MINBPC(enc), end, nextTokPtr);
|
||||
case BT_LSQB:
|
||||
return PREFIX(scanCdataSection)(enc, ptr + MINBPC(enc),
|
||||
end, nextTokPtr);
|
||||
}
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
case BT_QUEST:
|
||||
return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr);
|
||||
case BT_SOL:
|
||||
return PREFIX(scanEndTag)(enc, ptr + MINBPC(enc), end, nextTokPtr);
|
||||
default:
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
#ifdef XML_NS
|
||||
hadColon = 0;
|
||||
#endif
|
||||
/* we have a start-tag */
|
||||
while (ptr != end) {
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
|
||||
#ifdef XML_NS
|
||||
case BT_COLON:
|
||||
if (hadColon) {
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
hadColon = 1;
|
||||
ptr += MINBPC(enc);
|
||||
if (ptr == end)
|
||||
return XML_TOK_PARTIAL;
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
|
||||
default:
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
break;
|
||||
#endif
|
||||
case BT_S: case BT_CR: case BT_LF:
|
||||
{
|
||||
ptr += MINBPC(enc);
|
||||
while (ptr != end) {
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
|
||||
case BT_GT:
|
||||
goto gt;
|
||||
case BT_SOL:
|
||||
goto sol;
|
||||
case BT_S: case BT_CR: case BT_LF:
|
||||
ptr += MINBPC(enc);
|
||||
continue;
|
||||
default:
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
return PREFIX(scanAtts)(enc, ptr, end, nextTokPtr);
|
||||
}
|
||||
return XML_TOK_PARTIAL;
|
||||
}
|
||||
case BT_GT:
|
||||
gt:
|
||||
*nextTokPtr = ptr + MINBPC(enc);
|
||||
return XML_TOK_START_TAG_NO_ATTS;
|
||||
case BT_SOL:
|
||||
sol:
|
||||
ptr += MINBPC(enc);
|
||||
if (ptr == end)
|
||||
return XML_TOK_PARTIAL;
|
||||
if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
*nextTokPtr = ptr + MINBPC(enc);
|
||||
return XML_TOK_EMPTY_ELEMENT_NO_ATTS;
|
||||
default:
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
}
|
||||
return XML_TOK_PARTIAL;
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
PREFIX(contentTok)(const ENCODING *enc, const char *ptr, const char *end,
|
||||
const char **nextTokPtr)
|
||||
{
|
||||
if (ptr == end)
|
||||
return XML_TOK_NONE;
|
||||
if (MINBPC(enc) > 1) {
|
||||
size_t n = end - ptr;
|
||||
if (n & (MINBPC(enc) - 1)) {
|
||||
n &= ~(MINBPC(enc) - 1);
|
||||
if (n == 0)
|
||||
return XML_TOK_PARTIAL;
|
||||
end = ptr + n;
|
||||
}
|
||||
}
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
case BT_LT:
|
||||
return PREFIX(scanLt)(enc, ptr + MINBPC(enc), end, nextTokPtr);
|
||||
case BT_AMP:
|
||||
return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
|
||||
case BT_CR:
|
||||
ptr += MINBPC(enc);
|
||||
if (ptr == end)
|
||||
return XML_TOK_TRAILING_CR;
|
||||
if (BYTE_TYPE(enc, ptr) == BT_LF)
|
||||
ptr += MINBPC(enc);
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_DATA_NEWLINE;
|
||||
case BT_LF:
|
||||
*nextTokPtr = ptr + MINBPC(enc);
|
||||
return XML_TOK_DATA_NEWLINE;
|
||||
case BT_RSQB:
|
||||
ptr += MINBPC(enc);
|
||||
if (ptr == end)
|
||||
return XML_TOK_TRAILING_RSQB;
|
||||
if (!CHAR_MATCHES(enc, ptr, ASCII_RSQB))
|
||||
break;
|
||||
ptr += MINBPC(enc);
|
||||
if (ptr == end)
|
||||
return XML_TOK_TRAILING_RSQB;
|
||||
if (!CHAR_MATCHES(enc, ptr, ASCII_GT)) {
|
||||
ptr -= MINBPC(enc);
|
||||
break;
|
||||
}
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
INVALID_CASES(ptr, nextTokPtr)
|
||||
default:
|
||||
ptr += MINBPC(enc);
|
||||
break;
|
||||
}
|
||||
while (ptr != end) {
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
#define LEAD_CASE(n) \
|
||||
case BT_LEAD ## n: \
|
||||
if (end - ptr < n || IS_INVALID_CHAR(enc, ptr, n)) { \
|
||||
*nextTokPtr = ptr; \
|
||||
return XML_TOK_DATA_CHARS; \
|
||||
} \
|
||||
ptr += n; \
|
||||
break;
|
||||
LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
|
||||
#undef LEAD_CASE
|
||||
case BT_RSQB:
|
||||
if (ptr + MINBPC(enc) != end) {
|
||||
if (!CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_RSQB)) {
|
||||
ptr += MINBPC(enc);
|
||||
break;
|
||||
}
|
||||
if (ptr + 2*MINBPC(enc) != end) {
|
||||
if (!CHAR_MATCHES(enc, ptr + 2*MINBPC(enc), ASCII_GT)) {
|
||||
ptr += MINBPC(enc);
|
||||
break;
|
||||
}
|
||||
*nextTokPtr = ptr + 2*MINBPC(enc);
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
}
|
||||
/* fall through */
|
||||
case BT_AMP:
|
||||
case BT_LT:
|
||||
case BT_NONXML:
|
||||
case BT_MALFORM:
|
||||
case BT_TRAIL:
|
||||
case BT_CR:
|
||||
case BT_LF:
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_DATA_CHARS;
|
||||
default:
|
||||
ptr += MINBPC(enc);
|
||||
break;
|
||||
}
|
||||
}
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_DATA_CHARS;
|
||||
}
|
||||
|
||||
/* ptr points to character following "%" */
|
||||
|
||||
static int PTRCALL
|
||||
PREFIX(scanPercent)(const ENCODING *enc, const char *ptr, const char *end,
|
||||
const char **nextTokPtr)
|
||||
{
|
||||
if (ptr == end)
|
||||
return XML_TOK_PARTIAL;
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
|
||||
case BT_S: case BT_LF: case BT_CR: case BT_PERCNT:
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_PERCENT;
|
||||
default:
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
while (ptr != end) {
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
|
||||
case BT_SEMI:
|
||||
*nextTokPtr = ptr + MINBPC(enc);
|
||||
return XML_TOK_PARAM_ENTITY_REF;
|
||||
default:
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
}
|
||||
return XML_TOK_PARTIAL;
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
PREFIX(scanPoundName)(const ENCODING *enc, const char *ptr, const char *end,
|
||||
const char **nextTokPtr)
|
||||
{
|
||||
if (ptr == end)
|
||||
return XML_TOK_PARTIAL;
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
CHECK_NMSTRT_CASES(enc, ptr, end, nextTokPtr)
|
||||
default:
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
while (ptr != end) {
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
|
||||
case BT_CR: case BT_LF: case BT_S:
|
||||
case BT_RPAR: case BT_GT: case BT_PERCNT: case BT_VERBAR:
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_POUND_NAME;
|
||||
default:
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
}
|
||||
return -XML_TOK_POUND_NAME;
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
PREFIX(scanLit)(int open, const ENCODING *enc,
|
||||
const char *ptr, const char *end,
|
||||
const char **nextTokPtr)
|
||||
{
|
||||
while (ptr != end) {
|
||||
int t = BYTE_TYPE(enc, ptr);
|
||||
switch (t) {
|
||||
INVALID_CASES(ptr, nextTokPtr)
|
||||
case BT_QUOT:
|
||||
case BT_APOS:
|
||||
ptr += MINBPC(enc);
|
||||
if (t != open)
|
||||
break;
|
||||
if (ptr == end)
|
||||
return -XML_TOK_LITERAL;
|
||||
*nextTokPtr = ptr;
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
case BT_S: case BT_CR: case BT_LF:
|
||||
case BT_GT: case BT_PERCNT: case BT_LSQB:
|
||||
return XML_TOK_LITERAL;
|
||||
default:
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
default:
|
||||
ptr += MINBPC(enc);
|
||||
break;
|
||||
}
|
||||
}
|
||||
return XML_TOK_PARTIAL;
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
PREFIX(prologTok)(const ENCODING *enc, const char *ptr, const char *end,
|
||||
const char **nextTokPtr)
|
||||
{
|
||||
int tok;
|
||||
if (ptr == end)
|
||||
return XML_TOK_NONE;
|
||||
if (MINBPC(enc) > 1) {
|
||||
size_t n = end - ptr;
|
||||
if (n & (MINBPC(enc) - 1)) {
|
||||
n &= ~(MINBPC(enc) - 1);
|
||||
if (n == 0)
|
||||
return XML_TOK_PARTIAL;
|
||||
end = ptr + n;
|
||||
}
|
||||
}
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
case BT_QUOT:
|
||||
return PREFIX(scanLit)(BT_QUOT, enc, ptr + MINBPC(enc), end, nextTokPtr);
|
||||
case BT_APOS:
|
||||
return PREFIX(scanLit)(BT_APOS, enc, ptr + MINBPC(enc), end, nextTokPtr);
|
||||
case BT_LT:
|
||||
{
|
||||
ptr += MINBPC(enc);
|
||||
if (ptr == end)
|
||||
return XML_TOK_PARTIAL;
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
case BT_EXCL:
|
||||
return PREFIX(scanDecl)(enc, ptr + MINBPC(enc), end, nextTokPtr);
|
||||
case BT_QUEST:
|
||||
return PREFIX(scanPi)(enc, ptr + MINBPC(enc), end, nextTokPtr);
|
||||
case BT_NMSTRT:
|
||||
case BT_HEX:
|
||||
case BT_NONASCII:
|
||||
case BT_LEAD2:
|
||||
case BT_LEAD3:
|
||||
case BT_LEAD4:
|
||||
*nextTokPtr = ptr - MINBPC(enc);
|
||||
return XML_TOK_INSTANCE_START;
|
||||
}
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
case BT_CR:
|
||||
if (ptr + MINBPC(enc) == end) {
|
||||
*nextTokPtr = end;
|
||||
/* indicate that this might be part of a CR/LF pair */
|
||||
return -XML_TOK_PROLOG_S;
|
||||
}
|
||||
/* fall through */
|
||||
case BT_S: case BT_LF:
|
||||
for (;;) {
|
||||
ptr += MINBPC(enc);
|
||||
if (ptr == end)
|
||||
break;
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
case BT_S: case BT_LF:
|
||||
break;
|
||||
case BT_CR:
|
||||
/* don't split CR/LF pair */
|
||||
if (ptr + MINBPC(enc) != end)
|
||||
break;
|
||||
/* fall through */
|
||||
default:
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_PROLOG_S;
|
||||
}
|
||||
}
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_PROLOG_S;
|
||||
case BT_PERCNT:
|
||||
return PREFIX(scanPercent)(enc, ptr + MINBPC(enc), end, nextTokPtr);
|
||||
case BT_COMMA:
|
||||
*nextTokPtr = ptr + MINBPC(enc);
|
||||
return XML_TOK_COMMA;
|
||||
case BT_LSQB:
|
||||
*nextTokPtr = ptr + MINBPC(enc);
|
||||
return XML_TOK_OPEN_BRACKET;
|
||||
case BT_RSQB:
|
||||
ptr += MINBPC(enc);
|
||||
if (ptr == end)
|
||||
return -XML_TOK_CLOSE_BRACKET;
|
||||
if (CHAR_MATCHES(enc, ptr, ASCII_RSQB)) {
|
||||
if (ptr + MINBPC(enc) == end)
|
||||
return XML_TOK_PARTIAL;
|
||||
if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_GT)) {
|
||||
*nextTokPtr = ptr + 2*MINBPC(enc);
|
||||
return XML_TOK_COND_SECT_CLOSE;
|
||||
}
|
||||
}
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_CLOSE_BRACKET;
|
||||
case BT_LPAR:
|
||||
*nextTokPtr = ptr + MINBPC(enc);
|
||||
return XML_TOK_OPEN_PAREN;
|
||||
case BT_RPAR:
|
||||
ptr += MINBPC(enc);
|
||||
if (ptr == end)
|
||||
return -XML_TOK_CLOSE_PAREN;
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
case BT_AST:
|
||||
*nextTokPtr = ptr + MINBPC(enc);
|
||||
return XML_TOK_CLOSE_PAREN_ASTERISK;
|
||||
case BT_QUEST:
|
||||
*nextTokPtr = ptr + MINBPC(enc);
|
||||
return XML_TOK_CLOSE_PAREN_QUESTION;
|
||||
case BT_PLUS:
|
||||
*nextTokPtr = ptr + MINBPC(enc);
|
||||
return XML_TOK_CLOSE_PAREN_PLUS;
|
||||
case BT_CR: case BT_LF: case BT_S:
|
||||
case BT_GT: case BT_COMMA: case BT_VERBAR:
|
||||
case BT_RPAR:
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_CLOSE_PAREN;
|
||||
}
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
case BT_VERBAR:
|
||||
*nextTokPtr = ptr + MINBPC(enc);
|
||||
return XML_TOK_OR;
|
||||
case BT_GT:
|
||||
*nextTokPtr = ptr + MINBPC(enc);
|
||||
return XML_TOK_DECL_CLOSE;
|
||||
case BT_NUM:
|
||||
return PREFIX(scanPoundName)(enc, ptr + MINBPC(enc), end, nextTokPtr);
|
||||
#define LEAD_CASE(n) \
|
||||
case BT_LEAD ## n: \
|
||||
if (end - ptr < n) \
|
||||
return XML_TOK_PARTIAL_CHAR; \
|
||||
if (IS_NMSTRT_CHAR(enc, ptr, n)) { \
|
||||
ptr += n; \
|
||||
tok = XML_TOK_NAME; \
|
||||
break; \
|
||||
} \
|
||||
if (IS_NAME_CHAR(enc, ptr, n)) { \
|
||||
ptr += n; \
|
||||
tok = XML_TOK_NMTOKEN; \
|
||||
break; \
|
||||
} \
|
||||
*nextTokPtr = ptr; \
|
||||
return XML_TOK_INVALID;
|
||||
LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
|
||||
#undef LEAD_CASE
|
||||
case BT_NMSTRT:
|
||||
case BT_HEX:
|
||||
tok = XML_TOK_NAME;
|
||||
ptr += MINBPC(enc);
|
||||
break;
|
||||
case BT_DIGIT:
|
||||
case BT_NAME:
|
||||
case BT_MINUS:
|
||||
#ifdef XML_NS
|
||||
case BT_COLON:
|
||||
#endif
|
||||
tok = XML_TOK_NMTOKEN;
|
||||
ptr += MINBPC(enc);
|
||||
break;
|
||||
case BT_NONASCII:
|
||||
if (IS_NMSTRT_CHAR_MINBPC(enc, ptr)) {
|
||||
ptr += MINBPC(enc);
|
||||
tok = XML_TOK_NAME;
|
||||
break;
|
||||
}
|
||||
if (IS_NAME_CHAR_MINBPC(enc, ptr)) {
|
||||
ptr += MINBPC(enc);
|
||||
tok = XML_TOK_NMTOKEN;
|
||||
break;
|
||||
}
|
||||
/* fall through */
|
||||
default:
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
while (ptr != end) {
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
|
||||
case BT_GT: case BT_RPAR: case BT_COMMA:
|
||||
case BT_VERBAR: case BT_LSQB: case BT_PERCNT:
|
||||
case BT_S: case BT_CR: case BT_LF:
|
||||
*nextTokPtr = ptr;
|
||||
return tok;
|
||||
#ifdef XML_NS
|
||||
case BT_COLON:
|
||||
ptr += MINBPC(enc);
|
||||
switch (tok) {
|
||||
case XML_TOK_NAME:
|
||||
if (ptr == end)
|
||||
return XML_TOK_PARTIAL;
|
||||
tok = XML_TOK_PREFIXED_NAME;
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
CHECK_NAME_CASES(enc, ptr, end, nextTokPtr)
|
||||
default:
|
||||
tok = XML_TOK_NMTOKEN;
|
||||
break;
|
||||
}
|
||||
break;
|
||||
case XML_TOK_PREFIXED_NAME:
|
||||
tok = XML_TOK_NMTOKEN;
|
||||
break;
|
||||
}
|
||||
break;
|
||||
#endif
|
||||
case BT_PLUS:
|
||||
if (tok == XML_TOK_NMTOKEN) {
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
*nextTokPtr = ptr + MINBPC(enc);
|
||||
return XML_TOK_NAME_PLUS;
|
||||
case BT_AST:
|
||||
if (tok == XML_TOK_NMTOKEN) {
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
*nextTokPtr = ptr + MINBPC(enc);
|
||||
return XML_TOK_NAME_ASTERISK;
|
||||
case BT_QUEST:
|
||||
if (tok == XML_TOK_NMTOKEN) {
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
*nextTokPtr = ptr + MINBPC(enc);
|
||||
return XML_TOK_NAME_QUESTION;
|
||||
default:
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
}
|
||||
}
|
||||
return -tok;
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
PREFIX(attributeValueTok)(const ENCODING *enc, const char *ptr,
|
||||
const char *end, const char **nextTokPtr)
|
||||
{
|
||||
const char *start;
|
||||
if (ptr == end)
|
||||
return XML_TOK_NONE;
|
||||
start = ptr;
|
||||
while (ptr != end) {
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
#define LEAD_CASE(n) \
|
||||
case BT_LEAD ## n: ptr += n; break;
|
||||
LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
|
||||
#undef LEAD_CASE
|
||||
case BT_AMP:
|
||||
if (ptr == start)
|
||||
return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_DATA_CHARS;
|
||||
case BT_LT:
|
||||
/* this is for inside entity references */
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_INVALID;
|
||||
case BT_LF:
|
||||
if (ptr == start) {
|
||||
*nextTokPtr = ptr + MINBPC(enc);
|
||||
return XML_TOK_DATA_NEWLINE;
|
||||
}
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_DATA_CHARS;
|
||||
case BT_CR:
|
||||
if (ptr == start) {
|
||||
ptr += MINBPC(enc);
|
||||
if (ptr == end)
|
||||
return XML_TOK_TRAILING_CR;
|
||||
if (BYTE_TYPE(enc, ptr) == BT_LF)
|
||||
ptr += MINBPC(enc);
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_DATA_NEWLINE;
|
||||
}
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_DATA_CHARS;
|
||||
case BT_S:
|
||||
if (ptr == start) {
|
||||
*nextTokPtr = ptr + MINBPC(enc);
|
||||
return XML_TOK_ATTRIBUTE_VALUE_S;
|
||||
}
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_DATA_CHARS;
|
||||
default:
|
||||
ptr += MINBPC(enc);
|
||||
break;
|
||||
}
|
||||
}
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_DATA_CHARS;
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
PREFIX(entityValueTok)(const ENCODING *enc, const char *ptr,
|
||||
const char *end, const char **nextTokPtr)
|
||||
{
|
||||
const char *start;
|
||||
if (ptr == end)
|
||||
return XML_TOK_NONE;
|
||||
start = ptr;
|
||||
while (ptr != end) {
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
#define LEAD_CASE(n) \
|
||||
case BT_LEAD ## n: ptr += n; break;
|
||||
LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
|
||||
#undef LEAD_CASE
|
||||
case BT_AMP:
|
||||
if (ptr == start)
|
||||
return PREFIX(scanRef)(enc, ptr + MINBPC(enc), end, nextTokPtr);
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_DATA_CHARS;
|
||||
case BT_PERCNT:
|
||||
if (ptr == start) {
|
||||
int tok = PREFIX(scanPercent)(enc, ptr + MINBPC(enc),
|
||||
end, nextTokPtr);
|
||||
return (tok == XML_TOK_PERCENT) ? XML_TOK_INVALID : tok;
|
||||
}
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_DATA_CHARS;
|
||||
case BT_LF:
|
||||
if (ptr == start) {
|
||||
*nextTokPtr = ptr + MINBPC(enc);
|
||||
return XML_TOK_DATA_NEWLINE;
|
||||
}
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_DATA_CHARS;
|
||||
case BT_CR:
|
||||
if (ptr == start) {
|
||||
ptr += MINBPC(enc);
|
||||
if (ptr == end)
|
||||
return XML_TOK_TRAILING_CR;
|
||||
if (BYTE_TYPE(enc, ptr) == BT_LF)
|
||||
ptr += MINBPC(enc);
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_DATA_NEWLINE;
|
||||
}
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_DATA_CHARS;
|
||||
default:
|
||||
ptr += MINBPC(enc);
|
||||
break;
|
||||
}
|
||||
}
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_DATA_CHARS;
|
||||
}
|
||||
|
||||
#ifdef XML_DTD
|
||||
|
||||
static int PTRCALL
|
||||
PREFIX(ignoreSectionTok)(const ENCODING *enc, const char *ptr,
|
||||
const char *end, const char **nextTokPtr)
|
||||
{
|
||||
int level = 0;
|
||||
if (MINBPC(enc) > 1) {
|
||||
size_t n = end - ptr;
|
||||
if (n & (MINBPC(enc) - 1)) {
|
||||
n &= ~(MINBPC(enc) - 1);
|
||||
end = ptr + n;
|
||||
}
|
||||
}
|
||||
while (ptr != end) {
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
INVALID_CASES(ptr, nextTokPtr)
|
||||
case BT_LT:
|
||||
if ((ptr += MINBPC(enc)) == end)
|
||||
return XML_TOK_PARTIAL;
|
||||
if (CHAR_MATCHES(enc, ptr, ASCII_EXCL)) {
|
||||
if ((ptr += MINBPC(enc)) == end)
|
||||
return XML_TOK_PARTIAL;
|
||||
if (CHAR_MATCHES(enc, ptr, ASCII_LSQB)) {
|
||||
++level;
|
||||
ptr += MINBPC(enc);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case BT_RSQB:
|
||||
if ((ptr += MINBPC(enc)) == end)
|
||||
return XML_TOK_PARTIAL;
|
||||
if (CHAR_MATCHES(enc, ptr, ASCII_RSQB)) {
|
||||
if ((ptr += MINBPC(enc)) == end)
|
||||
return XML_TOK_PARTIAL;
|
||||
if (CHAR_MATCHES(enc, ptr, ASCII_GT)) {
|
||||
ptr += MINBPC(enc);
|
||||
if (level == 0) {
|
||||
*nextTokPtr = ptr;
|
||||
return XML_TOK_IGNORE_SECT;
|
||||
}
|
||||
--level;
|
||||
}
|
||||
}
|
||||
break;
|
||||
default:
|
||||
ptr += MINBPC(enc);
|
||||
break;
|
||||
}
|
||||
}
|
||||
return XML_TOK_PARTIAL;
|
||||
}
|
||||
|
||||
#endif /* XML_DTD */
|
||||
|
||||
static int PTRCALL
|
||||
PREFIX(isPublicId)(const ENCODING *enc, const char *ptr, const char *end,
|
||||
const char **badPtr)
|
||||
{
|
||||
ptr += MINBPC(enc);
|
||||
end -= MINBPC(enc);
|
||||
for (; ptr != end; ptr += MINBPC(enc)) {
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
case BT_DIGIT:
|
||||
case BT_HEX:
|
||||
case BT_MINUS:
|
||||
case BT_APOS:
|
||||
case BT_LPAR:
|
||||
case BT_RPAR:
|
||||
case BT_PLUS:
|
||||
case BT_COMMA:
|
||||
case BT_SOL:
|
||||
case BT_EQUALS:
|
||||
case BT_QUEST:
|
||||
case BT_CR:
|
||||
case BT_LF:
|
||||
case BT_SEMI:
|
||||
case BT_EXCL:
|
||||
case BT_AST:
|
||||
case BT_PERCNT:
|
||||
case BT_NUM:
|
||||
#ifdef XML_NS
|
||||
case BT_COLON:
|
||||
#endif
|
||||
break;
|
||||
case BT_S:
|
||||
if (CHAR_MATCHES(enc, ptr, ASCII_TAB)) {
|
||||
*badPtr = ptr;
|
||||
return 0;
|
||||
}
|
||||
break;
|
||||
case BT_NAME:
|
||||
case BT_NMSTRT:
|
||||
if (!(BYTE_TO_ASCII(enc, ptr) & ~0x7f))
|
||||
break;
|
||||
default:
|
||||
switch (BYTE_TO_ASCII(enc, ptr)) {
|
||||
case 0x24: /* $ */
|
||||
case 0x40: /* @ */
|
||||
break;
|
||||
default:
|
||||
*badPtr = ptr;
|
||||
return 0;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* This must only be called for a well-formed start-tag or empty
|
||||
element tag. Returns the number of attributes. Pointers to the
|
||||
first attsMax attributes are stored in atts.
|
||||
*/
|
||||
|
||||
static int PTRCALL
|
||||
PREFIX(getAtts)(const ENCODING *enc, const char *ptr,
|
||||
int attsMax, ATTRIBUTE *atts)
|
||||
{
|
||||
enum { other, inName, inValue } state = inName;
|
||||
int nAtts = 0;
|
||||
int open = 0; /* defined when state == inValue;
|
||||
initialization just to shut up compilers */
|
||||
|
||||
for (ptr += MINBPC(enc);; ptr += MINBPC(enc)) {
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
#define START_NAME \
|
||||
if (state == other) { \
|
||||
if (nAtts < attsMax) { \
|
||||
atts[nAtts].name = ptr; \
|
||||
atts[nAtts].normalized = 1; \
|
||||
} \
|
||||
state = inName; \
|
||||
}
|
||||
#define LEAD_CASE(n) \
|
||||
case BT_LEAD ## n: START_NAME ptr += (n - MINBPC(enc)); break;
|
||||
LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
|
||||
#undef LEAD_CASE
|
||||
case BT_NONASCII:
|
||||
case BT_NMSTRT:
|
||||
case BT_HEX:
|
||||
START_NAME
|
||||
break;
|
||||
#undef START_NAME
|
||||
case BT_QUOT:
|
||||
if (state != inValue) {
|
||||
if (nAtts < attsMax)
|
||||
atts[nAtts].valuePtr = ptr + MINBPC(enc);
|
||||
state = inValue;
|
||||
open = BT_QUOT;
|
||||
}
|
||||
else if (open == BT_QUOT) {
|
||||
state = other;
|
||||
if (nAtts < attsMax)
|
||||
atts[nAtts].valueEnd = ptr;
|
||||
nAtts++;
|
||||
}
|
||||
break;
|
||||
case BT_APOS:
|
||||
if (state != inValue) {
|
||||
if (nAtts < attsMax)
|
||||
atts[nAtts].valuePtr = ptr + MINBPC(enc);
|
||||
state = inValue;
|
||||
open = BT_APOS;
|
||||
}
|
||||
else if (open == BT_APOS) {
|
||||
state = other;
|
||||
if (nAtts < attsMax)
|
||||
atts[nAtts].valueEnd = ptr;
|
||||
nAtts++;
|
||||
}
|
||||
break;
|
||||
case BT_AMP:
|
||||
if (nAtts < attsMax)
|
||||
atts[nAtts].normalized = 0;
|
||||
break;
|
||||
case BT_S:
|
||||
if (state == inName)
|
||||
state = other;
|
||||
else if (state == inValue
|
||||
&& nAtts < attsMax
|
||||
&& atts[nAtts].normalized
|
||||
&& (ptr == atts[nAtts].valuePtr
|
||||
|| BYTE_TO_ASCII(enc, ptr) != ASCII_SPACE
|
||||
|| BYTE_TO_ASCII(enc, ptr + MINBPC(enc)) == ASCII_SPACE
|
||||
|| BYTE_TYPE(enc, ptr + MINBPC(enc)) == open))
|
||||
atts[nAtts].normalized = 0;
|
||||
break;
|
||||
case BT_CR: case BT_LF:
|
||||
/* This case ensures that the first attribute name is counted
|
||||
Apart from that we could just change state on the quote. */
|
||||
if (state == inName)
|
||||
state = other;
|
||||
else if (state == inValue && nAtts < attsMax)
|
||||
atts[nAtts].normalized = 0;
|
||||
break;
|
||||
case BT_GT:
|
||||
case BT_SOL:
|
||||
if (state != inValue)
|
||||
return nAtts;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
/* not reached */
|
||||
}
|
||||
|
||||
static int PTRFASTCALL
|
||||
PREFIX(charRefNumber)(const ENCODING *enc, const char *ptr)
|
||||
{
|
||||
int result = 0;
|
||||
/* skip &# */
|
||||
ptr += 2*MINBPC(enc);
|
||||
if (CHAR_MATCHES(enc, ptr, ASCII_x)) {
|
||||
for (ptr += MINBPC(enc);
|
||||
!CHAR_MATCHES(enc, ptr, ASCII_SEMI);
|
||||
ptr += MINBPC(enc)) {
|
||||
int c = BYTE_TO_ASCII(enc, ptr);
|
||||
switch (c) {
|
||||
case ASCII_0: 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 |= (c - ASCII_0);
|
||||
break;
|
||||
case ASCII_A: case ASCII_B: case ASCII_C:
|
||||
case ASCII_D: case ASCII_E: case ASCII_F:
|
||||
result <<= 4;
|
||||
result += 10 + (c - ASCII_A);
|
||||
break;
|
||||
case ASCII_a: case ASCII_b: case ASCII_c:
|
||||
case ASCII_d: case ASCII_e: case ASCII_f:
|
||||
result <<= 4;
|
||||
result += 10 + (c - ASCII_a);
|
||||
break;
|
||||
}
|
||||
if (result >= 0x110000)
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (; !CHAR_MATCHES(enc, ptr, ASCII_SEMI); ptr += MINBPC(enc)) {
|
||||
int c = BYTE_TO_ASCII(enc, ptr);
|
||||
result *= 10;
|
||||
result += (c - ASCII_0);
|
||||
if (result >= 0x110000)
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
return checkCharRefNumber(result);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
PREFIX(predefinedEntityName)(const ENCODING *enc, const char *ptr,
|
||||
const char *end)
|
||||
{
|
||||
switch ((end - ptr)/MINBPC(enc)) {
|
||||
case 2:
|
||||
if (CHAR_MATCHES(enc, ptr + MINBPC(enc), ASCII_t)) {
|
||||
switch (BYTE_TO_ASCII(enc, ptr)) {
|
||||
case ASCII_l:
|
||||
return ASCII_LT;
|
||||
case ASCII_g:
|
||||
return ASCII_GT;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 3:
|
||||
if (CHAR_MATCHES(enc, ptr, ASCII_a)) {
|
||||
ptr += MINBPC(enc);
|
||||
if (CHAR_MATCHES(enc, ptr, ASCII_m)) {
|
||||
ptr += MINBPC(enc);
|
||||
if (CHAR_MATCHES(enc, ptr, ASCII_p))
|
||||
return ASCII_AMP;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case 4:
|
||||
switch (BYTE_TO_ASCII(enc, ptr)) {
|
||||
case ASCII_q:
|
||||
ptr += MINBPC(enc);
|
||||
if (CHAR_MATCHES(enc, ptr, ASCII_u)) {
|
||||
ptr += MINBPC(enc);
|
||||
if (CHAR_MATCHES(enc, ptr, ASCII_o)) {
|
||||
ptr += MINBPC(enc);
|
||||
if (CHAR_MATCHES(enc, ptr, ASCII_t))
|
||||
return ASCII_QUOT;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case ASCII_a:
|
||||
ptr += MINBPC(enc);
|
||||
if (CHAR_MATCHES(enc, ptr, ASCII_p)) {
|
||||
ptr += MINBPC(enc);
|
||||
if (CHAR_MATCHES(enc, ptr, ASCII_o)) {
|
||||
ptr += MINBPC(enc);
|
||||
if (CHAR_MATCHES(enc, ptr, ASCII_s))
|
||||
return ASCII_APOS;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
PREFIX(sameName)(const ENCODING *enc, const char *ptr1, const char *ptr2)
|
||||
{
|
||||
for (;;) {
|
||||
switch (BYTE_TYPE(enc, ptr1)) {
|
||||
#define LEAD_CASE(n) \
|
||||
case BT_LEAD ## n: \
|
||||
if (*ptr1++ != *ptr2++) \
|
||||
return 0;
|
||||
LEAD_CASE(4) LEAD_CASE(3) LEAD_CASE(2)
|
||||
#undef LEAD_CASE
|
||||
/* fall through */
|
||||
if (*ptr1++ != *ptr2++)
|
||||
return 0;
|
||||
break;
|
||||
case BT_NONASCII:
|
||||
case BT_NMSTRT:
|
||||
#ifdef XML_NS
|
||||
case BT_COLON:
|
||||
#endif
|
||||
case BT_HEX:
|
||||
case BT_DIGIT:
|
||||
case BT_NAME:
|
||||
case BT_MINUS:
|
||||
if (*ptr2++ != *ptr1++)
|
||||
return 0;
|
||||
if (MINBPC(enc) > 1) {
|
||||
if (*ptr2++ != *ptr1++)
|
||||
return 0;
|
||||
if (MINBPC(enc) > 2) {
|
||||
if (*ptr2++ != *ptr1++)
|
||||
return 0;
|
||||
if (MINBPC(enc) > 3) {
|
||||
if (*ptr2++ != *ptr1++)
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
default:
|
||||
if (MINBPC(enc) == 1 && *ptr1 == *ptr2)
|
||||
return 1;
|
||||
switch (BYTE_TYPE(enc, ptr2)) {
|
||||
case BT_LEAD2:
|
||||
case BT_LEAD3:
|
||||
case BT_LEAD4:
|
||||
case BT_NONASCII:
|
||||
case BT_NMSTRT:
|
||||
#ifdef XML_NS
|
||||
case BT_COLON:
|
||||
#endif
|
||||
case BT_HEX:
|
||||
case BT_DIGIT:
|
||||
case BT_NAME:
|
||||
case BT_MINUS:
|
||||
return 0;
|
||||
default:
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
/* not reached */
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
PREFIX(nameMatchesAscii)(const ENCODING *enc, const char *ptr1,
|
||||
const char *end1, const char *ptr2)
|
||||
{
|
||||
for (; *ptr2; ptr1 += MINBPC(enc), ptr2++) {
|
||||
if (ptr1 == end1)
|
||||
return 0;
|
||||
if (!CHAR_MATCHES(enc, ptr1, *ptr2))
|
||||
return 0;
|
||||
}
|
||||
return ptr1 == end1;
|
||||
}
|
||||
|
||||
static int PTRFASTCALL
|
||||
PREFIX(nameLength)(const ENCODING *enc, const char *ptr)
|
||||
{
|
||||
const char *start = ptr;
|
||||
for (;;) {
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
#define LEAD_CASE(n) \
|
||||
case BT_LEAD ## n: ptr += n; break;
|
||||
LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
|
||||
#undef LEAD_CASE
|
||||
case BT_NONASCII:
|
||||
case BT_NMSTRT:
|
||||
#ifdef XML_NS
|
||||
case BT_COLON:
|
||||
#endif
|
||||
case BT_HEX:
|
||||
case BT_DIGIT:
|
||||
case BT_NAME:
|
||||
case BT_MINUS:
|
||||
ptr += MINBPC(enc);
|
||||
break;
|
||||
default:
|
||||
return (int)(ptr - start);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static const char * PTRFASTCALL
|
||||
PREFIX(skipS)(const ENCODING *enc, const char *ptr)
|
||||
{
|
||||
for (;;) {
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
case BT_LF:
|
||||
case BT_CR:
|
||||
case BT_S:
|
||||
ptr += MINBPC(enc);
|
||||
break;
|
||||
default:
|
||||
return ptr;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void PTRCALL
|
||||
PREFIX(updatePosition)(const ENCODING *enc,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
POSITION *pos)
|
||||
{
|
||||
while (ptr < end) {
|
||||
switch (BYTE_TYPE(enc, ptr)) {
|
||||
#define LEAD_CASE(n) \
|
||||
case BT_LEAD ## n: \
|
||||
ptr += n; \
|
||||
break;
|
||||
LEAD_CASE(2) LEAD_CASE(3) LEAD_CASE(4)
|
||||
#undef LEAD_CASE
|
||||
case BT_LF:
|
||||
pos->columnNumber = (XML_Size)-1;
|
||||
pos->lineNumber++;
|
||||
ptr += MINBPC(enc);
|
||||
break;
|
||||
case BT_CR:
|
||||
pos->lineNumber++;
|
||||
ptr += MINBPC(enc);
|
||||
if (ptr != end && BYTE_TYPE(enc, ptr) == BT_LF)
|
||||
ptr += MINBPC(enc);
|
||||
pos->columnNumber = (XML_Size)-1;
|
||||
break;
|
||||
default:
|
||||
ptr += MINBPC(enc);
|
||||
break;
|
||||
}
|
||||
pos->columnNumber++;
|
||||
}
|
||||
}
|
||||
|
||||
#undef DO_LEAD_CASE
|
||||
#undef MULTIBYTE_CASES
|
||||
#undef INVALID_CASES
|
||||
#undef CHECK_NAME_CASE
|
||||
#undef CHECK_NAME_CASES
|
||||
#undef CHECK_NMSTRT_CASE
|
||||
#undef CHECK_NMSTRT_CASES
|
||||
|
||||
#endif /* XML_TOK_IMPL_C */
|
||||
@@ -0,0 +1,46 @@
|
||||
/*
|
||||
Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
|
||||
See the file COPYING for copying permission.
|
||||
*/
|
||||
|
||||
enum {
|
||||
BT_NONXML,
|
||||
BT_MALFORM,
|
||||
BT_LT,
|
||||
BT_AMP,
|
||||
BT_RSQB,
|
||||
BT_LEAD2,
|
||||
BT_LEAD3,
|
||||
BT_LEAD4,
|
||||
BT_TRAIL,
|
||||
BT_CR,
|
||||
BT_LF,
|
||||
BT_GT,
|
||||
BT_QUOT,
|
||||
BT_APOS,
|
||||
BT_EQUALS,
|
||||
BT_QUEST,
|
||||
BT_EXCL,
|
||||
BT_SOL,
|
||||
BT_SEMI,
|
||||
BT_NUM,
|
||||
BT_LSQB,
|
||||
BT_S,
|
||||
BT_NMSTRT,
|
||||
BT_COLON,
|
||||
BT_HEX,
|
||||
BT_DIGIT,
|
||||
BT_NAME,
|
||||
BT_MINUS,
|
||||
BT_OTHER, /* known not to be a name or name start character */
|
||||
BT_NONASCII, /* might be a name or name start character */
|
||||
BT_PERCNT,
|
||||
BT_LPAR,
|
||||
BT_RPAR,
|
||||
BT_AST,
|
||||
BT_PLUS,
|
||||
BT_COMMA,
|
||||
BT_VERBAR
|
||||
};
|
||||
|
||||
#include <stddef.h>
|
||||
@@ -0,0 +1,115 @@
|
||||
/* Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
|
||||
See the file COPYING for copying permission.
|
||||
*/
|
||||
|
||||
/* This file is included! */
|
||||
#ifdef XML_TOK_NS_C
|
||||
|
||||
const ENCODING *
|
||||
NS(XmlGetUtf8InternalEncoding)(void)
|
||||
{
|
||||
return &ns(internal_utf8_encoding).enc;
|
||||
}
|
||||
|
||||
const ENCODING *
|
||||
NS(XmlGetUtf16InternalEncoding)(void)
|
||||
{
|
||||
#if BYTEORDER == 1234
|
||||
return &ns(internal_little2_encoding).enc;
|
||||
#elif BYTEORDER == 4321
|
||||
return &ns(internal_big2_encoding).enc;
|
||||
#else
|
||||
const short n = 1;
|
||||
return (*(const char *)&n
|
||||
? &ns(internal_little2_encoding).enc
|
||||
: &ns(internal_big2_encoding).enc);
|
||||
#endif
|
||||
}
|
||||
|
||||
static const ENCODING * const NS(encodings)[] = {
|
||||
&ns(latin1_encoding).enc,
|
||||
&ns(ascii_encoding).enc,
|
||||
&ns(utf8_encoding).enc,
|
||||
&ns(big2_encoding).enc,
|
||||
&ns(big2_encoding).enc,
|
||||
&ns(little2_encoding).enc,
|
||||
&ns(utf8_encoding).enc /* NO_ENC */
|
||||
};
|
||||
|
||||
static int PTRCALL
|
||||
NS(initScanProlog)(const ENCODING *enc, const char *ptr, const char *end,
|
||||
const char **nextTokPtr)
|
||||
{
|
||||
return initScan(NS(encodings), (const INIT_ENCODING *)enc,
|
||||
XML_PROLOG_STATE, ptr, end, nextTokPtr);
|
||||
}
|
||||
|
||||
static int PTRCALL
|
||||
NS(initScanContent)(const ENCODING *enc, const char *ptr, const char *end,
|
||||
const char **nextTokPtr)
|
||||
{
|
||||
return initScan(NS(encodings), (const INIT_ENCODING *)enc,
|
||||
XML_CONTENT_STATE, ptr, end, nextTokPtr);
|
||||
}
|
||||
|
||||
int
|
||||
NS(XmlInitEncoding)(INIT_ENCODING *p, const ENCODING **encPtr,
|
||||
const char *name)
|
||||
{
|
||||
int i = getEncodingIndex(name);
|
||||
if (i == UNKNOWN_ENC)
|
||||
return 0;
|
||||
SET_INIT_ENC_INDEX(p, i);
|
||||
p->initEnc.scanners[XML_PROLOG_STATE] = NS(initScanProlog);
|
||||
p->initEnc.scanners[XML_CONTENT_STATE] = NS(initScanContent);
|
||||
p->initEnc.updatePosition = initUpdatePosition;
|
||||
p->encPtr = encPtr;
|
||||
*encPtr = &(p->initEnc);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static const ENCODING *
|
||||
NS(findEncoding)(const ENCODING *enc, const char *ptr, const char *end)
|
||||
{
|
||||
#define ENCODING_MAX 128
|
||||
char buf[ENCODING_MAX];
|
||||
char *p = buf;
|
||||
int i;
|
||||
XmlUtf8Convert(enc, &ptr, end, &p, p + ENCODING_MAX - 1);
|
||||
if (ptr != end)
|
||||
return 0;
|
||||
*p = 0;
|
||||
if (streqci(buf, KW_UTF_16) && enc->minBytesPerChar == 2)
|
||||
return enc;
|
||||
i = getEncodingIndex(buf);
|
||||
if (i == UNKNOWN_ENC)
|
||||
return 0;
|
||||
return NS(encodings)[i];
|
||||
}
|
||||
|
||||
int
|
||||
NS(XmlParseXmlDecl)(int isGeneralTextEntity,
|
||||
const ENCODING *enc,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const char **badPtr,
|
||||
const char **versionPtr,
|
||||
const char **versionEndPtr,
|
||||
const char **encodingName,
|
||||
const ENCODING **encoding,
|
||||
int *standalone)
|
||||
{
|
||||
return doParseXmlDecl(NS(findEncoding),
|
||||
isGeneralTextEntity,
|
||||
enc,
|
||||
ptr,
|
||||
end,
|
||||
badPtr,
|
||||
versionPtr,
|
||||
versionEndPtr,
|
||||
encodingName,
|
||||
encoding,
|
||||
standalone);
|
||||
}
|
||||
|
||||
#endif /* XML_TOK_NS_C */
|
||||
Reference in New Issue
Block a user