mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-08 10:44:56 +00:00
Add copy of expat 1.95.2 for use with Xft. Not part of the default pull or build.
This commit is contained in:
parent
0ae8f0ab89
commit
6a8db7f18f
21
other-licenses/expat/COPYING
Normal file
21
other-licenses/expat/COPYING
Normal file
@ -0,0 +1,21 @@
|
||||
Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd
|
||||
and Clark Cooper
|
||||
|
||||
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.
|
46
other-licenses/expat/Changes
Normal file
46
other-licenses/expat/Changes
Normal file
@ -0,0 +1,46 @@
|
||||
Release 1.95.2 Fri Jul 27 2001
|
||||
- Nore changes to make MSVC happy with the build; add a single
|
||||
workspace to support both the library and xmlwf applicatiion.
|
||||
- Added a Windows installer for Windows users; includes
|
||||
xmlwf.exe.
|
||||
- Added compile-time constants that can be used to determine the
|
||||
Expat version
|
||||
- Removed a lot of GNU-specific dependencies to aide portability
|
||||
among the various Unix flavors.
|
||||
- Fix the UTF-8 BOM bug.
|
||||
- Cleaned up warning messages for several compilers.
|
||||
- Added the -Wall, -Wstrict-prototypes options for GCC.
|
||||
Release 1.95.1 Sun Oct 22 15:11:36 EDT 2000
|
||||
- Changes to get expat to build under Microsoft compiler
|
||||
- Removed all aborts and instead return an UNEXPECTED_STATE error.
|
||||
- Fixed a bug where a stray '%' in an entity value would cause an
|
||||
abort.
|
||||
- Defined XML_SetEndNamespaceDeclHandler. Thanks to Darryl Miles for
|
||||
finding this oversight.
|
||||
- Changed default patterns in lib/Makefile.in to fit non-GNU makes
|
||||
Thanks to robin@unrated.net for reporting and providing an
|
||||
account to test on.
|
||||
- The reference had the wrong label for XML_SetStartNamespaceDecl.
|
||||
Reported by an anonymous user.
|
||||
Release 1.95.0 Fri Sep 29 2000
|
||||
- XML_ParserCreate_MM
|
||||
Allows you to set a memory management suite to replace the
|
||||
standard malloc,realloc, and free.
|
||||
- XML_SetReturnNSTriplet
|
||||
If you turn this feature on when namespace processing is in
|
||||
effect, then qualified, prefixed element and attribute names
|
||||
are returned as "uri|name|prefix" where '|' is whatever
|
||||
separator character is used in namespace processing.
|
||||
- Merged in features from perl-expat
|
||||
o XML_SetElementDeclHandler
|
||||
o XML_SetAttlistDeclHandler
|
||||
o XML_SetXmlDeclHandler
|
||||
o XML_SetEntityDeclHandler
|
||||
o StartDoctypeDeclHandler takes 3 additional parameters:
|
||||
sysid, pubid, has_internal_subset
|
||||
o Many paired handler setters (like XML_SetElementHandler)
|
||||
now have corresponding individual handler setters
|
||||
o XML_GetInputContext for getting the input context of
|
||||
the current parse position.
|
||||
- Added reference material
|
||||
- Packaged into a distribution that builds a sharable library
|
58
other-licenses/expat/MANIFEST
Normal file
58
other-licenses/expat/MANIFEST
Normal file
@ -0,0 +1,58 @@
|
||||
Changes
|
||||
COPYING
|
||||
MANIFEST
|
||||
Makefile.in
|
||||
README
|
||||
config.h.in
|
||||
configure
|
||||
configure.in
|
||||
conftools/PrintPath
|
||||
conftools/ac_c_bigendian_cross.m4
|
||||
conftools/config.guess
|
||||
conftools/config.sub
|
||||
conftools/install-sh
|
||||
conftools/ltconfig
|
||||
conftools/ltmain.sh
|
||||
conftools/missing
|
||||
conftools/mkinstalldirs
|
||||
doc/reference.html
|
||||
doc/style.css
|
||||
examples/Makefile.in
|
||||
examples/elements.c
|
||||
examples/outline.c
|
||||
lib/Makefile.in
|
||||
lib/ascii.h
|
||||
lib/asciitab.h
|
||||
lib/expat.h.in
|
||||
lib/iasciitab.h
|
||||
lib/latin1tab.h
|
||||
lib/nametab.h
|
||||
lib/utf8tab.h
|
||||
lib/xmlparse.c
|
||||
lib/xmlrole.c
|
||||
lib/xmlrole.h
|
||||
lib/xmltok.c
|
||||
lib/xmltok.h
|
||||
lib/xmltok_impl.c
|
||||
lib/xmltok_impl.h
|
||||
lib/xmltok_ns.c
|
||||
lib/winconfig.h
|
||||
xmlwf/Makefile.in
|
||||
xmlwf/codepage.c
|
||||
xmlwf/codepage.h
|
||||
xmlwf/ct.c
|
||||
xmlwf/filemap.h
|
||||
xmlwf/readfilemap.c
|
||||
xmlwf/unixfilemap.c
|
||||
xmlwf/wfcheck.c
|
||||
xmlwf/wfcheck.h
|
||||
xmlwf/wfcheckmessage.c
|
||||
xmlwf/win32filemap.c
|
||||
xmlwf/xmlfile.c
|
||||
xmlwf/xmlfile.h
|
||||
xmlwf/xmlmime.c
|
||||
xmlwf/xmlmime.h
|
||||
xmlwf/xmltchar.h
|
||||
xmlwf/xmlurl.h
|
||||
xmlwf/xmlwf.c
|
||||
xmlwf/xmlwin32url.cxx
|
165
other-licenses/expat/Makefile.in
Normal file
165
other-licenses/expat/Makefile.in
Normal file
@ -0,0 +1,165 @@
|
||||
################################################################
|
||||
# Process this file with top-level configure script to produce Makefile
|
||||
#
|
||||
# Copyright 2000 Clark Cooper
|
||||
#
|
||||
# This file is part of EXPAT.
|
||||
#
|
||||
# EXPAT is free software; you can redistribute it and/or modify it
|
||||
# under the terms of the License (based on the MIT/X license) contained
|
||||
# in the file COPYING that comes with this distribution.
|
||||
#
|
||||
# EXPAT IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
||||
# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
||||
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
||||
# SOFTWARE OR THE USE OR OTHER DEALINGS IN EXPAT.
|
||||
#
|
||||
# ---
|
||||
# I started using automake, but
|
||||
# 1) it seemed like overkill
|
||||
# 2) I don't want all the GNU policies
|
||||
# 3) I wanted more explicit control over what gets built
|
||||
#
|
||||
# So I'm doing my Makefile.in files manually. But a fair part is based
|
||||
# on what I learned from perusing the Makefile.in's generated by automake,
|
||||
# and the automake authors still get my kudos.
|
||||
#
|
||||
|
||||
SHELL = @SHELL@
|
||||
|
||||
srcdir = @srcdir@
|
||||
top_srcdir = @top_srcdir@
|
||||
VPATH = @srcdir@
|
||||
prefix = @prefix@
|
||||
exec_prefix = @exec_prefix@
|
||||
|
||||
bindir = @bindir@
|
||||
sbindir = @sbindir@
|
||||
libexecdir = @libexecdir@
|
||||
datadir = @datadir@
|
||||
sysconfdir = @sysconfdir@
|
||||
sharedstatedir = @sharedstatedir@
|
||||
localstatedir = @localstatedir@
|
||||
libdir = @libdir@
|
||||
infodir = @infodir@
|
||||
mandir = @mandir@
|
||||
includedir = @includedir@
|
||||
oldincludedir = /usr/include
|
||||
|
||||
top_builddir = .
|
||||
|
||||
|
||||
AUTOCONF = autoconf
|
||||
|
||||
INSTALL = @INSTALL@
|
||||
INSTALL_PROGRAM = @INSTALL_PROGRAM@
|
||||
INSTALL_DATA = @INSTALL_DATA@
|
||||
INSTALL_SCRIPT = @INSTALL_SCRIPT@
|
||||
|
||||
NORMAL_INSTALL = :
|
||||
PRE_INSTALL = :
|
||||
POST_INSTALL = :
|
||||
NORMAL_UNINSTALL = :
|
||||
PRE_UNINSTALL = :
|
||||
POST_UNINSTALL = :
|
||||
host_alias = @host_alias@
|
||||
host_triplet = @host@
|
||||
|
||||
CC = @CC@
|
||||
|
||||
LIBTOOL = @LIBTOOL@
|
||||
LN_S = @LN_S@
|
||||
PACKAGE = @PACKAGE@
|
||||
RANLIB = @RANLIB@
|
||||
VERSION = @VERSION@
|
||||
|
||||
SUBDIRS = lib examples xmlwf
|
||||
INSTALLSUBDIRS = lib xmlwf
|
||||
ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
|
||||
CONFIG_HEADERS = config.h
|
||||
|
||||
DISTDIR = $(PACKAGE)-$(VERSION)
|
||||
DISTRIBUTION = $(DISTDIR).tar.gz
|
||||
|
||||
default: lib xmlwf
|
||||
|
||||
buildlib: lib
|
||||
|
||||
all: $(SUBDIRS)
|
||||
|
||||
Makefile: Makefile.in config.status
|
||||
CONFIG_FILES=$@ CONFIG_HEADERS= $(SHELL) config.status
|
||||
|
||||
config.status: configure
|
||||
@if test -f $@; then \
|
||||
$(SHELL) config.status --recheck ; \
|
||||
else \
|
||||
$(SHELL) configure ; \
|
||||
fi
|
||||
|
||||
configure: configure.in
|
||||
$(AUTOCONF)
|
||||
|
||||
config.h: config.h.in config.status
|
||||
CONFIG_FILES= CONFIG_HEADERS=$(CONFIG_HEADERS) \
|
||||
$(SHELL) ./config.status
|
||||
|
||||
$(SUBDIRS):
|
||||
cd $@ && $(MAKE)
|
||||
|
||||
clean:
|
||||
for dir in $(SUBDIRS); do \
|
||||
(cd $$dir && $(MAKE) clean); \
|
||||
done
|
||||
rm -f core *~
|
||||
|
||||
distclean:
|
||||
for dir in $(SUBDIRS); do \
|
||||
(cd $$dir && $(MAKE) distclean); \
|
||||
done
|
||||
rm -f config.h config.status config.log config.cache libtool
|
||||
rm -f Makefile examples/Makefile xmlwf/Makefile
|
||||
|
||||
extraclean: distclean
|
||||
rm -f aclocal.m4 config.h.in configure
|
||||
rm -f conftools/config.guess conftools/config.sub
|
||||
rm -f conftools/ltconfig conftools/ltmain.sh
|
||||
|
||||
maintainer-clean: distclean
|
||||
rm -f $(DISTRIBUTION)
|
||||
rm -rf $(DISTDIR)
|
||||
|
||||
distdir: MANIFEST
|
||||
test -d $(DISTDIR) && rm -rf $(DISTDIR); \
|
||||
mkdir $(DISTDIR); \
|
||||
flist=`sed -e "s/[ ]:.*$$//" MANIFEST`; for file in $$flist; do \
|
||||
cp -P $$file $(DISTDIR); \
|
||||
done
|
||||
|
||||
check: $(SUBDIRS)
|
||||
@echo
|
||||
@echo This package does not yet have a regression test.
|
||||
@echo
|
||||
|
||||
$(DISTRIBUTION): distdir
|
||||
tar cf - $(DISTDIR) | gzip -9 >$(DISTRIBUTION)
|
||||
|
||||
dist: $(DISTRIBUTION)
|
||||
|
||||
install:
|
||||
for dir in $(INSTALLSUBDIRS); do \
|
||||
(cd $$dir && $(MAKE) install); \
|
||||
done
|
||||
|
||||
uninstall:
|
||||
for dir in $(INSTALLSUBDIRS); do \
|
||||
(cd $$dir && $(MAKE) uninstall); \
|
||||
done
|
||||
|
||||
.PHONY: buildlib all $(SUBDIRS) \
|
||||
clean distclean extraclean maintainer-clean \
|
||||
dist distdir \
|
||||
install uninstall
|
72
other-licenses/expat/README
Normal file
72
other-licenses/expat/README
Normal file
@ -0,0 +1,72 @@
|
||||
|
||||
Expat, Release 1.95.2
|
||||
|
||||
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 executalbes, 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.
|
||||
|
||||
To build expat, 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
|
||||
|
||||
After running the configure script, the "make" command will build
|
||||
things and "make install" will install things into their proper
|
||||
location. Note that you need to have write permission into the
|
||||
directories into which things will be installed.
|
||||
|
||||
When building for use with C++, you may need to add additional
|
||||
compiler flags to support proper interaction with exceptions. This
|
||||
can be done by setting the CFLAGS environment variable. For example,
|
||||
when using GCC, you can use:
|
||||
|
||||
CFLAGS=-fexceptions ./configure
|
||||
|
||||
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
|
||||
|
||||
A reference manual is available in the file doc/reference.html in this
|
||||
distribution.
|
||||
|
||||
The homepage for this project is http://expat.sourceforge.net/. 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@lists.sourceforge.net.
|
||||
|
||||
Discussion related to the direction of future expat development takes
|
||||
place on expat-discuss@lists.sourceforge.net. Archives of this list
|
||||
may be found at http://www.geocrawler.com/redir-sf.php3?list=expat-discuss.
|
52
other-licenses/expat/config.h.in
Normal file
52
other-licenses/expat/config.h.in
Normal file
@ -0,0 +1,52 @@
|
||||
/* config.h.in. Generated automatically from configure.in by autoheader. */
|
||||
|
||||
/* Define to empty if the keyword does not work. */
|
||||
#undef const
|
||||
|
||||
/* Define if you have a working `mmap' system call. */
|
||||
#undef HAVE_MMAP
|
||||
|
||||
/* Define to `long' if <sys/types.h> doesn't define. */
|
||||
#undef off_t
|
||||
|
||||
/* Define to `unsigned' if <sys/types.h> doesn't define. */
|
||||
#undef size_t
|
||||
|
||||
/* Define if you have the ANSI C header files. */
|
||||
#undef STDC_HEADERS
|
||||
|
||||
/* Define if you have the bcopy function. */
|
||||
#undef HAVE_BCOPY
|
||||
|
||||
/* Define if you have the getpagesize function. */
|
||||
#undef HAVE_GETPAGESIZE
|
||||
|
||||
/* Define if you have the memmove function. */
|
||||
#undef HAVE_MEMMOVE
|
||||
|
||||
/* Define if you have the <fcntl.h> header file. */
|
||||
#undef HAVE_FCNTL_H
|
||||
|
||||
/* Define if you have the <unistd.h> header file. */
|
||||
#undef HAVE_UNISTD_H
|
||||
|
||||
/* whether byteorder is bigendian */
|
||||
#undef WORDS_BIGENDIAN
|
||||
|
||||
/* 1234 = LIL_ENDIAN, 4321 = BIGENDIAN */
|
||||
#undef BYTEORDER
|
||||
|
||||
|
||||
#define XML_NS
|
||||
#define XML_DTD
|
||||
|
||||
#define XML_CONTEXT_BYTES 1024
|
||||
|
||||
#ifndef HAVE_MEMMOVE
|
||||
#ifdef HAVE_BCOPY
|
||||
#define memmove(d,s,l) bcopy((s),(d),(l))
|
||||
#else
|
||||
#define memmove(d,s,l) ;punting on memmove;
|
||||
#endif
|
||||
|
||||
#endif
|
3022
other-licenses/expat/configure
vendored
Executable file
3022
other-licenses/expat/configure
vendored
Executable file
File diff suppressed because it is too large
Load Diff
111
other-licenses/expat/configure.in
Normal file
111
other-licenses/expat/configure.in
Normal file
@ -0,0 +1,111 @@
|
||||
dnl configuration script for expat
|
||||
dnl Process this file with autoconf to produce a configure script.
|
||||
dnl
|
||||
dnl Copyright 2000 Clark Cooper
|
||||
dnl
|
||||
dnl This file is part of EXPAT.
|
||||
dnl
|
||||
dnl EXPAT is free software; you can redistribute it and/or modify it
|
||||
dnl under the terms of the License (based on the MIT/X license) contained
|
||||
dnl in the file COPYING that comes with this distribution.
|
||||
dnl
|
||||
|
||||
AC_INIT(Makefile.in)
|
||||
AC_CONFIG_AUX_DIR(conftools)
|
||||
|
||||
dnl
|
||||
dnl Follow the GNU/Linux convention of odd number minor version for
|
||||
dnl beta/development releases and even number minor version for stable
|
||||
dnl releases. Edit is bumped with each release and set to 0 with
|
||||
dnl change to major or minor version.
|
||||
dnl
|
||||
|
||||
EXPAT_MAJOR_VERSION=1
|
||||
EXPAT_MINOR_VERSION=95
|
||||
EXPAT_EDIT=2
|
||||
|
||||
EXPAT_VERSION=$EXPAT_MAJOR_VERSION.$EXPAT_MINOR_VERSION.$EXPAT_EDIT
|
||||
VERSION=$EXPAT_VERSION
|
||||
PACKAGE=expat
|
||||
|
||||
dnl
|
||||
dnl Increment LIBREVISION if source code has changed at all
|
||||
dnl
|
||||
dnl If the API has changed, increment LIBCURRENT and set LIBREVISION to 0
|
||||
dnl
|
||||
dnl If the API changes compatibly (i.e. simply adding a new function
|
||||
dnl without changing or removing earlier interfaces), then increment LIBAGE.
|
||||
dnl
|
||||
dnl If the API changes incompatibly set LIBAGE back to 0
|
||||
dnl
|
||||
|
||||
LIBCURRENT=1
|
||||
LIBREVISION=0
|
||||
LIBAGE=1
|
||||
|
||||
AC_CONFIG_HEADER(config.h)
|
||||
|
||||
AC_LIBTOOL_WIN32_DLL
|
||||
AC_PROG_LIBTOOL
|
||||
|
||||
AC_SUBST(PACKAGE)
|
||||
AC_SUBST(VERSION)
|
||||
AC_SUBST(EXPAT_MAJOR_VERSION)
|
||||
AC_SUBST(EXPAT_MINOR_VERSION)
|
||||
AC_SUBST(EXPAT_EDIT)
|
||||
|
||||
AC_SUBST(LIBCURRENT)
|
||||
AC_SUBST(LIBREVISION)
|
||||
AC_SUBST(LIBAGE)
|
||||
|
||||
dnl Checks for programs.
|
||||
AC_PROG_CC
|
||||
AC_PROG_INSTALL
|
||||
|
||||
if test "$GCC" = yes ; then
|
||||
CFLAGS="$CFLAGS -Wall -Wmissing-prototypes -Wstrict-prototypes -fexceptions"
|
||||
fi
|
||||
|
||||
dnl Checks for libraries.
|
||||
|
||||
dnl Checks for header files.
|
||||
AC_HEADER_STDC
|
||||
AC_CHECK_HEADERS(fcntl.h unistd.h)
|
||||
|
||||
dnl Checks for typedefs, structures, and compiler characteristics.
|
||||
|
||||
dnl Note: Avoid using AC_C_BIGENDIAN because it does not
|
||||
dnl work in a cross compile.
|
||||
AC_C_BIGENDIAN_CROSS
|
||||
|
||||
AC_C_CONST
|
||||
AC_TYPE_OFF_T
|
||||
AC_TYPE_SIZE_T
|
||||
|
||||
dnl Checks for library functions.
|
||||
|
||||
AC_FUNC_MEMCMP
|
||||
AC_FUNC_MMAP
|
||||
|
||||
if test -z "$HAVE_MMAP"; then
|
||||
FILEMAP_OBJ=unixfilemap.o
|
||||
else
|
||||
FILEMAP_OBJ=readfilemap.o
|
||||
fi
|
||||
AC_SUBST(FILEMAP_OBJ)
|
||||
|
||||
AC_CHECK_FUNCS(memmove bcopy)
|
||||
|
||||
dnl Generate makefiles only for the directories that are present;
|
||||
dnl this allows this (and the generated configure script) to work
|
||||
dnl in "embedded distributions", where only part of the Expat sources
|
||||
dnl are included in the sources for another project.
|
||||
|
||||
OUTPUT="Makefile lib/Makefile lib/expat.h"
|
||||
if test -d ${srcdir}/xmlwf; then
|
||||
OUTPUT="$OUTPUT xmlwf/Makefile"
|
||||
fi
|
||||
if test -d ${srcdir}/examples; then
|
||||
OUTPUT="$OUTPUT examples/Makefile"
|
||||
fi
|
||||
AC_OUTPUT($OUTPUT)
|
116
other-licenses/expat/conftools/PrintPath
Executable file
116
other-licenses/expat/conftools/PrintPath
Executable file
@ -0,0 +1,116 @@
|
||||
#!/bin/sh
|
||||
# Look for program[s] somewhere in $PATH.
|
||||
#
|
||||
# Options:
|
||||
# -s
|
||||
# Do not print out full pathname. (silent)
|
||||
# -pPATHNAME
|
||||
# Look in PATHNAME instead of $PATH
|
||||
#
|
||||
# Usage:
|
||||
# PrintPath [-s] [-pPATHNAME] program [program ...]
|
||||
#
|
||||
# Initially written by Jim Jagielski for the Apache configuration mechanism
|
||||
# (with kudos to Kernighan/Pike)
|
||||
#
|
||||
# This script falls under the Apache License.
|
||||
# See http://www.apache.org/licenses/LICENSE
|
||||
|
||||
##
|
||||
# Some "constants"
|
||||
##
|
||||
pathname=$PATH
|
||||
echo="yes"
|
||||
|
||||
##
|
||||
# Find out what OS we are running for later on
|
||||
##
|
||||
os=`(uname) 2>/dev/null`
|
||||
|
||||
##
|
||||
# Parse command line
|
||||
##
|
||||
for args in $*
|
||||
do
|
||||
case $args in
|
||||
-s ) echo="no" ;;
|
||||
-p* ) pathname="`echo $args | sed 's/^..//'`" ;;
|
||||
* ) programs="$programs $args" ;;
|
||||
esac
|
||||
done
|
||||
|
||||
##
|
||||
# Now we make the adjustments required for OS/2 and everyone
|
||||
# else :)
|
||||
#
|
||||
# First of all, all OS/2 programs have the '.exe' extension.
|
||||
# Next, we adjust PATH (or what was given to us as PATH) to
|
||||
# be whitespace seperated directories.
|
||||
# Finally, we try to determine the best flag to use for
|
||||
# test/[] to look for an executable file. OS/2 just has '-r'
|
||||
# but with other OSs, we do some funny stuff to check to see
|
||||
# if test/[] knows about -x, which is the prefered flag.
|
||||
##
|
||||
|
||||
if [ "x$os" = "xOS/2" ]
|
||||
then
|
||||
ext=".exe"
|
||||
pathname=`echo -E $pathname |
|
||||
sed 's/^;/.;/
|
||||
s/;;/;.;/g
|
||||
s/;$/;./
|
||||
s/;/ /g
|
||||
s/\\\\/\\//g' `
|
||||
test_exec_flag="-r"
|
||||
else
|
||||
ext="" # No default extensions
|
||||
pathname=`echo $pathname |
|
||||
sed 's/^:/.:/
|
||||
s/::/:.:/g
|
||||
s/:$/:./
|
||||
s/:/ /g' `
|
||||
# Here is how we test to see if test/[] can handle -x
|
||||
testfile="pp.t.$$"
|
||||
|
||||
cat > $testfile <<ENDTEST
|
||||
#!/bin/sh
|
||||
if [ -x / ] || [ -x /bin ] || [ -x /bin/ls ]; then
|
||||
exit 0
|
||||
fi
|
||||
exit 1
|
||||
ENDTEST
|
||||
|
||||
if `/bin/sh $testfile 2>/dev/null`; then
|
||||
test_exec_flag="-x"
|
||||
else
|
||||
test_exec_flag="-r"
|
||||
fi
|
||||
rm -f $testfile
|
||||
fi
|
||||
|
||||
for program in $programs
|
||||
do
|
||||
for path in $pathname
|
||||
do
|
||||
if [ $test_exec_flag $path/${program}${ext} ] && \
|
||||
[ ! -d $path/${program}${ext} ]; then
|
||||
if [ "x$echo" = "xyes" ]; then
|
||||
echo $path/${program}${ext}
|
||||
fi
|
||||
exit 0
|
||||
fi
|
||||
|
||||
# Next try without extension (if one was used above)
|
||||
if [ "x$ext" != "x" ]; then
|
||||
if [ $test_exec_flag $path/${program} ] && \
|
||||
[ ! -d $path/${program} ]; then
|
||||
if [ "x$echo" = "xyes" ]; then
|
||||
echo $path/${program}
|
||||
fi
|
||||
exit 0
|
||||
fi
|
||||
fi
|
||||
done
|
||||
done
|
||||
exit 1
|
||||
|
81
other-licenses/expat/conftools/ac_c_bigendian_cross.m4
Normal file
81
other-licenses/expat/conftools/ac_c_bigendian_cross.m4
Normal file
@ -0,0 +1,81 @@
|
||||
dnl @synopsis AC_C_BIGENDIAN_CROSS
|
||||
dnl
|
||||
dnl Check endianess even when crosscompiling
|
||||
dnl (partially based on the original AC_C_BIGENDIAN).
|
||||
dnl
|
||||
dnl The implementation will create a binary, and instead of running
|
||||
dnl the binary it will be grep'ed for some symbols that will look
|
||||
dnl different for different endianess of the binary.
|
||||
dnl
|
||||
dnl @version $Id: ac_c_bigendian_cross.m4,v 1.1 2002/02/25 06:52:57 blizzard%redhat.com Exp $
|
||||
dnl @author Guido Draheim <guidod@gmx.de>
|
||||
dnl
|
||||
AC_DEFUN([AC_C_BIGENDIAN_CROSS],
|
||||
[AC_CACHE_CHECK(whether byte ordering is bigendian, ac_cv_c_bigendian,
|
||||
[ac_cv_c_bigendian=unknown
|
||||
# See if sys/param.h defines the BYTE_ORDER macro.
|
||||
AC_TRY_COMPILE([#include <sys/types.h>
|
||||
#include <sys/param.h>], [
|
||||
#if !BYTE_ORDER || !BIG_ENDIAN || !LITTLE_ENDIAN
|
||||
bogus endian macros
|
||||
#endif], [# It does; now see whether it defined to BIG_ENDIAN or not.
|
||||
AC_TRY_COMPILE([#include <sys/types.h>
|
||||
#include <sys/param.h>], [
|
||||
#if BYTE_ORDER != BIG_ENDIAN
|
||||
not big endian
|
||||
#endif], ac_cv_c_bigendian=yes, ac_cv_c_bigendian=no)])
|
||||
if test $ac_cv_c_bigendian = unknown; then
|
||||
AC_TRY_RUN([main () {
|
||||
/* Are we little or big endian? From Harbison&Steele. */
|
||||
union
|
||||
{
|
||||
long l;
|
||||
char c[sizeof (long)];
|
||||
} u;
|
||||
u.l = 1;
|
||||
exit (u.c[sizeof (long) - 1] == 1);
|
||||
}], ac_cv_c_bigendian=no, ac_cv_c_bigendian=yes,
|
||||
[ echo $ac_n "cross-compiling... " 2>&AC_FD_MSG ])
|
||||
fi])
|
||||
if test $ac_cv_c_bigendian = unknown; then
|
||||
AC_MSG_CHECKING(to probe for byte ordering)
|
||||
[
|
||||
cat >conftest.c <<EOF
|
||||
short ascii_mm[] = { 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 };
|
||||
short ascii_ii[] = { 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 };
|
||||
void _ascii() { char* s = (char*) ascii_mm; s = (char*) ascii_ii; }
|
||||
short ebcdic_ii[] = { 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 };
|
||||
short ebcdic_mm[] = { 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 };
|
||||
void _ebcdic() { char* s = (char*) ebcdic_mm; s = (char*) ebcdic_ii; }
|
||||
int main() { _ascii (); _ebcdic (); return 0; }
|
||||
EOF
|
||||
] if test -f conftest.c ; then
|
||||
if ${CC-cc} conftest.c -o conftest.o && test -f conftest.o ; then
|
||||
if test `grep -l BIGenDianSyS conftest.o` ; then
|
||||
echo $ac_n ' big endian probe OK, ' 1>&AC_FD_MSG
|
||||
ac_cv_c_bigendian=yes
|
||||
fi
|
||||
if test `grep -l LiTTleEnDian conftest.o` ; then
|
||||
echo $ac_n ' little endian probe OK, ' 1>&AC_FD_MSG
|
||||
if test $ac_cv_c_bigendian = yes ; then
|
||||
ac_cv_c_bigendian=unknown;
|
||||
else
|
||||
ac_cv_c_bigendian=no
|
||||
fi
|
||||
fi
|
||||
echo $ac_n 'guessing bigendian ... ' >&AC_FD_MSG
|
||||
fi
|
||||
fi
|
||||
AC_MSG_RESULT($ac_cv_c_bigendian)
|
||||
fi
|
||||
if test $ac_cv_c_bigendian = yes; then
|
||||
AC_DEFINE(WORDS_BIGENDIAN, 1, [whether byteorder is bigendian])
|
||||
BYTEORDER=4321
|
||||
else
|
||||
BYTEORDER=1234
|
||||
fi
|
||||
AC_DEFINE_UNQUOTED(BYTEORDER, $BYTEORDER, [1234 = LIL_ENDIAN, 4321 = BIGENDIAN])
|
||||
if test $ac_cv_c_bigendian = unknown; then
|
||||
AC_MSG_ERROR(unknown endianess - sorry, please pre-set ac_cv_c_bigendian)
|
||||
fi
|
||||
])
|
1183
other-licenses/expat/conftools/config.guess
vendored
Executable file
1183
other-licenses/expat/conftools/config.guess
vendored
Executable file
File diff suppressed because it is too large
Load Diff
1268
other-licenses/expat/conftools/config.sub
vendored
Executable file
1268
other-licenses/expat/conftools/config.sub
vendored
Executable file
File diff suppressed because it is too large
Load Diff
251
other-licenses/expat/conftools/install-sh
Executable file
251
other-licenses/expat/conftools/install-sh
Executable file
@ -0,0 +1,251 @@
|
||||
#!/bin/sh
|
||||
#
|
||||
# install - install a program, script, or datafile
|
||||
# This comes from X11R5 (mit/util/scripts/install.sh).
|
||||
#
|
||||
# Copyright 1991 by the Massachusetts Institute of Technology
|
||||
#
|
||||
# Permission to use, copy, modify, distribute, and sell this software and its
|
||||
# documentation for any purpose is hereby granted without fee, provided that
|
||||
# the above copyright notice appear in all copies and that both that
|
||||
# copyright notice and this permission notice appear in supporting
|
||||
# documentation, and that the name of M.I.T. not be used in advertising or
|
||||
# publicity pertaining to distribution of the software without specific,
|
||||
# written prior permission. M.I.T. makes no representations about the
|
||||
# suitability of this software for any purpose. It is provided "as is"
|
||||
# without express or implied warranty.
|
||||
#
|
||||
# Calling this script install-sh is preferred over install.sh, to prevent
|
||||
# `make' implicit rules from creating a file called install from it
|
||||
# when there is no Makefile.
|
||||
#
|
||||
# This script is compatible with the BSD install script, but was written
|
||||
# from scratch. It can only install one file at a time, a restriction
|
||||
# shared with many OS's install programs.
|
||||
|
||||
|
||||
# set DOITPROG to echo to test this script
|
||||
|
||||
# Don't use :- since 4.3BSD and earlier shells don't like it.
|
||||
doit="${DOITPROG-}"
|
||||
|
||||
|
||||
# put in absolute paths if you don't have them in your path; or use env. vars.
|
||||
|
||||
mvprog="${MVPROG-mv}"
|
||||
cpprog="${CPPROG-cp}"
|
||||
chmodprog="${CHMODPROG-chmod}"
|
||||
chownprog="${CHOWNPROG-chown}"
|
||||
chgrpprog="${CHGRPPROG-chgrp}"
|
||||
stripprog="${STRIPPROG-strip}"
|
||||
rmprog="${RMPROG-rm}"
|
||||
mkdirprog="${MKDIRPROG-mkdir}"
|
||||
|
||||
transformbasename=""
|
||||
transform_arg=""
|
||||
instcmd="$mvprog"
|
||||
chmodcmd="$chmodprog 0755"
|
||||
chowncmd=""
|
||||
chgrpcmd=""
|
||||
stripcmd=""
|
||||
rmcmd="$rmprog -f"
|
||||
mvcmd="$mvprog"
|
||||
src=""
|
||||
dst=""
|
||||
dir_arg=""
|
||||
|
||||
while [ x"$1" != x ]; do
|
||||
case $1 in
|
||||
-c) instcmd="$cpprog"
|
||||
shift
|
||||
continue;;
|
||||
|
||||
-d) dir_arg=true
|
||||
shift
|
||||
continue;;
|
||||
|
||||
-m) chmodcmd="$chmodprog $2"
|
||||
shift
|
||||
shift
|
||||
continue;;
|
||||
|
||||
-o) chowncmd="$chownprog $2"
|
||||
shift
|
||||
shift
|
||||
continue;;
|
||||
|
||||
-g) chgrpcmd="$chgrpprog $2"
|
||||
shift
|
||||
shift
|
||||
continue;;
|
||||
|
||||
-s) stripcmd="$stripprog"
|
||||
shift
|
||||
continue;;
|
||||
|
||||
-t=*) transformarg=`echo $1 | sed 's/-t=//'`
|
||||
shift
|
||||
continue;;
|
||||
|
||||
-b=*) transformbasename=`echo $1 | sed 's/-b=//'`
|
||||
shift
|
||||
continue;;
|
||||
|
||||
*) if [ x"$src" = x ]
|
||||
then
|
||||
src=$1
|
||||
else
|
||||
# this colon is to work around a 386BSD /bin/sh bug
|
||||
:
|
||||
dst=$1
|
||||
fi
|
||||
shift
|
||||
continue;;
|
||||
esac
|
||||
done
|
||||
|
||||
if [ x"$src" = x ]
|
||||
then
|
||||
echo "install: no input file specified"
|
||||
exit 1
|
||||
else
|
||||
true
|
||||
fi
|
||||
|
||||
if [ x"$dir_arg" != x ]; then
|
||||
dst=$src
|
||||
src=""
|
||||
|
||||
if [ -d $dst ]; then
|
||||
instcmd=:
|
||||
chmodcmd=""
|
||||
else
|
||||
instcmd=mkdir
|
||||
fi
|
||||
else
|
||||
|
||||
# Waiting for this to be detected by the "$instcmd $src $dsttmp" command
|
||||
# might cause directories to be created, which would be especially bad
|
||||
# if $src (and thus $dsttmp) contains '*'.
|
||||
|
||||
if [ -f $src -o -d $src ]
|
||||
then
|
||||
true
|
||||
else
|
||||
echo "install: $src does not exist"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
if [ x"$dst" = x ]
|
||||
then
|
||||
echo "install: no destination specified"
|
||||
exit 1
|
||||
else
|
||||
true
|
||||
fi
|
||||
|
||||
# If destination is a directory, append the input filename; if your system
|
||||
# does not like double slashes in filenames, you may need to add some logic
|
||||
|
||||
if [ -d $dst ]
|
||||
then
|
||||
dst="$dst"/`basename $src`
|
||||
else
|
||||
true
|
||||
fi
|
||||
fi
|
||||
|
||||
## this sed command emulates the dirname command
|
||||
dstdir=`echo $dst | sed -e 's,[^/]*$,,;s,/$,,;s,^$,.,'`
|
||||
|
||||
# Make sure that the destination directory exists.
|
||||
# this part is taken from Noah Friedman's mkinstalldirs script
|
||||
|
||||
# Skip lots of stat calls in the usual case.
|
||||
if [ ! -d "$dstdir" ]; then
|
||||
defaultIFS='
|
||||
'
|
||||
IFS="${IFS-${defaultIFS}}"
|
||||
|
||||
oIFS="${IFS}"
|
||||
# Some sh's can't handle IFS=/ for some reason.
|
||||
IFS='%'
|
||||
set - `echo ${dstdir} | sed -e 's@/@%@g' -e 's@^%@/@'`
|
||||
IFS="${oIFS}"
|
||||
|
||||
pathcomp=''
|
||||
|
||||
while [ $# -ne 0 ] ; do
|
||||
pathcomp="${pathcomp}${1}"
|
||||
shift
|
||||
|
||||
if [ ! -d "${pathcomp}" ] ;
|
||||
then
|
||||
$mkdirprog "${pathcomp}"
|
||||
else
|
||||
true
|
||||
fi
|
||||
|
||||
pathcomp="${pathcomp}/"
|
||||
done
|
||||
fi
|
||||
|
||||
if [ x"$dir_arg" != x ]
|
||||
then
|
||||
$doit $instcmd $dst &&
|
||||
|
||||
if [ x"$chowncmd" != x ]; then $doit $chowncmd $dst; else true ; fi &&
|
||||
if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dst; else true ; fi &&
|
||||
if [ x"$stripcmd" != x ]; then $doit $stripcmd $dst; else true ; fi &&
|
||||
if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dst; else true ; fi
|
||||
else
|
||||
|
||||
# If we're going to rename the final executable, determine the name now.
|
||||
|
||||
if [ x"$transformarg" = x ]
|
||||
then
|
||||
dstfile=`basename $dst`
|
||||
else
|
||||
dstfile=`basename $dst $transformbasename |
|
||||
sed $transformarg`$transformbasename
|
||||
fi
|
||||
|
||||
# don't allow the sed command to completely eliminate the filename
|
||||
|
||||
if [ x"$dstfile" = x ]
|
||||
then
|
||||
dstfile=`basename $dst`
|
||||
else
|
||||
true
|
||||
fi
|
||||
|
||||
# Make a temp file name in the proper directory.
|
||||
|
||||
dsttmp=$dstdir/#inst.$$#
|
||||
|
||||
# Move or copy the file name to the temp name
|
||||
|
||||
$doit $instcmd $src $dsttmp &&
|
||||
|
||||
trap "rm -f ${dsttmp}" 0 &&
|
||||
|
||||
# and set any options; do chmod last to preserve setuid bits
|
||||
|
||||
# If any of these fail, we abort the whole thing. If we want to
|
||||
# ignore errors from any of these, just make sure not to ignore
|
||||
# errors from the above "$doit $instcmd $src $dsttmp" command.
|
||||
|
||||
if [ x"$chowncmd" != x ]; then $doit $chowncmd $dsttmp; else true;fi &&
|
||||
if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dsttmp; else true;fi &&
|
||||
if [ x"$stripcmd" != x ]; then $doit $stripcmd $dsttmp; else true;fi &&
|
||||
if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dsttmp; else true;fi &&
|
||||
|
||||
# Now rename the file to the real destination.
|
||||
|
||||
$doit $rmcmd -f $dstdir/$dstfile &&
|
||||
$doit $mvcmd $dsttmp $dstdir/$dstfile
|
||||
|
||||
fi &&
|
||||
|
||||
|
||||
exit 0
|
3115
other-licenses/expat/conftools/ltconfig
Executable file
3115
other-licenses/expat/conftools/ltconfig
Executable file
File diff suppressed because it is too large
Load Diff
4028
other-licenses/expat/conftools/ltmain.sh
Normal file
4028
other-licenses/expat/conftools/ltmain.sh
Normal file
File diff suppressed because it is too large
Load Diff
190
other-licenses/expat/conftools/missing
Executable file
190
other-licenses/expat/conftools/missing
Executable file
@ -0,0 +1,190 @@
|
||||
#! /bin/sh
|
||||
# Common stub for a few missing GNU programs while installing.
|
||||
# Copyright (C) 1996, 1997 Free Software Foundation, Inc.
|
||||
# Franc,ois Pinard <pinard@iro.umontreal.ca>, 1996.
|
||||
|
||||
# This program is free software; you can redistribute it and/or modify
|
||||
# it under the terms of the GNU General Public License as published by
|
||||
# the Free Software Foundation; either version 2, or (at your option)
|
||||
# any later version.
|
||||
|
||||
# This program is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
# GNU General Public License for more details.
|
||||
|
||||
# You should have received a copy of the GNU General Public License
|
||||
# along with this program; if not, write to the Free Software
|
||||
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
|
||||
# 02111-1307, USA.
|
||||
|
||||
if test $# -eq 0; then
|
||||
echo 1>&2 "Try \`$0 --help' for more information"
|
||||
exit 1
|
||||
fi
|
||||
|
||||
case "$1" in
|
||||
|
||||
-h|--h|--he|--hel|--help)
|
||||
echo "\
|
||||
$0 [OPTION]... PROGRAM [ARGUMENT]...
|
||||
|
||||
Handle \`PROGRAM [ARGUMENT]...' for when PROGRAM is missing, or return an
|
||||
error status if there is no known handling for PROGRAM.
|
||||
|
||||
Options:
|
||||
-h, --help display this help and exit
|
||||
-v, --version output version information and exit
|
||||
|
||||
Supported PROGRAM values:
|
||||
aclocal touch file \`aclocal.m4'
|
||||
autoconf touch file \`configure'
|
||||
autoheader touch file \`config.h.in'
|
||||
automake touch all \`Makefile.in' files
|
||||
bison create \`y.tab.[ch]', if possible, from existing .[ch]
|
||||
flex create \`lex.yy.c', if possible, from existing .c
|
||||
lex create \`lex.yy.c', if possible, from existing .c
|
||||
makeinfo touch the output file
|
||||
yacc create \`y.tab.[ch]', if possible, from existing .[ch]"
|
||||
;;
|
||||
|
||||
-v|--v|--ve|--ver|--vers|--versi|--versio|--version)
|
||||
echo "missing - GNU libit 0.0"
|
||||
;;
|
||||
|
||||
-*)
|
||||
echo 1>&2 "$0: Unknown \`$1' option"
|
||||
echo 1>&2 "Try \`$0 --help' for more information"
|
||||
exit 1
|
||||
;;
|
||||
|
||||
aclocal)
|
||||
echo 1>&2 "\
|
||||
WARNING: \`$1' is missing on your system. You should only need it if
|
||||
you modified \`acinclude.m4' or \`configure.in'. You might want
|
||||
to install the \`Automake' and \`Perl' packages. Grab them from
|
||||
any GNU archive site."
|
||||
touch aclocal.m4
|
||||
;;
|
||||
|
||||
autoconf)
|
||||
echo 1>&2 "\
|
||||
WARNING: \`$1' is missing on your system. You should only need it if
|
||||
you modified \`configure.in'. You might want to install the
|
||||
\`Autoconf' and \`GNU m4' packages. Grab them from any GNU
|
||||
archive site."
|
||||
touch configure
|
||||
;;
|
||||
|
||||
autoheader)
|
||||
echo 1>&2 "\
|
||||
WARNING: \`$1' is missing on your system. You should only need it if
|
||||
you modified \`acconfig.h' or \`configure.in'. You might want
|
||||
to install the \`Autoconf' and \`GNU m4' packages. Grab them
|
||||
from any GNU archive site."
|
||||
files=`sed -n 's/^[ ]*A[CM]_CONFIG_HEADER(\([^)]*\)).*/\1/p' configure.in`
|
||||
test -z "$files" && files="config.h"
|
||||
touch_files=
|
||||
for f in $files; do
|
||||
case "$f" in
|
||||
*:*) touch_files="$touch_files "`echo "$f" |
|
||||
sed -e 's/^[^:]*://' -e 's/:.*//'`;;
|
||||
*) touch_files="$touch_files $f.in";;
|
||||
esac
|
||||
done
|
||||
touch $touch_files
|
||||
;;
|
||||
|
||||
automake)
|
||||
echo 1>&2 "\
|
||||
WARNING: \`$1' is missing on your system. You should only need it if
|
||||
you modified \`Makefile.am', \`acinclude.m4' or \`configure.in'.
|
||||
You might want to install the \`Automake' and \`Perl' packages.
|
||||
Grab them from any GNU archive site."
|
||||
find . -type f -name Makefile.am -print |
|
||||
sed 's/\.am$/.in/' |
|
||||
while read f; do touch "$f"; done
|
||||
;;
|
||||
|
||||
bison|yacc)
|
||||
echo 1>&2 "\
|
||||
WARNING: \`$1' is missing on your system. You should only need it if
|
||||
you modified a \`.y' file. You may need the \`Bison' package
|
||||
in order for those modifications to take effect. You can get
|
||||
\`Bison' from any GNU archive site."
|
||||
rm -f y.tab.c y.tab.h
|
||||
if [ $# -ne 1 ]; then
|
||||
eval LASTARG="\${$#}"
|
||||
case "$LASTARG" in
|
||||
*.y)
|
||||
SRCFILE=`echo "$LASTARG" | sed 's/y$/c/'`
|
||||
if [ -f "$SRCFILE" ]; then
|
||||
cp "$SRCFILE" y.tab.c
|
||||
fi
|
||||
SRCFILE=`echo "$LASTARG" | sed 's/y$/h/'`
|
||||
if [ -f "$SRCFILE" ]; then
|
||||
cp "$SRCFILE" y.tab.h
|
||||
fi
|
||||
;;
|
||||
esac
|
||||
fi
|
||||
if [ ! -f y.tab.h ]; then
|
||||
echo >y.tab.h
|
||||
fi
|
||||
if [ ! -f y.tab.c ]; then
|
||||
echo 'main() { return 0; }' >y.tab.c
|
||||
fi
|
||||
;;
|
||||
|
||||
lex|flex)
|
||||
echo 1>&2 "\
|
||||
WARNING: \`$1' is missing on your system. You should only need it if
|
||||
you modified a \`.l' file. You may need the \`Flex' package
|
||||
in order for those modifications to take effect. You can get
|
||||
\`Flex' from any GNU archive site."
|
||||
rm -f lex.yy.c
|
||||
if [ $# -ne 1 ]; then
|
||||
eval LASTARG="\${$#}"
|
||||
case "$LASTARG" in
|
||||
*.l)
|
||||
SRCFILE=`echo "$LASTARG" | sed 's/l$/c/'`
|
||||
if [ -f "$SRCFILE" ]; then
|
||||
cp "$SRCFILE" lex.yy.c
|
||||
fi
|
||||
;;
|
||||
esac
|
||||
fi
|
||||
if [ ! -f lex.yy.c ]; then
|
||||
echo 'main() { return 0; }' >lex.yy.c
|
||||
fi
|
||||
;;
|
||||
|
||||
makeinfo)
|
||||
echo 1>&2 "\
|
||||
WARNING: \`$1' is missing on your system. You should only need it if
|
||||
you modified a \`.texi' or \`.texinfo' file, or any other file
|
||||
indirectly affecting the aspect of the manual. The spurious
|
||||
call might also be the consequence of using a buggy \`make' (AIX,
|
||||
DU, IRIX). You might want to install the \`Texinfo' package or
|
||||
the \`GNU make' package. Grab either from any GNU archive site."
|
||||
file=`echo "$*" | sed -n 's/.*-o \([^ ]*\).*/\1/p'`
|
||||
if test -z "$file"; then
|
||||
file=`echo "$*" | sed 's/.* \([^ ]*\) *$/\1/'`
|
||||
file=`sed -n '/^@setfilename/ { s/.* \([^ ]*\) *$/\1/; p; q; }' $file`
|
||||
fi
|
||||
touch $file
|
||||
;;
|
||||
|
||||
*)
|
||||
echo 1>&2 "\
|
||||
WARNING: \`$1' is needed, and you do not seem to have it handy on your
|
||||
system. You might have modified some files without having the
|
||||
proper tools for further handling them. Check the \`README' file,
|
||||
it often tells you about the needed prerequirements for installing
|
||||
this package. You may also peek at any GNU archive site, in case
|
||||
some other package would contain this missing \`$1' program."
|
||||
exit 1
|
||||
;;
|
||||
esac
|
||||
|
||||
exit 0
|
40
other-licenses/expat/conftools/mkinstalldirs
Executable file
40
other-licenses/expat/conftools/mkinstalldirs
Executable file
@ -0,0 +1,40 @@
|
||||
#! /bin/sh
|
||||
# mkinstalldirs --- make directory hierarchy
|
||||
# Author: Noah Friedman <friedman@prep.ai.mit.edu>
|
||||
# Created: 1993-05-16
|
||||
# Public domain
|
||||
|
||||
# $Id: mkinstalldirs,v 1.1 2002/02/25 06:52:59 blizzard%redhat.com Exp $
|
||||
|
||||
errstatus=0
|
||||
|
||||
for file
|
||||
do
|
||||
set fnord `echo ":$file" | sed -ne 's/^:\//#/;s/^://;s/\// /g;s/^#/\//;p'`
|
||||
shift
|
||||
|
||||
pathcomp=
|
||||
for d
|
||||
do
|
||||
pathcomp="$pathcomp$d"
|
||||
case "$pathcomp" in
|
||||
-* ) pathcomp=./$pathcomp ;;
|
||||
esac
|
||||
|
||||
if test ! -d "$pathcomp"; then
|
||||
echo "mkdir $pathcomp"
|
||||
|
||||
mkdir "$pathcomp" || lasterr=$?
|
||||
|
||||
if test ! -d "$pathcomp"; then
|
||||
errstatus=$lasterr
|
||||
fi
|
||||
fi
|
||||
|
||||
pathcomp="$pathcomp/"
|
||||
done
|
||||
done
|
||||
|
||||
exit $errstatus
|
||||
|
||||
# mkinstalldirs ends here
|
1518
other-licenses/expat/doc/reference.html
Normal file
1518
other-licenses/expat/doc/reference.html
Normal file
File diff suppressed because it is too large
Load Diff
47
other-licenses/expat/doc/style.css
Normal file
47
other-licenses/expat/doc/style.css
Normal file
@ -0,0 +1,47 @@
|
||||
body {
|
||||
background-color: white
|
||||
}
|
||||
|
||||
.eg {
|
||||
padding-left: 1em;
|
||||
padding-top: .5em;
|
||||
border: solid thin;
|
||||
margin: 1em 0;
|
||||
background-color: tan;
|
||||
margin-left: 5%;
|
||||
margin-right: 10%;
|
||||
}
|
||||
|
||||
.handler {
|
||||
width: 100%;
|
||||
border-top-width: thin;
|
||||
margin-left: 5%;
|
||||
margin-bottom: 1em;
|
||||
}
|
||||
|
||||
.handler p {
|
||||
margin-left: 3%;
|
||||
}
|
||||
|
||||
.setter {
|
||||
font-weight: bold;
|
||||
}
|
||||
|
||||
.signature {
|
||||
color: navy;
|
||||
}
|
||||
|
||||
.fcndec {
|
||||
width: 100%;
|
||||
border-top-width: thin;
|
||||
font-weight: bold;
|
||||
}
|
||||
|
||||
.fcndef {
|
||||
margin-left: 5%;
|
||||
margin-bottom: 2em;
|
||||
}
|
||||
|
||||
dd {
|
||||
margin-bottom: 2em;
|
||||
}
|
54
other-licenses/expat/examples/Makefile.in
Normal file
54
other-licenses/expat/examples/Makefile.in
Normal file
@ -0,0 +1,54 @@
|
||||
################################################################
|
||||
# Process this file with top-level configure script to produce Makefile
|
||||
#
|
||||
# Copyright 2000 Clark Cooper
|
||||
#
|
||||
# This file is part of EXPAT.
|
||||
#
|
||||
# EXPAT is free software; you can redistribute it and/or modify it
|
||||
# under the terms of the License (based on the MIT/X license) contained
|
||||
# in the file COPYING that comes with this distribution.
|
||||
#
|
||||
# EXPAT IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
||||
# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
||||
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
||||
# SOFTWARE OR THE USE OR OTHER DEALINGS IN EXPAT.
|
||||
#
|
||||
|
||||
LIBDIR = ../lib/.libs
|
||||
INCDIR = ../lib
|
||||
|
||||
CPPFLAGS = @CPPFLAGS@
|
||||
LDFLAGS = @LDFLAGS@ -static
|
||||
LIBS = -L$(LIBDIR) -lexpat
|
||||
CC = @CC@
|
||||
CFLAGS = @CFLAGS@ -I$(INCDIR)
|
||||
|
||||
srcdir = @srcdir@
|
||||
top_srcdir = @top_srcdir@
|
||||
VPATH = @srcdir@
|
||||
|
||||
|
||||
all: elements outline
|
||||
|
||||
elements: elements.o
|
||||
$(CC) -o $@ $< $(LDFLAGS) $(LIBS)
|
||||
|
||||
outline: outline.o
|
||||
$(CC) -o $@ $< $(LDFLAGS) $(LIBS)
|
||||
|
||||
check: $(SUBDIRS)
|
||||
@echo
|
||||
@echo This package does not yet have a regression test.
|
||||
@echo
|
||||
|
||||
clean:
|
||||
rm -f elements outline core *.o
|
||||
|
||||
distclean: clean
|
||||
rm -f Makefile
|
||||
|
||||
maintainer-clean: distclean
|
49
other-licenses/expat/examples/elements.c
Normal file
49
other-licenses/expat/examples/elements.c
Normal file
@ -0,0 +1,49 @@
|
||||
/* This is simple demonstration of how to use expat. This program
|
||||
reads an XML document from standard input and writes a line with the
|
||||
name of each element to standard output indenting child elements by
|
||||
one tab stop more than their parent element. */
|
||||
|
||||
#include <stdio.h>
|
||||
#include "expat.h"
|
||||
|
||||
static void
|
||||
startElement(void *userData, const char *name, const char **atts)
|
||||
{
|
||||
int i;
|
||||
int *depthPtr = userData;
|
||||
for (i = 0; i < *depthPtr; i++)
|
||||
putchar('\t');
|
||||
puts(name);
|
||||
*depthPtr += 1;
|
||||
}
|
||||
|
||||
static void
|
||||
endElement(void *userData, const char *name)
|
||||
{
|
||||
int *depthPtr = userData;
|
||||
*depthPtr -= 1;
|
||||
}
|
||||
|
||||
int
|
||||
main(int argc, char *argv[])
|
||||
{
|
||||
char buf[BUFSIZ];
|
||||
XML_Parser parser = XML_ParserCreate(NULL);
|
||||
int done;
|
||||
int depth = 0;
|
||||
XML_SetUserData(parser, &depth);
|
||||
XML_SetElementHandler(parser, startElement, endElement);
|
||||
do {
|
||||
size_t len = fread(buf, 1, sizeof(buf), stdin);
|
||||
done = len < sizeof(buf);
|
||||
if (!XML_Parse(parser, buf, len, done)) {
|
||||
fprintf(stderr,
|
||||
"%s at line %d\n",
|
||||
XML_ErrorString(XML_GetErrorCode(parser)),
|
||||
XML_GetCurrentLineNumber(parser));
|
||||
return 1;
|
||||
}
|
||||
} while (!done);
|
||||
XML_ParserFree(parser);
|
||||
return 0;
|
||||
}
|
88
other-licenses/expat/examples/outline.c
Normal file
88
other-licenses/expat/examples/outline.c
Normal file
@ -0,0 +1,88 @@
|
||||
/*****************************************************************
|
||||
* outline.c
|
||||
*
|
||||
* Copyright 1999, Clark Cooper
|
||||
* All rights reserved.
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the license contained in the
|
||||
* COPYING file that comes with the expat distribution.
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
* Read an XML document from standard input and print an element
|
||||
* outline on standard output.
|
||||
*/
|
||||
|
||||
|
||||
#include <stdio.h>
|
||||
#include <expat.h>
|
||||
|
||||
#define BUFFSIZE 8192
|
||||
|
||||
char Buff[BUFFSIZE];
|
||||
|
||||
int Depth;
|
||||
|
||||
static void
|
||||
start(void *data, const char *el, const char **attr) {
|
||||
int i;
|
||||
|
||||
for (i = 0; i < Depth; i++)
|
||||
printf(" ");
|
||||
|
||||
printf("%s", el);
|
||||
|
||||
for (i = 0; attr[i]; i += 2) {
|
||||
printf(" %s='%s'", attr[i], attr[i + 1]);
|
||||
}
|
||||
|
||||
printf("\n");
|
||||
Depth++;
|
||||
} /* End of start handler */
|
||||
|
||||
static void
|
||||
end(void *data, const char *el) {
|
||||
Depth--;
|
||||
} /* End of end handler */
|
||||
|
||||
int
|
||||
main(int argc, char *argv[]) {
|
||||
XML_Parser p = XML_ParserCreate(NULL);
|
||||
if (! p) {
|
||||
fprintf(stderr, "Couldn't allocate memory for parser\n");
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
XML_SetElementHandler(p, start, end);
|
||||
|
||||
for (;;) {
|
||||
int done;
|
||||
int len;
|
||||
|
||||
len = fread(Buff, 1, BUFFSIZE, stdin);
|
||||
if (ferror(stdin)) {
|
||||
fprintf(stderr, "Read error\n");
|
||||
exit(-1);
|
||||
}
|
||||
done = feof(stdin);
|
||||
|
||||
if (! XML_Parse(p, Buff, len, done)) {
|
||||
fprintf(stderr, "Parse error at line %d:\n%s\n",
|
||||
XML_GetCurrentLineNumber(p),
|
||||
XML_ErrorString(XML_GetErrorCode(p)));
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
if (done)
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
} /* End of main */
|
||||
|
158
other-licenses/expat/lib/Makefile.in
Normal file
158
other-licenses/expat/lib/Makefile.in
Normal file
@ -0,0 +1,158 @@
|
||||
################################################################
|
||||
# Process this file with top-level configure script to produce Makefile
|
||||
#
|
||||
# Copyright 2000 Clark Cooper
|
||||
#
|
||||
# This file is part of EXPAT.
|
||||
#
|
||||
# EXPAT is free software; you can redistribute it and/or modify it
|
||||
# under the terms of the License (based on the MIT/X license) contained
|
||||
# in the file COPYING that comes with this distribution.
|
||||
#
|
||||
# EXPAT IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
||||
# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
||||
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
||||
# SOFTWARE OR THE USE OR OTHER DEALINGS IN EXPAT.
|
||||
#
|
||||
|
||||
|
||||
SHELL = @SHELL@
|
||||
|
||||
srcdir = @srcdir@
|
||||
top_srcdir = @top_srcdir@
|
||||
VPATH = @srcdir@
|
||||
prefix = @prefix@
|
||||
exec_prefix = @exec_prefix@
|
||||
|
||||
bindir = @bindir@
|
||||
sbindir = @sbindir@
|
||||
libexecdir = @libexecdir@
|
||||
datadir = @datadir@
|
||||
sysconfdir = @sysconfdir@
|
||||
sharedstatedir = @sharedstatedir@
|
||||
localstatedir = @localstatedir@
|
||||
libdir = @libdir@
|
||||
infodir = @infodir@
|
||||
mandir = @mandir@
|
||||
includedir = @includedir@
|
||||
oldincludedir = /usr/include
|
||||
|
||||
subdir = lib
|
||||
|
||||
top_builddir = ..
|
||||
|
||||
INSTALL = @INSTALL@
|
||||
INSTALL_PROGRAM = @INSTALL_PROGRAM@
|
||||
INSTALL_SCRIPT = @INSTALL_SCRIPT@
|
||||
INSTALL_DATA = @INSTALL_DATA@
|
||||
|
||||
host_alias = @host_alias@
|
||||
host_triplet = @host@
|
||||
AS = @AS@
|
||||
CC = @CC@
|
||||
DLLTOOL = @DLLTOOL@
|
||||
LIBTOOL = @LIBTOOL@
|
||||
LN_S = @LN_S@
|
||||
OBJDUMP = @OBJDUMP@
|
||||
PACKAGE = @PACKAGE@
|
||||
RANLIB = @RANLIB@
|
||||
VERSION = @VERSION@
|
||||
|
||||
LIBRARY = libexpat.la
|
||||
SOURCES = xmlparse.c xmltok.c xmlrole.c
|
||||
OBJECTS = $(SOURCES:.c=.o)
|
||||
LTOBJECTS = $(SOURCES:.c=.lo)
|
||||
|
||||
TEMPLATES = xmltok_impl.c xmltok_ns.c
|
||||
APIHEADER = expat.h
|
||||
HEADERS = ascii.h iasciitab.h utf8tab.h xmltok.h asciitab.h latin1tab.h \
|
||||
nametab.h xmldef.h xmlrole.h xmltok_impl.h
|
||||
|
||||
mkinstalldirs = $(SHELL) $(top_srcdir)/conftools/mkinstalldirs
|
||||
CONFIG_HEADER = ../config.h
|
||||
CONFIG_CLEAN_FILES =
|
||||
|
||||
INCLUDES = -I$(srcdir) -I. -I..
|
||||
DEFS = @DEFS@ -DPACKAGE='"$(PACKAGE)"' -DVERSION='"$(PACKAGE)_$(VERSION)"'
|
||||
|
||||
CPPFLAGS = @CPPFLAGS@
|
||||
LDFLAGS = @LDFLAGS@
|
||||
LIBS = @LIBS@
|
||||
CFLAGS = @CFLAGS@
|
||||
|
||||
LIBREVISION = @LIBREVISION@
|
||||
LIBCURRENT = @LIBCURRENT@
|
||||
LIBAGE = @LIBAGE@
|
||||
|
||||
COMPILE = $(CC) $(DEFS) $(INCLUDES) $(CPPFLAGS) $(CFLAGS)
|
||||
LTCOMPILE = $(LIBTOOL) --mode=compile $(CC) $(DEFS) $(INCLUDES) $(CPPFLAGS) $(CFLAGS)
|
||||
CCLD = $(CC)
|
||||
LINK = $(LIBTOOL) --mode=link $(CCLD) -version-info $(LIBCURRENT):$(LIBREVISION):$(LIBAGE) $(CFLAGS) $(LDFLAGS) -o $@
|
||||
DIST_COMMON = Makefile.in
|
||||
|
||||
|
||||
DISTFILES = $(DIST_COMMON) $(SOURCES) $(TEMPLATES) $(APIHEADER) $(HEADERS)
|
||||
|
||||
TAR = gtar
|
||||
GZIP_ENV = --best
|
||||
|
||||
all: $(LIBRARY)
|
||||
|
||||
.SUFFIXES: .c .lo .o
|
||||
.PHONY: all clean distclean maintainer-clean
|
||||
|
||||
.c.o:
|
||||
$(COMPILE) -c $<
|
||||
|
||||
.c.lo:
|
||||
$(LTCOMPILE) -c $<
|
||||
|
||||
Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
|
||||
cd $(top_builddir) \
|
||||
&& CONFIG_FILES=$(subdir)/$@ CONFIG_HEADERS= $(SHELL) ./config.status
|
||||
|
||||
$(top_builddir)/config.status: $(top_builddir)/configure
|
||||
cd $(top_builddir) && $(MAKE) config.status
|
||||
|
||||
$(top_builddir)/config.h: $(top_builddir)/config.h.in
|
||||
cd $(top_builddir) && $(MAKE) config.h
|
||||
|
||||
clean:
|
||||
rm -f $(LIBRARY) *.o *.lo *~
|
||||
rm -rf .libs _libs
|
||||
|
||||
distclean: clean
|
||||
rm -f Makefile
|
||||
|
||||
maintainer-clean: distclean
|
||||
|
||||
check: $(SUBDIRS)
|
||||
@echo
|
||||
@echo This package does not yet have a regression test.
|
||||
@echo
|
||||
|
||||
install: $(LIBRARY) $(APIHEADER)
|
||||
$(mkinstalldirs) $(libdir) $(includedir)
|
||||
$(LIBTOOL) --mode=install $(INSTALL) $(LIBRARY) $(libdir)/$(LIBRARY)
|
||||
$(INSTALL_DATA) $(APIHEADER) $(includedir)
|
||||
|
||||
uninstall:
|
||||
$(LIBTOOL) --mode=uninstall rm -f $(libdir)/$(LIBRARY);
|
||||
rm -f $(libdir)/$(APIHEADER)
|
||||
|
||||
$(LIBRARY): $(LTOBJECTS)
|
||||
$(LINK) -rpath $(libdir) $(LDFLAGS) $(LTOBJECTS)
|
||||
|
||||
xmlparse.o \
|
||||
xmlparse.lo: xmlparse.c expat.h xmlrole.h xmltok.h $(top_builddir)/config.h
|
||||
|
||||
xmlrole.o \
|
||||
xmlrole.lo: xmlrole.c ascii.h xmlrole.h $(top_builddir)/config.h
|
||||
|
||||
xmltok.o \
|
||||
xmltok.lo: xmltok.c xmltok_impl.c xmltok_ns.c \
|
||||
ascii.h asciitab.h iasciitab.h latin1tab.h nametab.h utf8tab.h \
|
||||
xmltok.h xmltok_impl.h $(top_builddir)/config.h
|
86
other-licenses/expat/lib/ascii.h
Normal file
86
other-licenses/expat/lib/ascii.h
Normal file
@ -0,0 +1,86 @@
|
||||
/*
|
||||
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
|
37
other-licenses/expat/lib/asciitab.h
Normal file
37
other-licenses/expat/lib/asciitab.h
Normal file
@ -0,0 +1,37 @@
|
||||
/*
|
||||
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,
|
735
other-licenses/expat/lib/expat.h.in
Normal file
735
other-licenses/expat/lib/expat.h.in
Normal file
@ -0,0 +1,735 @@
|
||||
/*
|
||||
Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd
|
||||
See the file COPYING for copying permission.
|
||||
*/
|
||||
|
||||
#ifndef XmlParse_INCLUDED
|
||||
#define XmlParse_INCLUDED 1
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#ifndef XMLPARSEAPI
|
||||
# if defined(__declspec) && !defined(__BEOS__)
|
||||
# define XMLPARSEAPI(type) __declspec(dllimport) type __cdecl
|
||||
# else
|
||||
# define XMLPARSEAPI(type) type
|
||||
# endif
|
||||
#endif /* not defined XMLPARSEAPI */
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef void *XML_Parser;
|
||||
|
||||
/* Information is UTF-8 encoded. */
|
||||
typedef char XML_Char;
|
||||
typedef char XML_LChar;
|
||||
|
||||
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 (*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 (*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 (*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. When a namespace is not declared,
|
||||
the name and prefix will be passed through without expansion. */
|
||||
|
||||
XMLPARSEAPI(XML_Parser)
|
||||
XML_ParserCreateNS(const XML_Char *encoding, XML_Char namespaceSeparator);
|
||||
|
||||
|
||||
/* Constructs a new parser using the memory management suit 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);
|
||||
|
||||
/* atts is array of name/value pairs, terminated by 0;
|
||||
names and values are 0 terminated. */
|
||||
|
||||
typedef void (*XML_StartElementHandler)(void *userData,
|
||||
const XML_Char *name,
|
||||
const XML_Char **atts);
|
||||
|
||||
typedef void (*XML_EndElementHandler)(void *userData,
|
||||
const XML_Char *name);
|
||||
|
||||
|
||||
/* s is not 0 terminated. */
|
||||
typedef void (*XML_CharacterDataHandler)(void *userData,
|
||||
const XML_Char *s,
|
||||
int len);
|
||||
|
||||
/* target and data are 0 terminated */
|
||||
typedef void (*XML_ProcessingInstructionHandler)(void *userData,
|
||||
const XML_Char *target,
|
||||
const XML_Char *data);
|
||||
|
||||
/* data is 0 terminated */
|
||||
typedef void (*XML_CommentHandler)(void *userData, const XML_Char *data);
|
||||
|
||||
typedef void (*XML_StartCdataSectionHandler)(void *userData);
|
||||
typedef void (*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. 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 (*XML_DefaultHandler)(void *userData,
|
||||
const XML_Char *s,
|
||||
int len);
|
||||
|
||||
/* This is called for the start of the DOCTYPE declaration, before
|
||||
any DTD or internal subset is parsed. */
|
||||
|
||||
typedef void (*XML_StartDoctypeDeclHandler)(void *userData,
|
||||
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 (*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 null 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.
|
||||
*/
|
||||
|
||||
typedef void (*XML_EntityDeclHandler) (void *userData,
|
||||
const XML_Char *entityName,
|
||||
int is_parameter_entity,
|
||||
const XML_Char *value,
|
||||
int value_length,
|
||||
const XML_Char *base,
|
||||
const XML_Char *systemId,
|
||||
const XML_Char *publicId,
|
||||
const XML_Char *notationName);
|
||||
|
||||
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 (*XML_UnparsedEntityDeclHandler)(void *userData,
|
||||
const XML_Char *entityName,
|
||||
const XML_Char *base,
|
||||
const XML_Char *systemId,
|
||||
const XML_Char *publicId,
|
||||
const XML_Char *notationName);
|
||||
|
||||
/* This is called for a declaration of notation.
|
||||
The base argument is whatever was set by XML_SetBase.
|
||||
The notationName will never be null. The other arguments can be. */
|
||||
|
||||
typedef void (*XML_NotationDeclHandler)(void *userData,
|
||||
const XML_Char *notationName,
|
||||
const XML_Char *base,
|
||||
const XML_Char *systemId,
|
||||
const XML_Char *publicId);
|
||||
|
||||
/* 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 (*XML_StartNamespaceDeclHandler)(void *userData,
|
||||
const XML_Char *prefix,
|
||||
const XML_Char *uri);
|
||||
|
||||
typedef void (*XML_EndNamespaceDeclHandler)(void *userData,
|
||||
const XML_Char *prefix);
|
||||
|
||||
/* This is called if the document is not standalone (it has an
|
||||
external subset or a reference to a parameter entity, but does not
|
||||
have standalone="yes"). If this handler returns 0, then processing
|
||||
will not continue, and the parser will return a
|
||||
XML_ERROR_NOT_STANDALONE error. */
|
||||
|
||||
typedef int (*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.
|
||||
The handler should return 0 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 (*XML_ExternalEntityRefHandler)(XML_Parser parser,
|
||||
const XML_Char *context,
|
||||
const XML_Char *base,
|
||||
const XML_Char *systemId,
|
||||
const XML_Char *publicId);
|
||||
|
||||
/* 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 (*convert)(void *data, const char *s);
|
||||
void (*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 1.
|
||||
Otherwise it must return 0.
|
||||
If info does not describe a suitable encoding,
|
||||
then the parser will return an XML_UNKNOWN_ENCODING error. */
|
||||
|
||||
typedef int (*XML_UnknownEncodingHandler)(void *encodingHandlerData,
|
||||
const XML_Char *name,
|
||||
XML_Encoding *info);
|
||||
|
||||
XMLPARSEAPI(void)
|
||||
XML_SetElementHandler(XML_Parser parser,
|
||||
XML_StartElementHandler start,
|
||||
XML_EndElementHandler end);
|
||||
|
||||
XMLPARSEAPI(void)
|
||||
XML_SetStartElementHandler(XML_Parser, XML_StartElementHandler);
|
||||
|
||||
XMLPARSEAPI(void)
|
||||
XML_SetEndElementHandler(XML_Parser, XML_EndElementHandler);
|
||||
|
||||
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. The entity reference will be passed to the default
|
||||
handler. */
|
||||
|
||||
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, void *arg);
|
||||
|
||||
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 names
|
||||
has a prefix.
|
||||
*/
|
||||
|
||||
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. It must not be called after XML_Parse
|
||||
or XML_ParseBuffer. */
|
||||
|
||||
XMLPARSEAPI(int)
|
||||
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);
|
||||
|
||||
/* 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 zero if out of memory, non-zero otherwise. */
|
||||
|
||||
XMLPARSEAPI(int)
|
||||
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);
|
||||
|
||||
/* Parses some input. Returns 0 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). */
|
||||
XMLPARSEAPI(int)
|
||||
XML_Parse(XML_Parser parser, const char *s, int len, int isFinal);
|
||||
|
||||
XMLPARSEAPI(void *)
|
||||
XML_GetBuffer(XML_Parser parser, int len);
|
||||
|
||||
XMLPARSEAPI(int)
|
||||
XML_ParseBuffer(XML_Parser parser, int len, int isFinal);
|
||||
|
||||
/* 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 0 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. */
|
||||
|
||||
XMLPARSEAPI(int)
|
||||
XML_SetParamEntityParsing(XML_Parser parser,
|
||||
enum XML_ParamEntityParsing parsing);
|
||||
|
||||
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
|
||||
};
|
||||
|
||||
/* If XML_Parse or XML_ParseBuffer have returned 0, 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 when XML_Parse or XML_ParseBuffer return 0;
|
||||
in this case the location is the location of the character at which
|
||||
the error was detected.
|
||||
They may also be called from any other callback called to report
|
||||
some parse event; in this the location is the location of the first
|
||||
of the sequence of characters that generated the event. */
|
||||
|
||||
XMLPARSEAPI(int) XML_GetCurrentLineNumber(XML_Parser parser);
|
||||
XMLPARSEAPI(int) XML_GetCurrentColumnNumber(XML_Parser parser);
|
||||
XMLPARSEAPI(long) 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 memory used by the parser. */
|
||||
XMLPARSEAPI(void)
|
||||
XML_ParserFree(XML_Parser parser);
|
||||
|
||||
/* Returns a string describing the error. */
|
||||
XMLPARSEAPI(const XML_LChar *)
|
||||
XML_ErrorString(int 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);
|
||||
|
||||
#define XML_MAJOR_VERSION @EXPAT_MAJOR_VERSION@
|
||||
#define XML_MINOR_VERSION @EXPAT_MINOR_VERSION@
|
||||
#define XML_MICRO_VERSION @EXPAT_EDIT@
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* not XmlParse_INCLUDED */
|
38
other-licenses/expat/lib/iasciitab.h
Normal file
38
other-licenses/expat/lib/iasciitab.h
Normal file
@ -0,0 +1,38 @@
|
||||
/*
|
||||
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,
|
37
other-licenses/expat/lib/latin1tab.h
Normal file
37
other-licenses/expat/lib/latin1tab.h
Normal file
@ -0,0 +1,37 @@
|
||||
/*
|
||||
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,
|
150
other-licenses/expat/lib/nametab.h
Normal file
150
other-licenses/expat/lib/nametab.h
Normal file
@ -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,
|
||||
};
|
38
other-licenses/expat/lib/utf8tab.h
Normal file
38
other-licenses/expat/lib/utf8tab.h
Normal file
@ -0,0 +1,38 @@
|
||||
/*
|
||||
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,
|
27
other-licenses/expat/lib/winconfig.h
Normal file
27
other-licenses/expat/lib/winconfig.h
Normal file
@ -0,0 +1,27 @@
|
||||
/*================================================================
|
||||
** 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_BYTE_ORDER 12
|
||||
#define XML_CONTEXT_BYTES 1024
|
||||
|
||||
#endif /* ndef WINCONFIG_H */
|
4635
other-licenses/expat/lib/xmlparse.c
Normal file
4635
other-licenses/expat/lib/xmlparse.c
Normal file
File diff suppressed because it is too large
Load Diff
1275
other-licenses/expat/lib/xmlrole.c
Normal file
1275
other-licenses/expat/lib/xmlrole.c
Normal file
File diff suppressed because it is too large
Load Diff
100
other-licenses/expat/lib/xmlrole.h
Normal file
100
other-licenses/expat/lib/xmlrole.h
Normal file
@ -0,0 +1,100 @@
|
||||
/*
|
||||
Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
|
||||
See the file COPYING for copying permission.
|
||||
*/
|
||||
|
||||
#ifndef XmlRole_INCLUDED
|
||||
#define XmlRole_INCLUDED 1
|
||||
|
||||
#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_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_VALUE,
|
||||
XML_ROLE_ENTITY_SYSTEM_ID,
|
||||
XML_ROLE_ENTITY_PUBLIC_ID,
|
||||
XML_ROLE_ENTITY_COMPLETE,
|
||||
XML_ROLE_ENTITY_NOTATION_NAME,
|
||||
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_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_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,
|
||||
#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 (*handler)(struct prolog_state *state,
|
||||
int tok,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
const ENCODING *enc);
|
||||
unsigned level;
|
||||
#ifdef XML_DTD
|
||||
unsigned includeLevel;
|
||||
int documentEntity;
|
||||
#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 */
|
1566
other-licenses/expat/lib/xmltok.c
Normal file
1566
other-licenses/expat/lib/xmltok.c
Normal file
File diff suppressed because it is too large
Load Diff
299
other-licenses/expat/lib/xmltok.h
Normal file
299
other-licenses/expat/lib/xmltok.h
Normal file
@ -0,0 +1,299 @@
|
||||
/*
|
||||
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 */
|
||||
unsigned long lineNumber;
|
||||
unsigned long columnNumber;
|
||||
} POSITION;
|
||||
|
||||
typedef struct {
|
||||
const char *name;
|
||||
const char *valuePtr;
|
||||
const char *valueEnd;
|
||||
char normalized;
|
||||
} ATTRIBUTE;
|
||||
|
||||
struct encoding;
|
||||
typedef struct encoding ENCODING;
|
||||
|
||||
struct encoding {
|
||||
int (*scanners[XML_N_STATES])(const ENCODING *,
|
||||
const char *,
|
||||
const char *,
|
||||
const char **);
|
||||
int (*literalScanners[XML_N_LITERAL_TYPES])(const ENCODING *,
|
||||
const char *,
|
||||
const char *,
|
||||
const char **);
|
||||
int (*sameName)(const ENCODING *,
|
||||
const char *, const char *);
|
||||
int (*nameMatchesAscii)(const ENCODING *,
|
||||
const char *, const char *, const char *);
|
||||
int (*nameLength)(const ENCODING *, const char *);
|
||||
const char *(*skipS)(const ENCODING *, const char *);
|
||||
int (*getAtts)(const ENCODING *enc, const char *ptr,
|
||||
int attsMax, ATTRIBUTE *atts);
|
||||
int (*charRefNumber)(const ENCODING *enc, const char *ptr);
|
||||
int (*predefinedEntityName)(const ENCODING *, const char *, const char *);
|
||||
void (*updatePosition)(const ENCODING *,
|
||||
const char *ptr,
|
||||
const char *end,
|
||||
POSITION *);
|
||||
int (*isPublicId)(const ENCODING *enc, const char *ptr, const char *end,
|
||||
const char **badPtr);
|
||||
void (*utf8Convert)(const ENCODING *enc,
|
||||
const char **fromP,
|
||||
const char *fromLim,
|
||||
char **toP,
|
||||
const char *toLim);
|
||||
void (*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 XmlUtf8Encode(int charNumber, char *buf);
|
||||
int XmlUtf16Encode(int charNumber, unsigned short *buf);
|
||||
|
||||
int XmlSizeOfUnknownEncoding(void);
|
||||
ENCODING *
|
||||
XmlInitUnknownEncoding(void *mem,
|
||||
int *table,
|
||||
int (*conv)(void *userData, const char *p),
|
||||
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,
|
||||
int (*conv)(void *userData, const char *p),
|
||||
void *userData);
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* not XmlTok_INCLUDED */
|
1768
other-licenses/expat/lib/xmltok_impl.c
Normal file
1768
other-licenses/expat/lib/xmltok_impl.c
Normal file
File diff suppressed because it is too large
Load Diff
46
other-licenses/expat/lib/xmltok_impl.h
Normal file
46
other-licenses/expat/lib/xmltok_impl.h
Normal file
@ -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>
|
98
other-licenses/expat/lib/xmltok_ns.c
Normal file
98
other-licenses/expat/lib/xmltok_ns.c
Normal file
@ -0,0 +1,98 @@
|
||||
const ENCODING *NS(XmlGetUtf8InternalEncoding)(void)
|
||||
{
|
||||
return &ns(internal_utf8_encoding).enc;
|
||||
}
|
||||
|
||||
const ENCODING *NS(XmlGetUtf16InternalEncoding)(void)
|
||||
{
|
||||
#if XML_BYTE_ORDER == 12
|
||||
return &ns(internal_little2_encoding).enc;
|
||||
#elif XML_BYTE_ORDER == 21
|
||||
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 *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 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 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);
|
||||
}
|
68
other-licenses/expat/xmlwf/Makefile.in
Normal file
68
other-licenses/expat/xmlwf/Makefile.in
Normal file
@ -0,0 +1,68 @@
|
||||
################################################################
|
||||
# Process this file with top-level configure script to produce Makefile
|
||||
#
|
||||
# Copyright 2000 Clark Cooper
|
||||
#
|
||||
# This file is part of EXPAT.
|
||||
#
|
||||
# EXPAT is free software; you can redistribute it and/or modify it
|
||||
# under the terms of the License (based on the MIT/X license) contained
|
||||
# in the file COPYING that comes with this distribution.
|
||||
#
|
||||
# EXPAT IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
||||
# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
||||
# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
||||
# SOFTWARE OR THE USE OR OTHER DEALINGS IN EXPAT.
|
||||
#
|
||||
|
||||
bindir = @bindir@
|
||||
|
||||
LIBDIR= ../lib/.libs
|
||||
INCDIR= ../lib
|
||||
|
||||
LDFLAGS= @LDFLAGS@ -static
|
||||
CFLAGS= @CFLAGS@ -I$(INCDIR)
|
||||
CC = @CC@
|
||||
|
||||
FILEMAP_OBJ= @FILEMAP_OBJ@
|
||||
OBJS= xmlwf.o xmlfile.o codepage.o $(FILEMAP_OBJ)
|
||||
LIBS= -L$(LIBDIR) -lexpat
|
||||
|
||||
INSTALL = @INSTALL@
|
||||
INSTALL_PROGRAM = ${INSTALL}
|
||||
LIBTOOL = @LIBTOOL@
|
||||
mkinstalldirs = $(SHELL) $(top_srcdir)/conftools/mkinstalldirs
|
||||
|
||||
srcdir = @srcdir@
|
||||
top_builddir = ..
|
||||
top_srcdir = @top_srcdir@
|
||||
VPATH = @srcdir@
|
||||
prefix = @prefix@
|
||||
exec_prefix = @exec_prefix@
|
||||
|
||||
|
||||
xmlwf: $(OBJS)
|
||||
$(CC) -o xmlwf $(LDFLAGS) $(OBJS) $(LIBS)
|
||||
|
||||
install: xmlwf
|
||||
$(mkinstalldirs) $(bindir)
|
||||
$(LIBTOOL) --mode=install $(INSTALL_PROGRAM) xmlwf $(bindir)/xmlwf
|
||||
|
||||
uninstall:
|
||||
$(LIBTOOL) --mode=uninstall rm -f $(bindir)/xmlwf
|
||||
|
||||
check: $(SUBDIRS)
|
||||
@echo
|
||||
@echo This package does not yet have a regression test.
|
||||
@echo
|
||||
|
||||
clean:
|
||||
rm -f xmlwf core *.o
|
||||
|
||||
distclean: clean
|
||||
rm -f Makefile
|
||||
|
||||
maintainer-clean: distclean
|
65
other-licenses/expat/xmlwf/codepage.c
Executable file
65
other-licenses/expat/xmlwf/codepage.c
Executable file
@ -0,0 +1,65 @@
|
||||
/*
|
||||
Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
|
||||
See the file COPYING for copying permission.
|
||||
*/
|
||||
|
||||
#include "codepage.h"
|
||||
|
||||
#ifdef WIN32
|
||||
#define STRICT 1
|
||||
#define WIN32_LEAN_AND_MEAN 1
|
||||
|
||||
#include <windows.h>
|
||||
|
||||
int codepageMap(int cp, int *map)
|
||||
{
|
||||
int i;
|
||||
CPINFO info;
|
||||
if (!GetCPInfo(cp, &info) || info.MaxCharSize > 2)
|
||||
return 0;
|
||||
for (i = 0; i < 256; i++)
|
||||
map[i] = -1;
|
||||
if (info.MaxCharSize > 1) {
|
||||
for (i = 0; i < MAX_LEADBYTES; i++) {
|
||||
int j, lim;
|
||||
if (info.LeadByte[i] == 0 && info.LeadByte[i + 1] == 0)
|
||||
break;
|
||||
lim = info.LeadByte[i + 1];
|
||||
for (j = info.LeadByte[i]; j < lim; j++)
|
||||
map[j] = -2;
|
||||
}
|
||||
}
|
||||
for (i = 0; i < 256; i++) {
|
||||
if (map[i] == -1) {
|
||||
char c = i;
|
||||
unsigned short n;
|
||||
if (MultiByteToWideChar(cp, MB_PRECOMPOSED|MB_ERR_INVALID_CHARS,
|
||||
&c, 1, &n, 1) == 1)
|
||||
map[i] = n;
|
||||
}
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
int codepageConvert(int cp, const char *p)
|
||||
{
|
||||
unsigned short c;
|
||||
if (MultiByteToWideChar(cp, MB_PRECOMPOSED|MB_ERR_INVALID_CHARS,
|
||||
p, 2, &c, 1) == 1)
|
||||
return c;
|
||||
return -1;
|
||||
}
|
||||
|
||||
#else /* not WIN32 */
|
||||
|
||||
int codepageMap(int cp, int *map)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
int codepageConvert(int cp, const char *p)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
|
||||
#endif /* not WIN32 */
|
7
other-licenses/expat/xmlwf/codepage.h
Executable file
7
other-licenses/expat/xmlwf/codepage.h
Executable file
@ -0,0 +1,7 @@
|
||||
/*
|
||||
Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
|
||||
See the file COPYING for copying permission.
|
||||
*/
|
||||
|
||||
int codepageMap(int cp, int *map);
|
||||
int codepageConvert(int cp, const char *p);
|
145
other-licenses/expat/xmlwf/ct.c
Executable file
145
other-licenses/expat/xmlwf/ct.c
Executable file
@ -0,0 +1,145 @@
|
||||
#define CHARSET_MAX 41
|
||||
|
||||
static
|
||||
const char *getTok(const char **pp)
|
||||
{
|
||||
enum { inAtom, inString, init, inComment };
|
||||
int state = init;
|
||||
const char *tokStart = 0;
|
||||
for (;;) {
|
||||
switch (**pp) {
|
||||
case '\0':
|
||||
return 0;
|
||||
case ' ':
|
||||
case '\r':
|
||||
case '\t':
|
||||
case '\n':
|
||||
if (state == inAtom)
|
||||
return tokStart;
|
||||
break;
|
||||
case '(':
|
||||
if (state == inAtom)
|
||||
return tokStart;
|
||||
if (state != inString)
|
||||
state++;
|
||||
break;
|
||||
case ')':
|
||||
if (state > init)
|
||||
--state;
|
||||
else if (state != inString)
|
||||
return 0;
|
||||
break;
|
||||
case ';':
|
||||
case '/':
|
||||
case '=':
|
||||
if (state == inAtom)
|
||||
return tokStart;
|
||||
if (state == init)
|
||||
return (*pp)++;
|
||||
break;
|
||||
case '\\':
|
||||
++*pp;
|
||||
if (**pp == '\0')
|
||||
return 0;
|
||||
break;
|
||||
case '"':
|
||||
switch (state) {
|
||||
case inString:
|
||||
++*pp;
|
||||
return tokStart;
|
||||
case inAtom:
|
||||
return tokStart;
|
||||
case init:
|
||||
tokStart = *pp;
|
||||
state = inString;
|
||||
break;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
if (state == init) {
|
||||
tokStart = *pp;
|
||||
state = inAtom;
|
||||
}
|
||||
break;
|
||||
}
|
||||
++*pp;
|
||||
}
|
||||
/* not reached */
|
||||
}
|
||||
|
||||
/* key must be lowercase ASCII */
|
||||
|
||||
static
|
||||
int matchkey(const char *start, const char *end, const char *key)
|
||||
{
|
||||
if (!start)
|
||||
return 0;
|
||||
for (; start != end; start++, key++)
|
||||
if (*start != *key && *start != 'A' + (*key - 'a'))
|
||||
return 0;
|
||||
return *key == '\0';
|
||||
}
|
||||
|
||||
void getXMLCharset(const char *buf, char *charset)
|
||||
{
|
||||
const char *next, *p;
|
||||
|
||||
charset[0] = '\0';
|
||||
next = buf;
|
||||
p = getTok(&next);
|
||||
if (matchkey(p, next, "text"))
|
||||
strcpy(charset, "us-ascii");
|
||||
else if (!matchkey(p, next, "application"))
|
||||
return;
|
||||
p = getTok(&next);
|
||||
if (!p || *p != '/')
|
||||
return;
|
||||
p = getTok(&next);
|
||||
if (matchkey(p, next, "xml"))
|
||||
isXml = 1;
|
||||
p = getTok(&next);
|
||||
while (p) {
|
||||
if (*p == ';') {
|
||||
p = getTok(&next);
|
||||
if (matchkey(p, next, "charset")) {
|
||||
p = getTok(&next);
|
||||
if (p && *p == '=') {
|
||||
p = getTok(&next);
|
||||
if (p) {
|
||||
char *s = charset;
|
||||
if (*p == '"') {
|
||||
while (++p != next - 1) {
|
||||
if (*p == '\\')
|
||||
++p;
|
||||
if (s == charset + CHARSET_MAX - 1) {
|
||||
charset[0] = '\0';
|
||||
break;
|
||||
}
|
||||
*s++ = *p;
|
||||
}
|
||||
*s++ = '\0';
|
||||
}
|
||||
else {
|
||||
if (next - p > CHARSET_MAX - 1)
|
||||
break;
|
||||
while (p != next)
|
||||
*s++ = *p++;
|
||||
*s = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
p = getTok(&next);
|
||||
}
|
||||
}
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
char buf[CHARSET_MAX];
|
||||
getXMLCharset(argv[1], buf);
|
||||
printf("charset = \"%s\"\n", buf);
|
||||
return 0;
|
||||
}
|
17
other-licenses/expat/xmlwf/filemap.h
Executable file
17
other-licenses/expat/xmlwf/filemap.h
Executable file
@ -0,0 +1,17 @@
|
||||
/*
|
||||
Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
|
||||
See the file COPYING for copying permission.
|
||||
*/
|
||||
|
||||
|
||||
#include <stddef.h>
|
||||
|
||||
#ifdef XML_UNICODE
|
||||
int filemap(const wchar_t *name,
|
||||
void (*processor)(const void *, size_t, const wchar_t *, void *arg),
|
||||
void *arg);
|
||||
#else
|
||||
int filemap(const char *name,
|
||||
void (*processor)(const void *, size_t, const char *, void *arg),
|
||||
void *arg);
|
||||
#endif
|
74
other-licenses/expat/xmlwf/readfilemap.c
Executable file
74
other-licenses/expat/xmlwf/readfilemap.c
Executable file
@ -0,0 +1,74 @@
|
||||
/*
|
||||
Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
|
||||
See the file COPYING for copying permission.
|
||||
*/
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
#include <fcntl.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#ifndef S_ISREG
|
||||
#ifndef S_IFREG
|
||||
#define S_IFREG _S_IFREG
|
||||
#endif
|
||||
#ifndef S_IFMT
|
||||
#define S_IFMT _S_IFMT
|
||||
#endif
|
||||
#define S_ISREG(m) (((m) & S_IFMT) == S_IFREG)
|
||||
#endif /* not S_ISREG */
|
||||
|
||||
#ifndef O_BINARY
|
||||
#ifdef _O_BINARY
|
||||
#define O_BINARY _O_BINARY
|
||||
#else
|
||||
#define O_BINARY 0
|
||||
#endif
|
||||
#endif
|
||||
|
||||
int filemap(const char *name,
|
||||
void (*processor)(const void *, size_t, const char *, void *arg),
|
||||
void *arg)
|
||||
{
|
||||
size_t nbytes;
|
||||
int fd;
|
||||
int n;
|
||||
struct stat sb;
|
||||
void *p;
|
||||
|
||||
fd = open(name, O_RDONLY|O_BINARY);
|
||||
if (fd < 0) {
|
||||
perror(name);
|
||||
return 0;
|
||||
}
|
||||
if (fstat(fd, &sb) < 0) {
|
||||
perror(name);
|
||||
return 0;
|
||||
}
|
||||
if (!S_ISREG(sb.st_mode)) {
|
||||
fprintf(stderr, "%s: not a regular file\n", name);
|
||||
return 0;
|
||||
}
|
||||
nbytes = sb.st_size;
|
||||
p = malloc(nbytes);
|
||||
if (!p) {
|
||||
fprintf(stderr, "%s: out of memory\n", name);
|
||||
return 0;
|
||||
}
|
||||
n = read(fd, p, nbytes);
|
||||
if (n < 0) {
|
||||
perror(name);
|
||||
close(fd);
|
||||
return 0;
|
||||
}
|
||||
if (n != nbytes) {
|
||||
fprintf(stderr, "%s: read unexpected number of bytes\n", name);
|
||||
close(fd);
|
||||
return 0;
|
||||
}
|
||||
processor(p, nbytes, name, arg);
|
||||
free(p);
|
||||
close(fd);
|
||||
return 1;
|
||||
}
|
58
other-licenses/expat/xmlwf/unixfilemap.c
Executable file
58
other-licenses/expat/xmlwf/unixfilemap.c
Executable file
@ -0,0 +1,58 @@
|
||||
/*
|
||||
Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
|
||||
See the file COPYING for copying permission.
|
||||
*/
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <sys/mman.h>
|
||||
#include <sys/stat.h>
|
||||
#include <fcntl.h>
|
||||
#include <errno.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#ifndef MAP_FILE
|
||||
#define MAP_FILE 0
|
||||
#endif
|
||||
|
||||
#include "filemap.h"
|
||||
|
||||
int filemap(const char *name,
|
||||
void (*processor)(const void *, size_t, const char *, void *arg),
|
||||
void *arg)
|
||||
{
|
||||
int fd;
|
||||
size_t nbytes;
|
||||
struct stat sb;
|
||||
void *p;
|
||||
|
||||
fd = open(name, O_RDONLY);
|
||||
if (fd < 0) {
|
||||
perror(name);
|
||||
return 0;
|
||||
}
|
||||
if (fstat(fd, &sb) < 0) {
|
||||
perror(name);
|
||||
close(fd);
|
||||
return 0;
|
||||
}
|
||||
if (!S_ISREG(sb.st_mode)) {
|
||||
close(fd);
|
||||
fprintf(stderr, "%s: not a regular file\n", name);
|
||||
return 0;
|
||||
}
|
||||
|
||||
nbytes = sb.st_size;
|
||||
p = (void *)mmap((caddr_t)0, (size_t)nbytes, PROT_READ,
|
||||
MAP_FILE|MAP_PRIVATE, fd, (off_t)0);
|
||||
if (p == (void *)-1) {
|
||||
perror(name);
|
||||
close(fd);
|
||||
return 0;
|
||||
}
|
||||
processor(p, nbytes, name, arg);
|
||||
munmap((caddr_t)p, nbytes);
|
||||
close(fd);
|
||||
return 1;
|
||||
}
|
953
other-licenses/expat/xmlwf/wfcheck.c
Executable file
953
other-licenses/expat/xmlwf/wfcheck.c
Executable file
@ -0,0 +1,953 @@
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "wfcheck.h"
|
||||
#include "hashtable.h"
|
||||
|
||||
#include "xmltok.h"
|
||||
#include "xmlrole.h"
|
||||
|
||||
typedef struct {
|
||||
const char *name;
|
||||
const char *textPtr;
|
||||
size_t textLen;
|
||||
const char *docTextPtr;
|
||||
const char *systemId;
|
||||
const char *publicId;
|
||||
const char *notation;
|
||||
char open;
|
||||
char wfInContent;
|
||||
char wfInAttribute;
|
||||
char magic;
|
||||
} ENTITY;
|
||||
|
||||
#define INIT_BLOCK_SIZE 1024
|
||||
|
||||
typedef struct block {
|
||||
struct block *next;
|
||||
char s[1];
|
||||
} BLOCK;
|
||||
|
||||
typedef struct {
|
||||
BLOCK *blocks;
|
||||
const char *end;
|
||||
char *ptr;
|
||||
char *start;
|
||||
} STRING_POOL;
|
||||
|
||||
typedef struct {
|
||||
HASH_TABLE generalEntities;
|
||||
HASH_TABLE paramEntities;
|
||||
STRING_POOL pool;
|
||||
int containsRef;
|
||||
int standalone;
|
||||
char *groupConnector;
|
||||
size_t groupSize;
|
||||
} DTD;
|
||||
|
||||
typedef struct {
|
||||
DTD dtd;
|
||||
size_t stackSize;
|
||||
const char **startName;
|
||||
int attsSize;
|
||||
ATTRIBUTE *atts;
|
||||
} CONTEXT;
|
||||
|
||||
static void poolInit(STRING_POOL *);
|
||||
static void poolDestroy(STRING_POOL *);
|
||||
static const char *poolAppend(STRING_POOL *pool, const ENCODING *enc,
|
||||
const char *ptr, const char *end);
|
||||
static const char *poolStoreString(STRING_POOL *pool, const ENCODING *enc,
|
||||
const char *ptr, const char *end);
|
||||
static int poolGrow(STRING_POOL *);
|
||||
static int dtdInit(DTD *);
|
||||
static void dtdDestroy(DTD *);
|
||||
static int contextInit(CONTEXT *);
|
||||
static void contextDestroy(CONTEXT *);
|
||||
|
||||
#define poolStart(pool) ((pool)->start)
|
||||
#define poolDiscard(pool) ((pool)->ptr = (pool)->start)
|
||||
#define poolFinish(pool) ((pool)->start = (pool)->ptr)
|
||||
|
||||
static enum WfCheckResult
|
||||
checkProlog(DTD *, const char *s, const char *end, const char **, const ENCODING **enc);
|
||||
static enum WfCheckResult
|
||||
checkContent(size_t level, CONTEXT *context, const ENCODING *enc,
|
||||
const char *s, const char *end, const char **badPtr);
|
||||
static enum WfCheckResult
|
||||
checkGeneralTextEntity(CONTEXT *context,
|
||||
const char *s, const char *end,
|
||||
const char **nextPtr,
|
||||
const ENCODING **enc);
|
||||
static enum WfCheckResult
|
||||
checkAttributeValue(DTD *, const ENCODING *, const char *, const char *, const char **);
|
||||
static enum WfCheckResult
|
||||
checkAttributeUniqueness(CONTEXT *context, const ENCODING *enc, int nAtts,
|
||||
const char **badPtr);
|
||||
static enum WfCheckResult
|
||||
checkParsedEntities(CONTEXT *context, const char **badPtr);
|
||||
|
||||
static
|
||||
enum WfCheckResult storeEntity(DTD *dtd,
|
||||
const ENCODING *enc,
|
||||
int isParam,
|
||||
const char *entityNamePtr,
|
||||
const char *entityNameEnd,
|
||||
const char *entityTextPtr,
|
||||
const char *entityTextEnd,
|
||||
const char **badPtr);
|
||||
|
||||
|
||||
enum WfCheckResult
|
||||
wfCheck(enum EntityType entityType, const char *s, size_t n,
|
||||
const char **badPtr, unsigned long *badLine, unsigned long *badCol)
|
||||
{
|
||||
CONTEXT context;
|
||||
const ENCODING *enc;
|
||||
const char *start = s;
|
||||
const char *end = s + n;
|
||||
const char *next = 0;
|
||||
enum WfCheckResult result;
|
||||
|
||||
if (!contextInit(&context)) {
|
||||
contextDestroy(&context);
|
||||
return noMemory;
|
||||
}
|
||||
if (entityType == documentEntity) {
|
||||
result = checkProlog(&context.dtd, s, end, &next, &enc);
|
||||
s = next;
|
||||
if (!result) {
|
||||
result = checkParsedEntities(&context, &next);
|
||||
s = next;
|
||||
if (!result) {
|
||||
result = checkContent(0, &context, enc, s, end, &next);
|
||||
s = next;
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
result = checkGeneralTextEntity(&context, s, end, &next, &enc);
|
||||
s = next;
|
||||
}
|
||||
if (result && s) {
|
||||
POSITION pos;
|
||||
memset(&pos, 0, sizeof(POSITION));
|
||||
XmlUpdatePosition(enc, start, s, &pos);
|
||||
*badPtr = s;
|
||||
*badLine = pos.lineNumber;
|
||||
*badCol = pos.columnNumber;
|
||||
}
|
||||
contextDestroy(&context);
|
||||
return result;
|
||||
}
|
||||
|
||||
static
|
||||
int contextInit(CONTEXT *p)
|
||||
{
|
||||
p->stackSize = 1024;
|
||||
p->startName = malloc(p->stackSize * sizeof(char *));
|
||||
p->attsSize = 1024;
|
||||
p->atts = malloc(p->attsSize * sizeof(ATTRIBUTE));
|
||||
return dtdInit(&(p->dtd)) && p->atts && p->startName;
|
||||
}
|
||||
|
||||
static
|
||||
void contextDestroy(CONTEXT *p)
|
||||
{
|
||||
dtdDestroy(&(p->dtd));
|
||||
free((void *)p->startName);
|
||||
free((void *)p->atts);
|
||||
}
|
||||
|
||||
static enum WfCheckResult
|
||||
checkContent(size_t level, CONTEXT *context, const ENCODING *enc,
|
||||
const char *s, const char *end, const char **badPtr)
|
||||
{
|
||||
size_t startLevel = level;
|
||||
const char *next;
|
||||
int tok = XmlContentTok(enc, s, end, &next);
|
||||
for (;;) {
|
||||
switch (tok) {
|
||||
case XML_TOK_TRAILING_CR:
|
||||
case XML_TOK_NONE:
|
||||
if (startLevel > 0) {
|
||||
if (level != startLevel) {
|
||||
*badPtr = s;
|
||||
return asyncEntity;
|
||||
}
|
||||
return wellFormed;
|
||||
}
|
||||
*badPtr = s;
|
||||
return noElements;
|
||||
case XML_TOK_INVALID:
|
||||
*badPtr = next;
|
||||
return invalidToken;
|
||||
case XML_TOK_PARTIAL:
|
||||
*badPtr = s;
|
||||
return unclosedToken;
|
||||
case XML_TOK_PARTIAL_CHAR:
|
||||
*badPtr = s;
|
||||
return partialChar;
|
||||
case XML_TOK_EMPTY_ELEMENT_NO_ATTS:
|
||||
break;
|
||||
case XML_TOK_ENTITY_REF:
|
||||
{
|
||||
const char *name = poolStoreString(&context->dtd.pool, enc,
|
||||
s + enc->minBytesPerChar,
|
||||
next - enc->minBytesPerChar);
|
||||
ENTITY *entity = (ENTITY *)lookup(&context->dtd.generalEntities, name, 0);
|
||||
poolDiscard(&context->dtd.pool);
|
||||
if (!entity) {
|
||||
if (!context->dtd.containsRef || context->dtd.standalone) {
|
||||
*badPtr = s;
|
||||
return undefinedEntity;
|
||||
}
|
||||
break;
|
||||
}
|
||||
if (entity->wfInContent)
|
||||
break;
|
||||
if (entity->open) {
|
||||
*badPtr = s;
|
||||
return recursiveEntityRef;
|
||||
}
|
||||
if (entity->notation) {
|
||||
*badPtr = s;
|
||||
return binaryEntityRef;
|
||||
}
|
||||
if (entity) {
|
||||
if (entity->textPtr) {
|
||||
enum WfCheckResult result;
|
||||
const ENCODING *internalEnc = XmlGetInternalEncoding(XML_UTF8_ENCODING);
|
||||
entity->open = 1;
|
||||
result = checkContent(level, context, internalEnc,
|
||||
entity->textPtr, entity->textPtr + entity->textLen,
|
||||
badPtr);
|
||||
entity->open = 0;
|
||||
if (result && *badPtr) {
|
||||
*badPtr = s;
|
||||
return result;
|
||||
}
|
||||
entity->wfInContent = 1;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
case XML_TOK_START_TAG_NO_ATTS:
|
||||
if (level == context->stackSize) {
|
||||
context->startName
|
||||
= realloc((void *)context->startName, (context->stackSize *= 2) * sizeof(char *));
|
||||
if (!context->startName)
|
||||
return noMemory;
|
||||
}
|
||||
context->startName[level++] = s + enc->minBytesPerChar;
|
||||
break;
|
||||
case XML_TOK_START_TAG_WITH_ATTS:
|
||||
if (level == context->stackSize) {
|
||||
context->startName = realloc((void *)context->startName, (context->stackSize *= 2) * sizeof(char *));
|
||||
if (!context->startName)
|
||||
return noMemory;
|
||||
}
|
||||
context->startName[level++] = s + enc->minBytesPerChar;
|
||||
/* fall through */
|
||||
case XML_TOK_EMPTY_ELEMENT_WITH_ATTS:
|
||||
{
|
||||
int i;
|
||||
int n = XmlGetAttributes(enc, s, context->attsSize, context->atts);
|
||||
if (n > context->attsSize) {
|
||||
context->attsSize = 2*n;
|
||||
context->atts = realloc((void *)context->atts, context->attsSize * sizeof(ATTRIBUTE));
|
||||
if (!context->atts)
|
||||
return noMemory;
|
||||
XmlGetAttributes(enc, s, n, context->atts);
|
||||
}
|
||||
for (i = 0; i < n; i++) {
|
||||
if (!context->atts[i].normalized) {
|
||||
enum WfCheckResult result
|
||||
= checkAttributeValue(&context->dtd, enc,
|
||||
context->atts[i].valuePtr,
|
||||
context->atts[i].valueEnd,
|
||||
badPtr);
|
||||
if (result)
|
||||
return result;
|
||||
}
|
||||
}
|
||||
if (i > 1) {
|
||||
enum WfCheckResult result = checkAttributeUniqueness(context, enc, n, badPtr);
|
||||
if (result)
|
||||
return result;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case XML_TOK_END_TAG:
|
||||
if (level == startLevel) {
|
||||
*badPtr = s;
|
||||
return asyncEntity;
|
||||
}
|
||||
--level;
|
||||
if (!XmlSameName(enc, context->startName[level], s + enc->minBytesPerChar * 2)) {
|
||||
*badPtr = s;
|
||||
return tagMismatch;
|
||||
}
|
||||
break;
|
||||
case XML_TOK_CHAR_REF:
|
||||
if (XmlCharRefNumber(enc, s) < 0) {
|
||||
*badPtr = s;
|
||||
return badCharRef;
|
||||
}
|
||||
break;
|
||||
case XML_TOK_XML_DECL:
|
||||
*badPtr = s;
|
||||
return misplacedXmlPi;
|
||||
}
|
||||
s = next;
|
||||
if (level == 0) {
|
||||
do {
|
||||
tok = XmlPrologTok(enc, s, end, &next);
|
||||
switch (tok) {
|
||||
case XML_TOK_TRAILING_CR:
|
||||
case XML_TOK_NONE:
|
||||
return wellFormed;
|
||||
case XML_TOK_PROLOG_S:
|
||||
case XML_TOK_COMMENT:
|
||||
case XML_TOK_PI:
|
||||
s = next;
|
||||
break;
|
||||
default:
|
||||
if (tok > 0) {
|
||||
*badPtr = s;
|
||||
return junkAfterDocElement;
|
||||
}
|
||||
break;
|
||||
}
|
||||
} while (tok > 0);
|
||||
}
|
||||
else
|
||||
tok = XmlContentTok(enc, s, end, &next);
|
||||
}
|
||||
/* not reached */
|
||||
}
|
||||
|
||||
static
|
||||
int attcmp(const void *p1, const void *p2)
|
||||
{
|
||||
const ATTRIBUTE *a1 = p1;
|
||||
const ATTRIBUTE *a2 = p2;
|
||||
size_t n1 = a1->valuePtr - a1->name;
|
||||
size_t n2 = a2->valuePtr - a2->name;
|
||||
|
||||
if (n1 == n2) {
|
||||
int n = memcmp(a1->name, a2->name, n1);
|
||||
if (n)
|
||||
return n;
|
||||
/* Sort identical attribute names by position, so that we always
|
||||
report the first duplicate attribute. */
|
||||
if (a1->name < a2->name)
|
||||
return -1;
|
||||
else if (a1->name > a2->name)
|
||||
return 1;
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
else if (n1 < n2)
|
||||
return -1;
|
||||
else
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* Note that this trashes the attribute values. */
|
||||
|
||||
static enum WfCheckResult
|
||||
checkAttributeUniqueness(CONTEXT *context, const ENCODING *enc, int nAtts,
|
||||
const char **badPtr)
|
||||
{
|
||||
#define QSORT_MIN_ATTS 10
|
||||
if (nAtts < QSORT_MIN_ATTS) {
|
||||
int i;
|
||||
for (i = 1; i < nAtts; i++) {
|
||||
int j;
|
||||
for (j = 0; j < i; j++) {
|
||||
if (XmlSameName(enc, context->atts[i].name, context->atts[j].name)) {
|
||||
*badPtr = context->atts[i].name;
|
||||
return duplicateAttribute;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
int i;
|
||||
const char *dup = 0;
|
||||
/* Store the end of the name in valuePtr */
|
||||
for (i = 0; i < nAtts; i++) {
|
||||
ATTRIBUTE *a = context->atts + i;
|
||||
a->valuePtr = a->name + XmlNameLength(enc, a->name);
|
||||
}
|
||||
qsort(context->atts, nAtts, sizeof(ATTRIBUTE), attcmp);
|
||||
for (i = 1; i < nAtts; i++) {
|
||||
ATTRIBUTE *a = context->atts + i;
|
||||
if (XmlSameName(enc, a->name, a[-1].name)) {
|
||||
if (!dup || a->name < dup)
|
||||
dup = a->name;
|
||||
}
|
||||
}
|
||||
if (dup) {
|
||||
*badPtr = dup;
|
||||
return duplicateAttribute;
|
||||
}
|
||||
}
|
||||
return wellFormed;
|
||||
}
|
||||
|
||||
static enum WfCheckResult
|
||||
checkProlog(DTD *dtd, const char *s, const char *end,
|
||||
const char **nextPtr, const ENCODING **enc)
|
||||
{
|
||||
const char *entityNamePtr, *entityNameEnd;
|
||||
int entityIsParam;
|
||||
PROLOG_STATE state;
|
||||
ENTITY *entity;
|
||||
INIT_ENCODING initEnc;
|
||||
XmlInitEncoding(&initEnc, enc);
|
||||
XmlPrologStateInit(&state);
|
||||
for (;;) {
|
||||
const char *next;
|
||||
int tok = XmlPrologTok(*enc, s, end, &next);
|
||||
switch (XmlTokenRole(&state, tok, s, next, *enc)) {
|
||||
case XML_ROLE_XML_DECL:
|
||||
{
|
||||
const char *encodingName = 0;
|
||||
const ENCODING *encoding = 0;
|
||||
const char *version;
|
||||
int standalone = -1;
|
||||
if (!XmlParseXmlDecl(0,
|
||||
*enc,
|
||||
s,
|
||||
next,
|
||||
nextPtr,
|
||||
&version,
|
||||
&encodingName,
|
||||
&encoding,
|
||||
&standalone))
|
||||
return syntaxError;
|
||||
if (encoding) {
|
||||
if (encoding->minBytesPerChar != (*enc)->minBytesPerChar) {
|
||||
*nextPtr = encodingName;
|
||||
return incorrectEncoding;
|
||||
}
|
||||
*enc = encoding;
|
||||
}
|
||||
else if (encodingName) {
|
||||
*nextPtr = encodingName;
|
||||
return unknownEncoding;
|
||||
}
|
||||
if (standalone == 1)
|
||||
dtd->standalone = 1;
|
||||
break;
|
||||
}
|
||||
case XML_ROLE_DOCTYPE_SYSTEM_ID:
|
||||
dtd->containsRef = 1;
|
||||
break;
|
||||
case XML_ROLE_DOCTYPE_PUBLIC_ID:
|
||||
case XML_ROLE_ENTITY_PUBLIC_ID:
|
||||
case XML_ROLE_NOTATION_PUBLIC_ID:
|
||||
if (!XmlIsPublicId(*enc, s, next, nextPtr))
|
||||
return syntaxError;
|
||||
break;
|
||||
case XML_ROLE_INSTANCE_START:
|
||||
*nextPtr = s;
|
||||
return wellFormed;
|
||||
case XML_ROLE_DEFAULT_ATTRIBUTE_VALUE:
|
||||
case XML_ROLE_FIXED_ATTRIBUTE_VALUE:
|
||||
{
|
||||
const char *tem = 0;
|
||||
enum WfCheckResult result
|
||||
= checkAttributeValue(dtd, *enc, s + (*enc)->minBytesPerChar,
|
||||
next - (*enc)->minBytesPerChar,
|
||||
&tem);
|
||||
if (result) {
|
||||
if (tem)
|
||||
*nextPtr = tem;
|
||||
return result;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case XML_ROLE_ENTITY_VALUE:
|
||||
{
|
||||
enum WfCheckResult result
|
||||
= storeEntity(dtd,
|
||||
*enc,
|
||||
entityIsParam,
|
||||
entityNamePtr,
|
||||
entityNameEnd,
|
||||
s,
|
||||
next,
|
||||
nextPtr);
|
||||
if (result != wellFormed)
|
||||
return result;
|
||||
}
|
||||
break;
|
||||
case XML_ROLE_ENTITY_SYSTEM_ID:
|
||||
{
|
||||
const char *name = poolStoreString(&dtd->pool, *enc, entityNamePtr, entityNameEnd);
|
||||
entity = (ENTITY *)lookup(entityIsParam ? &dtd->paramEntities : &dtd->generalEntities,
|
||||
name, sizeof(ENTITY));
|
||||
if (entity->name != name) {
|
||||
poolDiscard(&dtd->pool);
|
||||
entity = 0;
|
||||
}
|
||||
else {
|
||||
poolFinish(&dtd->pool);
|
||||
entity->systemId = poolStoreString(&dtd->pool, *enc,
|
||||
s + (*enc)->minBytesPerChar,
|
||||
next - (*enc)->minBytesPerChar);
|
||||
poolFinish(&dtd->pool);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case XML_ROLE_PARAM_ENTITY_REF:
|
||||
{
|
||||
const char *name = poolStoreString(&dtd->pool, *enc,
|
||||
s + (*enc)->minBytesPerChar,
|
||||
next - (*enc)->minBytesPerChar);
|
||||
ENTITY *entity = (ENTITY *)lookup(&dtd->paramEntities, name, 0);
|
||||
poolDiscard(&dtd->pool);
|
||||
if (!entity) {
|
||||
if (!dtd->containsRef || dtd->standalone) {
|
||||
*nextPtr = s;
|
||||
return undefinedEntity;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
case XML_ROLE_ENTITY_NOTATION_NAME:
|
||||
if (entity) {
|
||||
entity->notation = poolStoreString(&dtd->pool, *enc, s, next);
|
||||
poolFinish(&dtd->pool);
|
||||
}
|
||||
break;
|
||||
case XML_ROLE_GENERAL_ENTITY_NAME:
|
||||
entityNamePtr = s;
|
||||
entityNameEnd = next;
|
||||
entityIsParam = 0;
|
||||
break;
|
||||
case XML_ROLE_PARAM_ENTITY_NAME:
|
||||
entityNamePtr = s;
|
||||
entityNameEnd = next;
|
||||
entityIsParam = 1;
|
||||
break;
|
||||
case XML_ROLE_ERROR:
|
||||
*nextPtr = s;
|
||||
switch (tok) {
|
||||
case XML_TOK_PARAM_ENTITY_REF:
|
||||
return paramEntityRef;
|
||||
case XML_TOK_INVALID:
|
||||
*nextPtr = next;
|
||||
return invalidToken;
|
||||
case XML_TOK_NONE:
|
||||
return noElements;
|
||||
case XML_TOK_PARTIAL:
|
||||
return unclosedToken;
|
||||
case XML_TOK_PARTIAL_CHAR:
|
||||
return partialChar;
|
||||
case XML_TOK_TRAILING_CR:
|
||||
*nextPtr = s + (*enc)->minBytesPerChar;
|
||||
return noElements;
|
||||
case XML_TOK_XML_DECL:
|
||||
return misplacedXmlPi;
|
||||
default:
|
||||
return syntaxError;
|
||||
}
|
||||
case XML_ROLE_GROUP_OPEN:
|
||||
if (state.level >= dtd->groupSize) {
|
||||
if (dtd->groupSize)
|
||||
dtd->groupConnector = realloc(dtd->groupConnector, dtd->groupSize *= 2);
|
||||
else
|
||||
dtd->groupConnector = malloc(dtd->groupSize = 32);
|
||||
if (!dtd->groupConnector)
|
||||
return noMemory;
|
||||
}
|
||||
dtd->groupConnector[state.level] = 0;
|
||||
break;
|
||||
case XML_ROLE_GROUP_SEQUENCE:
|
||||
if (dtd->groupConnector[state.level] == '|') {
|
||||
*nextPtr = s;
|
||||
return syntaxError;
|
||||
}
|
||||
dtd->groupConnector[state.level] = ',';
|
||||
break;
|
||||
case XML_ROLE_GROUP_CHOICE:
|
||||
if (dtd->groupConnector[state.level] == ',') {
|
||||
*nextPtr = s;
|
||||
return syntaxError;
|
||||
}
|
||||
dtd->groupConnector[state.level] = '|';
|
||||
break;
|
||||
case XML_ROLE_NONE:
|
||||
if (tok == XML_TOK_PARAM_ENTITY_REF)
|
||||
dtd->containsRef = 1;
|
||||
break;
|
||||
}
|
||||
s = next;
|
||||
}
|
||||
/* not reached */
|
||||
}
|
||||
|
||||
static enum WfCheckResult
|
||||
checkParsedEntities(CONTEXT *context, const char **badPtr)
|
||||
{
|
||||
HASH_TABLE_ITER iter;
|
||||
hashTableIterInit(&iter, &context->dtd.generalEntities);
|
||||
for (;;) {
|
||||
ENTITY *entity = (ENTITY *)hashTableIterNext(&iter);
|
||||
if (!entity)
|
||||
break;
|
||||
if (entity->textPtr && !entity->wfInContent && !entity->magic) {
|
||||
enum WfCheckResult result;
|
||||
const ENCODING *internalEnc = XmlGetInternalEncoding(XML_UTF8_ENCODING);
|
||||
entity->open = 1;
|
||||
result = checkContent(1, context, internalEnc,
|
||||
entity->textPtr, entity->textPtr + entity->textLen,
|
||||
badPtr);
|
||||
entity->open = 0;
|
||||
if (result && *badPtr) {
|
||||
*badPtr = entity->docTextPtr;
|
||||
return result;
|
||||
}
|
||||
entity->wfInContent = 1;
|
||||
}
|
||||
}
|
||||
return wellFormed;
|
||||
}
|
||||
|
||||
static enum WfCheckResult
|
||||
checkGeneralTextEntity(CONTEXT *context,
|
||||
const char *s, const char *end,
|
||||
const char **nextPtr,
|
||||
const ENCODING **enc)
|
||||
{
|
||||
INIT_ENCODING initEnc;
|
||||
const char *next;
|
||||
int tok;
|
||||
|
||||
XmlInitEncoding(&initEnc, enc);
|
||||
tok = XmlContentTok(*enc, s, end, &next);
|
||||
|
||||
if (tok == XML_TOK_BOM) {
|
||||
s = next;
|
||||
tok = XmlContentTok(*enc, s, end, &next);
|
||||
}
|
||||
if (tok == XML_TOK_XML_DECL) {
|
||||
const char *encodingName = 0;
|
||||
const ENCODING *encoding = 0;
|
||||
const char *version;
|
||||
if (!XmlParseXmlDecl(1,
|
||||
*enc,
|
||||
s,
|
||||
next,
|
||||
nextPtr,
|
||||
&version,
|
||||
&encodingName,
|
||||
&encoding,
|
||||
0))
|
||||
return syntaxError;
|
||||
if (encoding) {
|
||||
if (encoding->minBytesPerChar != (*enc)->minBytesPerChar) {
|
||||
*nextPtr = encodingName;
|
||||
return incorrectEncoding;
|
||||
}
|
||||
*enc = encoding;
|
||||
}
|
||||
else if (encodingName) {
|
||||
*nextPtr = encodingName;
|
||||
return unknownEncoding;
|
||||
}
|
||||
s = next;
|
||||
}
|
||||
context->dtd.containsRef = 1;
|
||||
return checkContent(1, context, *enc, s, end, nextPtr);
|
||||
}
|
||||
|
||||
static enum WfCheckResult
|
||||
checkAttributeValue(DTD *dtd, const ENCODING *enc,
|
||||
const char *ptr, const char *end, const char **badPtr)
|
||||
{
|
||||
for (;;) {
|
||||
const char *next;
|
||||
int tok = XmlAttributeValueTok(enc, ptr, end, &next);
|
||||
switch (tok) {
|
||||
case XML_TOK_TRAILING_CR:
|
||||
case XML_TOK_NONE:
|
||||
return wellFormed;
|
||||
case XML_TOK_INVALID:
|
||||
*badPtr = next;
|
||||
return invalidToken;
|
||||
case XML_TOK_PARTIAL:
|
||||
*badPtr = ptr;
|
||||
return invalidToken;
|
||||
case XML_TOK_CHAR_REF:
|
||||
if (XmlCharRefNumber(enc, ptr) < 0) {
|
||||
*badPtr = ptr;
|
||||
return badCharRef;
|
||||
}
|
||||
break;
|
||||
case XML_TOK_DATA_CHARS:
|
||||
case XML_TOK_DATA_NEWLINE:
|
||||
break;
|
||||
case XML_TOK_ENTITY_REF:
|
||||
{
|
||||
const char *name = poolStoreString(&dtd->pool, enc,
|
||||
ptr + enc->minBytesPerChar,
|
||||
next - enc->minBytesPerChar);
|
||||
ENTITY *entity = (ENTITY *)lookup(&dtd->generalEntities, name, 0);
|
||||
poolDiscard(&dtd->pool);
|
||||
if (!entity) {
|
||||
if (!dtd->containsRef) {
|
||||
*badPtr = ptr;
|
||||
return undefinedEntity;
|
||||
}
|
||||
break;
|
||||
}
|
||||
if (entity->wfInAttribute)
|
||||
break;
|
||||
if (entity->open) {
|
||||
*badPtr = ptr;
|
||||
return recursiveEntityRef;
|
||||
}
|
||||
if (entity->notation) {
|
||||
*badPtr = ptr;
|
||||
return binaryEntityRef;
|
||||
}
|
||||
if (entity) {
|
||||
if (entity->textPtr) {
|
||||
enum WfCheckResult result;
|
||||
const ENCODING *internalEnc = XmlGetInternalEncoding(XML_UTF8_ENCODING);
|
||||
const char *textEnd = entity->textPtr + entity->textLen;
|
||||
entity->open = 1;
|
||||
result = checkAttributeValue(dtd, internalEnc, entity->textPtr, textEnd, badPtr);
|
||||
entity->open = 0;
|
||||
if (result && *badPtr) {
|
||||
*badPtr = ptr;
|
||||
return result;
|
||||
}
|
||||
entity->wfInAttribute = 1;
|
||||
}
|
||||
else {
|
||||
*badPtr = ptr;
|
||||
return attributeExternalEntityRef;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
abort();
|
||||
}
|
||||
ptr = next;
|
||||
}
|
||||
/* not reached */
|
||||
}
|
||||
|
||||
static
|
||||
void poolInit(STRING_POOL *pool)
|
||||
{
|
||||
pool->blocks = 0;
|
||||
pool->start = 0;
|
||||
pool->ptr = 0;
|
||||
pool->end = 0;
|
||||
}
|
||||
|
||||
static
|
||||
void poolDestroy(STRING_POOL *pool)
|
||||
{
|
||||
BLOCK *p = pool->blocks;
|
||||
while (p) {
|
||||
BLOCK *tem = p->next;
|
||||
free(p);
|
||||
p = tem;
|
||||
}
|
||||
pool->blocks = 0;
|
||||
pool->ptr = 0;
|
||||
pool->start = 0;
|
||||
pool->end = 0;
|
||||
}
|
||||
|
||||
static
|
||||
const char *poolAppend(STRING_POOL *pool, const ENCODING *enc,
|
||||
const char *ptr, const char *end)
|
||||
{
|
||||
for (;;) {
|
||||
XmlConvert(enc, XML_UTF8_ENCODING, &ptr, end, &(pool->ptr), pool->end);
|
||||
if (ptr == end)
|
||||
break;
|
||||
if (!poolGrow(pool))
|
||||
return 0;
|
||||
}
|
||||
return pool->start;
|
||||
}
|
||||
|
||||
static
|
||||
const char *poolStoreString(STRING_POOL *pool, const ENCODING *enc,
|
||||
const char *ptr, const char *end)
|
||||
{
|
||||
if (!poolAppend(pool, enc, ptr, end))
|
||||
return 0;
|
||||
if (pool->ptr == pool->end && !poolGrow(pool))
|
||||
return 0;
|
||||
*(pool->ptr)++ = 0;
|
||||
return pool->start;
|
||||
}
|
||||
|
||||
static
|
||||
int poolGrow(STRING_POOL *pool)
|
||||
{
|
||||
if (pool->blocks && pool->start == pool->blocks->s) {
|
||||
size_t blockSize = (pool->end - pool->start)*2;
|
||||
pool->blocks = realloc(pool->blocks, offsetof(BLOCK, s) + blockSize);
|
||||
if (!pool->blocks)
|
||||
return 0;
|
||||
pool->ptr = pool->blocks->s + (pool->ptr - pool->start);
|
||||
pool->start = pool->blocks->s;
|
||||
pool->end = pool->start + blockSize;
|
||||
}
|
||||
else {
|
||||
BLOCK *tem;
|
||||
size_t blockSize = pool->end - pool->start;
|
||||
if (blockSize < INIT_BLOCK_SIZE)
|
||||
blockSize = INIT_BLOCK_SIZE;
|
||||
else
|
||||
blockSize *= 2;
|
||||
tem = malloc(offsetof(BLOCK, s) + blockSize);
|
||||
if (!tem)
|
||||
return 0;
|
||||
tem->next = pool->blocks;
|
||||
pool->blocks = tem;
|
||||
memcpy(tem->s, pool->start, pool->ptr - pool->start);
|
||||
pool->ptr = tem->s + (pool->ptr - pool->start);
|
||||
pool->start = tem->s;
|
||||
pool->end = tem->s + blockSize;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int dtdInit(DTD *dtd)
|
||||
{
|
||||
static const char *names[] = { "lt", "amp", "gt", "quot", "apos" };
|
||||
static const char chars[] = { '<', '&', '>', '"', '\'' };
|
||||
int i;
|
||||
|
||||
poolInit(&(dtd->pool));
|
||||
hashTableInit(&(dtd->generalEntities));
|
||||
for (i = 0; i < 5; i++) {
|
||||
ENTITY *entity = (ENTITY *)lookup(&(dtd->generalEntities), names[i], sizeof(ENTITY));
|
||||
if (!entity)
|
||||
return 0;
|
||||
entity->textPtr = chars + i;
|
||||
entity->textLen = 1;
|
||||
entity->magic = 1;
|
||||
entity->wfInContent = 1;
|
||||
entity->wfInAttribute = 1;
|
||||
}
|
||||
hashTableInit(&(dtd->paramEntities));
|
||||
dtd->containsRef = 0;
|
||||
dtd->groupSize = 0;
|
||||
dtd->groupConnector = 0;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static void dtdDestroy(DTD *dtd)
|
||||
{
|
||||
poolDestroy(&(dtd->pool));
|
||||
hashTableDestroy(&(dtd->generalEntities));
|
||||
hashTableDestroy(&(dtd->paramEntities));
|
||||
free(dtd->groupConnector);
|
||||
}
|
||||
|
||||
static
|
||||
enum WfCheckResult storeEntity(DTD *dtd,
|
||||
const ENCODING *enc,
|
||||
int isParam,
|
||||
const char *entityNamePtr,
|
||||
const char *entityNameEnd,
|
||||
const char *entityTextPtr,
|
||||
const char *entityTextEnd,
|
||||
const char **badPtr)
|
||||
{
|
||||
ENTITY *entity;
|
||||
const ENCODING *utf8 = XmlGetInternalEncoding(XML_UTF8_ENCODING);
|
||||
STRING_POOL *pool = &(dtd->pool);
|
||||
if (!poolStoreString(pool, enc, entityNamePtr, entityNameEnd))
|
||||
return noMemory;
|
||||
entity = (ENTITY *)lookup(isParam ? &(dtd->paramEntities) : &(dtd->generalEntities),
|
||||
pool->start,
|
||||
sizeof(ENTITY));
|
||||
if (entity->name != pool->start) {
|
||||
poolDiscard(pool);
|
||||
entityNamePtr = 0;
|
||||
}
|
||||
else
|
||||
poolFinish(pool);
|
||||
entityTextPtr += enc->minBytesPerChar;
|
||||
entityTextEnd -= enc->minBytesPerChar;
|
||||
entity->docTextPtr = entityTextPtr;
|
||||
for (;;) {
|
||||
const char *next;
|
||||
int tok = XmlEntityValueTok(enc, entityTextPtr, entityTextEnd, &next);
|
||||
switch (tok) {
|
||||
case XML_TOK_PARAM_ENTITY_REF:
|
||||
*badPtr = entityTextPtr;
|
||||
return syntaxError;
|
||||
case XML_TOK_NONE:
|
||||
if (entityNamePtr) {
|
||||
entity->textPtr = pool->start;
|
||||
entity->textLen = pool->ptr - pool->start;
|
||||
poolFinish(pool);
|
||||
}
|
||||
else
|
||||
poolDiscard(pool);
|
||||
return wellFormed;
|
||||
case XML_TOK_ENTITY_REF:
|
||||
case XML_TOK_DATA_CHARS:
|
||||
if (!poolAppend(pool, enc, entityTextPtr, next))
|
||||
return noMemory;
|
||||
break;
|
||||
case XML_TOK_TRAILING_CR:
|
||||
next = entityTextPtr + enc->minBytesPerChar;
|
||||
/* fall through */
|
||||
case XML_TOK_DATA_NEWLINE:
|
||||
if (pool->end == pool->ptr && !poolGrow(pool))
|
||||
return noMemory;
|
||||
*(pool->ptr)++ = '\n';
|
||||
break;
|
||||
case XML_TOK_CHAR_REF:
|
||||
{
|
||||
char buf[XML_MAX_BYTES_PER_CHAR];
|
||||
int i;
|
||||
int n = XmlCharRefNumber(enc, entityTextPtr);
|
||||
if (n < 0) {
|
||||
*badPtr = entityTextPtr;
|
||||
return badCharRef;
|
||||
}
|
||||
n = XmlEncode(utf8, n, buf);
|
||||
if (!n) {
|
||||
*badPtr = entityTextPtr;
|
||||
return badCharRef;
|
||||
}
|
||||
for (i = 0; i < n; i++) {
|
||||
if (pool->end == pool->ptr && !poolGrow(pool))
|
||||
return noMemory;
|
||||
*(pool->ptr)++ = buf[i];
|
||||
}
|
||||
}
|
||||
break;
|
||||
case XML_TOK_PARTIAL:
|
||||
*badPtr = entityTextPtr;
|
||||
return invalidToken;
|
||||
case XML_TOK_INVALID:
|
||||
*badPtr = next;
|
||||
return invalidToken;
|
||||
default:
|
||||
abort();
|
||||
}
|
||||
entityTextPtr = next;
|
||||
}
|
||||
/* not reached */
|
||||
}
|
38
other-licenses/expat/xmlwf/wfcheck.h
Executable file
38
other-licenses/expat/xmlwf/wfcheck.h
Executable file
@ -0,0 +1,38 @@
|
||||
|
||||
#include <stddef.h>
|
||||
|
||||
enum WfCheckResult {
|
||||
wellFormed,
|
||||
noMemory,
|
||||
syntaxError,
|
||||
noElements,
|
||||
invalidToken,
|
||||
unclosedToken,
|
||||
partialChar,
|
||||
tagMismatch,
|
||||
duplicateAttribute,
|
||||
junkAfterDocElement,
|
||||
paramEntityRef,
|
||||
undefinedEntity,
|
||||
recursiveEntityRef,
|
||||
asyncEntity,
|
||||
badCharRef,
|
||||
binaryEntityRef,
|
||||
attributeExternalEntityRef,
|
||||
misplacedXmlPi,
|
||||
unknownEncoding,
|
||||
incorrectEncoding
|
||||
};
|
||||
|
||||
enum EntityType {
|
||||
documentEntity,
|
||||
generalTextEntity
|
||||
};
|
||||
|
||||
enum WfCheckResult wfCheck(enum EntityType entityType,
|
||||
const char *s, size_t n,
|
||||
const char **errorPtr,
|
||||
unsigned long *errorLineNumber,
|
||||
unsigned long *errorColNumber);
|
||||
const char *wfCheckMessage(enum WfCheckResult);
|
||||
|
30
other-licenses/expat/xmlwf/wfcheckmessage.c
Executable file
30
other-licenses/expat/xmlwf/wfcheckmessage.c
Executable file
@ -0,0 +1,30 @@
|
||||
#include "wfcheck.h"
|
||||
|
||||
const char *wfCheckMessage(enum WfCheckResult result)
|
||||
{
|
||||
static const char *message[] = {
|
||||
0,
|
||||
"out of memory",
|
||||
"syntax error",
|
||||
"no element found",
|
||||
"not well-formed",
|
||||
"unclosed token",
|
||||
"unclosed token",
|
||||
"mismatched tag",
|
||||
"duplicate attribute",
|
||||
"junk after document element",
|
||||
"parameter entity reference not allowed within declaration in internal subset",
|
||||
"undefined entity",
|
||||
"recursive entity reference",
|
||||
"asynchronous entity",
|
||||
"reference to invalid character number",
|
||||
"reference to binary entity",
|
||||
"reference to external entity in attribute",
|
||||
"xml pi not at start of external entity",
|
||||
"unknown encoding",
|
||||
"encoding specified in XML declaration is incorrect"
|
||||
};
|
||||
if (result > 0 && result < sizeof(message)/sizeof(message[0]))
|
||||
return message[result];
|
||||
return 0;
|
||||
}
|
95
other-licenses/expat/xmlwf/win32filemap.c
Executable file
95
other-licenses/expat/xmlwf/win32filemap.c
Executable file
@ -0,0 +1,95 @@
|
||||
/*
|
||||
Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
|
||||
See the file COPYING for copying permission.
|
||||
*/
|
||||
|
||||
#define STRICT 1
|
||||
#define WIN32_LEAN_AND_MEAN 1
|
||||
|
||||
#ifdef XML_UNICODE_WCHAR_T
|
||||
#ifndef XML_UNICODE
|
||||
#define XML_UNICODE
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef XML_UNICODE
|
||||
#define UNICODE
|
||||
#define _UNICODE
|
||||
#endif /* XML_UNICODE */
|
||||
#include <windows.h>
|
||||
#include <stdio.h>
|
||||
#include <tchar.h>
|
||||
#include "filemap.h"
|
||||
|
||||
static void win32perror(const TCHAR *);
|
||||
|
||||
int filemap(const TCHAR *name,
|
||||
void (*processor)(const void *, size_t, const TCHAR *, void *arg),
|
||||
void *arg)
|
||||
{
|
||||
HANDLE f;
|
||||
HANDLE m;
|
||||
DWORD size;
|
||||
DWORD sizeHi;
|
||||
void *p;
|
||||
|
||||
f = CreateFile(name, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING,
|
||||
FILE_FLAG_SEQUENTIAL_SCAN, NULL);
|
||||
if (f == INVALID_HANDLE_VALUE) {
|
||||
win32perror(name);
|
||||
return 0;
|
||||
}
|
||||
size = GetFileSize(f, &sizeHi);
|
||||
if (size == (DWORD)-1) {
|
||||
win32perror(name);
|
||||
return 0;
|
||||
}
|
||||
if (sizeHi) {
|
||||
_ftprintf(stderr, _T("%s: bigger than 2Gb\n"), name);
|
||||
return 0;
|
||||
}
|
||||
/* CreateFileMapping barfs on zero length files */
|
||||
if (size == 0) {
|
||||
static const char c = '\0';
|
||||
processor(&c, 0, name, arg);
|
||||
CloseHandle(f);
|
||||
return 1;
|
||||
}
|
||||
m = CreateFileMapping(f, NULL, PAGE_READONLY, 0, 0, NULL);
|
||||
if (m == NULL) {
|
||||
win32perror(name);
|
||||
CloseHandle(f);
|
||||
return 0;
|
||||
}
|
||||
p = MapViewOfFile(m, FILE_MAP_READ, 0, 0, 0);
|
||||
if (p == NULL) {
|
||||
win32perror(name);
|
||||
CloseHandle(m);
|
||||
CloseHandle(f);
|
||||
return 0;
|
||||
}
|
||||
processor(p, size, name, arg);
|
||||
UnmapViewOfFile(p);
|
||||
CloseHandle(m);
|
||||
CloseHandle(f);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static
|
||||
void win32perror(const TCHAR *s)
|
||||
{
|
||||
LPVOID buf;
|
||||
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
|
||||
NULL,
|
||||
GetLastError(),
|
||||
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
|
||||
(LPTSTR) &buf,
|
||||
0,
|
||||
NULL)) {
|
||||
_ftprintf(stderr, _T("%s: %s"), s, buf);
|
||||
fflush(stderr);
|
||||
LocalFree(buf);
|
||||
}
|
||||
else
|
||||
_ftprintf(stderr, _T("%s: unknown Windows error\n"), s);
|
||||
}
|
217
other-licenses/expat/xmlwf/xmlfile.c
Executable file
217
other-licenses/expat/xmlwf/xmlfile.c
Executable file
@ -0,0 +1,217 @@
|
||||
/*
|
||||
Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
|
||||
See the file COPYING for copying permission.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stddef.h>
|
||||
#include <string.h>
|
||||
#include <fcntl.h>
|
||||
#include "expat.h"
|
||||
#include "xmlfile.h"
|
||||
#include "xmltchar.h"
|
||||
#include "filemap.h"
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#include <io.h>
|
||||
#endif
|
||||
|
||||
#ifdef _POSIX_SOURCE
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
|
||||
#ifndef O_BINARY
|
||||
#ifdef _O_BINARY
|
||||
#define O_BINARY _O_BINARY
|
||||
#else
|
||||
#define O_BINARY 0
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef _DEBUG
|
||||
#define READ_SIZE 16
|
||||
#else
|
||||
#define READ_SIZE (1024*8)
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
typedef struct {
|
||||
XML_Parser parser;
|
||||
int *retPtr;
|
||||
} PROCESS_ARGS;
|
||||
|
||||
static
|
||||
void reportError(XML_Parser parser, const XML_Char *filename)
|
||||
{
|
||||
int code = XML_GetErrorCode(parser);
|
||||
const XML_Char *message = XML_ErrorString(code);
|
||||
if (message)
|
||||
ftprintf(stdout, T("%s:%d:%d: %s\n"),
|
||||
filename,
|
||||
XML_GetErrorLineNumber(parser),
|
||||
XML_GetErrorColumnNumber(parser),
|
||||
message);
|
||||
else
|
||||
ftprintf(stderr, T("%s: (unknown message %d)\n"), filename, code);
|
||||
}
|
||||
|
||||
static
|
||||
void processFile(const void *data,
|
||||
size_t size,
|
||||
const XML_Char *filename,
|
||||
void *args)
|
||||
{
|
||||
XML_Parser parser = ((PROCESS_ARGS *)args)->parser;
|
||||
int *retPtr = ((PROCESS_ARGS *)args)->retPtr;
|
||||
if (!XML_Parse(parser, data, size, 1)) {
|
||||
reportError(parser, filename);
|
||||
*retPtr = 0;
|
||||
}
|
||||
else
|
||||
*retPtr = 1;
|
||||
}
|
||||
|
||||
#ifdef WIN32
|
||||
|
||||
static
|
||||
int isAsciiLetter(XML_Char c)
|
||||
{
|
||||
return (T('a') <= c && c <= T('z')) || (T('A') <= c && c <= T('Z'));
|
||||
}
|
||||
|
||||
#endif /* WIN32 */
|
||||
|
||||
static
|
||||
const XML_Char *resolveSystemId(const XML_Char *base, const XML_Char *systemId, XML_Char **toFree)
|
||||
{
|
||||
XML_Char *s;
|
||||
*toFree = 0;
|
||||
if (!base
|
||||
|| *systemId == T('/')
|
||||
#ifdef WIN32
|
||||
|| *systemId == T('\\')
|
||||
|| (isAsciiLetter(systemId[0]) && systemId[1] == T(':'))
|
||||
#endif
|
||||
)
|
||||
return systemId;
|
||||
*toFree = (XML_Char *)malloc((tcslen(base) + tcslen(systemId) + 2)*sizeof(XML_Char));
|
||||
if (!*toFree)
|
||||
return systemId;
|
||||
tcscpy(*toFree, base);
|
||||
s = *toFree;
|
||||
if (tcsrchr(s, T('/')))
|
||||
s = tcsrchr(s, T('/')) + 1;
|
||||
#ifdef WIN32
|
||||
if (tcsrchr(s, T('\\')))
|
||||
s = tcsrchr(s, T('\\')) + 1;
|
||||
#endif
|
||||
tcscpy(s, systemId);
|
||||
return *toFree;
|
||||
}
|
||||
|
||||
static
|
||||
int externalEntityRefFilemap(XML_Parser parser,
|
||||
const XML_Char *context,
|
||||
const XML_Char *base,
|
||||
const XML_Char *systemId,
|
||||
const XML_Char *publicId)
|
||||
{
|
||||
int result;
|
||||
XML_Char *s;
|
||||
const XML_Char *filename;
|
||||
XML_Parser entParser = XML_ExternalEntityParserCreate(parser, context, 0);
|
||||
PROCESS_ARGS args;
|
||||
args.retPtr = &result;
|
||||
args.parser = entParser;
|
||||
filename = resolveSystemId(base, systemId, &s);
|
||||
XML_SetBase(entParser, filename);
|
||||
if (!filemap(filename, processFile, &args))
|
||||
result = 0;
|
||||
free(s);
|
||||
XML_ParserFree(entParser);
|
||||
return result;
|
||||
}
|
||||
|
||||
static
|
||||
int processStream(const XML_Char *filename, XML_Parser parser)
|
||||
{
|
||||
int fd = topen(filename, O_BINARY|O_RDONLY);
|
||||
if (fd < 0) {
|
||||
tperror(filename);
|
||||
return 0;
|
||||
}
|
||||
for (;;) {
|
||||
int nread;
|
||||
char *buf = XML_GetBuffer(parser, READ_SIZE);
|
||||
if (!buf) {
|
||||
close(fd);
|
||||
ftprintf(stderr, T("%s: out of memory\n"), filename);
|
||||
return 0;
|
||||
}
|
||||
nread = read(fd, buf, READ_SIZE);
|
||||
if (nread < 0) {
|
||||
tperror(filename);
|
||||
close(fd);
|
||||
return 0;
|
||||
}
|
||||
if (!XML_ParseBuffer(parser, nread, nread == 0)) {
|
||||
reportError(parser, filename);
|
||||
close(fd);
|
||||
return 0;
|
||||
}
|
||||
if (nread == 0) {
|
||||
close(fd);
|
||||
break;;
|
||||
}
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
static
|
||||
int externalEntityRefStream(XML_Parser parser,
|
||||
const XML_Char *context,
|
||||
const XML_Char *base,
|
||||
const XML_Char *systemId,
|
||||
const XML_Char *publicId)
|
||||
{
|
||||
XML_Char *s;
|
||||
const XML_Char *filename;
|
||||
int ret;
|
||||
XML_Parser entParser = XML_ExternalEntityParserCreate(parser, context, 0);
|
||||
filename = resolveSystemId(base, systemId, &s);
|
||||
XML_SetBase(entParser, filename);
|
||||
ret = processStream(filename, entParser);
|
||||
free(s);
|
||||
XML_ParserFree(entParser);
|
||||
return ret;
|
||||
}
|
||||
|
||||
int XML_ProcessFile(XML_Parser parser,
|
||||
const XML_Char *filename,
|
||||
unsigned flags)
|
||||
{
|
||||
int result;
|
||||
|
||||
if (!XML_SetBase(parser, filename)) {
|
||||
ftprintf(stderr, T("%s: out of memory"), filename);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
if (flags & XML_EXTERNAL_ENTITIES)
|
||||
XML_SetExternalEntityRefHandler(parser,
|
||||
(flags & XML_MAP_FILE)
|
||||
? externalEntityRefFilemap
|
||||
: externalEntityRefStream);
|
||||
if (flags & XML_MAP_FILE) {
|
||||
PROCESS_ARGS args;
|
||||
args.retPtr = &result;
|
||||
args.parser = parser;
|
||||
if (!filemap(filename, processFile, &args))
|
||||
result = 0;
|
||||
}
|
||||
else
|
||||
result = processStream(filename, parser);
|
||||
return result;
|
||||
}
|
11
other-licenses/expat/xmlwf/xmlfile.h
Executable file
11
other-licenses/expat/xmlwf/xmlfile.h
Executable file
@ -0,0 +1,11 @@
|
||||
/*
|
||||
Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
|
||||
See the file COPYING for copying permission.
|
||||
*/
|
||||
|
||||
#define XML_MAP_FILE 01
|
||||
#define XML_EXTERNAL_ENTITIES 02
|
||||
|
||||
extern int XML_ProcessFile(XML_Parser parser,
|
||||
const XML_Char *filename,
|
||||
unsigned flags);
|
161
other-licenses/expat/xmlwf/xmlmime.c
Executable file
161
other-licenses/expat/xmlwf/xmlmime.c
Executable file
@ -0,0 +1,161 @@
|
||||
#include <string.h>
|
||||
#include "xmlmime.h"
|
||||
|
||||
static
|
||||
const char *getTok(const char **pp)
|
||||
{
|
||||
/* inComment means one level of nesting; inComment+1 means two levels etc */
|
||||
enum { inAtom, inString, init, inComment };
|
||||
int state = init;
|
||||
const char *tokStart = 0;
|
||||
for (;;) {
|
||||
switch (**pp) {
|
||||
case '\0':
|
||||
if (state == inAtom)
|
||||
return tokStart;
|
||||
return 0;
|
||||
case ' ':
|
||||
case '\r':
|
||||
case '\t':
|
||||
case '\n':
|
||||
if (state == inAtom)
|
||||
return tokStart;
|
||||
break;
|
||||
case '(':
|
||||
if (state == inAtom)
|
||||
return tokStart;
|
||||
if (state != inString)
|
||||
state++;
|
||||
break;
|
||||
case ')':
|
||||
if (state > init)
|
||||
--state;
|
||||
else if (state != inString)
|
||||
return 0;
|
||||
break;
|
||||
case ';':
|
||||
case '/':
|
||||
case '=':
|
||||
if (state == inAtom)
|
||||
return tokStart;
|
||||
if (state == init)
|
||||
return (*pp)++;
|
||||
break;
|
||||
case '\\':
|
||||
++*pp;
|
||||
if (**pp == '\0')
|
||||
return 0;
|
||||
break;
|
||||
case '"':
|
||||
switch (state) {
|
||||
case inString:
|
||||
++*pp;
|
||||
return tokStart;
|
||||
case inAtom:
|
||||
return tokStart;
|
||||
case init:
|
||||
tokStart = *pp;
|
||||
state = inString;
|
||||
break;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
if (state == init) {
|
||||
tokStart = *pp;
|
||||
state = inAtom;
|
||||
}
|
||||
break;
|
||||
}
|
||||
++*pp;
|
||||
}
|
||||
/* not reached */
|
||||
}
|
||||
|
||||
/* key must be lowercase ASCII */
|
||||
|
||||
static
|
||||
int matchkey(const char *start, const char *end, const char *key)
|
||||
{
|
||||
if (!start)
|
||||
return 0;
|
||||
for (; start != end; start++, key++)
|
||||
if (*start != *key && *start != 'A' + (*key - 'a'))
|
||||
return 0;
|
||||
return *key == '\0';
|
||||
}
|
||||
|
||||
void getXMLCharset(const char *buf, char *charset)
|
||||
{
|
||||
const char *next, *p;
|
||||
|
||||
charset[0] = '\0';
|
||||
next = buf;
|
||||
p = getTok(&next);
|
||||
if (matchkey(p, next, "text"))
|
||||
strcpy(charset, "us-ascii");
|
||||
else if (!matchkey(p, next, "application"))
|
||||
return;
|
||||
p = getTok(&next);
|
||||
if (!p || *p != '/')
|
||||
return;
|
||||
p = getTok(&next);
|
||||
#if 0
|
||||
if (!matchkey(p, next, "xml") && charset[0] == '\0')
|
||||
return;
|
||||
#endif
|
||||
p = getTok(&next);
|
||||
while (p) {
|
||||
if (*p == ';') {
|
||||
p = getTok(&next);
|
||||
if (matchkey(p, next, "charset")) {
|
||||
p = getTok(&next);
|
||||
if (p && *p == '=') {
|
||||
p = getTok(&next);
|
||||
if (p) {
|
||||
char *s = charset;
|
||||
if (*p == '"') {
|
||||
while (++p != next - 1) {
|
||||
if (*p == '\\')
|
||||
++p;
|
||||
if (s == charset + CHARSET_MAX - 1) {
|
||||
charset[0] = '\0';
|
||||
break;
|
||||
}
|
||||
*s++ = *p;
|
||||
}
|
||||
*s++ = '\0';
|
||||
}
|
||||
else {
|
||||
if (next - p > CHARSET_MAX - 1)
|
||||
break;
|
||||
while (p != next)
|
||||
*s++ = *p++;
|
||||
*s = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
else
|
||||
p = getTok(&next);
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef TEST
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
char buf[CHARSET_MAX];
|
||||
if (argc <= 1)
|
||||
return 1;
|
||||
printf("%s\n", argv[1]);
|
||||
getXMLCharset(argv[1], buf);
|
||||
printf("charset=\"%s\"\n", buf);
|
||||
return 0;
|
||||
}
|
||||
|
||||
#endif /* TEST */
|
19
other-licenses/expat/xmlwf/xmlmime.h
Executable file
19
other-licenses/expat/xmlwf/xmlmime.h
Executable file
@ -0,0 +1,19 @@
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* Registered charset names are at most 40 characters long. */
|
||||
|
||||
#define CHARSET_MAX 41
|
||||
|
||||
/* Figure out the charset to use from the ContentType.
|
||||
buf contains the body of the header field (the part after "Content-Type:").
|
||||
charset gets the charset to use. It must be at least CHARSET_MAX chars long.
|
||||
charset will be empty if the default charset should be used. */
|
||||
|
||||
void getXMLCharset(const char *buf, char *charset);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
36
other-licenses/expat/xmlwf/xmltchar.h
Executable file
36
other-licenses/expat/xmlwf/xmltchar.h
Executable file
@ -0,0 +1,36 @@
|
||||
#ifdef XML_UNICODE
|
||||
#ifndef XML_UNICODE_WCHAR_T
|
||||
#error xmlwf requires a 16-bit Unicode-compatible wchar_t
|
||||
#endif
|
||||
#define T(x) L ## x
|
||||
#define ftprintf fwprintf
|
||||
#define tfopen _wfopen
|
||||
#define fputts fputws
|
||||
#define puttc putwc
|
||||
#define tcscmp wcscmp
|
||||
#define tcscpy wcscpy
|
||||
#define tcscat wcscat
|
||||
#define tcschr wcschr
|
||||
#define tcsrchr wcsrchr
|
||||
#define tcslen wcslen
|
||||
#define tperror _wperror
|
||||
#define topen _wopen
|
||||
#define tmain wmain
|
||||
#define tremove _wremove
|
||||
#else /* not XML_UNICODE */
|
||||
#define T(x) x
|
||||
#define ftprintf fprintf
|
||||
#define tfopen fopen
|
||||
#define fputts fputs
|
||||
#define puttc putc
|
||||
#define tcscmp strcmp
|
||||
#define tcscpy strcpy
|
||||
#define tcscat strcat
|
||||
#define tcschr strchr
|
||||
#define tcsrchr strrchr
|
||||
#define tcslen strlen
|
||||
#define tperror perror
|
||||
#define topen open
|
||||
#define tmain main
|
||||
#define tremove remove
|
||||
#endif /* not XML_UNICODE */
|
13
other-licenses/expat/xmlwf/xmlurl.h
Executable file
13
other-licenses/expat/xmlwf/xmlurl.h
Executable file
@ -0,0 +1,13 @@
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
int XML_URLInit();
|
||||
void XML_URLUninit();
|
||||
int XML_ProcessURL(XML_Parser parser,
|
||||
const XML_Char *url,
|
||||
unsigned flags);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
759
other-licenses/expat/xmlwf/xmlwf.c
Executable file
759
other-licenses/expat/xmlwf/xmlwf.c
Executable file
@ -0,0 +1,759 @@
|
||||
/*
|
||||
Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
|
||||
See the file COPYING for copying permission.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stddef.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "expat.h"
|
||||
#include "codepage.h"
|
||||
#include "xmlfile.h"
|
||||
#include "xmltchar.h"
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#include <crtdbg.h>
|
||||
#endif
|
||||
|
||||
/* This ensures proper sorting. */
|
||||
|
||||
#define NSSEP T('\001')
|
||||
|
||||
static void characterData(void *userData, const XML_Char *s, int len)
|
||||
{
|
||||
FILE *fp = userData;
|
||||
for (; len > 0; --len, ++s) {
|
||||
switch (*s) {
|
||||
case T('&'):
|
||||
fputts(T("&"), fp);
|
||||
break;
|
||||
case T('<'):
|
||||
fputts(T("<"), fp);
|
||||
break;
|
||||
case T('>'):
|
||||
fputts(T(">"), fp);
|
||||
break;
|
||||
#ifdef W3C14N
|
||||
case 13:
|
||||
fputts(T("
"), fp);
|
||||
break;
|
||||
#else
|
||||
case T('"'):
|
||||
fputts(T("""), fp);
|
||||
break;
|
||||
case 9:
|
||||
case 10:
|
||||
case 13:
|
||||
ftprintf(fp, T("&#%d;"), *s);
|
||||
break;
|
||||
#endif
|
||||
default:
|
||||
puttc(*s, fp);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void attributeValue(FILE *fp, const XML_Char *s)
|
||||
{
|
||||
puttc(T('='), fp);
|
||||
puttc(T('"'), fp);
|
||||
for (;;) {
|
||||
switch (*s) {
|
||||
case 0:
|
||||
case NSSEP:
|
||||
puttc(T('"'), fp);
|
||||
return;
|
||||
case T('&'):
|
||||
fputts(T("&"), fp);
|
||||
break;
|
||||
case T('<'):
|
||||
fputts(T("<"), fp);
|
||||
break;
|
||||
case T('"'):
|
||||
fputts(T("""), fp);
|
||||
break;
|
||||
#ifdef W3C14N
|
||||
case 9:
|
||||
fputts(T("	"), fp);
|
||||
break;
|
||||
case 10:
|
||||
fputts(T("
"), fp);
|
||||
break;
|
||||
case 13:
|
||||
fputts(T("
"), fp);
|
||||
break;
|
||||
#else
|
||||
case T('>'):
|
||||
fputts(T(">"), fp);
|
||||
break;
|
||||
case 9:
|
||||
case 10:
|
||||
case 13:
|
||||
ftprintf(fp, T("&#%d;"), *s);
|
||||
break;
|
||||
#endif
|
||||
default:
|
||||
puttc(*s, fp);
|
||||
break;
|
||||
}
|
||||
s++;
|
||||
}
|
||||
}
|
||||
|
||||
/* Lexicographically comparing UTF-8 encoded attribute values,
|
||||
is equivalent to lexicographically comparing based on the character number. */
|
||||
|
||||
static int attcmp(const void *att1, const void *att2)
|
||||
{
|
||||
return tcscmp(*(const XML_Char **)att1, *(const XML_Char **)att2);
|
||||
}
|
||||
|
||||
static void startElement(void *userData, const XML_Char *name, const XML_Char **atts)
|
||||
{
|
||||
int nAtts;
|
||||
const XML_Char **p;
|
||||
FILE *fp = userData;
|
||||
puttc(T('<'), fp);
|
||||
fputts(name, fp);
|
||||
|
||||
p = atts;
|
||||
while (*p)
|
||||
++p;
|
||||
nAtts = (p - atts) >> 1;
|
||||
if (nAtts > 1)
|
||||
qsort((void *)atts, nAtts, sizeof(XML_Char *) * 2, attcmp);
|
||||
while (*atts) {
|
||||
puttc(T(' '), fp);
|
||||
fputts(*atts++, fp);
|
||||
attributeValue(fp, *atts);
|
||||
atts++;
|
||||
}
|
||||
puttc(T('>'), fp);
|
||||
}
|
||||
|
||||
static void endElement(void *userData, const XML_Char *name)
|
||||
{
|
||||
FILE *fp = userData;
|
||||
puttc(T('<'), fp);
|
||||
puttc(T('/'), fp);
|
||||
fputts(name, fp);
|
||||
puttc(T('>'), fp);
|
||||
}
|
||||
|
||||
static int nsattcmp(const void *p1, const void *p2)
|
||||
{
|
||||
const XML_Char *att1 = *(const XML_Char **)p1;
|
||||
const XML_Char *att2 = *(const XML_Char **)p2;
|
||||
int sep1 = (tcsrchr(att1, NSSEP) != 0);
|
||||
int sep2 = (tcsrchr(att1, NSSEP) != 0);
|
||||
if (sep1 != sep2)
|
||||
return sep1 - sep2;
|
||||
return tcscmp(att1, att2);
|
||||
}
|
||||
|
||||
static void startElementNS(void *userData, const XML_Char *name, const XML_Char **atts)
|
||||
{
|
||||
int nAtts;
|
||||
int nsi;
|
||||
const XML_Char **p;
|
||||
FILE *fp = userData;
|
||||
const XML_Char *sep;
|
||||
puttc(T('<'), fp);
|
||||
|
||||
sep = tcsrchr(name, NSSEP);
|
||||
if (sep) {
|
||||
fputts(T("n1:"), fp);
|
||||
fputts(sep + 1, fp);
|
||||
fputts(T(" xmlns:n1"), fp);
|
||||
attributeValue(fp, name);
|
||||
nsi = 2;
|
||||
}
|
||||
else {
|
||||
fputts(name, fp);
|
||||
nsi = 1;
|
||||
}
|
||||
|
||||
p = atts;
|
||||
while (*p)
|
||||
++p;
|
||||
nAtts = (p - atts) >> 1;
|
||||
if (nAtts > 1)
|
||||
qsort((void *)atts, nAtts, sizeof(XML_Char *) * 2, nsattcmp);
|
||||
while (*atts) {
|
||||
name = *atts++;
|
||||
sep = tcsrchr(name, NSSEP);
|
||||
puttc(T(' '), fp);
|
||||
if (sep) {
|
||||
ftprintf(fp, T("n%d:"), nsi);
|
||||
fputts(sep + 1, fp);
|
||||
}
|
||||
else
|
||||
fputts(name, fp);
|
||||
attributeValue(fp, *atts);
|
||||
if (sep) {
|
||||
ftprintf(fp, T(" xmlns:n%d"), nsi++);
|
||||
attributeValue(fp, name);
|
||||
}
|
||||
atts++;
|
||||
}
|
||||
puttc(T('>'), fp);
|
||||
}
|
||||
|
||||
static void endElementNS(void *userData, const XML_Char *name)
|
||||
{
|
||||
FILE *fp = userData;
|
||||
const XML_Char *sep;
|
||||
puttc(T('<'), fp);
|
||||
puttc(T('/'), fp);
|
||||
sep = tcsrchr(name, NSSEP);
|
||||
if (sep) {
|
||||
fputts(T("n1:"), fp);
|
||||
fputts(sep + 1, fp);
|
||||
}
|
||||
else
|
||||
fputts(name, fp);
|
||||
puttc(T('>'), fp);
|
||||
}
|
||||
|
||||
#ifndef W3C14N
|
||||
|
||||
static void processingInstruction(void *userData, const XML_Char *target, const XML_Char *data)
|
||||
{
|
||||
FILE *fp = userData;
|
||||
puttc(T('<'), fp);
|
||||
puttc(T('?'), fp);
|
||||
fputts(target, fp);
|
||||
puttc(T(' '), fp);
|
||||
fputts(data, fp);
|
||||
puttc(T('?'), fp);
|
||||
puttc(T('>'), fp);
|
||||
}
|
||||
|
||||
#endif /* not W3C14N */
|
||||
|
||||
static void defaultCharacterData(XML_Parser parser, const XML_Char *s, int len)
|
||||
{
|
||||
XML_DefaultCurrent(parser);
|
||||
}
|
||||
|
||||
static void defaultStartElement(XML_Parser parser, const XML_Char *name, const XML_Char **atts)
|
||||
{
|
||||
XML_DefaultCurrent(parser);
|
||||
}
|
||||
|
||||
static void defaultEndElement(XML_Parser parser, const XML_Char *name)
|
||||
{
|
||||
XML_DefaultCurrent(parser);
|
||||
}
|
||||
|
||||
static void defaultProcessingInstruction(XML_Parser parser, const XML_Char *target, const XML_Char *data)
|
||||
{
|
||||
XML_DefaultCurrent(parser);
|
||||
}
|
||||
|
||||
static void nopCharacterData(XML_Parser parser, const XML_Char *s, int len)
|
||||
{
|
||||
}
|
||||
|
||||
static void nopStartElement(XML_Parser parser, const XML_Char *name, const XML_Char **atts)
|
||||
{
|
||||
}
|
||||
|
||||
static void nopEndElement(XML_Parser parser, const XML_Char *name)
|
||||
{
|
||||
}
|
||||
|
||||
static void nopProcessingInstruction(XML_Parser parser, const XML_Char *target, const XML_Char *data)
|
||||
{
|
||||
}
|
||||
|
||||
static void markup(XML_Parser parser, const XML_Char *s, int len)
|
||||
{
|
||||
FILE *fp = XML_GetUserData(parser);
|
||||
for (; len > 0; --len, ++s)
|
||||
puttc(*s, fp);
|
||||
}
|
||||
|
||||
static
|
||||
void metaLocation(XML_Parser parser)
|
||||
{
|
||||
const XML_Char *uri = XML_GetBase(parser);
|
||||
if (uri)
|
||||
ftprintf(XML_GetUserData(parser), T(" uri=\"%s\""), uri);
|
||||
ftprintf(XML_GetUserData(parser),
|
||||
T(" byte=\"%ld\" nbytes=\"%d\" line=\"%d\" col=\"%d\""),
|
||||
XML_GetCurrentByteIndex(parser),
|
||||
XML_GetCurrentByteCount(parser),
|
||||
XML_GetCurrentLineNumber(parser),
|
||||
XML_GetCurrentColumnNumber(parser));
|
||||
}
|
||||
|
||||
static
|
||||
void metaStartDocument(XML_Parser parser)
|
||||
{
|
||||
fputts(T("<document>\n"), XML_GetUserData(parser));
|
||||
}
|
||||
|
||||
static
|
||||
void metaEndDocument(XML_Parser parser)
|
||||
{
|
||||
fputts(T("</document>\n"), XML_GetUserData(parser));
|
||||
}
|
||||
|
||||
static
|
||||
void metaStartElement(XML_Parser parser, const XML_Char *name, const XML_Char **atts)
|
||||
{
|
||||
FILE *fp = XML_GetUserData(parser);
|
||||
const XML_Char **specifiedAttsEnd
|
||||
= atts + XML_GetSpecifiedAttributeCount(parser);
|
||||
const XML_Char **idAttPtr;
|
||||
int idAttIndex = XML_GetIdAttributeIndex(parser);
|
||||
if (idAttIndex < 0)
|
||||
idAttPtr = 0;
|
||||
else
|
||||
idAttPtr = atts + idAttIndex;
|
||||
|
||||
ftprintf(fp, T("<starttag name=\"%s\""), name);
|
||||
metaLocation(parser);
|
||||
if (*atts) {
|
||||
fputts(T(">\n"), fp);
|
||||
do {
|
||||
ftprintf(fp, T("<attribute name=\"%s\" value=\""), atts[0]);
|
||||
characterData(fp, atts[1], tcslen(atts[1]));
|
||||
if (atts >= specifiedAttsEnd)
|
||||
fputts(T("\" defaulted=\"yes\"/>\n"), fp);
|
||||
else if (atts == idAttPtr)
|
||||
fputts(T("\" id=\"yes\"/>\n"), fp);
|
||||
else
|
||||
fputts(T("\"/>\n"), fp);
|
||||
} while (*(atts += 2));
|
||||
fputts(T("</starttag>\n"), fp);
|
||||
}
|
||||
else
|
||||
fputts(T("/>\n"), fp);
|
||||
}
|
||||
|
||||
static
|
||||
void metaEndElement(XML_Parser parser, const XML_Char *name)
|
||||
{
|
||||
FILE *fp = XML_GetUserData(parser);
|
||||
ftprintf(fp, T("<endtag name=\"%s\""), name);
|
||||
metaLocation(parser);
|
||||
fputts(T("/>\n"), fp);
|
||||
}
|
||||
|
||||
static
|
||||
void metaProcessingInstruction(XML_Parser parser, const XML_Char *target, const XML_Char *data)
|
||||
{
|
||||
FILE *fp = XML_GetUserData(parser);
|
||||
ftprintf(fp, T("<pi target=\"%s\" data=\""), target);
|
||||
characterData(fp, data, tcslen(data));
|
||||
puttc(T('"'), fp);
|
||||
metaLocation(parser);
|
||||
fputts(T("/>\n"), fp);
|
||||
}
|
||||
|
||||
static
|
||||
void metaComment(XML_Parser parser, const XML_Char *data)
|
||||
{
|
||||
FILE *fp = XML_GetUserData(parser);
|
||||
fputts(T("<comment data=\""), fp);
|
||||
characterData(fp, data, tcslen(data));
|
||||
puttc(T('"'), fp);
|
||||
metaLocation(parser);
|
||||
fputts(T("/>\n"), fp);
|
||||
}
|
||||
|
||||
static
|
||||
void metaStartCdataSection(XML_Parser parser)
|
||||
{
|
||||
FILE *fp = XML_GetUserData(parser);
|
||||
fputts(T("<startcdata"), fp);
|
||||
metaLocation(parser);
|
||||
fputts(T("/>\n"), fp);
|
||||
}
|
||||
|
||||
static
|
||||
void metaEndCdataSection(XML_Parser parser)
|
||||
{
|
||||
FILE *fp = XML_GetUserData(parser);
|
||||
fputts(T("<endcdata"), fp);
|
||||
metaLocation(parser);
|
||||
fputts(T("/>\n"), fp);
|
||||
}
|
||||
|
||||
static
|
||||
void metaCharacterData(XML_Parser parser, const XML_Char *s, int len)
|
||||
{
|
||||
FILE *fp = XML_GetUserData(parser);
|
||||
fputts(T("<chars str=\""), fp);
|
||||
characterData(fp, s, len);
|
||||
puttc(T('"'), fp);
|
||||
metaLocation(parser);
|
||||
fputts(T("/>\n"), fp);
|
||||
}
|
||||
|
||||
static
|
||||
void metaStartDoctypeDecl(XML_Parser parser,
|
||||
const XML_Char *doctypeName,
|
||||
const XML_Char *sysid,
|
||||
const XML_Char *pubid,
|
||||
int has_internal_subset)
|
||||
{
|
||||
FILE *fp = XML_GetUserData(parser);
|
||||
ftprintf(fp, T("<startdoctype name=\"%s\""), doctypeName);
|
||||
metaLocation(parser);
|
||||
fputts(T("/>\n"), fp);
|
||||
}
|
||||
|
||||
static
|
||||
void metaEndDoctypeDecl(XML_Parser parser)
|
||||
{
|
||||
FILE *fp = XML_GetUserData(parser);
|
||||
fputts(T("<enddoctype"), fp);
|
||||
metaLocation(parser);
|
||||
fputts(T("/>\n"), fp);
|
||||
}
|
||||
|
||||
static
|
||||
void metaNotationDecl(XML_Parser parser,
|
||||
const XML_Char *notationName,
|
||||
const XML_Char *base,
|
||||
const XML_Char *systemId,
|
||||
const XML_Char *publicId)
|
||||
{
|
||||
FILE *fp = XML_GetUserData(parser);
|
||||
ftprintf(fp, T("<notation name=\"%s\""), notationName);
|
||||
if (publicId)
|
||||
ftprintf(fp, T(" public=\"%s\""), publicId);
|
||||
if (systemId) {
|
||||
fputts(T(" system=\""), fp);
|
||||
characterData(fp, systemId, tcslen(systemId));
|
||||
puttc(T('"'), fp);
|
||||
}
|
||||
metaLocation(parser);
|
||||
fputts(T("/>\n"), fp);
|
||||
}
|
||||
|
||||
|
||||
static
|
||||
void metaEntityDecl(XML_Parser parser,
|
||||
const XML_Char *entityName,
|
||||
int is_param,
|
||||
const XML_Char *value,
|
||||
int value_length,
|
||||
const XML_Char *base,
|
||||
const XML_Char *systemId,
|
||||
const XML_Char *publicId,
|
||||
const XML_Char *notationName)
|
||||
{
|
||||
FILE *fp = XML_GetUserData(parser);
|
||||
|
||||
if (value) {
|
||||
ftprintf(fp, T("<entity name=\"%s\""), entityName);
|
||||
metaLocation(parser);
|
||||
puttc(T('>'), fp);
|
||||
characterData(fp, value, value_length);
|
||||
fputts(T("</entity/>\n"), fp);
|
||||
}
|
||||
else if (notationName) {
|
||||
ftprintf(fp, T("<entity name=\"%s\""), entityName);
|
||||
if (publicId)
|
||||
ftprintf(fp, T(" public=\"%s\""), publicId);
|
||||
fputts(T(" system=\""), fp);
|
||||
characterData(fp, systemId, tcslen(systemId));
|
||||
puttc(T('"'), fp);
|
||||
ftprintf(fp, T(" notation=\"%s\""), notationName);
|
||||
metaLocation(parser);
|
||||
fputts(T("/>\n"), fp);
|
||||
}
|
||||
else {
|
||||
ftprintf(fp, T("<entity name=\"%s\""), entityName);
|
||||
if (publicId)
|
||||
ftprintf(fp, T(" public=\"%s\""), publicId);
|
||||
fputts(T(" system=\""), fp);
|
||||
characterData(fp, systemId, tcslen(systemId));
|
||||
puttc(T('"'), fp);
|
||||
metaLocation(parser);
|
||||
fputts(T("/>\n"), fp);
|
||||
}
|
||||
}
|
||||
|
||||
static
|
||||
void metaStartNamespaceDecl(XML_Parser parser,
|
||||
const XML_Char *prefix,
|
||||
const XML_Char *uri)
|
||||
{
|
||||
FILE *fp = XML_GetUserData(parser);
|
||||
fputts(T("<startns"), fp);
|
||||
if (prefix)
|
||||
ftprintf(fp, T(" prefix=\"%s\""), prefix);
|
||||
if (uri) {
|
||||
fputts(T(" ns=\""), fp);
|
||||
characterData(fp, uri, tcslen(uri));
|
||||
fputts(T("\"/>\n"), fp);
|
||||
}
|
||||
else
|
||||
fputts(T("/>\n"), fp);
|
||||
}
|
||||
|
||||
static
|
||||
void metaEndNamespaceDecl(XML_Parser parser, const XML_Char *prefix)
|
||||
{
|
||||
FILE *fp = XML_GetUserData(parser);
|
||||
if (!prefix)
|
||||
fputts(T("<endns/>\n"), fp);
|
||||
else
|
||||
ftprintf(fp, T("<endns prefix=\"%s\"/>\n"), prefix);
|
||||
}
|
||||
|
||||
static
|
||||
int unknownEncodingConvert(void *data, const char *p)
|
||||
{
|
||||
return codepageConvert(*(int *)data, p);
|
||||
}
|
||||
|
||||
static
|
||||
int unknownEncoding(void *userData,
|
||||
const XML_Char *name,
|
||||
XML_Encoding *info)
|
||||
{
|
||||
int cp;
|
||||
static const XML_Char prefixL[] = T("windows-");
|
||||
static const XML_Char prefixU[] = T("WINDOWS-");
|
||||
int i;
|
||||
|
||||
for (i = 0; prefixU[i]; i++)
|
||||
if (name[i] != prefixU[i] && name[i] != prefixL[i])
|
||||
return 0;
|
||||
|
||||
cp = 0;
|
||||
for (; name[i]; i++) {
|
||||
static const XML_Char digits[] = T("0123456789");
|
||||
const XML_Char *s = tcschr(digits, name[i]);
|
||||
if (!s)
|
||||
return 0;
|
||||
cp *= 10;
|
||||
cp += s - digits;
|
||||
if (cp >= 0x10000)
|
||||
return 0;
|
||||
}
|
||||
if (!codepageMap(cp, info->map))
|
||||
return 0;
|
||||
info->convert = unknownEncodingConvert;
|
||||
/* We could just cast the code page integer to a void *,
|
||||
and avoid the use of release. */
|
||||
info->release = free;
|
||||
info->data = malloc(sizeof(int));
|
||||
if (!info->data)
|
||||
return 0;
|
||||
*(int *)info->data = cp;
|
||||
return 1;
|
||||
}
|
||||
|
||||
static
|
||||
int notStandalone(void *userData)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static
|
||||
void usage(const XML_Char *prog)
|
||||
{
|
||||
ftprintf(stderr, T("usage: %s [-n] [-p] [-r] [-s] [-w] [-x] [-d output-dir] [-e encoding] file ...\n"), prog);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
int tmain(int argc, XML_Char **argv)
|
||||
{
|
||||
int i, j;
|
||||
const XML_Char *outputDir = 0;
|
||||
const XML_Char *encoding = 0;
|
||||
unsigned processFlags = XML_MAP_FILE;
|
||||
int windowsCodePages = 0;
|
||||
int outputType = 0;
|
||||
int useNamespaces = 0;
|
||||
int requireStandalone = 0;
|
||||
int paramEntityParsing = XML_PARAM_ENTITY_PARSING_NEVER;
|
||||
|
||||
#ifdef _MSC_VER
|
||||
_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF|_CRTDBG_LEAK_CHECK_DF);
|
||||
#endif
|
||||
|
||||
i = 1;
|
||||
j = 0;
|
||||
while (i < argc) {
|
||||
if (j == 0) {
|
||||
if (argv[i][0] != T('-'))
|
||||
break;
|
||||
if (argv[i][1] == T('-') && argv[i][2] == T('\0')) {
|
||||
i++;
|
||||
break;
|
||||
}
|
||||
j++;
|
||||
}
|
||||
switch (argv[i][j]) {
|
||||
case T('r'):
|
||||
processFlags &= ~XML_MAP_FILE;
|
||||
j++;
|
||||
break;
|
||||
case T('s'):
|
||||
requireStandalone = 1;
|
||||
j++;
|
||||
break;
|
||||
case T('n'):
|
||||
useNamespaces = 1;
|
||||
j++;
|
||||
break;
|
||||
case T('p'):
|
||||
paramEntityParsing = XML_PARAM_ENTITY_PARSING_ALWAYS;
|
||||
/* fall through */
|
||||
case T('x'):
|
||||
processFlags |= XML_EXTERNAL_ENTITIES;
|
||||
j++;
|
||||
break;
|
||||
case T('w'):
|
||||
windowsCodePages = 1;
|
||||
j++;
|
||||
break;
|
||||
case T('m'):
|
||||
outputType = 'm';
|
||||
j++;
|
||||
break;
|
||||
case T('c'):
|
||||
outputType = 'c';
|
||||
useNamespaces = 0;
|
||||
j++;
|
||||
break;
|
||||
case T('t'):
|
||||
outputType = 't';
|
||||
j++;
|
||||
break;
|
||||
case T('d'):
|
||||
if (argv[i][j + 1] == T('\0')) {
|
||||
if (++i == argc)
|
||||
usage(argv[0]);
|
||||
outputDir = argv[i];
|
||||
}
|
||||
else
|
||||
outputDir = argv[i] + j + 1;
|
||||
i++;
|
||||
j = 0;
|
||||
break;
|
||||
case T('e'):
|
||||
if (argv[i][j + 1] == T('\0')) {
|
||||
if (++i == argc)
|
||||
usage(argv[0]);
|
||||
encoding = argv[i];
|
||||
}
|
||||
else
|
||||
encoding = argv[i] + j + 1;
|
||||
i++;
|
||||
j = 0;
|
||||
break;
|
||||
case T('\0'):
|
||||
if (j > 1) {
|
||||
i++;
|
||||
j = 0;
|
||||
break;
|
||||
}
|
||||
/* fall through */
|
||||
default:
|
||||
usage(argv[0]);
|
||||
}
|
||||
}
|
||||
if (i == argc)
|
||||
usage(argv[0]);
|
||||
for (; i < argc; i++) {
|
||||
FILE *fp = 0;
|
||||
XML_Char *outName = 0;
|
||||
int result;
|
||||
XML_Parser parser;
|
||||
if (useNamespaces)
|
||||
parser = XML_ParserCreateNS(encoding, NSSEP);
|
||||
else
|
||||
parser = XML_ParserCreate(encoding);
|
||||
if (requireStandalone)
|
||||
XML_SetNotStandaloneHandler(parser, notStandalone);
|
||||
XML_SetParamEntityParsing(parser, paramEntityParsing);
|
||||
if (outputType == 't') {
|
||||
/* This is for doing timings; this gives a more realistic estimate of
|
||||
the parsing time. */
|
||||
outputDir = 0;
|
||||
XML_SetElementHandler(parser, nopStartElement, nopEndElement);
|
||||
XML_SetCharacterDataHandler(parser, nopCharacterData);
|
||||
XML_SetProcessingInstructionHandler(parser, nopProcessingInstruction);
|
||||
}
|
||||
else if (outputDir) {
|
||||
const XML_Char *file = argv[i];
|
||||
if (tcsrchr(file, T('/')))
|
||||
file = tcsrchr(file, T('/')) + 1;
|
||||
#ifdef WIN32
|
||||
if (tcsrchr(file, T('\\')))
|
||||
file = tcsrchr(file, T('\\')) + 1;
|
||||
#endif
|
||||
outName = malloc((tcslen(outputDir) + tcslen(file) + 2) * sizeof(XML_Char));
|
||||
tcscpy(outName, outputDir);
|
||||
tcscat(outName, T("/"));
|
||||
tcscat(outName, file);
|
||||
fp = tfopen(outName, T("wb"));
|
||||
if (!fp) {
|
||||
tperror(outName);
|
||||
exit(1);
|
||||
}
|
||||
setvbuf(fp, NULL, _IOFBF, 16384);
|
||||
#ifdef XML_UNICODE
|
||||
puttc(0xFEFF, fp);
|
||||
#endif
|
||||
XML_SetUserData(parser, fp);
|
||||
switch (outputType) {
|
||||
case 'm':
|
||||
XML_UseParserAsHandlerArg(parser);
|
||||
XML_SetElementHandler(parser, metaStartElement, metaEndElement);
|
||||
XML_SetProcessingInstructionHandler(parser, metaProcessingInstruction);
|
||||
XML_SetCommentHandler(parser, metaComment);
|
||||
XML_SetCdataSectionHandler(parser, metaStartCdataSection, metaEndCdataSection);
|
||||
XML_SetCharacterDataHandler(parser, metaCharacterData);
|
||||
XML_SetDoctypeDeclHandler(parser, metaStartDoctypeDecl, metaEndDoctypeDecl);
|
||||
XML_SetEntityDeclHandler(parser, metaEntityDecl);
|
||||
XML_SetNotationDeclHandler(parser, metaNotationDecl);
|
||||
XML_SetNamespaceDeclHandler(parser, metaStartNamespaceDecl, metaEndNamespaceDecl);
|
||||
metaStartDocument(parser);
|
||||
break;
|
||||
case 'c':
|
||||
XML_UseParserAsHandlerArg(parser);
|
||||
XML_SetDefaultHandler(parser, markup);
|
||||
XML_SetElementHandler(parser, defaultStartElement, defaultEndElement);
|
||||
XML_SetCharacterDataHandler(parser, defaultCharacterData);
|
||||
XML_SetProcessingInstructionHandler(parser, defaultProcessingInstruction);
|
||||
break;
|
||||
default:
|
||||
if (useNamespaces)
|
||||
XML_SetElementHandler(parser, startElementNS, endElementNS);
|
||||
else
|
||||
XML_SetElementHandler(parser, startElement, endElement);
|
||||
XML_SetCharacterDataHandler(parser, characterData);
|
||||
#ifndef W3C14N
|
||||
XML_SetProcessingInstructionHandler(parser, processingInstruction);
|
||||
#endif /* not W3C14N */
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (windowsCodePages)
|
||||
XML_SetUnknownEncodingHandler(parser, unknownEncoding, 0);
|
||||
result = XML_ProcessFile(parser, argv[i], processFlags);
|
||||
if (outputDir) {
|
||||
if (outputType == 'm')
|
||||
metaEndDocument(parser);
|
||||
fclose(fp);
|
||||
if (!result)
|
||||
tremove(outName);
|
||||
free(outName);
|
||||
}
|
||||
XML_ParserFree(parser);
|
||||
}
|
||||
return 0;
|
||||
}
|
371
other-licenses/expat/xmlwf/xmlwin32url.cxx
Executable file
371
other-licenses/expat/xmlwf/xmlwin32url.cxx
Executable file
@ -0,0 +1,371 @@
|
||||
#include "xmlparse.h"
|
||||
#ifdef XML_UNICODE
|
||||
#define UNICODE
|
||||
#endif
|
||||
#include <windows.h>
|
||||
#include <urlmon.h>
|
||||
#include <wininet.h>
|
||||
#include <stdio.h>
|
||||
#include <tchar.h>
|
||||
#include "xmlurl.h"
|
||||
#include "xmlmime.h"
|
||||
|
||||
static
|
||||
int processURL(XML_Parser parser, IMoniker *baseMoniker, const XML_Char *url);
|
||||
|
||||
typedef void (*StopHandler)(void *, HRESULT);
|
||||
|
||||
class Callback : public IBindStatusCallback {
|
||||
public:
|
||||
// IUnknown methods
|
||||
STDMETHODIMP QueryInterface(REFIID,void **);
|
||||
STDMETHODIMP_(ULONG) AddRef();
|
||||
STDMETHODIMP_(ULONG) Release();
|
||||
// IBindStatusCallback methods
|
||||
STDMETHODIMP OnStartBinding(DWORD, IBinding *);
|
||||
STDMETHODIMP GetPriority(LONG *);
|
||||
STDMETHODIMP OnLowResource(DWORD);
|
||||
STDMETHODIMP OnProgress(ULONG, ULONG, ULONG, LPCWSTR);
|
||||
STDMETHODIMP OnStopBinding(HRESULT, LPCWSTR);
|
||||
STDMETHODIMP GetBindInfo(DWORD *, BINDINFO *);
|
||||
STDMETHODIMP OnDataAvailable(DWORD, DWORD, FORMATETC *, STGMEDIUM *);
|
||||
STDMETHODIMP OnObjectAvailable(REFIID, IUnknown *);
|
||||
Callback(XML_Parser, IMoniker *, StopHandler, void *);
|
||||
~Callback();
|
||||
int externalEntityRef(const XML_Char *context, const XML_Char *systemId, const XML_Char *publicId);
|
||||
private:
|
||||
XML_Parser parser_;
|
||||
IMoniker *baseMoniker_;
|
||||
DWORD totalRead_;
|
||||
ULONG ref_;
|
||||
IBinding *pBinding_;
|
||||
StopHandler stopHandler_;
|
||||
void *stopArg_;
|
||||
};
|
||||
|
||||
STDMETHODIMP_(ULONG) Callback::AddRef()
|
||||
{
|
||||
return ref_++;
|
||||
}
|
||||
|
||||
STDMETHODIMP_(ULONG) Callback::Release()
|
||||
{
|
||||
if (--ref_ == 0) {
|
||||
delete this;
|
||||
return 0;
|
||||
}
|
||||
return ref_;
|
||||
}
|
||||
|
||||
STDMETHODIMP Callback::QueryInterface(REFIID riid, void** ppv)
|
||||
{
|
||||
if (IsEqualGUID(riid, IID_IUnknown))
|
||||
*ppv = (IUnknown *)this;
|
||||
else if (IsEqualGUID(riid, IID_IBindStatusCallback))
|
||||
*ppv = (IBindStatusCallback *)this;
|
||||
else
|
||||
return E_NOINTERFACE;
|
||||
((LPUNKNOWN)*ppv)->AddRef();
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
STDMETHODIMP Callback::OnStartBinding(DWORD, IBinding* pBinding)
|
||||
{
|
||||
pBinding_ = pBinding;
|
||||
pBinding->AddRef();
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
STDMETHODIMP Callback::GetPriority(LONG *)
|
||||
{
|
||||
return E_NOTIMPL;
|
||||
}
|
||||
|
||||
STDMETHODIMP Callback::OnLowResource(DWORD)
|
||||
{
|
||||
return E_NOTIMPL;
|
||||
}
|
||||
|
||||
STDMETHODIMP Callback::OnProgress(ULONG, ULONG, ULONG, LPCWSTR)
|
||||
{
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
STDMETHODIMP Callback::OnStopBinding(HRESULT hr, LPCWSTR szError)
|
||||
{
|
||||
if (pBinding_) {
|
||||
pBinding_->Release();
|
||||
pBinding_ = 0;
|
||||
}
|
||||
if (baseMoniker_) {
|
||||
baseMoniker_->Release();
|
||||
baseMoniker_ = 0;
|
||||
}
|
||||
stopHandler_(stopArg_, hr);
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
STDMETHODIMP Callback::GetBindInfo(DWORD* pgrfBINDF, BINDINFO* pbindinfo)
|
||||
{
|
||||
*pgrfBINDF = BINDF_ASYNCHRONOUS;
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
static
|
||||
void reportError(XML_Parser parser)
|
||||
{
|
||||
int code = XML_GetErrorCode(parser);
|
||||
const XML_Char *message = XML_ErrorString(code);
|
||||
if (message)
|
||||
_ftprintf(stderr, _T("%s:%d:%ld: %s\n"),
|
||||
XML_GetBase(parser),
|
||||
XML_GetErrorLineNumber(parser),
|
||||
XML_GetErrorColumnNumber(parser),
|
||||
message);
|
||||
else
|
||||
_ftprintf(stderr, _T("%s: (unknown message %d)\n"), XML_GetBase(parser), code);
|
||||
}
|
||||
|
||||
STDMETHODIMP Callback::OnDataAvailable(DWORD grfBSCF,
|
||||
DWORD dwSize,
|
||||
FORMATETC *pfmtetc,
|
||||
STGMEDIUM* pstgmed)
|
||||
{
|
||||
if (grfBSCF & BSCF_FIRSTDATANOTIFICATION) {
|
||||
IWinInetHttpInfo *hp;
|
||||
HRESULT hr = pBinding_->QueryInterface(IID_IWinInetHttpInfo, (void **)&hp);
|
||||
if (SUCCEEDED(hr)) {
|
||||
char contentType[1024];
|
||||
DWORD bufSize = sizeof(contentType);
|
||||
DWORD flags = 0;
|
||||
contentType[0] = 0;
|
||||
hr = hp->QueryInfo(HTTP_QUERY_CONTENT_TYPE, contentType, &bufSize, 0, NULL);
|
||||
if (SUCCEEDED(hr)) {
|
||||
char charset[CHARSET_MAX];
|
||||
getXMLCharset(contentType, charset);
|
||||
if (charset[0]) {
|
||||
#ifdef XML_UNICODE
|
||||
XML_Char wcharset[CHARSET_MAX];
|
||||
XML_Char *p1 = wcharset;
|
||||
const char *p2 = charset;
|
||||
while ((*p1++ = (unsigned char)*p2++) != 0)
|
||||
;
|
||||
XML_SetEncoding(parser_, wcharset);
|
||||
#else
|
||||
XML_SetEncoding(parser_, charset);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
hp->Release();
|
||||
}
|
||||
}
|
||||
if (!parser_)
|
||||
return E_ABORT;
|
||||
if (pstgmed->tymed == TYMED_ISTREAM) {
|
||||
while (totalRead_ < dwSize) {
|
||||
#define READ_MAX (64*1024)
|
||||
DWORD nToRead = dwSize - totalRead_;
|
||||
if (nToRead > READ_MAX)
|
||||
nToRead = READ_MAX;
|
||||
void *buf = XML_GetBuffer(parser_, nToRead);
|
||||
if (!buf) {
|
||||
_ftprintf(stderr, _T("out of memory\n"));
|
||||
return E_ABORT;
|
||||
}
|
||||
DWORD nRead;
|
||||
HRESULT hr = pstgmed->pstm->Read(buf, nToRead, &nRead);
|
||||
if (SUCCEEDED(hr)) {
|
||||
totalRead_ += nRead;
|
||||
if (!XML_ParseBuffer(parser_,
|
||||
nRead,
|
||||
(grfBSCF & BSCF_LASTDATANOTIFICATION) != 0
|
||||
&& totalRead_ == dwSize)) {
|
||||
reportError(parser_);
|
||||
return E_ABORT;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
STDMETHODIMP Callback::OnObjectAvailable(REFIID, IUnknown *)
|
||||
{
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
int Callback::externalEntityRef(const XML_Char *context, const XML_Char *systemId, const XML_Char *publicId)
|
||||
{
|
||||
XML_Parser entParser = XML_ExternalEntityParserCreate(parser_, context, 0);
|
||||
XML_SetBase(entParser, systemId);
|
||||
int ret = processURL(entParser, baseMoniker_, systemId);
|
||||
XML_ParserFree(entParser);
|
||||
return ret;
|
||||
}
|
||||
|
||||
Callback::Callback(XML_Parser parser, IMoniker *baseMoniker, StopHandler stopHandler, void *stopArg)
|
||||
: parser_(parser),
|
||||
baseMoniker_(baseMoniker),
|
||||
ref_(0),
|
||||
pBinding_(0),
|
||||
totalRead_(0),
|
||||
stopHandler_(stopHandler),
|
||||
stopArg_(stopArg)
|
||||
{
|
||||
if (baseMoniker_)
|
||||
baseMoniker_->AddRef();
|
||||
}
|
||||
|
||||
Callback::~Callback()
|
||||
{
|
||||
if (pBinding_)
|
||||
pBinding_->Release();
|
||||
if (baseMoniker_)
|
||||
baseMoniker_->Release();
|
||||
}
|
||||
|
||||
static
|
||||
int externalEntityRef(void *arg,
|
||||
const XML_Char *context,
|
||||
const XML_Char *base,
|
||||
const XML_Char *systemId,
|
||||
const XML_Char *publicId)
|
||||
{
|
||||
return ((Callback *)arg)->externalEntityRef(context, systemId, publicId);
|
||||
}
|
||||
|
||||
|
||||
static
|
||||
HRESULT openStream(XML_Parser parser,
|
||||
IMoniker *baseMoniker,
|
||||
const XML_Char *uri,
|
||||
StopHandler stopHandler, void *stopArg)
|
||||
{
|
||||
if (!XML_SetBase(parser, uri))
|
||||
return E_OUTOFMEMORY;
|
||||
HRESULT hr;
|
||||
IMoniker *m;
|
||||
#ifdef XML_UNICODE
|
||||
hr = CreateURLMoniker(0, uri, &m);
|
||||
#else
|
||||
LPWSTR uriw = new wchar_t[strlen(uri) + 1];
|
||||
for (int i = 0;; i++) {
|
||||
uriw[i] = uri[i];
|
||||
if (uriw[i] == 0)
|
||||
break;
|
||||
}
|
||||
hr = CreateURLMoniker(baseMoniker, uriw, &m);
|
||||
delete [] uriw;
|
||||
#endif
|
||||
if (FAILED(hr))
|
||||
return hr;
|
||||
IBindStatusCallback *cb = new Callback(parser, m, stopHandler, stopArg);
|
||||
XML_SetExternalEntityRefHandler(parser, externalEntityRef);
|
||||
XML_SetExternalEntityRefHandlerArg(parser, cb);
|
||||
cb->AddRef();
|
||||
IBindCtx *b;
|
||||
if (FAILED(hr = CreateAsyncBindCtx(0, cb, 0, &b))) {
|
||||
cb->Release();
|
||||
m->Release();
|
||||
return hr;
|
||||
}
|
||||
cb->Release();
|
||||
IStream *pStream;
|
||||
hr = m->BindToStorage(b, 0, IID_IStream, (void **)&pStream);
|
||||
if (SUCCEEDED(hr)) {
|
||||
if (pStream)
|
||||
pStream->Release();
|
||||
}
|
||||
if (hr == MK_S_ASYNCHRONOUS)
|
||||
hr = S_OK;
|
||||
m->Release();
|
||||
b->Release();
|
||||
return hr;
|
||||
}
|
||||
|
||||
struct QuitInfo {
|
||||
const XML_Char *url;
|
||||
HRESULT hr;
|
||||
int stop;
|
||||
};
|
||||
|
||||
static
|
||||
void winPerror(const XML_Char *url, HRESULT hr)
|
||||
{
|
||||
LPVOID buf;
|
||||
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER
|
||||
| FORMAT_MESSAGE_FROM_HMODULE,
|
||||
GetModuleHandleA("urlmon.dll"),
|
||||
hr,
|
||||
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
|
||||
(LPTSTR) &buf,
|
||||
0,
|
||||
NULL)
|
||||
|| FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER
|
||||
| FORMAT_MESSAGE_FROM_SYSTEM,
|
||||
0,
|
||||
hr,
|
||||
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
|
||||
(LPTSTR) &buf,
|
||||
0,
|
||||
NULL)) {
|
||||
/* The system error messages seem to end with a newline. */
|
||||
_ftprintf(stderr, _T("%s: %s"), url, buf);
|
||||
fflush(stderr);
|
||||
LocalFree(buf);
|
||||
}
|
||||
else
|
||||
_ftprintf(stderr, _T("%s: error %x\n"), url, hr);
|
||||
}
|
||||
|
||||
static void threadQuit(void *p, HRESULT hr)
|
||||
{
|
||||
QuitInfo *qi = (QuitInfo *)p;
|
||||
qi->hr = hr;
|
||||
qi->stop = 1;
|
||||
}
|
||||
|
||||
extern "C"
|
||||
int XML_URLInit()
|
||||
{
|
||||
return SUCCEEDED(CoInitialize(0));
|
||||
}
|
||||
|
||||
extern "C"
|
||||
void XML_URLUninit()
|
||||
{
|
||||
CoUninitialize();
|
||||
}
|
||||
|
||||
static
|
||||
int processURL(XML_Parser parser, IMoniker *baseMoniker, const XML_Char *url)
|
||||
{
|
||||
QuitInfo qi;
|
||||
qi.stop = 0;
|
||||
qi.url = url;
|
||||
|
||||
XML_SetBase(parser, url);
|
||||
HRESULT hr = openStream(parser, baseMoniker, url, threadQuit, &qi);
|
||||
if (FAILED(hr)) {
|
||||
winPerror(url, hr);
|
||||
return 0;
|
||||
}
|
||||
else if (FAILED(qi.hr)) {
|
||||
winPerror(url, qi.hr);
|
||||
return 0;
|
||||
}
|
||||
MSG msg;
|
||||
while (!qi.stop && GetMessage (&msg, NULL, 0, 0)) {
|
||||
TranslateMessage (&msg);
|
||||
DispatchMessage (&msg);
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
extern "C"
|
||||
int XML_ProcessURL(XML_Parser parser,
|
||||
const XML_Char *url,
|
||||
unsigned flags)
|
||||
{
|
||||
return processURL(parser, 0, url);
|
||||
}
|
Loading…
Reference in New Issue
Block a user