-
-
Notifications
You must be signed in to change notification settings - Fork 925
Commit
nokogiri is 1.6.8.1, MIT libxml2 is 2.9.4, MIT libxslt is 1.1.29, MIT
There are no files selected for viewing
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -1 +1,4 @@ | ||
openssl is from MRI 2.3.1 | ||
nokogiri is 1.6.8.1, MIT | ||
libxml2 is 2.9.4, MIT | ||
libxslt is 1.1.29, MIT |
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,121 @@ | ||
*.o | ||
*.lo | ||
*.log | ||
*.pyc | ||
*.patch | ||
.deps | ||
.libs | ||
.memdump | ||
COPYING | ||
CVE-* | ||
INSTALL | ||
Makefile | ||
Makefile.in | ||
aclocal.m4 | ||
autom4te.cache | ||
bissect* | ||
config.guess | ||
config.h | ||
config.h.in | ||
config.h.in~ | ||
config.log | ||
config.status | ||
config.sub | ||
configure | ||
depcomp | ||
doc/Makefile | ||
doc/Makefile.in | ||
doc/devhelp/Makefile | ||
doc/devhelp/Makefile.in | ||
doc/examples/.deps | ||
doc/examples/Makefile | ||
doc/examples/Makefile.in | ||
doc/examples/io1 | ||
doc/examples/io2 | ||
doc/examples/parse1 | ||
doc/examples/parse2 | ||
doc/examples/parse3 | ||
doc/examples/parse4 | ||
doc/examples/reader1 | ||
doc/examples/reader2 | ||
doc/examples/reader3 | ||
doc/examples/reader4 | ||
doc/examples/testWriter | ||
doc/examples/tree1 | ||
doc/examples/tree2 | ||
doc/examples/xpath1 | ||
doc/examples/xpath2 | ||
example/.deps | ||
example/Makefile | ||
example/Makefile.in | ||
example/gjobread | ||
include/Makefile | ||
include/Makefile.in | ||
include/libxml/Makefile | ||
include/libxml/Makefile.in | ||
include/libxml/xmlversion.h | ||
install-sh | ||
libtool | ||
libxml-2.0-uninstalled.pc | ||
libxml-2.0.pc | ||
libxml2.la | ||
libxml2.spec | ||
list | ||
ltmain.sh | ||
log | ||
missing | ||
missing.lst | ||
m4 | ||
python/.deps | ||
python/.libs | ||
python/Makefile | ||
python/Makefile.in | ||
python/gen_prog | ||
python/libxml2-export.c | ||
python/libxml2-py.c | ||
python/libxml2-py.h | ||
python/libxml2.py | ||
python/libxml2class.py | ||
python/libxml2class.txt | ||
python/libxml2mod.la | ||
python/tests/Makefile | ||
python/tests/Makefile.in | ||
python/tests/tmp.xml | ||
runsuite | ||
runtest | ||
runxmlconf | ||
runxmlconf.log | ||
stamp-h1 | ||
tags | ||
test.out | ||
testAutomata | ||
testC14N | ||
testHTML | ||
testModule | ||
testReader | ||
testRegexp | ||
testRelax | ||
testSAX | ||
testSchemas | ||
testThreads | ||
testURI | ||
testXPath | ||
testapi | ||
testapi.c.new | ||
testchar | ||
testdict | ||
testdso.la | ||
testlimits | ||
testrecurse | ||
tmp | ||
tst.c | ||
tst | ||
xml2-config | ||
xml2Conf.sh | ||
xmlcatalog | ||
xmlconf | ||
xmllint | ||
xstc/Makefile | ||
xstc/Makefile.in | ||
xstc/Tests | ||
xstc/xsts-*.tar.gz |
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,5 @@ | ||
Daniel Veillard <daniel@veillard.com> | ||
Bjorn Reese <breese@users.sourceforge.net> | ||
William Brack <wbrack@mmm.com.hk> | ||
Igor Zlatkovic <igor@zlatkovic.com> for the Windows port | ||
Aleksey Sanin <aleksey@aleksey.com> |
Large diffs are not rendered by default.
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,23 @@ | ||
Except where otherwise noted in the source code (e.g. the files hash.c, | ||
list.c and the trio files, which are covered by a similar licence but | ||
with different Copyright notices) all the files are: | ||
|
||
Copyright (C) 1998-2012 Daniel Veillard. All Rights Reserved. | ||
|
||
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 fur- | ||
nished 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, FIT- | ||
NESS 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. |
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,305 @@ | ||
/* | ||
* DOCBparser.c : an attempt to parse SGML Docbook documents | ||
* | ||
* This is deprecated !!! | ||
* Code removed with release 2.6.0 it was broken. | ||
* The doc are expect to be migrated to XML DocBook | ||
* | ||
* See Copyright for the status of this software. | ||
* | ||
* daniel@veillard.com | ||
*/ | ||
|
||
#define IN_LIBXML | ||
#include "libxml.h" | ||
#ifdef LIBXML_DOCB_ENABLED | ||
|
||
#include <libxml/xmlerror.h> | ||
#include <libxml/DOCBparser.h> | ||
|
||
/** | ||
* docbEncodeEntities: | ||
* @out: a pointer to an array of bytes to store the result | ||
* @outlen: the length of @out | ||
* @in: a pointer to an array of UTF-8 chars | ||
* @inlen: the length of @in | ||
* @quoteChar: the quote character to escape (' or ") or zero. | ||
* | ||
* Take a block of UTF-8 chars in and try to convert it to an ASCII | ||
* plus SGML entities block of chars out. | ||
* | ||
* Returns 0 if success, -2 if the transcoding fails, or -1 otherwise | ||
* The value of @inlen after return is the number of octets consumed | ||
* as the return value is positive, else unpredictable. | ||
* The value of @outlen after return is the number of octets consumed. | ||
*/ | ||
int | ||
docbEncodeEntities(unsigned char *out ATTRIBUTE_UNUSED, | ||
int *outlen ATTRIBUTE_UNUSED, | ||
const unsigned char *in ATTRIBUTE_UNUSED, | ||
int *inlen ATTRIBUTE_UNUSED, | ||
int quoteChar ATTRIBUTE_UNUSED) | ||
{ | ||
static int deprecated = 0; | ||
|
||
if (!deprecated) { | ||
xmlGenericError(xmlGenericErrorContext, | ||
"docbEncodeEntities() deprecated function reached\n"); | ||
deprecated = 1; | ||
} | ||
return(-1); | ||
} | ||
|
||
/** | ||
* docbParseDocument: | ||
* @ctxt: an SGML parser context | ||
* | ||
* parse an SGML document (and build a tree if using the standard SAX | ||
* interface). | ||
* | ||
* Returns 0, -1 in case of error. the parser context is augmented | ||
* as a result of the parsing. | ||
*/ | ||
|
||
int | ||
docbParseDocument(docbParserCtxtPtr ctxt ATTRIBUTE_UNUSED) | ||
{ | ||
static int deprecated = 0; | ||
|
||
if (!deprecated) { | ||
xmlGenericError(xmlGenericErrorContext, | ||
"docbParseDocument() deprecated function reached\n"); | ||
deprecated = 1; | ||
} | ||
return (xmlParseDocument(ctxt)); | ||
} | ||
|
||
/** | ||
* docbFreeParserCtxt: | ||
* @ctxt: an SGML parser context | ||
* | ||
* Free all the memory used by a parser context. However the parsed | ||
* document in ctxt->myDoc is not freed. | ||
*/ | ||
|
||
void | ||
docbFreeParserCtxt(docbParserCtxtPtr ctxt ATTRIBUTE_UNUSED) | ||
{ | ||
static int deprecated = 0; | ||
|
||
if (!deprecated) { | ||
xmlGenericError(xmlGenericErrorContext, | ||
"docbFreeParserCtxt() deprecated function reached\n"); | ||
deprecated = 1; | ||
} | ||
xmlFreeParserCtxt(ctxt); | ||
} | ||
|
||
/** | ||
* docbParseChunk: | ||
* @ctxt: an XML parser context | ||
* @chunk: an char array | ||
* @size: the size in byte of the chunk | ||
* @terminate: last chunk indicator | ||
* | ||
* Parse a Chunk of memory | ||
* | ||
* Returns zero if no error, the xmlParserErrors otherwise. | ||
*/ | ||
int | ||
docbParseChunk(docbParserCtxtPtr ctxt ATTRIBUTE_UNUSED, | ||
const char *chunk ATTRIBUTE_UNUSED, | ||
int size ATTRIBUTE_UNUSED, | ||
int terminate ATTRIBUTE_UNUSED) | ||
{ | ||
static int deprecated = 0; | ||
|
||
if (!deprecated) { | ||
xmlGenericError(xmlGenericErrorContext, | ||
"docbParseChunk() deprecated function reached\n"); | ||
deprecated = 1; | ||
} | ||
|
||
return (xmlParseChunk(ctxt, chunk, size, terminate)); | ||
} | ||
|
||
/** | ||
* docbCreatePushParserCtxt: | ||
* @sax: a SAX handler | ||
* @user_data: The user data returned on SAX callbacks | ||
* @chunk: a pointer to an array of chars | ||
* @size: number of chars in the array | ||
* @filename: an optional file name or URI | ||
* @enc: an optional encoding | ||
* | ||
* Create a parser context for using the DocBook SGML parser in push mode | ||
* To allow content encoding detection, @size should be >= 4 | ||
* The value of @filename is used for fetching external entities | ||
* and error/warning reports. | ||
* | ||
* Returns the new parser context or NULL | ||
*/ | ||
docbParserCtxtPtr | ||
docbCreatePushParserCtxt(docbSAXHandlerPtr sax ATTRIBUTE_UNUSED, | ||
void *user_data ATTRIBUTE_UNUSED, | ||
const char *chunk ATTRIBUTE_UNUSED, | ||
int size ATTRIBUTE_UNUSED, | ||
const char *filename ATTRIBUTE_UNUSED, | ||
xmlCharEncoding enc ATTRIBUTE_UNUSED) | ||
{ | ||
static int deprecated = 0; | ||
|
||
if (!deprecated) { | ||
xmlGenericError(xmlGenericErrorContext, | ||
"docbParseChunk() deprecated function reached\n"); | ||
deprecated = 1; | ||
} | ||
|
||
return(xmlCreatePushParserCtxt(sax, user_data, chunk, size, filename)); | ||
} | ||
|
||
/** | ||
* docbSAXParseDoc: | ||
* @cur: a pointer to an array of xmlChar | ||
* @encoding: a free form C string describing the SGML document encoding, or NULL | ||
* @sax: the SAX handler block | ||
* @userData: if using SAX, this pointer will be provided on callbacks. | ||
* | ||
* parse an SGML in-memory document and build a tree. | ||
* It use the given SAX function block to handle the parsing callback. | ||
* If sax is NULL, fallback to the default DOM tree building routines. | ||
* | ||
* Returns the resulting document tree | ||
*/ | ||
|
||
docbDocPtr | ||
docbSAXParseDoc(xmlChar * cur ATTRIBUTE_UNUSED, | ||
const char *encoding ATTRIBUTE_UNUSED, | ||
docbSAXHandlerPtr sax ATTRIBUTE_UNUSED, | ||
void *userData ATTRIBUTE_UNUSED) | ||
{ | ||
static int deprecated = 0; | ||
|
||
if (!deprecated) { | ||
xmlGenericError(xmlGenericErrorContext, | ||
"docbParseChunk() deprecated function reached\n"); | ||
deprecated = 1; | ||
} | ||
|
||
return (xmlSAXParseMemoryWithData(sax, (const char *)cur, | ||
xmlStrlen((const xmlChar *) cur), 0, userData)); | ||
} | ||
|
||
/** | ||
* docbParseDoc: | ||
* @cur: a pointer to an array of xmlChar | ||
* @encoding: a free form C string describing the SGML document encoding, or NULL | ||
* | ||
* parse an SGML in-memory document and build a tree. | ||
* | ||
* Returns the resulting document tree | ||
*/ | ||
|
||
docbDocPtr | ||
docbParseDoc(xmlChar * cur ATTRIBUTE_UNUSED, | ||
const char *encoding ATTRIBUTE_UNUSED) | ||
{ | ||
static int deprecated = 0; | ||
|
||
if (!deprecated) { | ||
xmlGenericError(xmlGenericErrorContext, | ||
"docbParseChunk() deprecated function reached\n"); | ||
deprecated = 1; | ||
} | ||
|
||
return (xmlParseDoc(cur)); | ||
} | ||
|
||
|
||
/** | ||
* docbCreateFileParserCtxt: | ||
* @filename: the filename | ||
* @encoding: the SGML document encoding, or NULL | ||
* | ||
* Create a parser context for a file content. | ||
* Automatic support for ZLIB/Compress compressed document is provided | ||
* by default if found at compile-time. | ||
* | ||
* Returns the new parser context or NULL | ||
*/ | ||
docbParserCtxtPtr | ||
docbCreateFileParserCtxt(const char *filename ATTRIBUTE_UNUSED, | ||
const char *encoding ATTRIBUTE_UNUSED) | ||
{ | ||
static int deprecated = 0; | ||
|
||
if (!deprecated) { | ||
xmlGenericError(xmlGenericErrorContext, | ||
"docbCreateFileParserCtxt() deprecated function reached\n"); | ||
deprecated = 1; | ||
} | ||
|
||
return (xmlCreateFileParserCtxt(filename)); | ||
} | ||
|
||
/** | ||
* docbSAXParseFile: | ||
* @filename: the filename | ||
* @encoding: a free form C string describing the SGML document encoding, or NULL | ||
* @sax: the SAX handler block | ||
* @userData: if using SAX, this pointer will be provided on callbacks. | ||
* | ||
* parse an SGML file and build a tree. Automatic support for ZLIB/Compress | ||
* compressed document is provided by default if found at compile-time. | ||
* It use the given SAX function block to handle the parsing callback. | ||
* If sax is NULL, fallback to the default DOM tree building routines. | ||
* | ||
* Returns the resulting document tree | ||
*/ | ||
|
||
docbDocPtr | ||
docbSAXParseFile(const char *filename ATTRIBUTE_UNUSED, | ||
const char *encoding ATTRIBUTE_UNUSED, | ||
docbSAXHandlerPtr sax ATTRIBUTE_UNUSED, | ||
void *userData ATTRIBUTE_UNUSED) | ||
{ | ||
static int deprecated = 0; | ||
|
||
if (!deprecated) { | ||
xmlGenericError(xmlGenericErrorContext, | ||
"docbSAXParseFile() deprecated function reached\n"); | ||
deprecated = 1; | ||
} | ||
|
||
return (xmlSAXParseFileWithData(sax, filename, 0, userData)); | ||
} | ||
|
||
/** | ||
* docbParseFile: | ||
* @filename: the filename | ||
* @encoding: a free form C string describing document encoding, or NULL | ||
* | ||
* parse a Docbook SGML file and build a tree. Automatic support for | ||
* ZLIB/Compress compressed document is provided by default if found | ||
* at compile-time. | ||
* | ||
* Returns the resulting document tree | ||
*/ | ||
|
||
docbDocPtr | ||
docbParseFile(const char *filename ATTRIBUTE_UNUSED, | ||
const char *encoding ATTRIBUTE_UNUSED) | ||
{ | ||
static int deprecated = 0; | ||
|
||
if (!deprecated) { | ||
xmlGenericError(xmlGenericErrorContext, | ||
"docbParseFile() deprecated function reached\n"); | ||
deprecated = 1; | ||
} | ||
|
||
return (xmlParseFile(filename)); | ||
} | ||
#define bottom_DOCBparser | ||
#include "elfgcchack.h" | ||
#endif /* LIBXML_DOCB_ENABLED */ |
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,37 @@ | ||
NOTE: | ||
- the head of this module is package libxml-2 . There is incompatibilities | ||
with the old libxml-1 headers. I posted on gnome-hackers a recipe to | ||
change your code to compile with both, check it out ! Also read | ||
http://xmlsoft.org/upgrade.html | ||
- in the meantime the old 1.x code has been tagged with LIB_XML_1_BRANCH | ||
extract this version and drop me a mail if you want me to take care of | ||
the update of your module to libxml-2 <daniel@veillard.com> | ||
- the 1.x branch has a separate commit policy, please check the HACKING | ||
file for this branch | ||
|
||
Rules for commits on the gnome-xml module | ||
========================================= | ||
|
||
BEFORE READING FURTHER: DO NOT COMMIT DIRECTLY ! | ||
|
||
In the exceptional case where a serious breakage in this module | ||
prevents other core projects from making progress, then feel free | ||
to patch first and send mail afterward as long as the changes are limited. | ||
Please keep in mind that a large part of my user base is on Windows, so | ||
be careful with potential portability problems there. | ||
|
||
Otherwise, send me (veillard@redhat.com) a mail and if it's a bug | ||
issue, register it at bugzilla.gnome.org (module libxml). I check both | ||
my mail and the bug database on a regular basis. If you don't get an | ||
answer within a week (which is highly unprobable) then commit your changes. | ||
This simply mean that I'm on holliday or on the road. | ||
|
||
thanks in advance for following the rule, | ||
|
||
Daniel | ||
|
||
P.S.: Bjorn Reese, William Brack, Thomas Broyer, Igor Zlatkovic and | ||
Aleksey Sanin get an exception for the send before commit rule | ||
as well as John Fleck for the doc maintenance Send them mail if | ||
I don't answer to request in a timely fashion | ||
|
Large diffs are not rendered by default.
Large diffs are not rendered by default.
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,61 @@ | ||
Extracted from the documentation: | ||
http://xmlsoft.org/FAQ.html#Compilatio | ||
|
||
See also the generic INSTALL file for configure options | ||
|
||
Compilation | ||
|
||
1.What is the process to compile libxml ? | ||
|
||
As most UNIX libraries libxml follows the "standard": | ||
|
||
gunzip -c xxx.tar.gz | tar xvf - | ||
|
||
cd libxml-xxxx | ||
|
||
./configure --help | ||
|
||
to see the options, then the compilation/installation proper | ||
|
||
./configure [possible options] | ||
|
||
make | ||
|
||
make install | ||
|
||
At that point you may have to rerun ldconfig or similar utility to | ||
update your list of installed shared libs. | ||
|
||
At this point you can check that the library is properly functionning | ||
by running | ||
|
||
make tests | ||
|
||
2.What other libraries are needed to compile/install libxml ? | ||
|
||
Libxml does not requires any other library, the normal C ANSI API | ||
should be sufficient (please report any violation to this rule you | ||
may find). | ||
|
||
However if found at configuration time libxml will detect and use | ||
the following libs: | ||
|
||
libz: a highly portable and available widely compression library | ||
http://www.info-zip.org/pub/infozip/zlib/ | ||
iconv: a powerful character encoding conversion library. It's | ||
included by default on recent glibc libraries, so it doesn't | ||
need to be installed specifically on linux. It seems it's | ||
now part of the official UNIX specification. Here is one | ||
implementation of the library which source can be found here. | ||
http://clisp.cons.org/~haible/packages-libiconv.html | ||
ftp://ftp.ilog.fr/pub/Users/haible/gnu/ | ||
|
||
3.make tests may fail on some platforms | ||
|
||
Sometime the regression tests results don't completely match the | ||
value produced by the parser, and the makefile uses diff to print | ||
the delta. On some platforms the diff return breaks the compilation | ||
process, if the diff is small this is probably not a serious problem | ||
|
||
Daniel | ||
veillard@redhat.com |
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,9 @@ | ||
See first http://xmlsoft.org/bugs.html and use the list please. | ||
|
||
Daniel Veillard | ||
E-mail: veillard@redhat.com | ||
Userid: veillard | ||
|
||
Co-maintainer: William Brack <wbrack@mmm.com.hk> | ||
Windows port: Igor Zlatkovic <igor@zlatkovic.com> | ||
Rob Richards <rrichards@ctindustries.net> |
Large diffs are not rendered by default.
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,41 @@ | ||
# | ||
# You may have to ajust to call the right compiler, or other oprions | ||
# for compiling and linking | ||
# | ||
|
||
CFLAGS=`xml2-config --cflags` | ||
LIBS=`xml2-config --libs` | ||
THREADLIB= -lpthread | ||
EXEEXT= | ||
|
||
all: runtest$(EXEEXT) runsuite$(EXEEXT) testapi$(EXEEXT) testchar$(EXEEXT) | ||
|
||
clean: | ||
$(RM) runtest$(EXEEXT) runsuite$(EXEEXT) testapi$(EXEEXT) | ||
|
||
check: do_runtest do_testchar do_testapi do_runsuite | ||
|
||
runtest$(EXEEXT): runtest.c | ||
$(CC) -o runtest$(EXEEXT) $(CFLAGS) runtest.c $(LIBS) $(THREADLIB) | ||
|
||
do_runtest: runtest$(EXEEXT) | ||
./runtest | ||
|
||
runsuite$(EXEEXT): runsuite.c | ||
$(CC) -o runsuite$(EXEEXT) $(CFLAGS) runsuite.c $(LIBS) | ||
|
||
do_runsuite: runsuite$(EXEEXT) | ||
./runsuite | ||
|
||
testapi$(EXEEXT): testapi.c | ||
$(CC) -o testapi$(EXEEXT) $(CFLAGS) testapi.c $(LIBS) | ||
|
||
do_testapi: testapi$(EXEEXT) | ||
./testapi | ||
|
||
testchar$(EXEEXT): testchar.c | ||
$(CC) -o testchar$(EXEEXT) $(CFLAGS) testchar.c $(LIBS) | ||
|
||
do_testchar: testchar$(EXEEXT) | ||
./testchar | ||
|
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,34 @@ | ||
# This is a makefile for win32 systems (VC 5.0). | ||
# Christopher Blizzard | ||
# http://odin.appliedtheory.com/ | ||
|
||
CC = cl | ||
CFLAGS = /c /GB /Gi /nologo /I. /DWIN32 /MT /Zi | ||
|
||
LD = link | ||
LDFLAGS = /DEBUG /NODEFAULTLIB:libc | ||
|
||
AR = lib | ||
|
||
all: xml.lib | ||
|
||
test: tester.exe | ||
|
||
SHARED_OBJS = entities.obj parser.obj tree.obj SAX.obj | ||
|
||
xml.lib: $(SHARED_OBJS) | ||
$(AR) /out:xml.lib $(SHARED_OBJS) | ||
|
||
tester.obj: $(SHARED_OBJS) | ||
$(CC) $(CFLAGS) tester.c /out:tester.obj | ||
|
||
tester.exe: tester.obj xml.lib | ||
$(LD) $(LDFLAGS) /out:tester.exe tester.obj xml.lib | ||
|
||
clean: | ||
-del /f $(SHARED_OBJS) tester.obj | ||
-del /f tester.exe | ||
-del /f xml.lib | ||
-del /f *.pdb | ||
-del /f *.idb | ||
-del /f *.ilk |
Large diffs are not rendered by default.
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,39 @@ | ||
|
||
XML toolkit from the GNOME project | ||
|
||
Full documentation is available on-line at | ||
http://xmlsoft.org/ | ||
|
||
This code is released under the MIT Licence see the Copyright file. | ||
|
||
To build on an Unixised setup: | ||
./configure ; make ; make install | ||
To build on Windows: | ||
see instructions on win32/Readme.txt | ||
|
||
To assert build quality: | ||
on an Unixised setup: | ||
run make tests | ||
otherwise: | ||
There is 3 standalone tools runtest.c runsuite.c testapi.c, which | ||
should compile as part of the build or as any application would. | ||
Launch them from this directory to get results, runtest checks | ||
the proper functionning of libxml2 main APIs while testapi does | ||
a full coverage check. Report failures to the list. | ||
|
||
To report bugs, follow the instructions at: | ||
http://xmlsoft.org/bugs.html | ||
|
||
A mailing-list xml@gnome.org is available, to subscribe: | ||
http://mail.gnome.org/mailman/listinfo/xml | ||
|
||
The list archive is at: | ||
http://mail.gnome.org/archives/xml/ | ||
|
||
All technical answers asked privately will be automatically answered on | ||
the list and archived for public access unless privacy is explicitly | ||
required and justified. | ||
|
||
Daniel Veillard | ||
|
||
$Id$ |
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,5 @@ | ||
Please read the HACKING file for instructions | ||
|
||
Daniel | ||
|
||
$Id$ |
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,39 @@ | ||
README.tests | ||
|
||
Instructions for standalone test regressions of libxml2 | ||
|
||
libxml2-tests-$version.tar.gz contains 3 standalone C programs as well | ||
as a large amount of tests and results coming from libxml2 itself and | ||
from W3C, NIST, Sun Microsystems, Microsoft and James Clark. Each C | ||
program has a different testing purpose: | ||
|
||
runtest.c : runs libxml2 basic internal regression tests | ||
runsuite.c: runs libxml2 against external regression tests | ||
testapi.c : exercises the library public entry points | ||
testchar.c: exercise the check of character ranges and UTF-8 validation | ||
|
||
The command: | ||
|
||
make check | ||
or | ||
make -f Makefile.tests check | ||
|
||
should be sufficient on an Unix system to build and exercise the tests | ||
for the version of the library installed on the system. Note however | ||
that there isn't backward compatibility provided so if the installed | ||
version is older than the testsuite one, failing to compile or run the tests | ||
is likely. In any event this won't work with an installed libxml2 older | ||
than 2.6.20. | ||
|
||
Building on other platforms should be a matter of compiling the C files | ||
like any other program using libxml2, running the test should be done | ||
simply by launching the resulting executables. | ||
|
||
Also note the availability of a "make valgrind" target which will run the | ||
above tests under valgrind to check for memory errors (but this relies | ||
on the availability of the valgrind command and take far more time to | ||
complete). | ||
|
||
Daniel Veillard | ||
Mon May 7 2012 | ||
|
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,180 @@ | ||
/* | ||
* SAX.c : Old SAX v1 handlers to build a tree. | ||
* Deprecated except for compatibility | ||
* | ||
* See Copyright for the status of this software. | ||
* | ||
* Daniel Veillard <daniel@veillard.com> | ||
*/ | ||
|
||
|
||
#define IN_LIBXML | ||
#include "libxml.h" | ||
#include <stdlib.h> | ||
#include <string.h> | ||
#include <libxml/xmlmemory.h> | ||
#include <libxml/tree.h> | ||
#include <libxml/parser.h> | ||
#include <libxml/parserInternals.h> | ||
#include <libxml/valid.h> | ||
#include <libxml/entities.h> | ||
#include <libxml/xmlerror.h> | ||
#include <libxml/debugXML.h> | ||
#include <libxml/xmlIO.h> | ||
#include <libxml/SAX.h> | ||
#include <libxml/uri.h> | ||
#include <libxml/valid.h> | ||
#include <libxml/HTMLtree.h> | ||
#include <libxml/globals.h> | ||
#include <libxml/SAX2.h> | ||
|
||
#ifdef LIBXML_LEGACY_ENABLED | ||
#ifdef LIBXML_SAX1_ENABLED | ||
/** | ||
* initxmlDefaultSAXHandler: | ||
* @hdlr: the SAX handler | ||
* @warning: flag if non-zero sets the handler warning procedure | ||
* | ||
* Initialize the default XML SAX version 1 handler | ||
* DEPRECATED: use xmlSAX2InitDefaultSAXHandler() for the new SAX2 blocks | ||
*/ | ||
void | ||
initxmlDefaultSAXHandler(xmlSAXHandlerV1 *hdlr, int warning) | ||
{ | ||
|
||
if(hdlr->initialized == 1) | ||
return; | ||
|
||
hdlr->internalSubset = xmlSAX2InternalSubset; | ||
hdlr->externalSubset = xmlSAX2ExternalSubset; | ||
hdlr->isStandalone = xmlSAX2IsStandalone; | ||
hdlr->hasInternalSubset = xmlSAX2HasInternalSubset; | ||
hdlr->hasExternalSubset = xmlSAX2HasExternalSubset; | ||
hdlr->resolveEntity = xmlSAX2ResolveEntity; | ||
hdlr->getEntity = xmlSAX2GetEntity; | ||
hdlr->getParameterEntity = xmlSAX2GetParameterEntity; | ||
hdlr->entityDecl = xmlSAX2EntityDecl; | ||
hdlr->attributeDecl = xmlSAX2AttributeDecl; | ||
hdlr->elementDecl = xmlSAX2ElementDecl; | ||
hdlr->notationDecl = xmlSAX2NotationDecl; | ||
hdlr->unparsedEntityDecl = xmlSAX2UnparsedEntityDecl; | ||
hdlr->setDocumentLocator = xmlSAX2SetDocumentLocator; | ||
hdlr->startDocument = xmlSAX2StartDocument; | ||
hdlr->endDocument = xmlSAX2EndDocument; | ||
hdlr->startElement = xmlSAX2StartElement; | ||
hdlr->endElement = xmlSAX2EndElement; | ||
hdlr->reference = xmlSAX2Reference; | ||
hdlr->characters = xmlSAX2Characters; | ||
hdlr->cdataBlock = xmlSAX2CDataBlock; | ||
hdlr->ignorableWhitespace = xmlSAX2Characters; | ||
hdlr->processingInstruction = xmlSAX2ProcessingInstruction; | ||
if (warning == 0) | ||
hdlr->warning = NULL; | ||
else | ||
hdlr->warning = xmlParserWarning; | ||
hdlr->error = xmlParserError; | ||
hdlr->fatalError = xmlParserError; | ||
|
||
hdlr->initialized = 1; | ||
} | ||
|
||
#ifdef LIBXML_HTML_ENABLED | ||
|
||
/** | ||
* inithtmlDefaultSAXHandler: | ||
* @hdlr: the SAX handler | ||
* | ||
* Initialize the default HTML SAX version 1 handler | ||
* DEPRECATED: use xmlSAX2InitHtmlDefaultSAXHandler() for the new SAX2 blocks | ||
*/ | ||
void | ||
inithtmlDefaultSAXHandler(xmlSAXHandlerV1 *hdlr) | ||
{ | ||
if(hdlr->initialized == 1) | ||
return; | ||
|
||
hdlr->internalSubset = xmlSAX2InternalSubset; | ||
hdlr->externalSubset = NULL; | ||
hdlr->isStandalone = NULL; | ||
hdlr->hasInternalSubset = NULL; | ||
hdlr->hasExternalSubset = NULL; | ||
hdlr->resolveEntity = NULL; | ||
hdlr->getEntity = xmlSAX2GetEntity; | ||
hdlr->getParameterEntity = NULL; | ||
hdlr->entityDecl = NULL; | ||
hdlr->attributeDecl = NULL; | ||
hdlr->elementDecl = NULL; | ||
hdlr->notationDecl = NULL; | ||
hdlr->unparsedEntityDecl = NULL; | ||
hdlr->setDocumentLocator = xmlSAX2SetDocumentLocator; | ||
hdlr->startDocument = xmlSAX2StartDocument; | ||
hdlr->endDocument = xmlSAX2EndDocument; | ||
hdlr->startElement = xmlSAX2StartElement; | ||
hdlr->endElement = xmlSAX2EndElement; | ||
hdlr->reference = NULL; | ||
hdlr->characters = xmlSAX2Characters; | ||
hdlr->cdataBlock = xmlSAX2CDataBlock; | ||
hdlr->ignorableWhitespace = xmlSAX2IgnorableWhitespace; | ||
hdlr->processingInstruction = xmlSAX2ProcessingInstruction; | ||
hdlr->comment = xmlSAX2Comment; | ||
hdlr->warning = xmlParserWarning; | ||
hdlr->error = xmlParserError; | ||
hdlr->fatalError = xmlParserError; | ||
|
||
hdlr->initialized = 1; | ||
} | ||
|
||
#endif /* LIBXML_HTML_ENABLED */ | ||
|
||
#ifdef LIBXML_DOCB_ENABLED | ||
/** | ||
* initdocbDefaultSAXHandler: | ||
* @hdlr: the SAX handler | ||
* | ||
* Initialize the default DocBook SAX version 1 handler | ||
* DEPRECATED: use xmlSAX2InitDocbDefaultSAXHandler() for the new SAX2 blocks | ||
*/ | ||
void | ||
initdocbDefaultSAXHandler(xmlSAXHandlerV1 *hdlr) | ||
{ | ||
if(hdlr->initialized == 1) | ||
return; | ||
|
||
hdlr->internalSubset = xmlSAX2InternalSubset; | ||
hdlr->externalSubset = NULL; | ||
hdlr->isStandalone = xmlSAX2IsStandalone; | ||
hdlr->hasInternalSubset = xmlSAX2HasInternalSubset; | ||
hdlr->hasExternalSubset = xmlSAX2HasExternalSubset; | ||
hdlr->resolveEntity = xmlSAX2ResolveEntity; | ||
hdlr->getEntity = xmlSAX2GetEntity; | ||
hdlr->getParameterEntity = NULL; | ||
hdlr->entityDecl = xmlSAX2EntityDecl; | ||
hdlr->attributeDecl = NULL; | ||
hdlr->elementDecl = NULL; | ||
hdlr->notationDecl = NULL; | ||
hdlr->unparsedEntityDecl = NULL; | ||
hdlr->setDocumentLocator = xmlSAX2SetDocumentLocator; | ||
hdlr->startDocument = xmlSAX2StartDocument; | ||
hdlr->endDocument = xmlSAX2EndDocument; | ||
hdlr->startElement = xmlSAX2StartElement; | ||
hdlr->endElement = xmlSAX2EndElement; | ||
hdlr->reference = xmlSAX2Reference; | ||
hdlr->characters = xmlSAX2Characters; | ||
hdlr->cdataBlock = NULL; | ||
hdlr->ignorableWhitespace = xmlSAX2IgnorableWhitespace; | ||
hdlr->processingInstruction = NULL; | ||
hdlr->comment = xmlSAX2Comment; | ||
hdlr->warning = xmlParserWarning; | ||
hdlr->error = xmlParserError; | ||
hdlr->fatalError = xmlParserError; | ||
|
||
hdlr->initialized = 1; | ||
} | ||
|
||
#endif /* LIBXML_DOCB_ENABLED */ | ||
|
||
#endif /* LIBXML_SAX1_ENABLED */ | ||
|
||
#define bottom_SAX | ||
#include "elfgcchack.h" | ||
#endif /* LIBXML_LEGACY_ENABLED */ |
Large diffs are not rendered by default.
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,278 @@ | ||
124907 HTML parse buffer problem when parsing larse in-memory docs | ||
124110 DTD validation && wrong namespace | ||
123564 xmllint --html --format | ||
|
||
TODO for the XML parser and stuff: | ||
================================== | ||
|
||
$Id$ | ||
|
||
this tend to be outdated :-\ ... | ||
|
||
DOCS: | ||
===== | ||
|
||
- use case of using XInclude to load for example a description. | ||
order document + product base -(XSLT)-> quote with XIncludes | ||
| | ||
HTML output with description of parts <---(XSLT)-- | ||
|
||
TODO: | ||
===== | ||
- XInclude at the SAX level (libSRVG) | ||
- fix the C code prototype to bring back doc/libxml-undocumented.txt | ||
to a reasonable level | ||
- Computation of base when HTTP redirect occurs, might affect HTTP | ||
interfaces. | ||
- Computation of base in XInclude. Relativization of URIs. | ||
- listing all attributes in a node. | ||
- Better checking of external parsed entities TAG 1234 | ||
- Go through erratas and do the cleanup. | ||
http://www.w3.org/XML/xml-19980210-errata ... started ... | ||
- jamesh suggestion: SAX like functions to save a document ie. call a | ||
function to open a new element with given attributes, write character | ||
data, close last element, etc | ||
+ inversted SAX, initial patch in April 2002 archives. | ||
- htmlParseDoc has parameter encoding which is not used. | ||
Function htmlCreateDocParserCtxt ignore it. | ||
- fix realloc() usage. | ||
- Stricten the UTF8 conformance (Martin Duerst): | ||
http://www.w3.org/2001/06/utf-8-test/. | ||
The bad files are in http://www.w3.org/2001/06/utf-8-wrong/. | ||
- xml:id normalized value | ||
|
||
TODO: | ||
===== | ||
|
||
- move all string manipulation functions (xmlStrdup, xmlStrlen, etc.) to | ||
global.c. Bjorn noted that the following files depends on parser.o solely | ||
because of these string functions: entities.o, global.o, hash.o, tree.o, | ||
xmlIO.o, and xpath.o. | ||
|
||
- Optimization of tag strings allocation ? | ||
|
||
- maintain coherency of namespace when doing cut'n paste operations | ||
=> the functions are coded, but need testing | ||
|
||
- function to rebuild the ID table | ||
- functions to rebuild the DTD hash tables (after DTD changes). | ||
|
||
|
||
EXTENSIONS: | ||
=========== | ||
|
||
- Tools to produce man pages from the SGML docs. | ||
|
||
- Add Xpointer recognition/API | ||
|
||
- Add Xlink recognition/API | ||
=> started adding an xlink.[ch] with a unified API for XML and HTML. | ||
it's crap :-( | ||
|
||
- Implement XSchemas | ||
=> Really need to be done <grin/> | ||
- datatype are complete, but structure support is very limited. | ||
|
||
- extend the shell with: | ||
- edit | ||
- load/save | ||
- mv (yum, yum, but it's harder because directories are ordered in | ||
our case, mvup and mvdown would be required) | ||
|
||
|
||
Done: | ||
===== | ||
|
||
- Add HTML validation using the XHTML DTD | ||
- problem: do we want to keep and maintain the code for handling | ||
DTD/System ID cache directly in libxml ? | ||
=> not really done that way, but there are new APIs to check elements | ||
or attributes. Otherwise XHTML validation directly ... | ||
|
||
- XML Schemas datatypes except Base64 and BinHex | ||
|
||
- Relax NG validation | ||
|
||
- XmlTextReader streaming API + validation | ||
|
||
- Add a DTD cache prefilled with xhtml DTDs and entities and a program to | ||
manage them -> like the /usr/bin/install-catalog from SGML | ||
right place seems $datadir/xmldtds | ||
Maybe this is better left to user apps | ||
=> use a catalog instead , and xhtml1-dtd package | ||
|
||
- Add output to XHTML | ||
=> XML serializer automatically recognize the DTd and apply the specific | ||
rules. | ||
|
||
- Fix output of <tst val="x
y"/> | ||
|
||
- compliance to XML-Namespace checking, see section 6 of | ||
http://www.w3.org/TR/REC-xml-names/ | ||
|
||
- Correct standalone checking/emitting (hard) | ||
2.9 Standalone Document Declaration | ||
|
||
- Implement OASIS XML Catalog support | ||
http://www.oasis-open.org/committees/entity/ | ||
|
||
- Get OASIS testsuite to a more friendly result, check all the results | ||
once stable. the check-xml-test-suite.py script does this | ||
|
||
- Implement XSLT | ||
=> libxslt | ||
|
||
- Finish XPath | ||
=> attributes addressing troubles | ||
=> defaulted attributes handling | ||
=> namespace axis ? | ||
done as XSLT got debugged | ||
|
||
- bug reported by Michael Meallin on validation problems | ||
=> Actually means I need to add support (and warn) for non-deterministic | ||
content model. | ||
- Handle undefined namespaces in entity contents better ... at least | ||
issue a warning | ||
- DOM needs | ||
int xmlPruneProp(xmlNodePtr node, xmlAtttrPtr attr); | ||
=> done it's actually xmlRemoveProp xmlUnsetProp xmlUnsetNsProp | ||
|
||
- HTML: handling of Script and style data elements, need special code in | ||
the parser and saving functions (handling of < > " ' ...): | ||
http://www.w3.org/TR/html4/types.html#type-script | ||
Attributes are no problems since entities are accepted. | ||
- DOM needs | ||
xmlAttrPtr xmlNewDocProp(xmlDocPtr doc, const xmlChar *name, const xmlChar *value) | ||
- problem when parsing hrefs with & with the HTML parser (IRC ac) | ||
- If the internal encoding is not UTF8 saving to a given encoding doesn't | ||
work => fix to force UTF8 encoding ... | ||
done, added documentation too | ||
- Add an ASCII I/O encoder (asciiToUTF8 and UTF8Toascii) | ||
- Issue warning when using non-absolute namespaces URI. | ||
- the html parser should add <head> and <body> if they don't exist | ||
started, not finished. | ||
Done, the automatic closing is added and 3 testcases were inserted | ||
- Command to force the parser to stop parsing and ignore the rest of the file. | ||
xmlStopParser() should allow this, mostly untested | ||
- support for HTML empty attributes like <hr noshade> | ||
- plugged iconv() in for support of a large set of encodings. | ||
- xmlSwitchToEncoding() rewrite done | ||
- URI checkings (no fragments) rfc2396.txt | ||
- Added a clean mechanism for overload or added input methods: | ||
xmlRegisterInputCallbacks() | ||
- dynamically adapt the alloc entry point to use g_alloc()/g_free() | ||
if the programmer wants it: | ||
- use xmlMemSetup() to reset the routines used. | ||
- Check attribute normalization especially xmlGetProp() | ||
- Validity checking problems for NOTATIONS attributes | ||
- Validity checking problems for ENTITY ENTITIES attributes | ||
- Parsing of a well balanced chunk xmlParseBalancedChunkMemory() | ||
- URI module: validation, base, etc ... see uri.[ch] | ||
- turn tester into a generic program xmllint installed with libxml | ||
- extend validity checks to go through entities content instead of | ||
just labelling them PCDATA | ||
- Save Dtds using the children list instead of dumping the tables, | ||
order is preserved as well as comments and PIs | ||
- Wrote a notice of changes requires to go from 1.x to 2.x | ||
- make sure that all SAX callbacks are disabled if a WF error is detected | ||
- checking/handling of newline normalization | ||
http://localhost/www.xml.com/axml/target.html#sec-line-ends | ||
- correct checking of '&' '%' on entities content. | ||
- checking of PE/Nesting on entities declaration | ||
- checking/handling of xml:space | ||
- checking done. | ||
- handling done, not well tested | ||
- Language identification code, productions [33] to [38] | ||
=> done, the check has been added and report WFness errors | ||
- Conditional sections in DTDs [61] to [65] | ||
=> should this crap be really implemented ??? | ||
=> Yep OASIS testsuite uses them | ||
- Allow parsed entities defined in the internal subset to override | ||
the ones defined in the external subset (DtD customization). | ||
=> This mean that the entity content should be computed only at | ||
use time, i.e. keep the orig string only at parse time and expand | ||
only when referenced from the external subset :-( | ||
Needed for complete use of most DTD from Eve Maler | ||
- Add regression tests for all WFC errors | ||
=> did some in test/WFC | ||
=> added OASIS testsuite routines | ||
http://xmlsoft.org/conf/result.html | ||
|
||
- I18N: http://wap.trondheim.com/vaer/index.phtml is not XML and accepted | ||
by the XML parser, UTF-8 should be checked when there is no "encoding" | ||
declared ! | ||
- Support for UTF-8 and UTF-16 encoding | ||
=> added some convertion routines provided by Martin Durst | ||
patched them, got fixes from @@@ | ||
I plan to keep everything internally as UTF-8 (or ISO-Latin-X) | ||
this is slightly more costly but more compact, and recent processors | ||
efficiency is cache related. The key for good performances is keeping | ||
the data set small, so will I. | ||
=> the new progressive reading routines call the detection code | ||
is enabled, tested the ISO->UTF-8 stuff | ||
- External entities loading: | ||
- allow override by client code | ||
- make sure it is alled for all external entities referenced | ||
Done, client code should use xmlSetExternalEntityLoader() to set | ||
the default loading routine. It will be called each time an external | ||
entity entity resolution is triggered. | ||
- maintain ID coherency when removing/changing attributes | ||
The function used to deallocate attributes now check for it being an | ||
ID and removes it from the table. | ||
- push mode parsing i.e. non-blocking state based parser | ||
done, both for XML and HTML parsers. Use xmlCreatePushParserCtxt() | ||
and xmlParseChunk() and html counterparts. | ||
The tester program now has a --push option to select that parser | ||
front-end. Douplicated tests to use both and check results are similar. | ||
|
||
- Most of XPath, still see some troubles and occasionnal memleaks. | ||
- an XML shell, allowing to traverse/manipulate an XML document with | ||
a shell like interface, and using XPath for the anming syntax | ||
- use of readline and history added when available | ||
- the shell interface has been cleanly separated and moved to debugXML.c | ||
- HTML parser, should be fairly stable now | ||
- API to search the lang of an attribute | ||
- Collect IDs at parsing and maintain a table. | ||
PBM: maintain the table coherency | ||
PBM: how to detect ID types in absence of DtD ! | ||
- Use it for XPath ID support | ||
- Add validity checking | ||
Should be finished now ! | ||
- Add regression tests with entity substitutions | ||
|
||
- External Parsed entities, either XML or external Subset [78] and [79] | ||
parsing the xmllang DtD now works, so it should be sufficient for | ||
most cases ! | ||
|
||
- progressive reading. The entity support is a first step toward | ||
asbtraction of an input stream. A large part of the context is still | ||
located on the stack, moving to a state machine and putting everyting | ||
in the parsing context should provide an adequate solution. | ||
=> Rather than progressive parsing, give more power to the SAX-like | ||
interface. Currently the DOM-like representation is built but | ||
=> it should be possible to define that only as a set of SAX callbacks | ||
and remove the tree creation from the parser code. | ||
DONE | ||
|
||
- DOM support, instead of using a proprietary in memory | ||
format for the document representation, the parser should | ||
call a DOM API to actually build the resulting document. | ||
Then the parser becomes independent of the in-memory | ||
representation of the document. Even better using RPC's | ||
the parser can actually build the document in another | ||
program. | ||
=> Work started, now the internal representation is by default | ||
very near a direct DOM implementation. The DOM glue is implemented | ||
as a separate module. See the GNOME gdome module. | ||
|
||
- C++ support : John Ehresman <jehresma@dsg.harvard.edu> | ||
- Updated code to follow more recent specs, added compatibility flag | ||
- Better error handling, use a dedicated, overridable error | ||
handling function. | ||
- Support for CDATA. | ||
- Keep track of line numbers for better error reporting. | ||
- Support for PI (SAX one). | ||
- Support for Comments (bad, should be in ASAP, they are parsed | ||
but not stored), should be configurable. | ||
- Improve the support of entities on save (+SAX). | ||
|
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,31 @@ | ||
- implement counted transitions at the automata level | ||
|
||
- Unicode: | ||
+ upgrade to 3.2 | ||
+ improve the python script to generate better test | ||
expressions to check the list of ranges. | ||
|
||
- Implement the interface at the SAX level | ||
|
||
- Implement the missing parts in the Structure part | ||
+ all content model | ||
+ enumerations | ||
+ countless others c.f. the TODO scattered in the code | ||
|
||
- Complete the Built-In datatype collections and Facets implementations | ||
|
||
- Regression tests based on | ||
+ the primer: | ||
http://www.w3.org/TR/xmlschema-0/ | ||
+ the Schemas Test Collection: | ||
http://www.w3.org/2001/05/xmlschema-test-collection/ | ||
+ archives of the schemas-dev list | ||
|
||
- Integrity constraints: | ||
+ what's that ? How need to read about it | ||
|
||
- "formal" checking, i.e. go through the full Structure spec and | ||
bind code and associated parts of the Schemas spec | ||
|
||
- go though the erratas | ||
http://www.w3.org/2001/05/xmlschema-errata |
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,86 @@ | ||
libxml2 on VxWorks 6.4+ | ||
|
||
Here are my instructions for building on VxWorks.... I am very ashamed of | ||
how I did this because it is a complete hack, but it works great, so I | ||
can't complain too much. | ||
|
||
General Information | ||
|
||
1. The only way to build for VxWorks is to cross compile from a windows or | ||
linux system. We use a RedHat 5.1 workstation system as our build | ||
environment. | ||
|
||
2. VxWorks 6.X has two main types of executable, DKMs (dynamic kernel | ||
modules), and RTPs (real-time processes). Kernel modules are the bread | ||
and butter of VxWorks, but they look nothing like processes/threads in | ||
normal UNIX/Windows systems. RTPs are more like processes that have | ||
memory protection, threads, etc. VxWorks 6.X also introduces some level | ||
of POSIX conformance to their environment. The POSIX conformance was the | ||
key for us to be able to port libxml2. We support accessing libxml2 from | ||
both DKMs and RTPs. | ||
|
||
3. There are 2 compilers for VxWorks, the WindRiver compiler, and a port | ||
of the GNU toolchain, we have only tested and built with the GNU | ||
toolchain. | ||
|
||
How To Build | ||
|
||
1. Run the configure on your native linux system (this is the cheesy | ||
hack). Since the VxWorks GNU toolchain is very close in version to the | ||
one in red hat, it generates a good config.h file. We configured libxml2 | ||
with the following to keep the size down, (but we have done basic testing | ||
with everything compiled in). | ||
|
||
./configure --with-minimum --with-reader --with-writer --with-regexps | ||
--with-threads --with-thread-alloc | ||
|
||
2. Rename the libxml2 folder to "src". This step is required for our | ||
replacement makefile to work. | ||
|
||
3. Run the replacement makefile. I wrote a new makefile that sets all the | ||
proper vxworks defines and uses the correct compilers. The two defines on | ||
the make command line are to tell it which VxWorks Target (SH3.2 little | ||
endian), and the executable type. We have tested this code on PENTIUM2gnu | ||
and SH32gnule. | ||
|
||
This makefile creates a shared library that runs on VxWorks: (libxml2.so) | ||
make -f Makefile.vxworks clean all VXCPU=SH32gnule VXTYPE=RTP | ||
|
||
This makefile creates a kernel module that runs on VxWorks: (xml2.out) | ||
make -f Makefile.vxworks clean all VXCPU=SH32gnule VXTYPE=DKM | ||
|
||
Important Notes | ||
|
||
1. There are several ways that this process could be improved, but at the | ||
end of the day, we make products, not port libraries, so we did a meets | ||
minimum for our needs. | ||
|
||
2. VxWorks is the devil, give me embedded linux every day. | ||
|
||
3. No matter what I tried, I couldn't get the configure to pick up the | ||
VxWorks toolchain, and in my investigation, it has something to do with | ||
automake/autoconf, not any individual package. VxWorks doesn't play by | ||
the normal rules for building toolchains. | ||
|
||
4. The PIC flag in VxWorks (especially for SH processors) is very | ||
important, and very troublesome. On linux, you can liberally use the PIC | ||
flag when compiling and the compiler/linker will ignore it as needed, on | ||
VxWorks if must always be on for shared libraries, and always be off for | ||
static libraries and executables. | ||
|
||
5. If anyone wants to work on a better way to do the build of libxml2 for | ||
VxWorks, I'm happy to help as much as I can, but I'm not looking to | ||
support it myself. | ||
|
||
Attached Files | ||
|
||
1. To use my Makefile for vxworks, you should enter the vxworks | ||
environment (/opt/windriver/wrenv.linux -p vxworks-6.4 for me). | ||
2. Run: build.sh libxml2-2.6.32 SH32gnule RTP (where you have | ||
libxml2-2.6.32.tar.gz and the Makefile in the same directory as the script | ||
file). | ||
|
||
Thanks, | ||
|
||
Jim Wert Jr. | ||
JWert@ILSTechnology.com |
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,85 @@ | ||
LIBXML2=$1 | ||
TARGETCPU=$2 | ||
TARGETTYPE=$3 | ||
|
||
if [ -z "$2" ]; then | ||
TARGETCPU=SIMPENTIUMgnu | ||
fi | ||
|
||
if [ -z "$3" ]; then | ||
TARGETTYPE=RTP | ||
fi | ||
|
||
echo "LIBXML2 Version: ${LIBXML2}" | ||
echo "LIBXML2 Target CPU: ${TARGETCPU}" | ||
echo "LIBXML2 Target Type: ${TARGETTYPE}" | ||
|
||
rm -fR src | ||
tar xvzf ${LIBXML2}.tar.gz | ||
mv ${LIBXML2} src | ||
cd src | ||
|
||
./configure --with-minimum --with-reader --with-writer --with-regexps --with-threads --with-thread-alloc | ||
|
||
find . -name '*.in' -exec rm -fR {} + | ||
find . -name '*.am' -exec rm -fR {} + | ||
rm -fR *.m4 | ||
rm -fR *.pc | ||
rm -fR *.pl | ||
rm -fR *.py | ||
rm -fR *.spec | ||
rm -fR .deps | ||
rm -fR AUTHORS | ||
rm -fR bakefile | ||
rm -fR ChangeLog | ||
rm -fR config.guess | ||
rm -fR config.log | ||
rm -fR config.status | ||
rm -fR config.stub | ||
rm -fR config.sub | ||
rm -fR configure | ||
rm -fR COPYING | ||
rm -fR Copyright | ||
rm -fR depcomp | ||
rm -fR doc | ||
rm -fR example | ||
rm -fR INSTALL | ||
rm -fR install-sh | ||
rm -fR libxml.3 | ||
rm -fR ltmain.sh | ||
rm -fR Makefile | ||
rm -fR Makefile.tests | ||
rm -fR macos | ||
rm -fR mkinstalldirs | ||
rm -fR missing | ||
rm -fR nanoftp.c | ||
rm -fR nanohttp.c | ||
rm -fR NEWS | ||
rm -fR python | ||
rm -fR README | ||
rm -fR README.tests | ||
rm -fR regressions.xml | ||
rm -fR result | ||
rm -fR runsuite.c | ||
rm -fR runtest.c | ||
rm -fR test | ||
rm -fR test*.c | ||
rm -fR TODO* | ||
rm -fR trio* | ||
rm -fR vms | ||
rm -fR win32 | ||
rm -fR xml2* | ||
rm -fR xmllint.c | ||
rm -fR xstc | ||
|
||
cd .. | ||
|
||
make clean all VXCPU=${TARGETCPU} VXTYPE=${TARGETTYPE} | ||
|
||
if [ "${TARGETTYPE}" = "RTP" ]; then | ||
cp libxml2.so ../../lib/. | ||
else | ||
cp xml2.out ../../bin/. | ||
fi | ||
|
||
cp -R src/include/libxml ../../include/. |
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,28 @@ | ||
dnl Like AC_TRY_EVAL but also errors out if the compiler generates | ||
dnl _any_ output. Some compilers might issue warnings which we want | ||
dnl to catch. | ||
AC_DEFUN([AC_TRY_EVAL2], | ||
[{ (eval echo configure:__oline__: \"[$]$1\") 1>&AS_MESSAGE_LOG_FD; dnl | ||
(eval [$]$1) 2>&AS_MESSAGE_LOG_FD; _out=`eval [$]$1 2>&1` && test "x$_out" = x; }]) | ||
|
||
dnl Like AC_TRY_COMPILE but calls AC_TRY_EVAL2 instead of AC_TRY_EVAL | ||
AC_DEFUN([AC_TRY_COMPILE2], | ||
[cat > conftest.$ac_ext <<EOF | ||
[#]line __oline__ "configure" | ||
#include "confdefs.h" | ||
[$1] | ||
int main(void) { | ||
[$2] | ||
; return 0; } | ||
EOF | ||
if AC_TRY_EVAL2(ac_compile); then | ||
ifelse([$3], , :, [rm -rf conftest* | ||
$3]) | ||
else | ||
echo "configure: failed program was:" >&AS_MESSAGE_LOG_FD | ||
cat conftest.$ac_ext >&AS_MESSAGE_LOG_FD | ||
ifelse([$4], , , [ rm -rf conftest* | ||
$4 | ||
])dnl | ||
fi | ||
rm -f conftest*]) |
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,81 @@ | ||
#!/bin/sh | ||
# Run this to generate all the initial makefiles, etc. | ||
|
||
srcdir=`dirname $0` | ||
test -z "$srcdir" && srcdir=. | ||
|
||
THEDIR=`pwd` | ||
cd $srcdir | ||
DIE=0 | ||
|
||
(autoconf --version) < /dev/null > /dev/null 2>&1 || { | ||
echo | ||
echo "You must have autoconf installed to compile libxml." | ||
echo "Download the appropriate package for your distribution," | ||
echo "or see http://www.gnu.org/software/autoconf" | ||
DIE=1 | ||
} | ||
|
||
(libtoolize --version) < /dev/null > /dev/null 2>&1 || { | ||
echo | ||
echo "You must have libtool installed to compile libxml." | ||
echo "Download the appropriate package for your distribution," | ||
echo "or see http://www.gnu.org/software/libtool" | ||
DIE=1 | ||
} | ||
|
||
(automake --version) < /dev/null > /dev/null 2>&1 || { | ||
echo | ||
DIE=1 | ||
echo "You must have automake installed to compile libxml." | ||
echo "Download the appropriate package for your distribution," | ||
echo "or see http://www.gnu.org/software/automake" | ||
} | ||
|
||
if test "$DIE" -eq 1; then | ||
exit 1 | ||
fi | ||
|
||
test -f entities.c || { | ||
echo "You must run this script in the top-level libxml directory" | ||
exit 1 | ||
} | ||
|
||
EXTRA_ARGS= | ||
if test "x$1" = "x--system"; then | ||
shift | ||
prefix=/usr | ||
libdir=$prefix/lib | ||
sysconfdir=/etc | ||
localstatedir=/var | ||
if [ -d /usr/lib64 ]; then | ||
libdir=$prefix/lib64 | ||
fi | ||
EXTRA_ARGS="--prefix=$prefix --sysconfdir=$sysconfdir --localstatedir=$localstatedir --libdir=$libdir" | ||
echo "Running ./configure with $EXTRA_ARGS $@" | ||
else | ||
if test -z "$NOCONFIGURE" && test -z "$*"; then | ||
echo "I am going to run ./configure with no arguments - if you wish " | ||
echo "to pass any to it, please specify them on the $0 command line." | ||
fi | ||
fi | ||
|
||
if [ ! -d $srcdir/m4 ]; then | ||
mkdir $srcdir/m4 | ||
fi | ||
|
||
# Replaced by autoreconf below | ||
autoreconf -if -Wall | ||
|
||
cd $THEDIR | ||
|
||
if test x$OBJ_DIR != x; then | ||
mkdir -p "$OBJ_DIR" | ||
cd "$OBJ_DIR" | ||
fi | ||
|
||
if test -z "$NOCONFIGURE"; then | ||
$srcdir/configure $EXTRA_ARGS "$@" | ||
echo | ||
echo "Now type 'make' to compile libxml2." | ||
fi |
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,15 @@ | ||
<?xml version="1.0" ?> | ||
<!-- $Id$ --> | ||
|
||
<bakefile-gen> | ||
|
||
<disable-formats>gnu,dmars,cbx_unix,cbuilderx</disable-formats> | ||
<input>libxml2.bkl</input> | ||
|
||
<!-- List of output formats to generate: --> | ||
<add-formats> | ||
borland,dmars,mingw,msvc,msvc6prj,watcom,cbuilderx,cbx_unix,gnu | ||
</add-formats> | ||
|
||
|
||
</bakefile-gen> |
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,92 @@ | ||
|
||
LIBXML2 build system for Win32 README | ||
------------------------------------- | ||
|
||
In this folder are stored all the files required to compile LIBXML2 with win32 compilers. | ||
Bakefile (http://bakefile.sourceforge.net) is used as makefile generator. | ||
|
||
Supported makefiles: | ||
- makefile.vc for Microsoft NMAKE | ||
- makefile.bcc for Borland MAKE | ||
- makefile.wat for OpenWatcom MAKE | ||
- makefile.gcc for MinGW MINGW32-MAKE | ||
- all DSP & DSW for Microsoft VisualC++ 6.0 (can be used also with VS.NET AFAIK) | ||
|
||
This readme is organized as: | ||
1.0 HOWTO compile LIBXML2 using makefiles <-- for users who want to build the library using *command-line* | ||
1.1 HOWTO compile LIBXML2 using an IDE <-- for users who want to build the library using an *IDE* | ||
1.2 HOWTO regenerate makefiles for LIBXML2 <-- for libxml2 mantainers/developers/advanced users | ||
|
||
If you just want to compile the library (and the test programs) you should definitely avoid the | ||
section 1.1 and focus on the 1.0. | ||
|
||
|
||
|
||
|
||
|
||
|
||
1.0 HOWTO compile LIBXML2 using makefiles | ||
----------------------------------------- | ||
|
||
Choose your preferred compiler among those actually supported (see above) and then run | ||
|
||
mycompilermake -fmakefile.makefileext [options] | ||
|
||
for a full list of the available options you should open with a notepad (or something like that) | ||
the makefile you want to use; at the beginning you should see a section which starts as: | ||
|
||
# ------------------------------------------------------------------------- | ||
# These are configurable options: | ||
# ------------------------------------------------------------------------- | ||
|
||
here you can find all the options actually used by that makefile. | ||
They can be customized when running the makefile writing something like: | ||
|
||
nmake -fmakefile.vc BUILD=release | ||
mingw32-make -fmakefile.gcc BUILD=debug ICONV_DIR=c:\myiconv | ||
|
||
or they can be permanently changed modifying the makefile. | ||
That's all: for any problem/compile-error/suggestion, write to | ||
frm@users.sourceforge.net with the word "libxml2" in the subject. | ||
|
||
|
||
|
||
|
||
|
||
1.1 HOWTO compile LIBXML2 using an IDE | ||
-------------------------------------- | ||
|
||
Actually only the Microsoft VisualC++ 6.0 project files are generated. | ||
In future other Integrated Development Environments (IDEs) will be supported as well. | ||
|
||
With MSVC++ 6.0, you should open the DSW file and then set as the active project the | ||
"libxml2" project, if you want to build the library or one of the test projects if you | ||
want to run them. | ||
Using the command "Build->Set Active Configuration" you can choose one of the predefined | ||
configuration. | ||
|
||
|
||
|
||
|
||
|
||
1.2 HOWTO regenerate makefiles for LIBXML2 | ||
------------------------------------------ | ||
|
||
Be sure to have installed Bakefile (http://bakefile.sourceforge.net). | ||
Just run the "bakefile_gen" command inside the folder containing the "libxml2.bkl" file. | ||
NOTE: if you want to remove all the makefiles, you can use the "bakefile_gen -c" command. | ||
|
||
The template files used to generate all makefiles are only two: | ||
- libxml2.bkl (the main one) | ||
- Bakefiles.bkgen | ||
All the other files can be dinamically regenerated. | ||
|
||
|
||
|
||
|
||
|
||
If you have problems with the compilation of LIBXML2 under windows (using one of the supported compiler) | ||
please write to: | ||
|
||
Francesco Montorsi <frm@users.sourceforge.net> | ||
|
Large diffs are not rendered by default.
Large diffs are not rendered by default.
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,72 @@ | ||
/* | ||
* Summary: Internal Interfaces for memory buffers in libxml2 | ||
* Description: this module describes most of the new xmlBuf buffer | ||
* entry points, those are private routines, with a | ||
* few exceptions exported in tree.h. This was added | ||
* in 2.9.0. | ||
* | ||
* Copy: See Copyright for the status of this software. | ||
* | ||
* Author: Daniel Veillard | ||
*/ | ||
|
||
#ifndef __XML_BUF_H__ | ||
#define __XML_BUF_H__ | ||
|
||
#include <libxml/tree.h> | ||
|
||
#ifdef __cplusplus | ||
extern "C" { | ||
#endif | ||
|
||
xmlBufPtr xmlBufCreate(void); | ||
xmlBufPtr xmlBufCreateSize(size_t size); | ||
xmlBufPtr xmlBufCreateStatic(void *mem, size_t size); | ||
|
||
int xmlBufSetAllocationScheme(xmlBufPtr buf, | ||
xmlBufferAllocationScheme scheme); | ||
int xmlBufGetAllocationScheme(xmlBufPtr buf); | ||
|
||
void xmlBufFree(xmlBufPtr buf); | ||
void xmlBufEmpty(xmlBufPtr buf); | ||
|
||
/* size_t xmlBufShrink(xmlBufPtr buf, size_t len); */ | ||
int xmlBufGrow(xmlBufPtr buf, int len); | ||
int xmlBufInflate(xmlBufPtr buf, size_t len); | ||
int xmlBufResize(xmlBufPtr buf, size_t len); | ||
|
||
int xmlBufAdd(xmlBufPtr buf, const xmlChar *str, int len); | ||
int xmlBufAddHead(xmlBufPtr buf, const xmlChar *str, int len); | ||
int xmlBufCat(xmlBufPtr buf, const xmlChar *str); | ||
int xmlBufCCat(xmlBufPtr buf, const char *str); | ||
int xmlBufWriteCHAR(xmlBufPtr buf, const xmlChar *string); | ||
int xmlBufWriteChar(xmlBufPtr buf, const char *string); | ||
int xmlBufWriteQuotedString(xmlBufPtr buf, const xmlChar *string); | ||
|
||
size_t xmlBufAvail(const xmlBufPtr buf); | ||
size_t xmlBufLength(const xmlBufPtr buf); | ||
/* size_t xmlBufUse(const xmlBufPtr buf); */ | ||
int xmlBufIsEmpty(const xmlBufPtr buf); | ||
int xmlBufAddLen(xmlBufPtr buf, size_t len); | ||
int xmlBufErase(xmlBufPtr buf, size_t len); | ||
|
||
/* const xmlChar * xmlBufContent(const xmlBuf *buf); */ | ||
/* const xmlChar * xmlBufEnd(xmlBufPtr buf); */ | ||
|
||
xmlChar * xmlBufDetach(xmlBufPtr buf); | ||
|
||
size_t xmlBufDump(FILE *file, xmlBufPtr buf); | ||
|
||
xmlBufPtr xmlBufFromBuffer(xmlBufferPtr buffer); | ||
xmlBufferPtr xmlBufBackToBuffer(xmlBufPtr buf); | ||
int xmlBufMergeBuffer(xmlBufPtr buf, xmlBufferPtr buffer); | ||
|
||
int xmlBufResetInput(xmlBufPtr buf, xmlParserInputPtr input); | ||
size_t xmlBufGetInputBase(xmlBufPtr buf, xmlParserInputPtr input); | ||
int xmlBufSetInputBaseCur(xmlBufPtr buf, xmlParserInputPtr input, | ||
size_t base, size_t cur); | ||
#ifdef __cplusplus | ||
} | ||
#endif | ||
#endif /* __XML_BUF_H__ */ | ||
|
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,122 @@ | ||
#! /usr/bin/env python | ||
### | ||
# | ||
# build_glob.py : Build the global_functions.h and global_functions.c | ||
# files which are required to implement the user | ||
# interface to global variables now that thread specific | ||
# data (TSD) is used to emulate global state. | ||
# | ||
# See Copyright for the status of this software. | ||
# Gary.Pennington@sun.com | ||
### | ||
import os, string | ||
|
||
class globvar: | ||
def __init__(self, type, name): | ||
self.type=type | ||
self.name=name | ||
|
||
def striplinesep(line): | ||
while line and line[-1] in ('\r','\n'): | ||
line = line[:-1] | ||
return line | ||
|
||
def writeline(file, line=None): | ||
if line: | ||
file.write(line) | ||
file.write("\n") | ||
|
||
if __name__ == "__main__": | ||
globals={} | ||
global_data=open("global.data").readlines() | ||
global_code=open("globals.c").readlines() | ||
global_hdr=open("include/libxml/globals.h").readlines() | ||
global_functions_hdr=open("include/libxml/globals.h", "w+") | ||
global_functions_impl=open("globals.c", "w+") | ||
|
||
# | ||
# Rebuild the beginning of the file up to the | ||
# Automatically generated string | ||
# | ||
for line in global_hdr: | ||
line = striplinesep(line) | ||
if line == " * Automatically generated by build_glob.py.": | ||
break | ||
writeline(global_functions_hdr, line) | ||
|
||
writeline(global_functions_hdr, " * Automatically generated by build_glob.py.") | ||
writeline(global_functions_hdr, " * Do not modify the previous line.") | ||
writeline(global_functions_hdr, " */") | ||
writeline(global_functions_hdr) | ||
|
||
for line in global_code: | ||
line = striplinesep(line) | ||
if line == " * Automatically generated by build_glob.py.": | ||
break | ||
writeline(global_functions_impl, line) | ||
|
||
writeline(global_functions_impl, " * Automatically generated by build_glob.py.") | ||
writeline(global_functions_impl, " * Do not modify the previous line.") | ||
writeline(global_functions_impl, " */") | ||
writeline(global_functions_impl) | ||
|
||
# Now process the data and write it to the appropriate output file | ||
for line in global_data: | ||
if line[0]=='#': | ||
continue | ||
line = striplinesep(line) | ||
fields = string.split(line, ",") | ||
# Update the header file | ||
writeline(global_functions_hdr) | ||
global_functions_hdr.write("extern "+fields[0]+" *") | ||
if fields[2]: | ||
global_functions_hdr.write("(*") | ||
global_functions_hdr.write("__"+fields[1]+"(void)") | ||
if fields[2]: | ||
global_functions_hdr.write(")"+fields[2]) | ||
writeline(global_functions_hdr,";") | ||
writeline(global_functions_hdr, "#ifdef LIBXML_THREAD_ENABLED") | ||
writeline(global_functions_hdr,"#define "+fields[1]+" \\") | ||
writeline(global_functions_hdr,"(*(__"+fields[1]+"()))") | ||
writeline(global_functions_hdr,"#else") | ||
if fields[2]: | ||
writeline(global_functions_hdr,"LIBXML_DLL_IMPORT extern "+fields[0]+" "+fields[1]+fields[2]+";") | ||
else: | ||
writeline(global_functions_hdr,"LIBXML_DLL_IMPORT extern "+fields[0]+" "+fields[1]+";") | ||
writeline(global_functions_hdr,"#endif") | ||
# set/get for per-thread global defaults | ||
if fields[3]: | ||
writeline(global_functions_hdr,fields[0]+" "+fields[1][:3]+"ThrDef"+fields[1][3:]+"("+fields[0]+" v);") | ||
# Update the implementation file | ||
writeline(global_functions_impl) | ||
# writeline(global_functions_impl, "extern "+fields[0]+" "+fields[1]+";") | ||
writeline(global_functions_impl, "#undef\t"+fields[1]) | ||
writeline(global_functions_impl, fields[0]+" *") | ||
if fields[2]: | ||
global_functions_impl.write("(*") | ||
global_functions_impl.write("__"+fields[1]+"(void)") | ||
if fields[2]: | ||
writeline(global_functions_impl, ")[]") | ||
writeline(global_functions_impl, " {") | ||
writeline(global_functions_impl, " if (IS_MAIN_THREAD)") | ||
writeline(global_functions_impl, "\treturn (&"+fields[1]+");") | ||
writeline(global_functions_impl, " else") | ||
writeline(global_functions_impl, "\treturn (&xmlGetGlobalState()->"+fields[1]+");") | ||
writeline(global_functions_impl, "}") | ||
# set/get for per-thread global defaults | ||
if fields[3]: | ||
writeline(global_functions_impl,fields[0]+" "+fields[1][:3]+"ThrDef"+fields[1][3:]+"("+fields[0]+" v) {") | ||
writeline(global_functions_impl," "+fields[0]+" ret;"); | ||
writeline(global_functions_impl," xmlMutexLock(xmlThrDefMutex);") | ||
writeline(global_functions_impl," ret = "+fields[1][:3]+fields[1][3:]+"ThrDef;") | ||
writeline(global_functions_impl," "+fields[1][:3]+fields[1][3:]+"ThrDef = v;") | ||
writeline(global_functions_impl," xmlMutexUnlock(xmlThrDefMutex);") | ||
writeline(global_functions_impl," return ret;") | ||
writeline(global_functions_impl,"}") | ||
# Terminate the header file with appropriate boilerplate | ||
writeline(global_functions_hdr) | ||
writeline(global_functions_hdr, "#ifdef __cplusplus") | ||
writeline(global_functions_hdr, "}") | ||
writeline(global_functions_hdr, "#endif") | ||
writeline(global_functions_hdr) | ||
writeline(global_functions_hdr, "#endif /* __XML_GLOBALS_H */") |
Large diffs are not rendered by default.
Large diffs are not rendered by default.
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,394 @@ | ||
#!/usr/bin/python | ||
import sys | ||
import time | ||
import os | ||
import string | ||
import StringIO | ||
sys.path.insert(0, "python") | ||
import libxml2 | ||
|
||
# Memory debug specific | ||
libxml2.debugMemory(1) | ||
debug = 0 | ||
verbose = 0 | ||
quiet = 1 | ||
|
||
# | ||
# the testsuite description | ||
# | ||
CONF=os.path.join(os.path.dirname(__file__), "test/relaxng/OASIS/spectest.xml") | ||
LOG="check-relaxng-test-suite.log" | ||
RES="relaxng-test-results.xml" | ||
|
||
log = open(LOG, "w") | ||
nb_schemas_tests = 0 | ||
nb_schemas_success = 0 | ||
nb_schemas_failed = 0 | ||
nb_instances_tests = 0 | ||
nb_instances_success = 0 | ||
nb_instances_failed = 0 | ||
|
||
libxml2.lineNumbersDefault(1) | ||
# | ||
# Error and warnng callbacks | ||
# | ||
def callback(ctx, str): | ||
global log | ||
log.write("%s%s" % (ctx, str)) | ||
|
||
libxml2.registerErrorHandler(callback, "") | ||
|
||
# | ||
# Resolver callback | ||
# | ||
resources = {} | ||
def resolver(URL, ID, ctxt): | ||
global resources | ||
|
||
if string.find(URL, '#') != -1: | ||
URL = URL[0:string.find(URL, '#')] | ||
if resources.has_key(URL): | ||
return(StringIO.StringIO(resources[URL])) | ||
log.write("Resolver failure: asked %s\n" % (URL)) | ||
log.write("resources: %s\n" % (resources)) | ||
return None | ||
|
||
# | ||
# Load the previous results | ||
# | ||
#results = {} | ||
#previous = {} | ||
# | ||
#try: | ||
# res = libxml2.parseFile(RES) | ||
#except: | ||
# log.write("Could not parse %s" % (RES)) | ||
|
||
# | ||
# handle a valid instance | ||
# | ||
def handle_valid(node, schema): | ||
global log | ||
global nb_instances_success | ||
global nb_instances_failed | ||
|
||
instance = "" | ||
child = node.children | ||
while child != None: | ||
if child.type != 'text': | ||
instance = instance + child.serialize() | ||
child = child.next | ||
|
||
try: | ||
doc = libxml2.parseDoc(instance) | ||
except: | ||
doc = None | ||
|
||
if doc == None: | ||
log.write("\nFailed to parse correct instance:\n-----\n") | ||
log.write(instance) | ||
log.write("\n-----\n") | ||
nb_instances_failed = nb_instances_failed + 1 | ||
return | ||
|
||
try: | ||
ctxt = schema.relaxNGNewValidCtxt() | ||
ret = doc.relaxNGValidateDoc(ctxt) | ||
except: | ||
ret = -1 | ||
if ret != 0: | ||
log.write("\nFailed to validate correct instance:\n-----\n") | ||
log.write(instance) | ||
log.write("\n-----\n") | ||
nb_instances_failed = nb_instances_failed + 1 | ||
else: | ||
nb_instances_success = nb_instances_success + 1 | ||
doc.freeDoc() | ||
|
||
# | ||
# handle an invalid instance | ||
# | ||
def handle_invalid(node, schema): | ||
global log | ||
global nb_instances_success | ||
global nb_instances_failed | ||
|
||
instance = "" | ||
child = node.children | ||
while child != None: | ||
if child.type != 'text': | ||
instance = instance + child.serialize() | ||
child = child.next | ||
|
||
try: | ||
doc = libxml2.parseDoc(instance) | ||
except: | ||
doc = None | ||
|
||
if doc == None: | ||
log.write("\nStrange: failed to parse incorrect instance:\n-----\n") | ||
log.write(instance) | ||
log.write("\n-----\n") | ||
return | ||
|
||
try: | ||
ctxt = schema.relaxNGNewValidCtxt() | ||
ret = doc.relaxNGValidateDoc(ctxt) | ||
except: | ||
ret = -1 | ||
if ret == 0: | ||
log.write("\nFailed to detect validation problem in instance:\n-----\n") | ||
log.write(instance) | ||
log.write("\n-----\n") | ||
nb_instances_failed = nb_instances_failed + 1 | ||
else: | ||
nb_instances_success = nb_instances_success + 1 | ||
doc.freeDoc() | ||
|
||
# | ||
# handle an incorrect test | ||
# | ||
def handle_correct(node): | ||
global log | ||
global nb_schemas_success | ||
global nb_schemas_failed | ||
|
||
schema = "" | ||
child = node.children | ||
while child != None: | ||
if child.type != 'text': | ||
schema = schema + child.serialize() | ||
child = child.next | ||
|
||
try: | ||
rngp = libxml2.relaxNGNewMemParserCtxt(schema, len(schema)) | ||
rngs = rngp.relaxNGParse() | ||
except: | ||
rngs = None | ||
if rngs == None: | ||
log.write("\nFailed to compile correct schema:\n-----\n") | ||
log.write(schema) | ||
log.write("\n-----\n") | ||
nb_schemas_failed = nb_schemas_failed + 1 | ||
else: | ||
nb_schemas_success = nb_schemas_success + 1 | ||
return rngs | ||
|
||
def handle_incorrect(node): | ||
global log | ||
global nb_schemas_success | ||
global nb_schemas_failed | ||
|
||
schema = "" | ||
child = node.children | ||
while child != None: | ||
if child.type != 'text': | ||
schema = schema + child.serialize() | ||
child = child.next | ||
|
||
try: | ||
rngp = libxml2.relaxNGNewMemParserCtxt(schema, len(schema)) | ||
rngs = rngp.relaxNGParse() | ||
except: | ||
rngs = None | ||
if rngs != None: | ||
log.write("\nFailed to detect schema error in:\n-----\n") | ||
log.write(schema) | ||
log.write("\n-----\n") | ||
nb_schemas_failed = nb_schemas_failed + 1 | ||
else: | ||
# log.write("\nSuccess detecting schema error in:\n-----\n") | ||
# log.write(schema) | ||
# log.write("\n-----\n") | ||
nb_schemas_success = nb_schemas_success + 1 | ||
return None | ||
|
||
# | ||
# resource handling: keep a dictionary of URL->string mappings | ||
# | ||
def handle_resource(node, dir): | ||
global resources | ||
|
||
try: | ||
name = node.prop('name') | ||
except: | ||
name = None | ||
|
||
if name == None or name == '': | ||
log.write("resource has no name") | ||
return; | ||
|
||
if dir != None: | ||
# name = libxml2.buildURI(name, dir) | ||
name = dir + '/' + name | ||
|
||
res = "" | ||
child = node.children | ||
while child != None: | ||
if child.type != 'text': | ||
res = res + child.serialize() | ||
child = child.next | ||
resources[name] = res | ||
|
||
# | ||
# dir handling: pseudo directory resources | ||
# | ||
def handle_dir(node, dir): | ||
try: | ||
name = node.prop('name') | ||
except: | ||
name = None | ||
|
||
if name == None or name == '': | ||
log.write("resource has no name") | ||
return; | ||
|
||
if dir != None: | ||
# name = libxml2.buildURI(name, dir) | ||
name = dir + '/' + name | ||
|
||
dirs = node.xpathEval('dir') | ||
for dir in dirs: | ||
handle_dir(dir, name) | ||
res = node.xpathEval('resource') | ||
for r in res: | ||
handle_resource(r, name) | ||
|
||
# | ||
# handle a testCase element | ||
# | ||
def handle_testCase(node): | ||
global nb_schemas_tests | ||
global nb_instances_tests | ||
global resources | ||
|
||
sections = node.xpathEval('string(section)') | ||
log.write("\n ======== test %d line %d section %s ==========\n" % ( | ||
|
||
nb_schemas_tests, node.lineNo(), sections)) | ||
resources = {} | ||
if debug: | ||
print "test %d line %d" % (nb_schemas_tests, node.lineNo()) | ||
|
||
dirs = node.xpathEval('dir') | ||
for dir in dirs: | ||
handle_dir(dir, None) | ||
res = node.xpathEval('resource') | ||
for r in res: | ||
handle_resource(r, None) | ||
|
||
tsts = node.xpathEval('incorrect') | ||
if tsts != []: | ||
if len(tsts) != 1: | ||
print "warning test line %d has more than one <incorrect> example" %(node.lineNo()) | ||
schema = handle_incorrect(tsts[0]) | ||
else: | ||
tsts = node.xpathEval('correct') | ||
if tsts != []: | ||
if len(tsts) != 1: | ||
print "warning test line %d has more than one <correct> example"% (node.lineNo()) | ||
schema = handle_correct(tsts[0]) | ||
else: | ||
print "warning <testCase> line %d has no <correct> nor <incorrect> child" % (node.lineNo()) | ||
|
||
nb_schemas_tests = nb_schemas_tests + 1; | ||
|
||
valids = node.xpathEval('valid') | ||
invalids = node.xpathEval('invalid') | ||
nb_instances_tests = nb_instances_tests + len(valids) + len(invalids) | ||
if schema != None: | ||
for valid in valids: | ||
handle_valid(valid, schema) | ||
for invalid in invalids: | ||
handle_invalid(invalid, schema) | ||
|
||
|
||
# | ||
# handle a testSuite element | ||
# | ||
def handle_testSuite(node, level = 0): | ||
global nb_schemas_tests, nb_schemas_success, nb_schemas_failed | ||
global nb_instances_tests, nb_instances_success, nb_instances_failed | ||
global quiet | ||
if level >= 1: | ||
old_schemas_tests = nb_schemas_tests | ||
old_schemas_success = nb_schemas_success | ||
old_schemas_failed = nb_schemas_failed | ||
old_instances_tests = nb_instances_tests | ||
old_instances_success = nb_instances_success | ||
old_instances_failed = nb_instances_failed | ||
|
||
docs = node.xpathEval('documentation') | ||
authors = node.xpathEval('author') | ||
if docs != []: | ||
msg = "" | ||
for doc in docs: | ||
msg = msg + doc.content + " " | ||
if authors != []: | ||
msg = msg + "written by " | ||
for author in authors: | ||
msg = msg + author.content + " " | ||
if quiet == 0: | ||
print msg | ||
sections = node.xpathEval('section') | ||
if sections != [] and level <= 0: | ||
msg = "" | ||
for section in sections: | ||
msg = msg + section.content + " " | ||
if quiet == 0: | ||
print "Tests for section %s" % (msg) | ||
for test in node.xpathEval('testCase'): | ||
handle_testCase(test) | ||
for test in node.xpathEval('testSuite'): | ||
handle_testSuite(test, level + 1) | ||
|
||
|
||
if verbose and level >= 1 and sections != []: | ||
msg = "" | ||
for section in sections: | ||
msg = msg + section.content + " " | ||
print "Result of tests for section %s" % (msg) | ||
if nb_schemas_tests != old_schemas_tests: | ||
print "found %d test schemas: %d success %d failures" % ( | ||
nb_schemas_tests - old_schemas_tests, | ||
nb_schemas_success - old_schemas_success, | ||
nb_schemas_failed - old_schemas_failed) | ||
if nb_instances_tests != old_instances_tests: | ||
print "found %d test instances: %d success %d failures" % ( | ||
nb_instances_tests - old_instances_tests, | ||
nb_instances_success - old_instances_success, | ||
nb_instances_failed - old_instances_failed) | ||
# | ||
# Parse the conf file | ||
# | ||
libxml2.substituteEntitiesDefault(1); | ||
testsuite = libxml2.parseFile(CONF) | ||
libxml2.setEntityLoader(resolver) | ||
root = testsuite.getRootElement() | ||
if root.name != 'testSuite': | ||
print "%s doesn't start with a testSuite element, aborting" % (CONF) | ||
sys.exit(1) | ||
if quiet == 0: | ||
print "Running Relax NG testsuite" | ||
handle_testSuite(root) | ||
|
||
if quiet == 0: | ||
print "\nTOTAL:\n" | ||
if quiet == 0 or nb_schemas_failed != 0: | ||
print "found %d test schemas: %d success %d failures" % ( | ||
nb_schemas_tests, nb_schemas_success, nb_schemas_failed) | ||
if quiet == 0 or nb_instances_failed != 0: | ||
print "found %d test instances: %d success %d failures" % ( | ||
nb_instances_tests, nb_instances_success, nb_instances_failed) | ||
|
||
testsuite.freeDoc() | ||
|
||
# Memory debug specific | ||
libxml2.relaxNGCleanupTypes() | ||
libxml2.cleanupParser() | ||
if libxml2.debugMemory(1) == 0: | ||
if quiet == 0: | ||
print "OK" | ||
else: | ||
print "Memory leak %d bytes" % (libxml2.debugMemory(1)) | ||
libxml2.dumpMemory() |
Large diffs are not rendered by default.
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,221 @@ | ||
#!/usr/bin/python | ||
import sys | ||
import time | ||
import os | ||
import string | ||
sys.path.insert(0, "python") | ||
import libxml2 | ||
|
||
# | ||
# the testsuite description | ||
# | ||
DIR="xinclude-test-suite" | ||
CONF="testdescr.xml" | ||
LOG="check-xinclude-test-suite.log" | ||
|
||
log = open(LOG, "w") | ||
|
||
os.chdir(DIR) | ||
|
||
test_nr = 0 | ||
test_succeed = 0 | ||
test_failed = 0 | ||
test_error = 0 | ||
# | ||
# Error and warning handlers | ||
# | ||
error_nr = 0 | ||
error_msg = '' | ||
|
||
def errorHandler(ctx, str): | ||
global error_nr | ||
global error_msg | ||
|
||
if string.find(str, "error:") >= 0: | ||
error_nr = error_nr + 1 | ||
if len(error_msg) < 300: | ||
if len(error_msg) == 0 or error_msg[-1] == '\n': | ||
error_msg = error_msg + " >>" + str | ||
else: | ||
error_msg = error_msg + str | ||
|
||
libxml2.registerErrorHandler(errorHandler, None) | ||
|
||
def testXInclude(filename, id): | ||
global error_nr | ||
global error_msg | ||
global log | ||
|
||
error_nr = 0 | ||
error_msg = '' | ||
|
||
print "testXInclude(%s, %s)" % (filename, id) | ||
return 1 | ||
|
||
def runTest(test, basedir): | ||
global test_nr | ||
global test_failed | ||
global test_error | ||
global test_succeed | ||
global error_msg | ||
global log | ||
|
||
fatal_error = 0 | ||
uri = test.prop('href') | ||
id = test.prop('id') | ||
type = test.prop('type') | ||
if uri == None: | ||
print "Test without ID:", uri | ||
return -1 | ||
if id == None: | ||
print "Test without URI:", id | ||
return -1 | ||
if type == None: | ||
print "Test without URI:", id | ||
return -1 | ||
if basedir != None: | ||
URI = basedir + "/" + uri | ||
else: | ||
URI = uri | ||
if os.access(URI, os.R_OK) == 0: | ||
print "Test %s missing: base %s uri %s" % (URI, basedir, uri) | ||
return -1 | ||
|
||
expected = None | ||
outputfile = None | ||
diff = None | ||
if type != 'error': | ||
output = test.xpathEval('string(output)') | ||
if output == 'No output file.': | ||
output = None | ||
if output == '': | ||
output = None | ||
if output != None: | ||
if basedir != None: | ||
output = basedir + "/" + output | ||
if os.access(output, os.R_OK) == 0: | ||
print "Result for %s missing: %s" % (id, output) | ||
output = None | ||
else: | ||
try: | ||
f = open(output) | ||
expected = f.read() | ||
outputfile = output | ||
except: | ||
print "Result for %s unreadable: %s" % (id, output) | ||
|
||
try: | ||
# print "testing %s" % (URI) | ||
doc = libxml2.parseFile(URI) | ||
except: | ||
doc = None | ||
if doc != None: | ||
res = doc.xincludeProcess() | ||
if res >= 0 and expected != None: | ||
result = doc.serialize() | ||
if result != expected: | ||
print "Result for %s differs" % (id) | ||
open("xinclude.res", "w").write(result) | ||
diff = os.popen("diff %s xinclude.res" % outputfile).read() | ||
|
||
doc.freeDoc() | ||
else: | ||
print "Failed to parse %s" % (URI) | ||
res = -1 | ||
|
||
|
||
|
||
test_nr = test_nr + 1 | ||
if type == 'success': | ||
if res > 0: | ||
test_succeed = test_succeed + 1 | ||
elif res == 0: | ||
test_failed = test_failed + 1 | ||
print "Test %s: no substitution done ???" % (id) | ||
elif res < 0: | ||
test_error = test_error + 1 | ||
print "Test %s: failed valid XInclude processing" % (id) | ||
elif type == 'error': | ||
if res > 0: | ||
test_error = test_error + 1 | ||
print "Test %s: failed to detect invalid XInclude processing" % (id) | ||
elif res == 0: | ||
test_failed = test_failed + 1 | ||
print "Test %s: Invalid but no substitution done" % (id) | ||
elif res < 0: | ||
test_succeed = test_succeed + 1 | ||
elif type == 'optional': | ||
if res > 0: | ||
test_succeed = test_succeed + 1 | ||
else: | ||
print "Test %s: failed optional test" % (id) | ||
|
||
# Log the ontext | ||
if res != 1: | ||
log.write("Test ID %s\n" % (id)) | ||
log.write(" File: %s\n" % (URI)) | ||
content = string.strip(test.content) | ||
while content[-1] == '\n': | ||
content = content[0:-1] | ||
log.write(" %s:%s\n\n" % (type, content)) | ||
if error_msg != '': | ||
log.write(" ----\n%s ----\n" % (error_msg)) | ||
error_msg = '' | ||
log.write("\n") | ||
if diff != None: | ||
log.write("diff from test %s:\n" %(id)) | ||
log.write(" -----------\n%s\n -----------\n" % (diff)); | ||
|
||
return 0 | ||
|
||
|
||
def runTestCases(case): | ||
creator = case.prop('creator') | ||
if creator != None: | ||
print "=>", creator | ||
base = case.getBase(None) | ||
basedir = case.prop('basedir') | ||
if basedir != None: | ||
base = libxml2.buildURI(basedir, base) | ||
test = case.children | ||
while test != None: | ||
if test.name == 'testcase': | ||
runTest(test, base) | ||
if test.name == 'testcases': | ||
runTestCases(test) | ||
test = test.next | ||
|
||
conf = libxml2.parseFile(CONF) | ||
if conf == None: | ||
print "Unable to load %s" % CONF | ||
sys.exit(1) | ||
|
||
testsuite = conf.getRootElement() | ||
if testsuite.name != 'testsuite': | ||
print "Expecting TESTSUITE root element: aborting" | ||
sys.exit(1) | ||
|
||
profile = testsuite.prop('PROFILE') | ||
if profile != None: | ||
print profile | ||
|
||
start = time.time() | ||
|
||
case = testsuite.children | ||
while case != None: | ||
if case.name == 'testcases': | ||
old_test_nr = test_nr | ||
old_test_succeed = test_succeed | ||
old_test_failed = test_failed | ||
old_test_error = test_error | ||
runTestCases(case) | ||
print " Ran %d tests: %d suceeded, %d failed and %d generated an error" % ( | ||
test_nr - old_test_nr, test_succeed - old_test_succeed, | ||
test_failed - old_test_failed, test_error - old_test_error) | ||
case = case.next | ||
|
||
conf.freeDoc() | ||
log.close() | ||
|
||
print "Ran %d tests: %d suceeded, %d failed and %d generated an error in %.2f s." % ( | ||
test_nr, test_succeed, test_failed, test_error, time.time() - start) |
Large diffs are not rendered by default.
Large diffs are not rendered by default.
Original file line number | Diff line number | Diff line change |
---|---|---|
@@ -0,0 +1,336 @@ | ||
/* | ||
* chvalid.c: this module implements the character range | ||
* validation APIs | ||
* | ||
* This file is automatically generated from the cvs source | ||
* definition files using the genChRanges.py Python script | ||
* | ||
* Generation date: Mon Mar 27 11:09:48 2006 | ||
* Sources: chvalid.def | ||
* William Brack <wbrack@mmm.com.hk> | ||
*/ | ||
|
||
#define IN_LIBXML | ||
#include "libxml.h" | ||
#include <libxml/chvalid.h> | ||
|
||
/* | ||
* The initial tables ({func_name}_tab) are used to validate whether a | ||
* single-byte character is within the specified group. Each table | ||
* contains 256 bytes, with each byte representing one of the 256 | ||
* possible characters. If the table byte is set, the character is | ||
* allowed. | ||
* | ||
*/ | ||
const unsigned char xmlIsPubidChar_tab[256] = { | ||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, | ||
0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, | ||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00, 0x01, | ||
0x01, 0x01, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, | ||
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, | ||
0x00, 0x01, 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, 0x00, 0x00, 0x00, 0x00, 0x01, | ||
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, 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, 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, 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, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, | ||
0x00, 0x00, 0x00, 0x00 }; | ||
|
||
static const xmlChSRange xmlIsBaseChar_srng[] = { {0x100, 0x131}, | ||
{0x134, 0x13e}, {0x141, 0x148}, {0x14a, 0x17e}, {0x180, 0x1c3}, | ||
{0x1cd, 0x1f0}, {0x1f4, 0x1f5}, {0x1fa, 0x217}, {0x250, 0x2a8}, | ||
{0x2bb, 0x2c1}, {0x386, 0x386}, {0x388, 0x38a}, {0x38c, 0x38c}, | ||
{0x38e, 0x3a1}, {0x3a3, 0x3ce}, {0x3d0, 0x3d6}, {0x3da, 0x3da}, | ||
{0x3dc, 0x3dc}, {0x3de, 0x3de}, {0x3e0, 0x3e0}, {0x3e2, 0x3f3}, | ||
{0x401, 0x40c}, {0x40e, 0x44f}, {0x451, 0x45c}, {0x45e, 0x481}, | ||
{0x490, 0x4c4}, {0x4c7, 0x4c8}, {0x4cb, 0x4cc}, {0x4d0, 0x4eb}, | ||
{0x4ee, 0x4f5}, {0x4f8, 0x4f9}, {0x531, 0x556}, {0x559, 0x559}, | ||
{0x561, 0x586}, {0x5d0, 0x5ea}, {0x5f0, 0x5f2}, {0x621, 0x63a}, | ||
{0x641, 0x64a}, {0x671, 0x6b7}, {0x6ba, 0x6be}, {0x6c0, 0x6ce}, | ||
{0x6d0, 0x6d3}, {0x6d5, 0x6d5}, {0x6e5, 0x6e6}, {0x905, 0x939}, | ||
{0x93d, 0x93d}, {0x958, 0x961}, {0x985, 0x98c}, {0x98f, 0x990}, | ||
{0x993, 0x9a8}, {0x9aa, 0x9b0}, {0x9b2, 0x9b2}, {0x9b6, 0x9b9}, | ||
{0x9dc, 0x9dd}, {0x9df, 0x9e1}, {0x9f0, 0x9f1}, {0xa05, 0xa0a}, | ||
{0xa0f, 0xa10}, {0xa13, 0xa28}, {0xa2a, 0xa30}, {0xa32, 0xa33}, | ||
{0xa35, 0xa36}, {0xa38, 0xa39}, {0xa59, 0xa5c}, {0xa5e, 0xa5e}, | ||
{0xa72, 0xa74}, {0xa85, 0xa8b}, {0xa8d, 0xa8d}, {0xa8f, 0xa91}, | ||
{0xa93, 0xaa8}, {0xaaa, 0xab0}, {0xab2, 0xab3}, {0xab5, 0xab9}, | ||
{0xabd, 0xabd}, {0xae0, 0xae0}, {0xb05, 0xb0c}, {0xb0f, 0xb10}, | ||
{0xb13, 0xb28}, {0xb2a, 0xb30}, {0xb32, 0xb33}, {0xb36, 0xb39}, | ||
{0xb3d, 0xb3d}, {0xb5c, 0xb5d}, {0xb5f, 0xb61}, {0xb85, 0xb8a}, | ||
{0xb8e, 0xb90}, {0xb92, 0xb95}, {0xb99, 0xb9a}, {0xb9c, 0xb9c}, | ||
{0xb9e, 0xb9f}, {0xba3, 0xba4}, {0xba8, 0xbaa}, {0xbae, 0xbb5}, | ||
{0xbb7, 0xbb9}, {0xc05, 0xc0c}, {0xc0e, 0xc10}, {0xc12, 0xc28}, | ||
{0xc2a, 0xc33}, {0xc35, 0xc39}, {0xc60, 0xc61}, {0xc85, 0xc8c}, | ||
{0xc8e, 0xc90}, {0xc92, 0xca8}, {0xcaa, 0xcb3}, {0xcb5, 0xcb9}, | ||
{0xcde, 0xcde}, {0xce0, 0xce1}, {0xd05, 0xd0c}, {0xd0e, 0xd10}, | ||
{0xd12, 0xd28}, {0xd2a, 0xd39}, {0xd60, 0xd61}, {0xe01, 0xe2e}, | ||
{0xe30, 0xe30}, {0xe32, 0xe33}, {0xe40, 0xe45}, {0xe81, 0xe82}, | ||
{0xe84, 0xe84}, {0xe87, 0xe88}, {0xe8a, 0xe8a}, {0xe8d, 0xe8d}, | ||
{0xe94, 0xe97}, {0xe99, 0xe9f}, {0xea1, 0xea3}, {0xea5, 0xea5}, | ||
{0xea7, 0xea7}, {0xeaa, 0xeab}, {0xead, 0xeae}, {0xeb0, 0xeb0}, | ||
{0xeb2, 0xeb3}, {0xebd, 0xebd}, {0xec0, 0xec4}, {0xf40, 0xf47}, | ||
{0xf49, 0xf69}, {0x10a0, 0x10c5}, {0x10d0, 0x10f6}, {0x1100, 0x1100}, | ||
{0x1102, 0x1103}, {0x1105, 0x1107}, {0x1109, 0x1109}, {0x110b, 0x110c}, | ||
{0x110e, 0x1112}, {0x113c, 0x113c}, {0x113e, 0x113e}, {0x1140, 0x1140}, | ||
{0x114c, 0x114c}, {0x114e, 0x114e}, {0x1150, 0x1150}, {0x1154, 0x1155}, | ||
{0x1159, 0x1159}, {0x115f, 0x1161}, {0x1163, 0x1163}, {0x1165, 0x1165}, | ||
{0x1167, 0x1167}, {0x1169, 0x1169}, {0x116d, 0x116e}, {0x1172, 0x1173}, | ||
{0x1175, 0x1175}, {0x119e, 0x119e}, {0x11a8, 0x11a8}, {0x11ab, 0x11ab}, | ||
{0x11ae, 0x11af}, {0x11b7, 0x11b8}, {0x11ba, 0x11ba}, {0x11bc, 0x11c2}, | ||
{0x11eb, 0x11eb}, {0x11f0, 0x11f0}, {0x11f9, 0x11f9}, {0x1e00, 0x1e9b}, | ||
{0x1ea0, 0x1ef9}, {0x1f00, 0x1f15}, {0x1f18, 0x1f1d}, {0x1f20, 0x1f45}, | ||
{0x1f48, 0x1f4d}, {0x1f50, 0x1f57}, {0x1f59, 0x1f59}, {0x1f5b, 0x1f5b}, | ||
{0x1f5d, 0x1f5d}, {0x1f5f, 0x1f7d}, {0x1f80, 0x1fb4}, {0x1fb6, 0x1fbc}, | ||
{0x1fbe, 0x1fbe}, {0x1fc2, 0x1fc4}, {0x1fc6, 0x1fcc}, {0x1fd0, 0x1fd3}, | ||
{0x1fd6, 0x1fdb}, {0x1fe0, 0x1fec}, {0x1ff2, 0x1ff4}, {0x1ff6, 0x1ffc}, | ||
{0x2126, 0x2126}, {0x212a, 0x212b}, {0x212e, 0x212e}, {0x2180, 0x2182}, | ||
{0x3041, 0x3094}, {0x30a1, 0x30fa}, {0x3105, 0x312c}, {0xac00, 0xd7a3}}; | ||
const xmlChRangeGroup xmlIsBaseCharGroup = | ||
{197, 0, xmlIsBaseChar_srng, (xmlChLRangePtr)0}; | ||
|
||
static const xmlChSRange xmlIsChar_srng[] = { {0x100, 0xd7ff}, | ||
{0xe000, 0xfffd}}; | ||
static const xmlChLRange xmlIsChar_lrng[] = { {0x10000, 0x10ffff}}; | ||
const xmlChRangeGroup xmlIsCharGroup = | ||
{2, 1, xmlIsChar_srng, xmlIsChar_lrng}; | ||
|
||
static const xmlChSRange xmlIsCombining_srng[] = { {0x300, 0x345}, | ||
{0x360, 0x361}, {0x483, 0x486}, {0x591, 0x5a1}, {0x5a3, 0x5b9}, | ||
{0x5bb, 0x5bd}, {0x5bf, 0x5bf}, {0x5c1, 0x5c2}, {0x5c4, 0x5c4}, | ||
{0x64b, 0x652}, {0x670, 0x670}, {0x6d6, 0x6dc}, {0x6dd, 0x6df}, | ||
{0x6e0, 0x6e4}, {0x6e7, 0x6e8}, {0x6ea, 0x6ed}, {0x901, 0x903}, | ||
{0x93c, 0x93c}, {0x93e, 0x94c}, {0x94d, 0x94d}, {0x951, 0x954}, | ||
{0x962, 0x963}, {0x981, 0x983}, {0x9bc, 0x9bc}, {0x9be, 0x9be}, | ||
{0x9bf, 0x9bf}, {0x9c0, 0x9c4}, {0x9c7, 0x9c8}, {0x9cb, 0x9cd}, | ||
{0x9d7, 0x9d7}, {0x9e2, 0x9e3}, {0xa02, 0xa02}, {0xa3c, 0xa3c}, | ||
{0xa3e, 0xa3e}, {0xa3f, 0xa3f}, {0xa40, 0xa42}, {0xa47, 0xa48}, | ||
{0xa4b, 0xa4d}, {0xa70, 0xa71}, {0xa81, 0xa83}, {0xabc, 0xabc}, | ||
{0xabe, 0xac5}, {0xac7, 0xac9}, {0xacb, 0xacd}, {0xb01, 0xb03}, | ||
{0xb3c, 0xb3c}, {0xb3e, 0xb43}, {0xb47, 0xb48}, {0xb4b, 0xb4d}, | ||
{0xb56, 0xb57}, {0xb82, 0xb83}, {0xbbe, 0xbc2}, {0xbc6, 0xbc8}, | ||
{0xbca, 0xbcd}, {0xbd7, 0xbd7}, {0xc01, 0xc03}, {0xc3e, 0xc44}, | ||
{0xc46, 0xc48}, {0xc4a, 0xc4d}, {0xc55, 0xc56}, {0xc82, 0xc83}, | ||
{0xcbe, 0xcc4}, {0xcc6, 0xcc8}, {0xcca, 0xccd}, {0xcd5, 0xcd6}, | ||
{0xd02, 0xd03}, {0xd3e, 0xd43}, {0xd46, 0xd48}, {0xd4a, 0xd4d}, | ||
{0xd57, 0xd57}, {0xe31, 0xe31}, {0xe34, 0xe3a}, {0xe47, 0xe4e}, | ||
{0xeb1, 0xeb1}, {0xeb4, 0xeb9}, {0xebb, 0xebc}, {0xec8, 0xecd}, | ||
{0xf18, 0xf19}, {0xf35, 0xf35}, {0xf37, 0xf37}, {0xf39, 0xf39}, | ||
{0xf3e, 0xf3e}, {0xf3f, 0xf3f}, {0xf71, 0xf84}, {0xf86, 0xf8b}, | ||
{0xf90, 0xf95}, {0xf97, 0xf97}, {0xf99, 0xfad}, {0xfb1, 0xfb7}, | ||
{0xfb9, 0xfb9}, {0x20d0, 0x20dc}, {0x20e1, 0x20e1}, {0x302a, 0x302f}, | ||
{0x3099, 0x3099}, {0x309a, 0x309a}}; | ||
const xmlChRangeGroup xmlIsCombiningGroup = | ||
{95, 0, xmlIsCombining_srng, (xmlChLRangePtr)0}; | ||
|
||
static const xmlChSRange xmlIsDigit_srng[] = { {0x660, 0x669}, | ||
{0x6f0, 0x6f9}, {0x966, 0x96f}, {0x9e6, 0x9ef}, {0xa66, 0xa6f}, | ||
{0xae6, 0xaef}, {0xb66, 0xb6f}, {0xbe7, 0xbef}, {0xc66, 0xc6f}, | ||
{0xce6, 0xcef}, {0xd66, 0xd6f}, {0xe50, 0xe59}, {0xed0, 0xed9}, | ||
{0xf20, 0xf29}}; | ||
const xmlChRangeGroup xmlIsDigitGroup = | ||
{14, 0, xmlIsDigit_srng, (xmlChLRangePtr)0}; | ||
|
||
static const xmlChSRange xmlIsExtender_srng[] = { {0x2d0, 0x2d0}, | ||
{0x2d1, 0x2d1}, {0x387, 0x387}, {0x640, 0x640}, {0xe46, 0xe46}, | ||
{0xec6, 0xec6}, {0x3005, 0x3005}, {0x3031, 0x3035}, {0x309d, 0x309e}, | ||
{0x30fc, 0x30fe}}; | ||
const xmlChRangeGroup xmlIsExtenderGroup = | ||
{10, 0, xmlIsExtender_srng, (xmlChLRangePtr)0}; | ||
|
||
static const xmlChSRange xmlIsIdeographic_srng[] = { {0x3007, 0x3007}, | ||
{0x3021, 0x3029}, {0x4e00, 0x9fa5}}; | ||
const xmlChRangeGroup xmlIsIdeographicGroup = | ||
{3, 0, xmlIsIdeographic_srng, (xmlChLRangePtr)0}; | ||
|
||
|
||
/** | ||
* xmlCharInRange: | ||
* @val: character to be validated | ||
* @rptr: pointer to range to be used to validate | ||
* | ||
* Does a binary search of the range table to determine if char | ||
* is valid | ||
* | ||
* Returns: true if character valid, false otherwise | ||
*/ | ||
int | ||
xmlCharInRange (unsigned int val, const xmlChRangeGroup *rptr) { | ||
int low, high, mid; | ||
const xmlChSRange *sptr; | ||
const xmlChLRange *lptr; | ||
|
||
if (rptr == NULL) return(0); | ||
if (val < 0x10000) { /* is val in 'short' or 'long' array? */ | ||
if (rptr->nbShortRange == 0) | ||
return 0; | ||
low = 0; | ||
high = rptr->nbShortRange - 1; | ||
sptr = rptr->shortRange; | ||
while (low <= high) { | ||
mid = (low + high) / 2; | ||
if ((unsigned short) val < sptr[mid].low) { | ||
high = mid - 1; | ||
} else { | ||
if ((unsigned short) val > sptr[mid].high) { | ||
low = mid + 1; | ||
} else { | ||
return 1; | ||
} | ||
} | ||
} | ||
} else { | ||
if (rptr->nbLongRange == 0) { | ||
return 0; | ||
} | ||
low = 0; | ||
high = rptr->nbLongRange - 1; | ||
lptr = rptr->longRange; | ||
while (low <= high) { | ||
mid = (low + high) / 2; | ||
if (val < lptr[mid].low) { | ||
high = mid - 1; | ||
} else { | ||
if (val > lptr[mid].high) { | ||
low = mid + 1; | ||
} else { | ||
return 1; | ||
} | ||
} | ||
} | ||
} | ||
return 0; | ||
} | ||
|
||
|
||
/** | ||
* xmlIsBaseChar: | ||
* @ch: character to validate | ||
* | ||
* This function is DEPRECATED. | ||
* Use xmlIsBaseChar_ch or xmlIsBaseCharQ instead | ||
* | ||
* Returns true if argument valid, false otherwise | ||
*/ | ||
int | ||
xmlIsBaseChar(unsigned int ch) { | ||
return(xmlIsBaseCharQ(ch)); | ||
} | ||
|
||
|
||
/** | ||
* xmlIsBlank: | ||
* @ch: character to validate | ||
* | ||
* This function is DEPRECATED. | ||
* Use xmlIsBlank_ch or xmlIsBlankQ instead | ||
* | ||
* Returns true if argument valid, false otherwise | ||
*/ | ||
int | ||
xmlIsBlank(unsigned int ch) { | ||
return(xmlIsBlankQ(ch)); | ||
} | ||
|
||
|
||
/** | ||
* xmlIsChar: | ||
* @ch: character to validate | ||
* | ||
* This function is DEPRECATED. | ||
* Use xmlIsChar_ch or xmlIsCharQ instead | ||
* | ||
* Returns true if argument valid, false otherwise | ||
*/ | ||
int | ||
xmlIsChar(unsigned int ch) { | ||
return(xmlIsCharQ(ch)); | ||
} | ||
|
||
|
||
/** | ||
* xmlIsCombining: | ||
* @ch: character to validate | ||
* | ||
* This function is DEPRECATED. | ||
* Use xmlIsCombiningQ instead | ||
* | ||
* Returns true if argument valid, false otherwise | ||
*/ | ||
int | ||
xmlIsCombining(unsigned int ch) { | ||
return(xmlIsCombiningQ(ch)); | ||
} | ||
|
||
|
||
/** | ||
* xmlIsDigit: | ||
* @ch: character to validate | ||
* | ||
* This function is DEPRECATED. | ||
* Use xmlIsDigit_ch or xmlIsDigitQ instead | ||
* | ||
* Returns true if argument valid, false otherwise | ||
*/ | ||
int | ||
xmlIsDigit(unsigned int ch) { | ||
return(xmlIsDigitQ(ch)); | ||
} | ||
|
||
|
||
/** | ||
* xmlIsExtender: | ||
* @ch: character to validate | ||
* | ||
* This function is DEPRECATED. | ||
* Use xmlIsExtender_ch or xmlIsExtenderQ instead | ||
* | ||
* Returns true if argument valid, false otherwise | ||
*/ | ||
int | ||
xmlIsExtender(unsigned int ch) { | ||
return(xmlIsExtenderQ(ch)); | ||
} | ||
|
||
|
||
/** | ||
* xmlIsIdeographic: | ||
* @ch: character to validate | ||
* | ||
* This function is DEPRECATED. | ||
* Use xmlIsIdeographicQ instead | ||
* | ||
* Returns true if argument valid, false otherwise | ||
*/ | ||
int | ||
xmlIsIdeographic(unsigned int ch) { | ||
return(xmlIsIdeographicQ(ch)); | ||
} | ||
|
||
|
||
/** | ||
* xmlIsPubidChar: | ||
* @ch: character to validate | ||
* | ||
* This function is DEPRECATED. | ||
* Use xmlIsPubidChar_ch or xmlIsPubidCharQ instead | ||
* | ||
* Returns true if argument valid, false otherwise | ||
*/ | ||
int | ||
xmlIsPubidChar(unsigned int ch) { | ||
return(xmlIsPubidCharQ(ch)); | ||
} | ||
|
||
#define bottom_chvalid | ||
#include "elfgcchack.h" |