diff --git a/lib/libiconv/include/iconv.h b/lib/libiconv/include/iconv.h new file mode 100755 --- /dev/null +++ b/lib/libiconv/include/iconv.h @@ -0,0 +1,234 @@ +/* Copyright (C) 1999-2003, 2005-2006, 2008-2009 Free Software Foundation, Inc. + This file is part of the GNU LIBICONV Library. + + The GNU LIBICONV Library is free software; you can redistribute it + and/or modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either version 2 + of the License, or (at your option) any later version. + + The GNU LIBICONV Library is distributed in the hope that it will be + useful, but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with the GNU LIBICONV Library; see the file COPYING.LIB. + If not, write to the Free Software Foundation, Inc., 51 Franklin Street, + Fifth Floor, Boston, MA 02110-1301, USA. */ + +/* When installed, this file is called "iconv.h". */ + +#ifndef _LIBICONV_H +#define _LIBICONV_H + +#define _LIBICONV_VERSION 0x010D /* version number: (major<<8) + minor */ +extern __declspec (dllimport) int _libiconv_version; /* Likewise */ + +/* We would like to #include any system header file which could define + iconv_t, 1. in order to eliminate the risk that the user gets compilation + errors because some other system header file includes /usr/include/iconv.h + which defines iconv_t or declares iconv after this file, 2. when compiling + for LIBICONV_PLUG, we need the proper iconv_t type in order to produce + binary compatible code. + But gcc's #include_next is not portable. Thus, once libiconv's iconv.h + has been installed in /usr/local/include, there is no way any more to + include the original /usr/include/iconv.h. We simply have to get away + without it. + Ad 1. The risk that a system header file does + #include "iconv.h" or #include_next "iconv.h" + is small. They all do #include . + Ad 2. The iconv_t type is a pointer type in all cases I have seen. (It + has to be a scalar type because (iconv_t)(-1) is a possible return value + from iconv_open().) */ + +/* Define iconv_t ourselves. */ +#undef iconv_t +#define iconv_t libiconv_t +typedef void* iconv_t; + +/* Get size_t declaration. + Get wchar_t declaration if it exists. */ +#include + +/* Get errno declaration and values. */ +#include +/* Some systems, like SunOS 4, don't have EILSEQ. Some systems, like BSD/OS, + have EILSEQ in a different header. On these systems, define EILSEQ + ourselves. */ +#ifndef EILSEQ +#define EILSEQ +#endif + + +#ifdef __cplusplus +extern "C" { +#endif + + +/* Allocates descriptor for code conversion from encoding ‘fromcode’ to + encoding ‘tocode’. */ +#ifndef LIBICONV_PLUG +#define iconv_open libiconv_open +#endif +extern iconv_t iconv_open (const char* tocode, const char* fromcode); + +/* Converts, using conversion descriptor ‘cd’, at most ‘*inbytesleft’ bytes + starting at ‘*inbuf’, writing at most ‘*outbytesleft’ bytes starting at + ‘*outbuf’. + Decrements ‘*inbytesleft’ and increments ‘*inbuf’ by the same amount. + Decrements ‘*outbytesleft’ and increments ‘*outbuf’ by the same amount. */ +#ifndef LIBICONV_PLUG +#define iconv libiconv +#endif +extern size_t iconv (iconv_t cd, const char* * inbuf, size_t *inbytesleft, char* * outbuf, size_t *outbytesleft); + +/* Frees resources allocated for conversion descriptor ‘cd’. */ +#ifndef LIBICONV_PLUG +#define iconv_close libiconv_close +#endif +extern int iconv_close (iconv_t cd); + + +#ifndef LIBICONV_PLUG + +/* Nonstandard extensions. */ + +#if 1 +#if 0 +/* Tru64 with Desktop Toolkit C has a bug: must be included before + . + BSD/OS 4.0.1 has a bug: , and must be + included before . */ +#include +#include +#include +#endif +#include +#endif + +/* A type that holds all memory needed by a conversion descriptor. + A pointer to such an object can be used as an iconv_t. */ +typedef struct { + void* dummy1[28]; +#if 1 + mbstate_t dummy2; +#endif +} iconv_allocation_t; + +/* Allocates descriptor for code conversion from encoding ‘fromcode’ to + encoding ‘tocode’ into preallocated memory. Returns an error indicator + (0 or -1 with errno set). */ +#define iconv_open_into libiconv_open_into +extern int iconv_open_into (const char* tocode, const char* fromcode, + iconv_allocation_t* resultp); + +/* Control of attributes. */ +#define iconvctl libiconvctl +extern int iconvctl (iconv_t cd, int request, void* argument); + +/* Hook performed after every successful conversion of a Unicode character. */ +typedef void (*iconv_unicode_char_hook) (unsigned int uc, void* data); +/* Hook performed after every successful conversion of a wide character. */ +typedef void (*iconv_wide_char_hook) (wchar_t wc, void* data); +/* Set of hooks. */ +struct iconv_hooks { + iconv_unicode_char_hook uc_hook; + iconv_wide_char_hook wc_hook; + void* data; +}; + +/* Fallback function. Invoked when a small number of bytes could not be + converted to a Unicode character. This function should process all + bytes from inbuf and may produce replacement Unicode characters by calling + the write_replacement callback repeatedly. */ +typedef void (*iconv_unicode_mb_to_uc_fallback) + (const char* inbuf, size_t inbufsize, + void (*write_replacement) (const unsigned int *buf, size_t buflen, + void* callback_arg), + void* callback_arg, + void* data); +/* Fallback function. Invoked when a Unicode character could not be converted + to the target encoding. This function should process the character and + may produce replacement bytes (in the target encoding) by calling the + write_replacement callback repeatedly. */ +typedef void (*iconv_unicode_uc_to_mb_fallback) + (unsigned int code, + void (*write_replacement) (const char *buf, size_t buflen, + void* callback_arg), + void* callback_arg, + void* data); +#if 1 +/* Fallback function. Invoked when a number of bytes could not be converted to + a wide character. This function should process all bytes from inbuf and may + produce replacement wide characters by calling the write_replacement + callback repeatedly. */ +typedef void (*iconv_wchar_mb_to_wc_fallback) + (const char* inbuf, size_t inbufsize, + void (*write_replacement) (const wchar_t *buf, size_t buflen, + void* callback_arg), + void* callback_arg, + void* data); +/* Fallback function. Invoked when a wide character could not be converted to + the target encoding. This function should process the character and may + produce replacement bytes (in the target encoding) by calling the + write_replacement callback repeatedly. */ +typedef void (*iconv_wchar_wc_to_mb_fallback) + (wchar_t code, + void (*write_replacement) (const char *buf, size_t buflen, + void* callback_arg), + void* callback_arg, + void* data); +#else +/* If the wchar_t type does not exist, these two fallback functions are never + invoked. Their argument list therefore does not matter. */ +typedef void (*iconv_wchar_mb_to_wc_fallback) (); +typedef void (*iconv_wchar_wc_to_mb_fallback) (); +#endif +/* Set of fallbacks. */ +struct iconv_fallbacks { + iconv_unicode_mb_to_uc_fallback mb_to_uc_fallback; + iconv_unicode_uc_to_mb_fallback uc_to_mb_fallback; + iconv_wchar_mb_to_wc_fallback mb_to_wc_fallback; + iconv_wchar_wc_to_mb_fallback wc_to_mb_fallback; + void* data; +}; + +/* Requests for iconvctl. */ +#define ICONV_TRIVIALP 0 /* int *argument */ +#define ICONV_GET_TRANSLITERATE 1 /* int *argument */ +#define ICONV_SET_TRANSLITERATE 2 /* const int *argument */ +#define ICONV_GET_DISCARD_ILSEQ 3 /* int *argument */ +#define ICONV_SET_DISCARD_ILSEQ 4 /* const int *argument */ +#define ICONV_SET_HOOKS 5 /* const struct iconv_hooks *argument */ +#define ICONV_SET_FALLBACKS 6 /* const struct iconv_fallbacks *argument */ + +/* Listing of locale independent encodings. */ +#define iconvlist libiconvlist +extern void iconvlist (int (*do_one) (unsigned int namescount, + const char * const * names, + void* data), + void* data); + +/* Canonicalize an encoding name. + The result is either a canonical encoding name, or name itself. */ +extern const char * iconv_canonicalize (const char * name); + +/* Support for relocatable packages. */ + +/* Sets the original and the current installation prefix of the package. + Relocation simply replaces a pathname starting with the original prefix + by the corresponding pathname with the current prefix instead. Both + prefixes should be directory names without trailing slash (i.e. use "" + instead of "/"). */ +extern void libiconv_set_relocation_prefix (const char *orig_prefix, + const char *curr_prefix); + +#endif + + +#ifdef __cplusplus +} +#endif + + +#endif /* _LIBICONV_H */ diff --git a/lib/libiconv/include/libcharset.h b/lib/libiconv/include/libcharset.h new file mode 100755 --- /dev/null +++ b/lib/libiconv/include/libcharset.h @@ -0,0 +1,46 @@ +/* Copyright (C) 2003 Free Software Foundation, Inc. + This file is part of the GNU CHARSET Library. + + The GNU CHARSET Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + The GNU CHARSET Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public License + along with the GNU CHARSET Library; see the file COPYING.LIB. If not, + write to the Free Software Foundation, Inc., 51 Franklin Street, + Fifth Floor, Boston, MA 02110-1301, USA. */ + +#ifndef _LIBCHARSET_H +#define _LIBCHARSET_H + +#include + + +#ifdef __cplusplus +extern "C" { +#endif + + +/* Support for relocatable packages. */ + +/* Sets the original and the current installation prefix of the package. + Relocation simply replaces a pathname starting with the original prefix + by the corresponding pathname with the current prefix instead. Both + prefixes should be directory names without trailing slash (i.e. use "" + instead of "/"). */ +extern void libcharset_set_relocation_prefix (const char *orig_prefix, + const char *curr_prefix); + + +#ifdef __cplusplus +} +#endif + + +#endif /* _LIBCHARSET_H */ diff --git a/lib/libiconv/include/localcharset.h b/lib/libiconv/include/localcharset.h new file mode 100755 --- /dev/null +++ b/lib/libiconv/include/localcharset.h @@ -0,0 +1,42 @@ +/* Determine a canonical name for the current locale's character encoding. + Copyright (C) 2000-2003 Free Software Foundation, Inc. + This file is part of the GNU CHARSET Library. + + This program is free software; you can redistribute it and/or modify it + under the terms of the GNU Library General Public License as published + by the Free Software Foundation; either version 2, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, + USA. */ + +#ifndef _LOCALCHARSET_H +#define _LOCALCHARSET_H + + +#ifdef __cplusplus +extern "C" { +#endif + + +/* Determine the current locale's character encoding, and canonicalize it + into one of the canonical names listed in config.charset. + The result must not be freed; it is statically allocated. + If the canonical name cannot be determined, the result is a non-canonical + name. */ +extern const char * locale_charset (void); + + +#ifdef __cplusplus +} +#endif + + +#endif /* _LOCALCHARSET_H */ diff --git a/lib/libiconv/lib/charset.alias b/lib/libiconv/lib/charset.alias new file mode 100755 --- /dev/null +++ b/lib/libiconv/lib/charset.alias @@ -0,0 +1,4 @@ +# This file contains a table of character encoding aliases, +# suitable for operating system 'mingw32'. +# It was automatically generated from config.charset. +# Packages using this file: diff --git a/lib/libiconv/lib/libcharset.la b/lib/libiconv/lib/libcharset.la new file mode 100755 --- /dev/null +++ b/lib/libiconv/lib/libcharset.la @@ -0,0 +1,41 @@ +# libcharset.la - a libtool library file +# Generated by ltmain.sh (GNU libtool) 2.2.6 +# +# Please DO NOT delete this file! +# It is necessary for linking the library. + +# The name that we can dlopen(3). +dlname='../bin/libcharset-1.dll' + +# Names of this library. +library_names='libcharset.dll.a' + +# The name of the static archive. +old_library='libcharset.a' + +# Linker flags that can not go in dependency_libs. +inherited_linker_flags='' + +# Libraries that this one depends upon. +dependency_libs='' + +# Names of additional weak libraries provided by this library +weak_library_names='' + +# Version information for libcharset. +current=1 +age=0 +revision=0 + +# Is this an already installed library? +installed=yes + +# Should we warn about portability when linking against -modules? +shouldnotlink=no + +# Files to dlopen/dlpreopen +dlopen='' +dlpreopen='' + +# Directory that this library needs to be installed in: +libdir='c:/mingw/lib' diff --git a/lib/libiconv/lib/libiconv.la b/lib/libiconv/lib/libiconv.la new file mode 100755 --- /dev/null +++ b/lib/libiconv/lib/libiconv.la @@ -0,0 +1,41 @@ +# libiconv.la - a libtool library file +# Generated by ltmain.sh (GNU libtool) 2.2.6 +# +# Please DO NOT delete this file! +# It is necessary for linking the library. + +# The name that we can dlopen(3). +dlname='../bin/libiconv-2.dll' + +# Names of this library. +library_names='libiconv.dll.a' + +# The name of the static archive. +old_library='' + +# Linker flags that can not go in dependency_libs. +inherited_linker_flags='' + +# Libraries that this one depends upon. +dependency_libs='' + +# Names of additional weak libraries provided by this library +weak_library_names='' + +# Version information for libiconv. +current=7 +age=5 +revision=0 + +# Is this an already installed library? +installed=yes + +# Should we warn about portability when linking against -modules? +shouldnotlink=no + +# Files to dlopen/dlpreopen +dlopen='' +dlpreopen='' + +# Directory that this library needs to be installed in: +libdir='c:/mingw/lib' diff --git a/lib/libiconv/share/doc/libiconv/COPYING b/lib/libiconv/share/doc/libiconv/COPYING new file mode 100755 --- /dev/null +++ b/lib/libiconv/share/doc/libiconv/COPYING @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. diff --git a/lib/libiconv/share/doc/libiconv/COPYING.LIB b/lib/libiconv/share/doc/libiconv/COPYING.LIB new file mode 100755 --- /dev/null +++ b/lib/libiconv/share/doc/libiconv/COPYING.LIB @@ -0,0 +1,482 @@ + GNU LIBRARY GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1991 Free Software Foundation, Inc. + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + +[This is the first released version of the library GPL. It is + numbered 2 because it goes with version 2 of the ordinary GPL.] + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +Licenses are intended to guarantee your freedom to share and change +free software--to make sure the software is free for all its users. + + This license, the Library General Public License, applies to some +specially designated Free Software Foundation software, and to any +other libraries whose authors decide to use it. You can use it for +your libraries, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if +you distribute copies of the library, or if you modify it. + + For example, if you distribute copies of the library, whether gratis +or for a fee, you must give the recipients all the rights that we gave +you. You must make sure that they, too, receive or can get the source +code. If you link a program with the library, you must provide +complete object files to the recipients so that they can relink them +with the library, after making changes to the library and recompiling +it. And you must show them these terms so they know their rights. + + Our method of protecting your rights has two steps: (1) copyright +the library, and (2) offer you this license which gives you legal +permission to copy, distribute and/or modify the library. + + Also, for each distributor's protection, we want to make certain +that everyone understands that there is no warranty for this free +library. If the library is modified by someone else and passed on, we +want its recipients to know that what they have is not the original +version, so that any problems introduced by others will not reflect on +the original authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that companies distributing free +software will individually obtain patent licenses, thus in effect +transforming the program into proprietary software. To prevent this, +we have made it clear that any patent must be licensed for everyone's +free use or not licensed at all. + + Most GNU software, including some libraries, is covered by the ordinary +GNU General Public License, which was designed for utility programs. This +license, the GNU Library General Public License, applies to certain +designated libraries. This license is quite different from the ordinary +one; be sure to read it in full, and don't assume that anything in it is +the same as in the ordinary license. + + The reason we have a separate public license for some libraries is that +they blur the distinction we usually make between modifying or adding to a +program and simply using it. Linking a program with a library, without +changing the library, is in some sense simply using the library, and is +analogous to running a utility program or application program. However, in +a textual and legal sense, the linked executable is a combined work, a +derivative of the original library, and the ordinary General Public License +treats it as such. + + Because of this blurred distinction, using the ordinary General +Public License for libraries did not effectively promote software +sharing, because most developers did not use the libraries. We +concluded that weaker conditions might promote sharing better. + + However, unrestricted linking of non-free programs would deprive the +users of those programs of all benefit from the free status of the +libraries themselves. This Library General Public License is intended to +permit developers of non-free programs to use free libraries, while +preserving your freedom as a user of such programs to change the free +libraries that are incorporated in them. (We have not seen how to achieve +this as regards changes in header files, but we have achieved it as regards +changes in the actual functions of the Library.) The hope is that this +will lead to faster development of free libraries. + + The precise terms and conditions for copying, distribution and +modification follow. Pay close attention to the difference between a +"work based on the library" and a "work that uses the library". The +former contains code derived from the library, while the latter only +works together with the library. + + Note that it is possible for a library to be covered by the ordinary +General Public License rather than by this special one. + + GNU LIBRARY GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any software library which +contains a notice placed by the copyright holder or other authorized +party saying it may be distributed under the terms of this Library +General Public License (also called "this License"). Each licensee is +addressed as "you". + + A "library" means a collection of software functions and/or data +prepared so as to be conveniently linked with application programs +(which use some of those functions and data) to form executables. + + The "Library", below, refers to any such software library or work +which has been distributed under these terms. A "work based on the +Library" means either the Library or any derivative work under +copyright law: that is to say, a work containing the Library or a +portion of it, either verbatim or with modifications and/or translated +straightforwardly into another language. (Hereinafter, translation is +included without limitation in the term "modification".) + + "Source code" for a work means the preferred form of the work for +making modifications to it. For a library, complete source code means +all the source code for all modules it contains, plus any associated +interface definition files, plus the scripts used to control compilation +and installation of the library. + + Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running a program using the Library is not restricted, and output from +such a program is covered only if its contents constitute a work based +on the Library (independent of the use of the Library in a tool for +writing it). Whether that is true depends on what the Library does +and what the program that uses the Library does. + + 1. You may copy and distribute verbatim copies of the Library's +complete source code as you receive it, in any medium, provided that +you conspicuously and appropriately publish on each copy an +appropriate copyright notice and disclaimer of warranty; keep intact +all the notices that refer to this License and to the absence of any +warranty; and distribute a copy of this License along with the +Library. + + You may charge a fee for the physical act of transferring a copy, +and you may at your option offer warranty protection in exchange for a +fee. + + 2. You may modify your copy or copies of the Library or any portion +of it, thus forming a work based on the Library, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) The modified work must itself be a software library. + + b) You must cause the files modified to carry prominent notices + stating that you changed the files and the date of any change. + + c) You must cause the whole of the work to be licensed at no + charge to all third parties under the terms of this License. + + d) If a facility in the modified Library refers to a function or a + table of data to be supplied by an application program that uses + the facility, other than as an argument passed when the facility + is invoked, then you must make a good faith effort to ensure that, + in the event an application does not supply such function or + table, the facility still operates, and performs whatever part of + its purpose remains meaningful. + + (For example, a function in a library to compute square roots has + a purpose that is entirely well-defined independent of the + application. Therefore, Subsection 2d requires that any + application-supplied function or table used by this function must + be optional: if the application does not supply it, the square + root function must still compute square roots.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Library, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Library, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote +it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Library. + +In addition, mere aggregation of another work not based on the Library +with the Library (or with a work based on the Library) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may opt to apply the terms of the ordinary GNU General Public +License instead of this License to a given copy of the Library. To do +this, you must alter all the notices that refer to this License, so +that they refer to the ordinary GNU General Public License, version 2, +instead of to this License. (If a newer version than version 2 of the +ordinary GNU General Public License has appeared, then you can specify +that version instead if you wish.) Do not make any other change in +these notices. + + Once this change is made in a given copy, it is irreversible for +that copy, so the ordinary GNU General Public License applies to all +subsequent copies and derivative works made from that copy. + + This option is useful when you wish to copy part of the code of +the Library into a program that is not a library. + + 4. You may copy and distribute the Library (or a portion or +derivative of it, under Section 2) in object code or executable form +under the terms of Sections 1 and 2 above provided that you accompany +it with the complete corresponding machine-readable source code, which +must be distributed under the terms of Sections 1 and 2 above on a +medium customarily used for software interchange. + + If distribution of object code is made by offering access to copy +from a designated place, then offering equivalent access to copy the +source code from the same place satisfies the requirement to +distribute the source code, even though third parties are not +compelled to copy the source along with the object code. + + 5. A program that contains no derivative of any portion of the +Library, but is designed to work with the Library by being compiled or +linked with it, is called a "work that uses the Library". Such a +work, in isolation, is not a derivative work of the Library, and +therefore falls outside the scope of this License. + + However, linking a "work that uses the Library" with the Library +creates an executable that is a derivative of the Library (because it +contains portions of the Library), rather than a "work that uses the +library". The executable is therefore covered by this License. +Section 6 states terms for distribution of such executables. + + When a "work that uses the Library" uses material from a header file +that is part of the Library, the object code for the work may be a +derivative work of the Library even though the source code is not. +Whether this is true is especially significant if the work can be +linked without the Library, or if the work is itself a library. The +threshold for this to be true is not precisely defined by law. + + If such an object file uses only numerical parameters, data +structure layouts and accessors, and small macros and small inline +functions (ten lines or less in length), then the use of the object +file is unrestricted, regardless of whether it is legally a derivative +work. (Executables containing this object code plus portions of the +Library will still fall under Section 6.) + + Otherwise, if the work is a derivative of the Library, you may +distribute the object code for the work under the terms of Section 6. +Any executables containing that work also fall under Section 6, +whether or not they are linked directly with the Library itself. + + 6. As an exception to the Sections above, you may also compile or +link a "work that uses the Library" with the Library to produce a +work containing portions of the Library, and distribute that work +under terms of your choice, provided that the terms permit +modification of the work for the customer's own use and reverse +engineering for debugging such modifications. + + You must give prominent notice with each copy of the work that the +Library is used in it and that the Library and its use are covered by +this License. You must supply a copy of this License. If the work +during execution displays copyright notices, you must include the +copyright notice for the Library among them, as well as a reference +directing the user to the copy of this License. Also, you must do one +of these things: + + a) Accompany the work with the complete corresponding + machine-readable source code for the Library including whatever + changes were used in the work (which must be distributed under + Sections 1 and 2 above); and, if the work is an executable linked + with the Library, with the complete machine-readable "work that + uses the Library", as object code and/or source code, so that the + user can modify the Library and then relink to produce a modified + executable containing the modified Library. (It is understood + that the user who changes the contents of definitions files in the + Library will not necessarily be able to recompile the application + to use the modified definitions.) + + b) Accompany the work with a written offer, valid for at + least three years, to give the same user the materials + specified in Subsection 6a, above, for a charge no more + than the cost of performing this distribution. + + c) If distribution of the work is made by offering access to copy + from a designated place, offer equivalent access to copy the above + specified materials from the same place. + + d) Verify that the user has already received a copy of these + materials or that you have already sent this user a copy. + + For an executable, the required form of the "work that uses the +Library" must include any data and utility programs needed for +reproducing the executable from it. However, as a special exception, +the source code distributed need not include anything that is normally +distributed (in either source or binary form) with the major +components (compiler, kernel, and so on) of the operating system on +which the executable runs, unless that component itself accompanies +the executable. + + It may happen that this requirement contradicts the license +restrictions of other proprietary libraries that do not normally +accompany the operating system. Such a contradiction means you cannot +use both them and the Library together in an executable that you +distribute. + + 7. You may place library facilities that are a work based on the +Library side-by-side in a single library together with other library +facilities not covered by this License, and distribute such a combined +library, provided that the separate distribution of the work based on +the Library and of the other library facilities is otherwise +permitted, and provided that you do these two things: + + a) Accompany the combined library with a copy of the same work + based on the Library, uncombined with any other library + facilities. This must be distributed under the terms of the + Sections above. + + b) Give prominent notice with the combined library of the fact + that part of it is a work based on the Library, and explaining + where to find the accompanying uncombined form of the same work. + + 8. You may not copy, modify, sublicense, link with, or distribute +the Library except as expressly provided under this License. Any +attempt otherwise to copy, modify, sublicense, link with, or +distribute the Library is void, and will automatically terminate your +rights under this License. However, parties who have received copies, +or rights, from you under this License will not have their licenses +terminated so long as such parties remain in full compliance. + + 9. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Library or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Library (or any work based on the +Library), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Library or works based on it. + + 10. Each time you redistribute the Library (or any work based on the +Library), the recipient automatically receives a license from the +original licensor to copy, distribute, link with or modify the Library +subject to these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 11. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Library at all. For example, if a patent +license would not permit royalty-free redistribution of the Library by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Library. + +If any portion of this section is held invalid or unenforceable under any +particular circumstance, the balance of the section is intended to apply, +and the section as a whole is intended to apply in other circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 12. If the distribution and/or use of the Library is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Library under this License may add +an explicit geographical distribution limitation excluding those countries, +so that distribution is permitted only in or among countries not thus +excluded. In such case, this License incorporates the limitation as if +written in the body of this License. + + 13. The Free Software Foundation may publish revised and/or new +versions of the Library General Public License from time to time. +Such new versions will be similar in spirit to the present version, +but may differ in detail to address new problems or concerns. + +Each version is given a distinguishing version number. If the Library +specifies a version number of this License which applies to it and +"any later version", you have the option of following the terms and +conditions either of that version or of any later version published by +the Free Software Foundation. If the Library does not specify a +license version number, you may choose any version ever published by +the Free Software Foundation. + + 14. If you wish to incorporate parts of the Library into other free +programs whose distribution conditions are incompatible with these, +write to the author to ask for permission. For software which is +copyrighted by the Free Software Foundation, write to the Free +Software Foundation; we sometimes make exceptions for this. Our +decision will be guided by the two goals of preserving the free status +of all derivatives of our free software and of promoting the sharing +and reuse of software generally. + + NO WARRANTY + + 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO +WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR +OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY +KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE +LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME +THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN +WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY +AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU +FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR +CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE +LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING +RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A +FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF +SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGES. + + END OF TERMS AND CONDITIONS + + Appendix: How to Apply These Terms to Your New Libraries + + If you develop a new library, and you want it to be of the greatest +possible use to the public, we recommend making it free software that +everyone can redistribute and change. You can do so by permitting +redistribution under these terms (or, alternatively, under the terms of the +ordinary General Public License). + + To apply these terms, attach the following notices to the library. It is +safest to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least the +"copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free + Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, + MA 02110-1301, USA + +Also add information on how to contact you by electronic and paper mail. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the library, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the + library `Frob' (a library for tweaking knobs) written by James Random Hacker. + + , 1 April 1990 + Ty Coon, President of Vice + +That's all there is to it! diff --git a/lib/libiconv/share/doc/libiconv/NEWS b/lib/libiconv/share/doc/libiconv/NEWS new file mode 100755 --- /dev/null +++ b/lib/libiconv/share/doc/libiconv/NEWS @@ -0,0 +1,172 @@ +New in 1.13: +* The library and the iconv program now understand platform dependent aliases, + for better compatibility with the platform's own iconv_open function. + Examples: "646" on Solaris, "iso88591" on HP-UX, "IBM-1252" on AIX. +* For stateful encodings, when the input ends with a shift sequence followed + by invalid input, the iconv function now increments the input pointer past + the shift sequence before returning (size_t)(-1) with errno = EILSEQ. This + is also like GNU libc's iconv() behaves. +* The library exports a new function iconv_open_into() that stores the + conversion descriptor in pre-allocated memory, rather than allocating fresh + memory for it. +* Added CP1131 converter. + +New in 1.12: +* The iconv program is now licensed under the GPL version 3, instead of the + GPL version 2. The libiconv library continues to be licensed under LGPL. +* Added RK1048 converter. +* On AIX, an existing system libiconv no longer causes setlocale() to fail. +* Upgraded EUC-KR, JOHAB to include the Korean postal code sign. + +New in 1.11: +* The iconv program has new options --unicode-subst, --byte-subst, + --widechar-subst that allow to specify substitutions for characters that + cannot be converted. +* The iconv program now understands long options: + long option equivalent to + --from-code -f + --to-code -t + --list -l + --silent -s +* The CP936 converter is now different from the GBK converter: it has changed + to include the Euro sign and private area characters. CP936 is no longer an + alias of GBK. +* Updated GB18030 converter to include all private area characters. +* Updated CP950 converter to include the Euro sign and private area characters. +* Updated CP949 converter to include private area characters. +* Updated the BIG5-HKSCS converter. The old BIG5-HKSCS converter is renamed to + BIG5-HKSCS:1999 and updated to Unicode 4. New converters BIG5-HKSCS:2001 and + BIG5-HKSCS:2004 are added. BIG5-HKSCS is now an alias for BIG5-HKSCS:2004. +* Added a few irreversible mappings to the CP932 converter. +* Tidy up the list of symbols exported from libiconv (assumes gcc >= 4.0). + +New in 1.10: +* Added ISO-8859-11 converter. +* Updated the ISO-8859-7 converter. +* Added ATARIST converter, available through --enable-extra-encodings. +* Added BIG5-2003 converter (experimental), available through + --enable-extra-encodings. +* Updated EUC-TW converter to include the Euro sign. +* The preloadable library has been renamed from libiconv_plug.so to + preloadable_libiconv.so. +* Portability to mingw. + +New in 1.9: +* Many more transliterations. +* New configuration option --enable-relocatable. See the INSTALL.generic file + for details. + +New in 1.8: +* The iconv program has new options -l, -c, -s. +* The iconv program is internationalized. +* Added C99 converter. +* Added KOI8-T converter. +* New configuration option --enable-extra-encodings that enables a bunch of + additional encodings; see the README for details. +* Updated the ISO-8859-16 converter. +* Upgraded BIG5-HKSCS, EUC-TW, ISO-2022-CN, ISO-2022-CN-EXT converters to + Unicode 3.2. +* Upgraded EUC-KR, CP949, JOHAB converters to include the Euro sign. +* Changed the ARMSCII-8 converter. +* Extended the EUC-JP encoder so that YEN SIGN characters don't cause failures + in Shift_JIS to EUC-JP conversion. +* The JAVA converter now handles characters outside the Unicode BMP correctly. +* Fixed a bug in the CP1255, CP1258, TCVN decoders: The base characters of + combining characters could be dropped at the end of the conversion buffer. +* Fixed a bug in the transliteration that could lead to excessive memory + allocations in libintl when transliteration was needed. +* Portability to BSD/OS and SCO 3.2.5. + +New in 1.7: +* Added UTF-32, UTF-32BE, UTF-32LE converters. +* Changed CP1255, CP1258 and TCVN converters to handle combining characters. +* Changed EUC-JP, SHIFT_JIS, CP932, ISO-2022-JP, ISO-2022-JP-2, ISO-2022-JP-1 + converters to use fullwidth Yen sign instead of halfwidth Yen sign, and + fullwidth tilde instead of halfwidth tilde. +* Upgraded EUC-TW, ISO-2022-CN, ISO-2022-CN-EXT converters to Unicode 3.1. +* Changed the GB18030 converter to not reject unassigned and private-use + Unicode characters. +* Fixed a bug in the byte order mark treatment of the UCS-4 decoder. +* The manual pages are now distributed also in HTML format. + +New in 1.6: +* The iconv program's -f and -t options are now optional. +* Many more transliterations. +* Added CP862 converter. +* Changed the GB18030 converter. +* Portability to DOS with DJGPP. + +New in 1.5: +* Added an iconv(1) program. +* New locale dependent encodings "char", "wchar_t". +* Transliteration is now off by default. Use a //TRANSLIT suffix to enable it. +* The JOHAB encoding is documented again. +* Changed a few mappings in the CP950 converter. + +New in 1.4: +* Added GB18030, BIG5HKSCS converters. +* Portability to OS/2 with emx+gcc. + +New in 1.3: +* Added UCS-2BE, UCS-2LE, UCS-4BE, UCS-4LE converters. +* Fixed the definition of EILSEQ on SunOS4. +* Fixed a build problem on OSF/1. +* Support for building as a shared library on Woe32. + +New in 1.2: +* Added UTF-16BE and UTF-16LE converters. +* Changed the UTF-16 encoder. +* Fixed the treatment of tab characters in the UTF-7 converter. +* Fixed an internal error when output buffer was not large enough. + +New in 1.1: +* Added ISO-8859-16 converter. +* Added CP932 converter, a variant of SHIFT_JIS. +* Added CP949 converter, a variant of EUC-KR. +* Improved the ISO-2022-CN-EXT converter: It now covers the ISO-IR-165 range. +* Updated the ISO-8859-8 conversion table. +* The JOHAB encoding is deprecated and not documented any more. +* Fixed two build problems: 1. "make -n check" failed. 2. When libiconv was + already installed, "make" failed. + +New in 1.0: +* Added transliteration facilities. +* Added a test suite. +* Fixed the iconv(3) manual page and function: the return value was not + described correctly. +* Fixed a bug in the CP1258 decoder: invalid bytes now yield EILSEQ instead of + U+FFFD. +* Fixed a bug in the Georgian-PS encoder: accept U+00E6. +* Fixed a bug in the EUC-JP encoder: reject 0x8E5C and 0x8E7E. +* Fixed a bug in the KSC5601 and JOHAB converters: they recognized some Hangul + characters at some invalid code positions. +* Fixed a bug in the EUC-TW decoder; it was severely broken. +* Fixed a bug in the CP950 converter: it recognized a dubious BIG5 range. + +New in 0.3: +* Reduced the size of the tables needed for the JOHAB converter. +* Portability to Woe32. + +New in 0.2: +* Added KOI8-RU, CP850, CP866, CP874, CP950, ISO-2022-CN-EXT, GBK and + ISO-2022-JP-1 converters. +* Added MACINTOSH as an alias for MAC-ROMAN. +* Added ASMO-708 as an alias for ISO-8859-6. +* Added ELOT_928 as an alias for ISO-8859-7. +* Improved the EUC-TW converter: Treat CNS 11643 plane 3. +* Improved the ISO-2022-KR and EUC-KR converters: Hangul characters are + decomposed into Jamo when needed. +* Improved the CP932 converter. +* Updated the CP1133, MULELAO-1 and ARMSCII-8 mappings. +* The EUC-JP and SHIFT_JIS converters now cover the user-defined range. +* Fixed a possible buffer overrun in the JOHAB converter. +* Fixed a bug in the UTF-7, ISO-2022-*, HZ decoders: a shift sequence a the + end of the input no longer gives an error. +* The HZ encoder now always terminates its output in the ASCII state. +* Use a perfect hash table for looking up the aliases. + +New in 0.1: +* Portability to Linux/glibc-2.0.x, Linux/libc5, OSF/1, FreeBSD. +* Fixed a bug in the EUC-JP decoder. Extended the ISO-2022-JP-2 converter. +* Made TIS-620 mapping consistent with glibc-2.1. + diff --git a/lib/libiconv/share/doc/libiconv/NOTES b/lib/libiconv/share/doc/libiconv/NOTES new file mode 100755 --- /dev/null +++ b/lib/libiconv/share/doc/libiconv/NOTES @@ -0,0 +1,399 @@ +Q: Why does libiconv support encoding XXX? Why does libiconv not support + encoding ZZZ? + +A: libiconv, as an internationalization library, supports those character + sets and encodings which are in wide-spread use in at least one territory + of the world. + + Hint1: On http://www.w3c.org/International/O-charset-lang.html you find a + page "Languages, countries, and the charsets typically used for them". + From this table, we can conclude that the following are in active use: + + ISO-8859-1, CP1252 Afrikaans, Albanian, Basque, Catalan, Danish, Dutch, + English, Faroese, Finnish, French, Galician, German, + Icelandic, Irish, Italian, Norwegian, Portuguese, + Scottish, Spanish, Swedish + ISO-8859-2 Croatian, Czech, Hungarian, Polish, Romanian, Slovak, + Slovenian + ISO-8859-3 Esperanto, Maltese + ISO-8859-5 Bulgarian, Byelorussian, Macedonian, Russian, + Serbian, Ukrainian + ISO-8859-6 Arabic + ISO-8859-7 Greek + ISO-8859-8 Hebrew + ISO-8859-9, CP1254 Turkish + ISO-8859-10 Inuit, Lapp + ISO-8859-13 Latvian, Lithuanian + ISO-8859-15 Estonian + KOI8-R Russian + SHIFT_JIS Japanese + ISO-2022-JP Japanese + EUC-JP Japanese + + Ordered by frequency on the web (1997): + ISO-8859-1, CP1252 96% + SHIFT_JIS 1.6% + ISO-2022-JP 1.2% + EUC-JP 0.4% + CP1250 0.3% + CP1251 0.2% + CP850 0.1% + MACINTOSH 0.1% + ISO-8859-5 0.1% + ISO-8859-2 0.0% + + Hint2: The character sets mentioned in the XFree86 4.0 locale.alias file. + + ISO-8859-1 Afrikaans, Basque, Breton, Catalan, Danish, Dutch, + English, Estonian, Faroese, Finnish, French, + Galician, German, Greenlandic, Icelandic, + Indonesian, Irish, Italian, Lithuanian, Norwegian, + Occitan, Portuguese, Scottish, Spanish, Swedish, + Walloon, Welsh + ISO-8859-2 Albanian, Croatian, Czech, Hungarian, Polish, + Romanian, Serbian, Slovak, Slovenian + ISO-8859-3 Esperanto + ISO-8859-4 Estonian, Latvian, Lithuanian + ISO-8859-5 Bulgarian, Byelorussian, Macedonian, Russian, + Serbian, Ukrainian + ISO-8859-6 Arabic + ISO-8859-7 Greek + ISO-8859-8 Hebrew + ISO-8859-9 Turkish + ISO-8859-14 Breton, Irish, Scottish, Welsh + ISO-8859-15 Basque, Breton, Catalan, Danish, Dutch, Estonian, + Faroese, Finnish, French, Galician, German, + Greenlandic, Icelandic, Irish, Italian, Lithuanian, + Norwegian, Occitan, Portuguese, Scottish, Spanish, + Swedish, Walloon, Welsh + KOI8-R Russian + KOI8-U Russian, Ukrainian + EUC-JP (alias eucJP) Japanese + ISO-2022-JP (alias JIS7) Japanese + SHIFT_JIS (alias SJIS) Japanese + U90 Japanese + S90 Japanese + EUC-CN (alias eucCN) Chinese + EUC-TW (alias eucTW) Chinese + BIG5 Chinese + EUC-KR (alias eucKR) Korean + ARMSCII-8 Armenian + GEORGIAN-ACADEMY Georgian + GEORGIAN-PS Georgian + TIS-620 (alias TACTIS) Thai + MULELAO-1 Laothian + IBM-CP1133 Laothian + VISCII Vietnamese + TCVN Vietnamese + NUNACOM-8 Inuktitut + + Hint3: The character sets supported by Netscape Communicator 4. + + Where is this documented? For the complete picture, I had to use + "strings netscape" and then a lot of guesswork. For a quick take, + look at the "View - Character set" menu of Netscape Communicator 4.6: + + ISO-8859-{1,2,5,7,9,15} + WINDOWS-{1250,1251,1253} + KOI8-R Cyrillic + CP866 Cyrillic + Autodetect Japanese (EUC-JP, ISO-2022-JP, ISO-2022-JP-2, SJIS) + EUC-JP Japanese + SHIFT_JIS Japanese + GB2312 Chinese + BIG5 Chinese + EUC-TW Chinese + Autodetect Korean (EUC-KR, ISO-2022-KR, but not JOHAB) + + UTF-8 + UTF-7 + + Hint4: The character sets supported by Microsoft Internet Explorer 4. + + ISO-8859-{1,2,3,4,5,6,7,8,9} + WINDOWS-{1250,1251,1252,1253,1254,1255,1256,1257} + KOI8-R Cyrillic + KOI8-RU Ukrainian + ASMO-708 Arabic + EUC-JP Japanese + ISO-2022-JP Japanese + SHIFT_JIS Japanese + GB2312 Chinese + HZ-GB-2312 Chinese + BIG5 Chinese + EUC-KR Korean + ISO-2022-KR Korean + WINDOWS-874 Thai + WINDOWS-1258 Vietnamese + + UTF-8 + UTF-7 + UNICODE actually UNICODE-LITTLE + UNICODEFEFF actually UNICODE-BIG + + and various DOS character sets: DOS-720, DOS-862, IBM852, CP866. + + We take the union of all these four sets. The result is: + + European and Semitic languages + * ASCII. + We implement this because it is occasionally useful to know or to + check whether some text is entirely ASCII (i.e. if the conversion + ISO-8859-x -> UTF-8 is trivial). + * ISO-8859-{1,2,3,4,5,6,7,8,9,10} + We implement this because they are widely used. Except ISO-8859-4 + which appears to have been superseded by ISO-8859-13 in the baltic + countries. But it's an ISO standard anyway. + * ISO-8859-13 + We implement this because it's a standard in Lithuania and Latvia. + * ISO-8859-14 + We implement this because it's an ISO standard. + * ISO-8859-15 + We implement this because it's increasingly used in Europe, because + of the Euro symbol. + * ISO-8859-16 + We implement this because it's an ISO standard. + * KOI8-R, KOI8-U + We implement this because it appears to be the predominant encoding + on Unix in Russia and Ukraine, respectively. + * KOI8-RU + We implement this because MSIE4 supports it. + * KOI8-T + We implement this because it is the locale encoding in glibc's Tajik + locale. + * PT154 + We implement this because it is the locale encoding in glibc's Kazakh + locale. + * RK1048 + We implement this because it's a standard in Kazakhstan. + * CP{1250,1251,1252,1253,1254,1255,1256,1257} + We implement these because they are the predominant Windows encodings + in Europe. + * CP850 + We implement this because it is mentioned as occurring in the web + in the aforementioned statistics. + * CP862 + We implement this because Ron Aaron says it is sometimes used in web + pages and emails. + * CP866 + We implement this because Netscape Communicator does. + * CP1131 + We implement this because it is the locale encoding of a Belorusian + locale in FreeBSD and MacOS X. + * Mac{Roman,CentralEurope,Croatian,Romania,Cyrillic,Greek,Turkish} and + Mac{Hebrew,Arabic} + We implement these because the Sun JDK does, and because Mac users + don't deserve to be punished. + * Macintosh + We implement this because it is mentioned as occurring in the web + in the aforementioned statistics. + Japanese + * EUC-JP, SHIFT_JIS, ISO-2022-JP + We implement these because they are widely used. EUC-JP and SHIFT_JIS + are more used for files, whereas ISO-2022-JP is recommended for email. + * CP932 + We implement this because it is the Microsoft variant of SHIFT_JIS, + used on Windows. + * ISO-2022-JP-2 + We implement this because it's the common way to represent mails which + make use of JIS X 0212 characters. + * ISO-2022-JP-1 + We implement this because it's in the RFCs, but I don't think it is + really used. + * U90, S90 + We DON'T implement this because I have no informations about what it + is or who uses it. + Simplified Chinese + * EUC-CN = GB2312 + We implement this because it is the widely used representation + of simplified Chinese. + * GBK + We implement this because it appears to be used on Solaris and Windows. + * GB18030 + We implement this because it is an official requirement in the + People's Republic of China. + * ISO-2022-CN + We implement this because it is in the RFCs, but I have no idea + whether it is really used. + * ISO-2022-CN-EXT + We implement this because it's in the RFCs, but I don't think it is + really used. + * HZ = HZ-GB-2312 + We implement this because the RFCs recommend it for Usenet postings, + and because MSIE4 supports it. + Traditional Chinese + * EUC-TW + We implement it because it appears to be used on Unix. + * BIG5 + We implement it because it is the de-facto standard for traditional + Chinese. + * CP950 + We implement this because it is the Microsoft variant of BIG5, used + on Windows. + * BIG5+ + We DON'T implement this because it doesn't appear to be in wide use. + Only the CWEX fonts use this encoding. Furthermore, the conversion + tables in the big5p package are not coherent: If you convert directly, + you get different results than when you convert via GBK. + * BIG5-HKSCS + We implement it because it is the de-facto standard for traditional + Chinese in Hongkong. + Korean + * EUC-KR + We implement these because they appear to be the widely used + representations for Korean. + * CP949 + We implement this because it is the Microsoft variant of EUC-KR, used + on Windows. + * ISO-2022-KR + We implement it because it is in the RFCs and because MSIE4 supports + it, but I have no idea whether it's really used. + * JOHAB + We implement this because it is apparently used on Windows as a locale + encoding (codepage 1361). + * ISO-646-KR + We DON'T implement this because although an old ASCII variant, its + glyph for 0x7E is not clear: RFC 1345 and unicode.org's JOHAB.TXT + say it's a tilde, but Ken Lunde's "CJKV information processing" says + it's an overline. And it is not ISO-IR registered. + Armenian + * ARMSCII-8 + We implement it because XFree86 supports it. + Georgian + * Georgian-Academy, Georgian-PS + We implement these because they appear to be both used for Georgian; + Xfree86 supports them. + Thai + * ISO-8859-11, TIS-620 + We implement these because it seems to be standard for Thai. + * CP874 + We implement this because MSIE4 supports it. + * MacThai + We implement this because the Sun JDK does, and because Mac users + don't deserve to be punished. + Laotian + * MuleLao-1, CP1133 + We implement these because XFree86 supports them. I have no idea which + one is used more widely. + Vietnamese + * VISCII, TCVN + We implement these because XFree86 supports them. + * CP1258 + We implement this because MSIE4 supports it. + Other languages + * NUNACOM-8 (Inuktitut) + We DON'T implement this because it isn't part of Unicode yet, and + therefore doesn't convert to anything except itself. + Platform specifics + * HP-ROMAN8, NEXTSTEP + We implement these because they were the native character set on HPs + and NeXTs for a long time, and libiconv is intended to be usable on + these old machines. + Full Unicode + * UTF-8, UCS-2, UCS-4 + We implement these. Obviously. + * UCS-2BE, UCS-2LE, UCS-4BE, UCS-4LE + We implement these because they are the preferred internal + representation of strings in Unicode aware applications. These are + non-ambiguous names, known to glibc. (glibc doesn't have + UCS-2-INTERNAL and UCS-4-INTERNAL.) + * UTF-16, UTF-16BE, UTF-16LE + We implement these, because UTF-16 is still the favourite encoding of + the president of the Unicode Consortium (for political reasons), and + because they appear in RFC 2781. + * UTF-32, UTF-32BE, UTF-32LE + We implement these because they are part of Unicode 3.1. + * UTF-7 + We implement this because it is essential functionality for mail + applications. + * C99 + We implement it because it's used for C and C++ programs and because + it's a nice encoding for debugging. + * JAVA + We implement it because it's used for Java programs and because it's + a nice encoding for debugging. + * UNICODE (big endian), UNICODEFEFF (little endian) + We DON'T implement these because they are stupid and not standardized. + Full Unicode, in terms of `uint16_t' or `uint32_t' + (with machine dependent endianness and alignment) + * UCS-2-INTERNAL, UCS-4-INTERNAL + We implement these because they are the preferred internal + representation of strings in Unicode aware applications. + +Q: Support encodings mentioned in RFC 1345 ? +A: No, they are not in use any more. Supporting ISO-646 variants is pointless + since ISO-8859-* have been adopted. + +Q: Support EBCDIC ? +A: No! + +Q: How do I add a new character set? +A: 1. Explain the "why" in this file, above. + 2. You need to have a conversion table from/to Unicode. Transform it into + the format used by the mapping tables found on ftp.unicode.org: each line + contains the character code, in hex, with 0x prefix, then whitespace, + then the Unicode code point, in hex, 4 hex digits, with 0x prefix. '#' + counts as a comment delimiter until end of line. + Please also send your table to Mark Leisher so he + can include it in his collection. + 3. If it's an 8-bit character set, use the '8bit_tab_to_h' program in the + tools directory to generate the C code for the conversion. You may tweak + the resulting C code if you are not satisfied with its quality, but this + is rarely needed. + If it's a two-dimensional character set (with rows and columns), use the + 'cjk_tab_to_h' program in the tools directory to generate the C code for + the conversion. You will need to modify the main() function to recognize + the new character set name, with the proper dimensions, but that shouldn't + be too hard. This yields the CCS. The CES you have to write by hand. + 4. Store the resulting C code file in the lib directory. Add a #include + directive to converters.h, and add an entry to the encodings.def file. + 5. Compile the package, and test your new encoding using a program like + iconv(1) or clisp(1). + 6. Augment the testsuite: Add a line to tests/Makefile.in. For a stateless + encoding, create the complete table as a TXT file. For a stateful encoding, + provide a text snippet encoded using your new encoding and its UTF-8 + equivalent. + 7. Update the README and man/iconv_open.3, to mention the new encoding. + Add a note in the NEWS file. + +Q: What about bidirectional text? Should it be tagged or reversed when + converting from ISO-8859-8 or ISO-8859-6 to Unicode? Qt appears to do + this, see qt-2.0.1/src/tools/qrtlcodec.cpp. +A: After reading RFC 1556: I don't think so. Support for ISO-8859-8-I and + ISO-8859-E remains to be implemented. + On the other hand, a page on www.w3c.org says that ISO-8859-8 in *email* + is visually encoded, ISO-8859-8 in *HTML* is logically encoded, i.e. + the same as ISO-8859-8-I. I'm confused. + +Other character sets not implemented: +"MNEMONIC" = "csMnemonic" +"MNEM" = "csMnem" +"ISO-10646-UCS-Basic" = "csUnicodeASCII" +"ISO-10646-Unicode-Latin1" = "csUnicodeLatin1" = "ISO-10646" +"ISO-10646-J-1" +"UNICODE-1-1" = "csUnicode11" +"csWindows31Latin5" + +Other aliases not implemented (and not implemented in glibc-2.1 either): + From MSIE4: + ISO-8859-1: alias ISO8859-1 + ISO-8859-2: alias ISO8859-2 + KSC_5601: alias KS_C_5601 + UTF-8: aliases UNICODE-1-1-UTF-8 UNICODE-2-0-UTF-8 + + +Q: How can I integrate libiconv into my package? +A: Just copy the entire libiconv package into a subdirectory of your package. + At configuration time, call libiconv's configure script with the + appropriate --srcdir option and maybe --enable-static or --disable-shared. + Then "cd libiconv && make && make install-lib libdir=... includedir=...". + 'install-lib' is a special (not GNU standardized) target which installs + only the include file - in $(includedir) - and the library - in $(libdir) - + and does not use other directory variables. After "installing" libiconv + in your package's build directory, building of your package can proceed. + +Q: Why is the testsuite so big? +A: Because some of the tests are very comprehensive. + If you don't feel like using the testsuite, you can simply remove the + tests/ directory. + diff --git a/lib/libxml2/include/libxml/DOCBparser.h b/lib/libxml2/include/libxml/DOCBparser.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/DOCBparser.h @@ -0,0 +1,96 @@ +/* + * Summary: old DocBook SGML parser + * Description: interface for a DocBook SGML non-verifying parser + * This code is DEPRECATED, and should not be used anymore. + * + * Copy: See Copyright for the status of this software. + * + * Author: Daniel Veillard + */ + +#ifndef __DOCB_PARSER_H__ +#define __DOCB_PARSER_H__ +#include + +#ifdef LIBXML_DOCB_ENABLED + +#include +#include + +#ifndef IN_LIBXML +#ifdef __GNUC__ +#warning "The DOCBparser module has been deprecated in libxml2-2.6.0" +#endif +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * Most of the back-end structures from XML and SGML are shared. + */ +typedef xmlParserCtxt docbParserCtxt; +typedef xmlParserCtxtPtr docbParserCtxtPtr; +typedef xmlSAXHandler docbSAXHandler; +typedef xmlSAXHandlerPtr docbSAXHandlerPtr; +typedef xmlParserInput docbParserInput; +typedef xmlParserInputPtr docbParserInputPtr; +typedef xmlDocPtr docbDocPtr; + +/* + * There is only few public functions. + */ +XMLPUBFUN int XMLCALL + docbEncodeEntities(unsigned char *out, + int *outlen, + const unsigned char *in, + int *inlen, int quoteChar); + +XMLPUBFUN docbDocPtr XMLCALL + docbSAXParseDoc (xmlChar *cur, + const char *encoding, + docbSAXHandlerPtr sax, + void *userData); +XMLPUBFUN docbDocPtr XMLCALL + docbParseDoc (xmlChar *cur, + const char *encoding); +XMLPUBFUN docbDocPtr XMLCALL + docbSAXParseFile (const char *filename, + const char *encoding, + docbSAXHandlerPtr sax, + void *userData); +XMLPUBFUN docbDocPtr XMLCALL + docbParseFile (const char *filename, + const char *encoding); + +/** + * Interfaces for the Push mode. + */ +XMLPUBFUN void XMLCALL + docbFreeParserCtxt (docbParserCtxtPtr ctxt); +XMLPUBFUN docbParserCtxtPtr XMLCALL + docbCreatePushParserCtxt(docbSAXHandlerPtr sax, + void *user_data, + const char *chunk, + int size, + const char *filename, + xmlCharEncoding enc); +XMLPUBFUN int XMLCALL + docbParseChunk (docbParserCtxtPtr ctxt, + const char *chunk, + int size, + int terminate); +XMLPUBFUN docbParserCtxtPtr XMLCALL + docbCreateFileParserCtxt(const char *filename, + const char *encoding); +XMLPUBFUN int XMLCALL + docbParseDocument (docbParserCtxtPtr ctxt); + +#ifdef __cplusplus +} +#endif + +#endif /* LIBXML_DOCB_ENABLED */ + +#endif /* __DOCB_PARSER_H__ */ diff --git a/lib/libxml2/include/libxml/HTMLparser.h b/lib/libxml2/include/libxml/HTMLparser.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/HTMLparser.h @@ -0,0 +1,304 @@ +/* + * Summary: interface for an HTML 4.0 non-verifying parser + * Description: this module implements an HTML 4.0 non-verifying parser + * with API compatible with the XML parser ones. It should + * be able to parse "real world" HTML, even if severely + * broken from a specification point of view. + * + * Copy: See Copyright for the status of this software. + * + * Author: Daniel Veillard + */ + +#ifndef __HTML_PARSER_H__ +#define __HTML_PARSER_H__ +#include +#include + +#ifdef LIBXML_HTML_ENABLED + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * Most of the back-end structures from XML and HTML are shared. + */ +typedef xmlParserCtxt htmlParserCtxt; +typedef xmlParserCtxtPtr htmlParserCtxtPtr; +typedef xmlParserNodeInfo htmlParserNodeInfo; +typedef xmlSAXHandler htmlSAXHandler; +typedef xmlSAXHandlerPtr htmlSAXHandlerPtr; +typedef xmlParserInput htmlParserInput; +typedef xmlParserInputPtr htmlParserInputPtr; +typedef xmlDocPtr htmlDocPtr; +typedef xmlNodePtr htmlNodePtr; + +/* + * Internal description of an HTML element, representing HTML 4.01 + * and XHTML 1.0 (which share the same structure). + */ +typedef struct _htmlElemDesc htmlElemDesc; +typedef htmlElemDesc *htmlElemDescPtr; +struct _htmlElemDesc { + const char *name; /* The tag name */ + char startTag; /* Whether the start tag can be implied */ + char endTag; /* Whether the end tag can be implied */ + char saveEndTag; /* Whether the end tag should be saved */ + char empty; /* Is this an empty element ? */ + char depr; /* Is this a deprecated element ? */ + char dtd; /* 1: only in Loose DTD, 2: only Frameset one */ + char isinline; /* is this a block 0 or inline 1 element */ + const char *desc; /* the description */ + +/* NRK Jan.2003 + * New fields encapsulating HTML structure + * + * Bugs: + * This is a very limited representation. It fails to tell us when + * an element *requires* subelements (we only have whether they're + * allowed or not), and it doesn't tell us where CDATA and PCDATA + * are allowed. Some element relationships are not fully represented: + * these are flagged with the word MODIFIER + */ + const char** subelts; /* allowed sub-elements of this element */ + const char* defaultsubelt; /* subelement for suggested auto-repair + if necessary or NULL */ + const char** attrs_opt; /* Optional Attributes */ + const char** attrs_depr; /* Additional deprecated attributes */ + const char** attrs_req; /* Required attributes */ +}; + +/* + * Internal description of an HTML entity. + */ +typedef struct _htmlEntityDesc htmlEntityDesc; +typedef htmlEntityDesc *htmlEntityDescPtr; +struct _htmlEntityDesc { + unsigned int value; /* the UNICODE value for the character */ + const char *name; /* The entity name */ + const char *desc; /* the description */ +}; + +/* + * There is only few public functions. + */ +XMLPUBFUN const htmlElemDesc * XMLCALL + htmlTagLookup (const xmlChar *tag); +XMLPUBFUN const htmlEntityDesc * XMLCALL + htmlEntityLookup(const xmlChar *name); +XMLPUBFUN const htmlEntityDesc * XMLCALL + htmlEntityValueLookup(unsigned int value); + +XMLPUBFUN int XMLCALL + htmlIsAutoClosed(htmlDocPtr doc, + htmlNodePtr elem); +XMLPUBFUN int XMLCALL + htmlAutoCloseTag(htmlDocPtr doc, + const xmlChar *name, + htmlNodePtr elem); +XMLPUBFUN const htmlEntityDesc * XMLCALL + htmlParseEntityRef(htmlParserCtxtPtr ctxt, + const xmlChar **str); +XMLPUBFUN int XMLCALL + htmlParseCharRef(htmlParserCtxtPtr ctxt); +XMLPUBFUN void XMLCALL + htmlParseElement(htmlParserCtxtPtr ctxt); + +XMLPUBFUN htmlParserCtxtPtr XMLCALL + htmlNewParserCtxt(void); + +XMLPUBFUN htmlParserCtxtPtr XMLCALL + htmlCreateMemoryParserCtxt(const char *buffer, + int size); + +XMLPUBFUN int XMLCALL + htmlParseDocument(htmlParserCtxtPtr ctxt); +XMLPUBFUN htmlDocPtr XMLCALL + htmlSAXParseDoc (xmlChar *cur, + const char *encoding, + htmlSAXHandlerPtr sax, + void *userData); +XMLPUBFUN htmlDocPtr XMLCALL + htmlParseDoc (xmlChar *cur, + const char *encoding); +XMLPUBFUN htmlDocPtr XMLCALL + htmlSAXParseFile(const char *filename, + const char *encoding, + htmlSAXHandlerPtr sax, + void *userData); +XMLPUBFUN htmlDocPtr XMLCALL + htmlParseFile (const char *filename, + const char *encoding); +XMLPUBFUN int XMLCALL + UTF8ToHtml (unsigned char *out, + int *outlen, + const unsigned char *in, + int *inlen); +XMLPUBFUN int XMLCALL + htmlEncodeEntities(unsigned char *out, + int *outlen, + const unsigned char *in, + int *inlen, int quoteChar); +XMLPUBFUN int XMLCALL + htmlIsScriptAttribute(const xmlChar *name); +XMLPUBFUN int XMLCALL + htmlHandleOmittedElem(int val); + +#ifdef LIBXML_PUSH_ENABLED +/** + * Interfaces for the Push mode. + */ +XMLPUBFUN htmlParserCtxtPtr XMLCALL + htmlCreatePushParserCtxt(htmlSAXHandlerPtr sax, + void *user_data, + const char *chunk, + int size, + const char *filename, + xmlCharEncoding enc); +XMLPUBFUN int XMLCALL + htmlParseChunk (htmlParserCtxtPtr ctxt, + const char *chunk, + int size, + int terminate); +#endif /* LIBXML_PUSH_ENABLED */ + +XMLPUBFUN void XMLCALL + htmlFreeParserCtxt (htmlParserCtxtPtr ctxt); + +/* + * New set of simpler/more flexible APIs + */ +/** + * xmlParserOption: + * + * This is the set of XML parser options that can be passed down + * to the xmlReadDoc() and similar calls. + */ +typedef enum { + HTML_PARSE_RECOVER = 1<<0, /* Relaxed parsing */ + HTML_PARSE_NOERROR = 1<<5, /* suppress error reports */ + HTML_PARSE_NOWARNING= 1<<6, /* suppress warning reports */ + HTML_PARSE_PEDANTIC = 1<<7, /* pedantic error reporting */ + HTML_PARSE_NOBLANKS = 1<<8, /* remove blank nodes */ + HTML_PARSE_NONET = 1<<11,/* Forbid network access */ + HTML_PARSE_NOIMPLIED= 1<<13,/* Do not add implied html/body... elements */ + HTML_PARSE_COMPACT = 1<<16 /* compact small text nodes */ +} htmlParserOption; + +XMLPUBFUN void XMLCALL + htmlCtxtReset (htmlParserCtxtPtr ctxt); +XMLPUBFUN int XMLCALL + htmlCtxtUseOptions (htmlParserCtxtPtr ctxt, + int options); +XMLPUBFUN htmlDocPtr XMLCALL + htmlReadDoc (const xmlChar *cur, + const char *URL, + const char *encoding, + int options); +XMLPUBFUN htmlDocPtr XMLCALL + htmlReadFile (const char *URL, + const char *encoding, + int options); +XMLPUBFUN htmlDocPtr XMLCALL + htmlReadMemory (const char *buffer, + int size, + const char *URL, + const char *encoding, + int options); +XMLPUBFUN htmlDocPtr XMLCALL + htmlReadFd (int fd, + const char *URL, + const char *encoding, + int options); +XMLPUBFUN htmlDocPtr XMLCALL + htmlReadIO (xmlInputReadCallback ioread, + xmlInputCloseCallback ioclose, + void *ioctx, + const char *URL, + const char *encoding, + int options); +XMLPUBFUN htmlDocPtr XMLCALL + htmlCtxtReadDoc (xmlParserCtxtPtr ctxt, + const xmlChar *cur, + const char *URL, + const char *encoding, + int options); +XMLPUBFUN htmlDocPtr XMLCALL + htmlCtxtReadFile (xmlParserCtxtPtr ctxt, + const char *filename, + const char *encoding, + int options); +XMLPUBFUN htmlDocPtr XMLCALL + htmlCtxtReadMemory (xmlParserCtxtPtr ctxt, + const char *buffer, + int size, + const char *URL, + const char *encoding, + int options); +XMLPUBFUN htmlDocPtr XMLCALL + htmlCtxtReadFd (xmlParserCtxtPtr ctxt, + int fd, + const char *URL, + const char *encoding, + int options); +XMLPUBFUN htmlDocPtr XMLCALL + htmlCtxtReadIO (xmlParserCtxtPtr ctxt, + xmlInputReadCallback ioread, + xmlInputCloseCallback ioclose, + void *ioctx, + const char *URL, + const char *encoding, + int options); + +/* NRK/Jan2003: further knowledge of HTML structure + */ +typedef enum { + HTML_NA = 0 , /* something we don't check at all */ + HTML_INVALID = 0x1 , + HTML_DEPRECATED = 0x2 , + HTML_VALID = 0x4 , + HTML_REQUIRED = 0xc /* VALID bit set so ( & HTML_VALID ) is TRUE */ +} htmlStatus ; + +/* Using htmlElemDesc rather than name here, to emphasise the fact + that otherwise there's a lookup overhead +*/ +XMLPUBFUN htmlStatus XMLCALL htmlAttrAllowed(const htmlElemDesc*, const xmlChar*, int) ; +XMLPUBFUN int XMLCALL htmlElementAllowedHere(const htmlElemDesc*, const xmlChar*) ; +XMLPUBFUN htmlStatus XMLCALL htmlElementStatusHere(const htmlElemDesc*, const htmlElemDesc*) ; +XMLPUBFUN htmlStatus XMLCALL htmlNodeStatus(const htmlNodePtr, int) ; +/** + * htmlDefaultSubelement: + * @elt: HTML element + * + * Returns the default subelement for this element + */ +#define htmlDefaultSubelement(elt) elt->defaultsubelt +/** + * htmlElementAllowedHereDesc: + * @parent: HTML parent element + * @elt: HTML element + * + * Checks whether an HTML element description may be a + * direct child of the specified element. + * + * Returns 1 if allowed; 0 otherwise. + */ +#define htmlElementAllowedHereDesc(parent,elt) \ + htmlElementAllowedHere((parent), (elt)->name) +/** + * htmlRequiredAttrs: + * @elt: HTML element + * + * Returns the attributes required for the specified element. + */ +#define htmlRequiredAttrs(elt) (elt)->attrs_req + + +#ifdef __cplusplus +} +#endif + +#endif /* LIBXML_HTML_ENABLED */ +#endif /* __HTML_PARSER_H__ */ diff --git a/lib/libxml2/include/libxml/HTMLtree.h b/lib/libxml2/include/libxml/HTMLtree.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/HTMLtree.h @@ -0,0 +1,147 @@ +/* + * Summary: specific APIs to process HTML tree, especially serialization + * Description: this module implements a few function needed to process + * tree in an HTML specific way. + * + * Copy: See Copyright for the status of this software. + * + * Author: Daniel Veillard + */ + +#ifndef __HTML_TREE_H__ +#define __HTML_TREE_H__ + +#include +#include +#include +#include + +#ifdef LIBXML_HTML_ENABLED + +#ifdef __cplusplus +extern "C" { +#endif + + +/** + * HTML_TEXT_NODE: + * + * Macro. A text node in a HTML document is really implemented + * the same way as a text node in an XML document. + */ +#define HTML_TEXT_NODE XML_TEXT_NODE +/** + * HTML_ENTITY_REF_NODE: + * + * Macro. An entity reference in a HTML document is really implemented + * the same way as an entity reference in an XML document. + */ +#define HTML_ENTITY_REF_NODE XML_ENTITY_REF_NODE +/** + * HTML_COMMENT_NODE: + * + * Macro. A comment in a HTML document is really implemented + * the same way as a comment in an XML document. + */ +#define HTML_COMMENT_NODE XML_COMMENT_NODE +/** + * HTML_PRESERVE_NODE: + * + * Macro. A preserved node in a HTML document is really implemented + * the same way as a CDATA section in an XML document. + */ +#define HTML_PRESERVE_NODE XML_CDATA_SECTION_NODE +/** + * HTML_PI_NODE: + * + * Macro. A processing instruction in a HTML document is really implemented + * the same way as a processing instruction in an XML document. + */ +#define HTML_PI_NODE XML_PI_NODE + +XMLPUBFUN htmlDocPtr XMLCALL + htmlNewDoc (const xmlChar *URI, + const xmlChar *ExternalID); +XMLPUBFUN htmlDocPtr XMLCALL + htmlNewDocNoDtD (const xmlChar *URI, + const xmlChar *ExternalID); +XMLPUBFUN const xmlChar * XMLCALL + htmlGetMetaEncoding (htmlDocPtr doc); +XMLPUBFUN int XMLCALL + htmlSetMetaEncoding (htmlDocPtr doc, + const xmlChar *encoding); +#ifdef LIBXML_OUTPUT_ENABLED +XMLPUBFUN void XMLCALL + htmlDocDumpMemory (xmlDocPtr cur, + xmlChar **mem, + int *size); +XMLPUBFUN void XMLCALL + htmlDocDumpMemoryFormat (xmlDocPtr cur, + xmlChar **mem, + int *size, + int format); +XMLPUBFUN int XMLCALL + htmlDocDump (FILE *f, + xmlDocPtr cur); +XMLPUBFUN int XMLCALL + htmlSaveFile (const char *filename, + xmlDocPtr cur); +XMLPUBFUN int XMLCALL + htmlNodeDump (xmlBufferPtr buf, + xmlDocPtr doc, + xmlNodePtr cur); +XMLPUBFUN void XMLCALL + htmlNodeDumpFile (FILE *out, + xmlDocPtr doc, + xmlNodePtr cur); +XMLPUBFUN int XMLCALL + htmlNodeDumpFileFormat (FILE *out, + xmlDocPtr doc, + xmlNodePtr cur, + const char *encoding, + int format); +XMLPUBFUN int XMLCALL + htmlSaveFileEnc (const char *filename, + xmlDocPtr cur, + const char *encoding); +XMLPUBFUN int XMLCALL + htmlSaveFileFormat (const char *filename, + xmlDocPtr cur, + const char *encoding, + int format); + +XMLPUBFUN void XMLCALL + htmlNodeDumpFormatOutput(xmlOutputBufferPtr buf, + xmlDocPtr doc, + xmlNodePtr cur, + const char *encoding, + int format); +XMLPUBFUN void XMLCALL + htmlDocContentDumpOutput(xmlOutputBufferPtr buf, + xmlDocPtr cur, + const char *encoding); +XMLPUBFUN void XMLCALL + htmlDocContentDumpFormatOutput(xmlOutputBufferPtr buf, + xmlDocPtr cur, + const char *encoding, + int format); +XMLPUBFUN void XMLCALL + htmlNodeDumpOutput (xmlOutputBufferPtr buf, + xmlDocPtr doc, + xmlNodePtr cur, + const char *encoding); + +#endif /* LIBXML_OUTPUT_ENABLED */ + +XMLPUBFUN int XMLCALL + htmlIsBooleanAttr (const xmlChar *name); + + +#ifdef __cplusplus +} +#endif + +#endif /* LIBXML_HTML_ENABLED */ + +#endif /* __HTML_TREE_H__ */ + diff --git a/lib/libxml2/include/libxml/SAX.h b/lib/libxml2/include/libxml/SAX.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/SAX.h @@ -0,0 +1,173 @@ +/* + * Summary: Old SAX version 1 handler, deprecated + * Description: DEPRECATED set of SAX version 1 interfaces used to + * build the DOM tree. + * + * Copy: See Copyright for the status of this software. + * + * Author: Daniel Veillard + */ + + +#ifndef __XML_SAX_H__ +#define __XML_SAX_H__ + +#include +#include +#include +#include +#include + +#ifdef LIBXML_LEGACY_ENABLED + +#ifdef __cplusplus +extern "C" { +#endif +XMLPUBFUN const xmlChar * XMLCALL + getPublicId (void *ctx); +XMLPUBFUN const xmlChar * XMLCALL + getSystemId (void *ctx); +XMLPUBFUN void XMLCALL + setDocumentLocator (void *ctx, + xmlSAXLocatorPtr loc); + +XMLPUBFUN int XMLCALL + getLineNumber (void *ctx); +XMLPUBFUN int XMLCALL + getColumnNumber (void *ctx); + +XMLPUBFUN int XMLCALL + isStandalone (void *ctx); +XMLPUBFUN int XMLCALL + hasInternalSubset (void *ctx); +XMLPUBFUN int XMLCALL + hasExternalSubset (void *ctx); + +XMLPUBFUN void XMLCALL + internalSubset (void *ctx, + const xmlChar *name, + const xmlChar *ExternalID, + const xmlChar *SystemID); +XMLPUBFUN void XMLCALL + externalSubset (void *ctx, + const xmlChar *name, + const xmlChar *ExternalID, + const xmlChar *SystemID); +XMLPUBFUN xmlEntityPtr XMLCALL + getEntity (void *ctx, + const xmlChar *name); +XMLPUBFUN xmlEntityPtr XMLCALL + getParameterEntity (void *ctx, + const xmlChar *name); +XMLPUBFUN xmlParserInputPtr XMLCALL + resolveEntity (void *ctx, + const xmlChar *publicId, + const xmlChar *systemId); + +XMLPUBFUN void XMLCALL + entityDecl (void *ctx, + const xmlChar *name, + int type, + const xmlChar *publicId, + const xmlChar *systemId, + xmlChar *content); +XMLPUBFUN void XMLCALL + attributeDecl (void *ctx, + const xmlChar *elem, + const xmlChar *fullname, + int type, + int def, + const xmlChar *defaultValue, + xmlEnumerationPtr tree); +XMLPUBFUN void XMLCALL + elementDecl (void *ctx, + const xmlChar *name, + int type, + xmlElementContentPtr content); +XMLPUBFUN void XMLCALL + notationDecl (void *ctx, + const xmlChar *name, + const xmlChar *publicId, + const xmlChar *systemId); +XMLPUBFUN void XMLCALL + unparsedEntityDecl (void *ctx, + const xmlChar *name, + const xmlChar *publicId, + const xmlChar *systemId, + const xmlChar *notationName); + +XMLPUBFUN void XMLCALL + startDocument (void *ctx); +XMLPUBFUN void XMLCALL + endDocument (void *ctx); +XMLPUBFUN void XMLCALL + attribute (void *ctx, + const xmlChar *fullname, + const xmlChar *value); +XMLPUBFUN void XMLCALL + startElement (void *ctx, + const xmlChar *fullname, + const xmlChar **atts); +XMLPUBFUN void XMLCALL + endElement (void *ctx, + const xmlChar *name); +XMLPUBFUN void XMLCALL + reference (void *ctx, + const xmlChar *name); +XMLPUBFUN void XMLCALL + characters (void *ctx, + const xmlChar *ch, + int len); +XMLPUBFUN void XMLCALL + ignorableWhitespace (void *ctx, + const xmlChar *ch, + int len); +XMLPUBFUN void XMLCALL + processingInstruction (void *ctx, + const xmlChar *target, + const xmlChar *data); +XMLPUBFUN void XMLCALL + globalNamespace (void *ctx, + const xmlChar *href, + const xmlChar *prefix); +XMLPUBFUN void XMLCALL + setNamespace (void *ctx, + const xmlChar *name); +XMLPUBFUN xmlNsPtr XMLCALL + getNamespace (void *ctx); +XMLPUBFUN int XMLCALL + checkNamespace (void *ctx, + xmlChar *nameSpace); +XMLPUBFUN void XMLCALL + namespaceDecl (void *ctx, + const xmlChar *href, + const xmlChar *prefix); +XMLPUBFUN void XMLCALL + comment (void *ctx, + const xmlChar *value); +XMLPUBFUN void XMLCALL + cdataBlock (void *ctx, + const xmlChar *value, + int len); + +#ifdef LIBXML_SAX1_ENABLED +XMLPUBFUN void XMLCALL + initxmlDefaultSAXHandler (xmlSAXHandlerV1 *hdlr, + int warning); +#ifdef LIBXML_HTML_ENABLED +XMLPUBFUN void XMLCALL + inithtmlDefaultSAXHandler (xmlSAXHandlerV1 *hdlr); +#endif +#ifdef LIBXML_DOCB_ENABLED +XMLPUBFUN void XMLCALL + initdocbDefaultSAXHandler (xmlSAXHandlerV1 *hdlr); +#endif +#endif /* LIBXML_SAX1_ENABLED */ + +#ifdef __cplusplus +} +#endif + +#endif /* LIBXML_LEGACY_ENABLED */ + +#endif /* __XML_SAX_H__ */ diff --git a/lib/libxml2/include/libxml/SAX2.h b/lib/libxml2/include/libxml/SAX2.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/SAX2.h @@ -0,0 +1,176 @@ +/* + * Summary: SAX2 parser interface used to build the DOM tree + * Description: those are the default SAX2 interfaces used by + * the library when building DOM tree. + * + * Copy: See Copyright for the status of this software. + * + * Author: Daniel Veillard + */ + + +#ifndef __XML_SAX2_H__ +#define __XML_SAX2_H__ + +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif +XMLPUBFUN const xmlChar * XMLCALL + xmlSAX2GetPublicId (void *ctx); +XMLPUBFUN const xmlChar * XMLCALL + xmlSAX2GetSystemId (void *ctx); +XMLPUBFUN void XMLCALL + xmlSAX2SetDocumentLocator (void *ctx, + xmlSAXLocatorPtr loc); + +XMLPUBFUN int XMLCALL + xmlSAX2GetLineNumber (void *ctx); +XMLPUBFUN int XMLCALL + xmlSAX2GetColumnNumber (void *ctx); + +XMLPUBFUN int XMLCALL + xmlSAX2IsStandalone (void *ctx); +XMLPUBFUN int XMLCALL + xmlSAX2HasInternalSubset (void *ctx); +XMLPUBFUN int XMLCALL + xmlSAX2HasExternalSubset (void *ctx); + +XMLPUBFUN void XMLCALL + xmlSAX2InternalSubset (void *ctx, + const xmlChar *name, + const xmlChar *ExternalID, + const xmlChar *SystemID); +XMLPUBFUN void XMLCALL + xmlSAX2ExternalSubset (void *ctx, + const xmlChar *name, + const xmlChar *ExternalID, + const xmlChar *SystemID); +XMLPUBFUN xmlEntityPtr XMLCALL + xmlSAX2GetEntity (void *ctx, + const xmlChar *name); +XMLPUBFUN xmlEntityPtr XMLCALL + xmlSAX2GetParameterEntity (void *ctx, + const xmlChar *name); +XMLPUBFUN xmlParserInputPtr XMLCALL + xmlSAX2ResolveEntity (void *ctx, + const xmlChar *publicId, + const xmlChar *systemId); + +XMLPUBFUN void XMLCALL + xmlSAX2EntityDecl (void *ctx, + const xmlChar *name, + int type, + const xmlChar *publicId, + const xmlChar *systemId, + xmlChar *content); +XMLPUBFUN void XMLCALL + xmlSAX2AttributeDecl (void *ctx, + const xmlChar *elem, + const xmlChar *fullname, + int type, + int def, + const xmlChar *defaultValue, + xmlEnumerationPtr tree); +XMLPUBFUN void XMLCALL + xmlSAX2ElementDecl (void *ctx, + const xmlChar *name, + int type, + xmlElementContentPtr content); +XMLPUBFUN void XMLCALL + xmlSAX2NotationDecl (void *ctx, + const xmlChar *name, + const xmlChar *publicId, + const xmlChar *systemId); +XMLPUBFUN void XMLCALL + xmlSAX2UnparsedEntityDecl (void *ctx, + const xmlChar *name, + const xmlChar *publicId, + const xmlChar *systemId, + const xmlChar *notationName); + +XMLPUBFUN void XMLCALL + xmlSAX2StartDocument (void *ctx); +XMLPUBFUN void XMLCALL + xmlSAX2EndDocument (void *ctx); +#if defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_WRITER_ENABLED) || defined(LIBXML_DOCB_ENABLED) +XMLPUBFUN void XMLCALL + xmlSAX2StartElement (void *ctx, + const xmlChar *fullname, + const xmlChar **atts); +XMLPUBFUN void XMLCALL + xmlSAX2EndElement (void *ctx, + const xmlChar *name); +#endif /* LIBXML_SAX1_ENABLED or LIBXML_HTML_ENABLED */ +XMLPUBFUN void XMLCALL + xmlSAX2StartElementNs (void *ctx, + const xmlChar *localname, + const xmlChar *prefix, + const xmlChar *URI, + int nb_namespaces, + const xmlChar **namespaces, + int nb_attributes, + int nb_defaulted, + const xmlChar **attributes); +XMLPUBFUN void XMLCALL + xmlSAX2EndElementNs (void *ctx, + const xmlChar *localname, + const xmlChar *prefix, + const xmlChar *URI); +XMLPUBFUN void XMLCALL + xmlSAX2Reference (void *ctx, + const xmlChar *name); +XMLPUBFUN void XMLCALL + xmlSAX2Characters (void *ctx, + const xmlChar *ch, + int len); +XMLPUBFUN void XMLCALL + xmlSAX2IgnorableWhitespace (void *ctx, + const xmlChar *ch, + int len); +XMLPUBFUN void XMLCALL + xmlSAX2ProcessingInstruction (void *ctx, + const xmlChar *target, + const xmlChar *data); +XMLPUBFUN void XMLCALL + xmlSAX2Comment (void *ctx, + const xmlChar *value); +XMLPUBFUN void XMLCALL + xmlSAX2CDataBlock (void *ctx, + const xmlChar *value, + int len); + +#ifdef LIBXML_SAX1_ENABLED +XMLPUBFUN int XMLCALL + xmlSAXDefaultVersion (int version); +#endif /* LIBXML_SAX1_ENABLED */ + +XMLPUBFUN int XMLCALL + xmlSAXVersion (xmlSAXHandler *hdlr, + int version); +XMLPUBFUN void XMLCALL + xmlSAX2InitDefaultSAXHandler (xmlSAXHandler *hdlr, + int warning); +#ifdef LIBXML_HTML_ENABLED +XMLPUBFUN void XMLCALL + xmlSAX2InitHtmlDefaultSAXHandler(xmlSAXHandler *hdlr); +XMLPUBFUN void XMLCALL + htmlDefaultSAXHandlerInit (void); +#endif +#ifdef LIBXML_DOCB_ENABLED +XMLPUBFUN void XMLCALL + xmlSAX2InitDocbDefaultSAXHandler(xmlSAXHandler *hdlr); +XMLPUBFUN void XMLCALL + docbDefaultSAXHandlerInit (void); +#endif +XMLPUBFUN void XMLCALL + xmlDefaultSAXHandlerInit (void); +#ifdef __cplusplus +} +#endif +#endif /* __XML_SAX2_H__ */ diff --git a/lib/libxml2/include/libxml/c14n.h b/lib/libxml2/include/libxml/c14n.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/c14n.h @@ -0,0 +1,126 @@ +/* + * Summary: Provide Canonical XML and Exclusive XML Canonicalization + * Description: the c14n modules provides a + * + * "Canonical XML" implementation + * http://www.w3.org/TR/xml-c14n + * + * and an + * + * "Exclusive XML Canonicalization" implementation + * http://www.w3.org/TR/xml-exc-c14n + + * Copy: See Copyright for the status of this software. + * + * Author: Aleksey Sanin + */ +#ifndef __XML_C14N_H__ +#define __XML_C14N_H__ +#ifdef LIBXML_C14N_ENABLED +#ifdef LIBXML_OUTPUT_ENABLED + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +#include +#include +#include + +/* + * XML Canonicazation + * http://www.w3.org/TR/xml-c14n + * + * Exclusive XML Canonicazation + * http://www.w3.org/TR/xml-exc-c14n + * + * Canonical form of an XML document could be created if and only if + * a) default attributes (if any) are added to all nodes + * b) all character and parsed entity references are resolved + * In order to achive this in libxml2 the document MUST be loaded with + * following global setings: + * + * xmlLoadExtDtdDefaultValue = XML_DETECT_IDS | XML_COMPLETE_ATTRS; + * xmlSubstituteEntitiesDefault(1); + * + * or corresponding parser context setting: + * xmlParserCtxtPtr ctxt; + * + * ... + * ctxt->loadsubset = XML_DETECT_IDS | XML_COMPLETE_ATTRS; + * ctxt->replaceEntities = 1; + * ... + */ + +/* + * xmlC14NMode: + * + * Predefined values for C14N modes + * + */ +typedef enum { + XML_C14N_1_0 = 0, /* Origianal C14N 1.0 spec */ + XML_C14N_EXCLUSIVE_1_0 = 1, /* Exclusive C14N 1.0 spec */ + XML_C14N_1_1 = 2 /* C14N 1.1 spec */ +} xmlC14NMode; + +XMLPUBFUN int XMLCALL + xmlC14NDocSaveTo (xmlDocPtr doc, + xmlNodeSetPtr nodes, + int mode, /* a xmlC14NMode */ + xmlChar **inclusive_ns_prefixes, + int with_comments, + xmlOutputBufferPtr buf); + +XMLPUBFUN int XMLCALL + xmlC14NDocDumpMemory (xmlDocPtr doc, + xmlNodeSetPtr nodes, + int mode, /* a xmlC14NMode */ + xmlChar **inclusive_ns_prefixes, + int with_comments, + xmlChar **doc_txt_ptr); + +XMLPUBFUN int XMLCALL + xmlC14NDocSave (xmlDocPtr doc, + xmlNodeSetPtr nodes, + int mode, /* a xmlC14NMode */ + xmlChar **inclusive_ns_prefixes, + int with_comments, + const char* filename, + int compression); + + +/** + * This is the core C14N function + */ +/** + * xmlC14NIsVisibleCallback: + * @user_data: user data + * @node: the curent node + * @parent: the parent node + * + * Signature for a C14N callback on visible nodes + * + * Returns 1 if the node should be included + */ +typedef int (*xmlC14NIsVisibleCallback) (void* user_data, + xmlNodePtr node, + xmlNodePtr parent); + +XMLPUBFUN int XMLCALL + xmlC14NExecute (xmlDocPtr doc, + xmlC14NIsVisibleCallback is_visible_callback, + void* user_data, + int mode, /* a xmlC14NMode */ + xmlChar **inclusive_ns_prefixes, + int with_comments, + xmlOutputBufferPtr buf); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /* LIBXML_OUTPUT_ENABLED */ +#endif /* LIBXML_C14N_ENABLED */ +#endif /* __XML_C14N_H__ */ + diff --git a/lib/libxml2/include/libxml/catalog.h b/lib/libxml2/include/libxml/catalog.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/catalog.h @@ -0,0 +1,182 @@ +/** + * Summary: interfaces to the Catalog handling system + * Description: the catalog module implements the support for + * XML Catalogs and SGML catalogs + * + * SGML Open Technical Resolution TR9401:1997. + * http://www.jclark.com/sp/catalog.htm + * + * XML Catalogs Working Draft 06 August 2001 + * http://www.oasis-open.org/committees/entity/spec-2001-08-06.html + * + * Copy: See Copyright for the status of this software. + * + * Author: Daniel Veillard + */ + +#ifndef __XML_CATALOG_H__ +#define __XML_CATALOG_H__ + +#include + +#include +#include +#include + +#ifdef LIBXML_CATALOG_ENABLED + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * XML_CATALOGS_NAMESPACE: + * + * The namespace for the XML Catalogs elements. + */ +#define XML_CATALOGS_NAMESPACE \ + (const xmlChar *) "urn:oasis:names:tc:entity:xmlns:xml:catalog" +/** + * XML_CATALOG_PI: + * + * The specific XML Catalog Processing Instuction name. + */ +#define XML_CATALOG_PI \ + (const xmlChar *) "oasis-xml-catalog" + +/* + * The API is voluntarily limited to general cataloging. + */ +typedef enum { + XML_CATA_PREFER_NONE = 0, + XML_CATA_PREFER_PUBLIC = 1, + XML_CATA_PREFER_SYSTEM +} xmlCatalogPrefer; + +typedef enum { + XML_CATA_ALLOW_NONE = 0, + XML_CATA_ALLOW_GLOBAL = 1, + XML_CATA_ALLOW_DOCUMENT = 2, + XML_CATA_ALLOW_ALL = 3 +} xmlCatalogAllow; + +typedef struct _xmlCatalog xmlCatalog; +typedef xmlCatalog *xmlCatalogPtr; + +/* + * Operations on a given catalog. + */ +XMLPUBFUN xmlCatalogPtr XMLCALL + xmlNewCatalog (int sgml); +XMLPUBFUN xmlCatalogPtr XMLCALL + xmlLoadACatalog (const char *filename); +XMLPUBFUN xmlCatalogPtr XMLCALL + xmlLoadSGMLSuperCatalog (const char *filename); +XMLPUBFUN int XMLCALL + xmlConvertSGMLCatalog (xmlCatalogPtr catal); +XMLPUBFUN int XMLCALL + xmlACatalogAdd (xmlCatalogPtr catal, + const xmlChar *type, + const xmlChar *orig, + const xmlChar *replace); +XMLPUBFUN int XMLCALL + xmlACatalogRemove (xmlCatalogPtr catal, + const xmlChar *value); +XMLPUBFUN xmlChar * XMLCALL + xmlACatalogResolve (xmlCatalogPtr catal, + const xmlChar *pubID, + const xmlChar *sysID); +XMLPUBFUN xmlChar * XMLCALL + xmlACatalogResolveSystem(xmlCatalogPtr catal, + const xmlChar *sysID); +XMLPUBFUN xmlChar * XMLCALL + xmlACatalogResolvePublic(xmlCatalogPtr catal, + const xmlChar *pubID); +XMLPUBFUN xmlChar * XMLCALL + xmlACatalogResolveURI (xmlCatalogPtr catal, + const xmlChar *URI); +#ifdef LIBXML_OUTPUT_ENABLED +XMLPUBFUN void XMLCALL + xmlACatalogDump (xmlCatalogPtr catal, + FILE *out); +#endif /* LIBXML_OUTPUT_ENABLED */ +XMLPUBFUN void XMLCALL + xmlFreeCatalog (xmlCatalogPtr catal); +XMLPUBFUN int XMLCALL + xmlCatalogIsEmpty (xmlCatalogPtr catal); + +/* + * Global operations. + */ +XMLPUBFUN void XMLCALL + xmlInitializeCatalog (void); +XMLPUBFUN int XMLCALL + xmlLoadCatalog (const char *filename); +XMLPUBFUN void XMLCALL + xmlLoadCatalogs (const char *paths); +XMLPUBFUN void XMLCALL + xmlCatalogCleanup (void); +#ifdef LIBXML_OUTPUT_ENABLED +XMLPUBFUN void XMLCALL + xmlCatalogDump (FILE *out); +#endif /* LIBXML_OUTPUT_ENABLED */ +XMLPUBFUN xmlChar * XMLCALL + xmlCatalogResolve (const xmlChar *pubID, + const xmlChar *sysID); +XMLPUBFUN xmlChar * XMLCALL + xmlCatalogResolveSystem (const xmlChar *sysID); +XMLPUBFUN xmlChar * XMLCALL + xmlCatalogResolvePublic (const xmlChar *pubID); +XMLPUBFUN xmlChar * XMLCALL + xmlCatalogResolveURI (const xmlChar *URI); +XMLPUBFUN int XMLCALL + xmlCatalogAdd (const xmlChar *type, + const xmlChar *orig, + const xmlChar *replace); +XMLPUBFUN int XMLCALL + xmlCatalogRemove (const xmlChar *value); +XMLPUBFUN xmlDocPtr XMLCALL + xmlParseCatalogFile (const char *filename); +XMLPUBFUN int XMLCALL + xmlCatalogConvert (void); + +/* + * Strictly minimal interfaces for per-document catalogs used + * by the parser. + */ +XMLPUBFUN void XMLCALL + xmlCatalogFreeLocal (void *catalogs); +XMLPUBFUN void * XMLCALL + xmlCatalogAddLocal (void *catalogs, + const xmlChar *URL); +XMLPUBFUN xmlChar * XMLCALL + xmlCatalogLocalResolve (void *catalogs, + const xmlChar *pubID, + const xmlChar *sysID); +XMLPUBFUN xmlChar * XMLCALL + xmlCatalogLocalResolveURI(void *catalogs, + const xmlChar *URI); +/* + * Preference settings. + */ +XMLPUBFUN int XMLCALL + xmlCatalogSetDebug (int level); +XMLPUBFUN xmlCatalogPrefer XMLCALL + xmlCatalogSetDefaultPrefer(xmlCatalogPrefer prefer); +XMLPUBFUN void XMLCALL + xmlCatalogSetDefaults (xmlCatalogAllow allow); +XMLPUBFUN xmlCatalogAllow XMLCALL + xmlCatalogGetDefaults (void); + + +/* DEPRECATED interfaces */ +XMLPUBFUN const xmlChar * XMLCALL + xmlCatalogGetSystem (const xmlChar *sysID); +XMLPUBFUN const xmlChar * XMLCALL + xmlCatalogGetPublic (const xmlChar *pubID); + +#ifdef __cplusplus +} +#endif +#endif /* LIBXML_CATALOG_ENABLED */ +#endif /* __XML_CATALOG_H__ */ diff --git a/lib/libxml2/include/libxml/chvalid.h b/lib/libxml2/include/libxml/chvalid.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/chvalid.h @@ -0,0 +1,230 @@ +/* + * Summary: Unicode character range checking + * Description: this module exports interfaces for 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 + * Author: William Brack + */ + +#ifndef __XML_CHVALID_H__ +#define __XML_CHVALID_H__ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * Define our typedefs and structures + * + */ +typedef struct _xmlChSRange xmlChSRange; +typedef xmlChSRange *xmlChSRangePtr; +struct _xmlChSRange { + unsigned short low; + unsigned short high; +}; + +typedef struct _xmlChLRange xmlChLRange; +typedef xmlChLRange *xmlChLRangePtr; +struct _xmlChLRange { + unsigned int low; + unsigned int high; +}; + +typedef struct _xmlChRangeGroup xmlChRangeGroup; +typedef xmlChRangeGroup *xmlChRangeGroupPtr; +struct _xmlChRangeGroup { + int nbShortRange; + int nbLongRange; + const xmlChSRange *shortRange; /* points to an array of ranges */ + const xmlChLRange *longRange; +}; + +/** + * Range checking routine + */ +XMLPUBFUN int XMLCALL + xmlCharInRange(unsigned int val, const xmlChRangeGroup *group); + + +/** + * xmlIsBaseChar_ch: + * @c: char to validate + * + * Automatically generated by genChRanges.py + */ +#define xmlIsBaseChar_ch(c) (((0x41 <= (c)) && ((c) <= 0x5a)) || \ + ((0x61 <= (c)) && ((c) <= 0x7a)) || \ + ((0xc0 <= (c)) && ((c) <= 0xd6)) || \ + ((0xd8 <= (c)) && ((c) <= 0xf6)) || \ + (0xf8 <= (c))) + +/** + * xmlIsBaseCharQ: + * @c: char to validate + * + * Automatically generated by genChRanges.py + */ +#define xmlIsBaseCharQ(c) (((c) < 0x100) ? \ + xmlIsBaseChar_ch((c)) : \ + xmlCharInRange((c), &xmlIsBaseCharGroup)) + +XMLPUBVAR const xmlChRangeGroup xmlIsBaseCharGroup; + +/** + * xmlIsBlank_ch: + * @c: char to validate + * + * Automatically generated by genChRanges.py + */ +#define xmlIsBlank_ch(c) (((c) == 0x20) || \ + ((0x9 <= (c)) && ((c) <= 0xa)) || \ + ((c) == 0xd)) + +/** + * xmlIsBlankQ: + * @c: char to validate + * + * Automatically generated by genChRanges.py + */ +#define xmlIsBlankQ(c) (((c) < 0x100) ? \ + xmlIsBlank_ch((c)) : 0) + + +/** + * xmlIsChar_ch: + * @c: char to validate + * + * Automatically generated by genChRanges.py + */ +#define xmlIsChar_ch(c) (((0x9 <= (c)) && ((c) <= 0xa)) || \ + ((c) == 0xd) || \ + (0x20 <= (c))) + +/** + * xmlIsCharQ: + * @c: char to validate + * + * Automatically generated by genChRanges.py + */ +#define xmlIsCharQ(c) (((c) < 0x100) ? \ + xmlIsChar_ch((c)) :\ + (((0x100 <= (c)) && ((c) <= 0xd7ff)) || \ + ((0xe000 <= (c)) && ((c) <= 0xfffd)) || \ + ((0x10000 <= (c)) && ((c) <= 0x10ffff)))) + +XMLPUBVAR const xmlChRangeGroup xmlIsCharGroup; + +/** + * xmlIsCombiningQ: + * @c: char to validate + * + * Automatically generated by genChRanges.py + */ +#define xmlIsCombiningQ(c) (((c) < 0x100) ? \ + 0 : \ + xmlCharInRange((c), &xmlIsCombiningGroup)) + +XMLPUBVAR const xmlChRangeGroup xmlIsCombiningGroup; + +/** + * xmlIsDigit_ch: + * @c: char to validate + * + * Automatically generated by genChRanges.py + */ +#define xmlIsDigit_ch(c) (((0x30 <= (c)) && ((c) <= 0x39))) + +/** + * xmlIsDigitQ: + * @c: char to validate + * + * Automatically generated by genChRanges.py + */ +#define xmlIsDigitQ(c) (((c) < 0x100) ? \ + xmlIsDigit_ch((c)) : \ + xmlCharInRange((c), &xmlIsDigitGroup)) + +XMLPUBVAR const xmlChRangeGroup xmlIsDigitGroup; + +/** + * xmlIsExtender_ch: + * @c: char to validate + * + * Automatically generated by genChRanges.py + */ +#define xmlIsExtender_ch(c) (((c) == 0xb7)) + +/** + * xmlIsExtenderQ: + * @c: char to validate + * + * Automatically generated by genChRanges.py + */ +#define xmlIsExtenderQ(c) (((c) < 0x100) ? \ + xmlIsExtender_ch((c)) : \ + xmlCharInRange((c), &xmlIsExtenderGroup)) + +XMLPUBVAR const xmlChRangeGroup xmlIsExtenderGroup; + +/** + * xmlIsIdeographicQ: + * @c: char to validate + * + * Automatically generated by genChRanges.py + */ +#define xmlIsIdeographicQ(c) (((c) < 0x100) ? \ + 0 :\ + (((0x4e00 <= (c)) && ((c) <= 0x9fa5)) || \ + ((c) == 0x3007) || \ + ((0x3021 <= (c)) && ((c) <= 0x3029)))) + +XMLPUBVAR const xmlChRangeGroup xmlIsIdeographicGroup; +XMLPUBVAR const unsigned char xmlIsPubidChar_tab[256]; + +/** + * xmlIsPubidChar_ch: + * @c: char to validate + * + * Automatically generated by genChRanges.py + */ +#define xmlIsPubidChar_ch(c) (xmlIsPubidChar_tab[(c)]) + +/** + * xmlIsPubidCharQ: + * @c: char to validate + * + * Automatically generated by genChRanges.py + */ +#define xmlIsPubidCharQ(c) (((c) < 0x100) ? \ + xmlIsPubidChar_ch((c)) : 0) + +XMLPUBFUN int XMLCALL + xmlIsBaseChar(unsigned int ch); +XMLPUBFUN int XMLCALL + xmlIsBlank(unsigned int ch); +XMLPUBFUN int XMLCALL + xmlIsChar(unsigned int ch); +XMLPUBFUN int XMLCALL + xmlIsCombining(unsigned int ch); +XMLPUBFUN int XMLCALL + xmlIsDigit(unsigned int ch); +XMLPUBFUN int XMLCALL + xmlIsExtender(unsigned int ch); +XMLPUBFUN int XMLCALL + xmlIsIdeographic(unsigned int ch); +XMLPUBFUN int XMLCALL + xmlIsPubidChar(unsigned int ch); + +#ifdef __cplusplus +} +#endif +#endif /* __XML_CHVALID_H__ */ diff --git a/lib/libxml2/include/libxml/debugXML.h b/lib/libxml2/include/libxml/debugXML.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/debugXML.h @@ -0,0 +1,217 @@ +/* + * Summary: Tree debugging APIs + * Description: Interfaces to a set of routines used for debugging the tree + * produced by the XML parser. + * + * Copy: See Copyright for the status of this software. + * + * Author: Daniel Veillard + */ + +#ifndef __DEBUG_XML__ +#define __DEBUG_XML__ +#include +#include +#include + +#ifdef LIBXML_DEBUG_ENABLED + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * The standard Dump routines. + */ +XMLPUBFUN void XMLCALL + xmlDebugDumpString (FILE *output, + const xmlChar *str); +XMLPUBFUN void XMLCALL + xmlDebugDumpAttr (FILE *output, + xmlAttrPtr attr, + int depth); +XMLPUBFUN void XMLCALL + xmlDebugDumpAttrList (FILE *output, + xmlAttrPtr attr, + int depth); +XMLPUBFUN void XMLCALL + xmlDebugDumpOneNode (FILE *output, + xmlNodePtr node, + int depth); +XMLPUBFUN void XMLCALL + xmlDebugDumpNode (FILE *output, + xmlNodePtr node, + int depth); +XMLPUBFUN void XMLCALL + xmlDebugDumpNodeList (FILE *output, + xmlNodePtr node, + int depth); +XMLPUBFUN void XMLCALL + xmlDebugDumpDocumentHead(FILE *output, + xmlDocPtr doc); +XMLPUBFUN void XMLCALL + xmlDebugDumpDocument (FILE *output, + xmlDocPtr doc); +XMLPUBFUN void XMLCALL + xmlDebugDumpDTD (FILE *output, + xmlDtdPtr dtd); +XMLPUBFUN void XMLCALL + xmlDebugDumpEntities (FILE *output, + xmlDocPtr doc); + +/**************************************************************** + * * + * Checking routines * + * * + ****************************************************************/ + +XMLPUBFUN int XMLCALL + xmlDebugCheckDocument (FILE * output, + xmlDocPtr doc); + +/**************************************************************** + * * + * XML shell helpers * + * * + ****************************************************************/ + +XMLPUBFUN void XMLCALL + xmlLsOneNode (FILE *output, xmlNodePtr node); +XMLPUBFUN int XMLCALL + xmlLsCountNode (xmlNodePtr node); + +XMLPUBFUN const char * XMLCALL + xmlBoolToText (int boolval); + +/**************************************************************** + * * + * The XML shell related structures and functions * + * * + ****************************************************************/ + +#ifdef LIBXML_XPATH_ENABLED +/** + * xmlShellReadlineFunc: + * @prompt: a string prompt + * + * This is a generic signature for the XML shell input function. + * + * Returns a string which will be freed by the Shell. + */ +typedef char * (* xmlShellReadlineFunc)(char *prompt); + +/** + * xmlShellCtxt: + * + * A debugging shell context. + * TODO: add the defined function tables. + */ +typedef struct _xmlShellCtxt xmlShellCtxt; +typedef xmlShellCtxt *xmlShellCtxtPtr; +struct _xmlShellCtxt { + char *filename; + xmlDocPtr doc; + xmlNodePtr node; + xmlXPathContextPtr pctxt; + int loaded; + FILE *output; + xmlShellReadlineFunc input; +}; + +/** + * xmlShellCmd: + * @ctxt: a shell context + * @arg: a string argument + * @node: a first node + * @node2: a second node + * + * This is a generic signature for the XML shell functions. + * + * Returns an int, negative returns indicating errors. + */ +typedef int (* xmlShellCmd) (xmlShellCtxtPtr ctxt, + char *arg, + xmlNodePtr node, + xmlNodePtr node2); + +XMLPUBFUN void XMLCALL + xmlShellPrintXPathError (int errorType, + const char *arg); +XMLPUBFUN void XMLCALL + xmlShellPrintXPathResult(xmlXPathObjectPtr list); +XMLPUBFUN int XMLCALL + xmlShellList (xmlShellCtxtPtr ctxt, + char *arg, + xmlNodePtr node, + xmlNodePtr node2); +XMLPUBFUN int XMLCALL + xmlShellBase (xmlShellCtxtPtr ctxt, + char *arg, + xmlNodePtr node, + xmlNodePtr node2); +XMLPUBFUN int XMLCALL + xmlShellDir (xmlShellCtxtPtr ctxt, + char *arg, + xmlNodePtr node, + xmlNodePtr node2); +XMLPUBFUN int XMLCALL + xmlShellLoad (xmlShellCtxtPtr ctxt, + char *filename, + xmlNodePtr node, + xmlNodePtr node2); +#ifdef LIBXML_OUTPUT_ENABLED +XMLPUBFUN void XMLCALL + xmlShellPrintNode (xmlNodePtr node); +XMLPUBFUN int XMLCALL + xmlShellCat (xmlShellCtxtPtr ctxt, + char *arg, + xmlNodePtr node, + xmlNodePtr node2); +XMLPUBFUN int XMLCALL + xmlShellWrite (xmlShellCtxtPtr ctxt, + char *filename, + xmlNodePtr node, + xmlNodePtr node2); +XMLPUBFUN int XMLCALL + xmlShellSave (xmlShellCtxtPtr ctxt, + char *filename, + xmlNodePtr node, + xmlNodePtr node2); +#endif /* LIBXML_OUTPUT_ENABLED */ +#ifdef LIBXML_VALID_ENABLED +XMLPUBFUN int XMLCALL + xmlShellValidate (xmlShellCtxtPtr ctxt, + char *dtd, + xmlNodePtr node, + xmlNodePtr node2); +#endif /* LIBXML_VALID_ENABLED */ +XMLPUBFUN int XMLCALL + xmlShellDu (xmlShellCtxtPtr ctxt, + char *arg, + xmlNodePtr tree, + xmlNodePtr node2); +XMLPUBFUN int XMLCALL + xmlShellPwd (xmlShellCtxtPtr ctxt, + char *buffer, + xmlNodePtr node, + xmlNodePtr node2); + +/* + * The Shell interface. + */ +XMLPUBFUN void XMLCALL + xmlShell (xmlDocPtr doc, + char *filename, + xmlShellReadlineFunc input, + FILE *output); + +#endif /* LIBXML_XPATH_ENABLED */ + +#ifdef __cplusplus +} +#endif + +#endif /* LIBXML_DEBUG_ENABLED */ +#endif /* __DEBUG_XML__ */ diff --git a/lib/libxml2/include/libxml/dict.h b/lib/libxml2/include/libxml/dict.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/dict.h @@ -0,0 +1,69 @@ +/* + * Summary: string dictionnary + * Description: dictionary of reusable strings, just used to avoid allocation + * and freeing operations. + * + * Copy: See Copyright for the status of this software. + * + * Author: Daniel Veillard + */ + +#ifndef __XML_DICT_H__ +#define __XML_DICT_H__ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * The dictionnary. + */ +typedef struct _xmlDict xmlDict; +typedef xmlDict *xmlDictPtr; + +/* + * Constructor and destructor. + */ +XMLPUBFUN xmlDictPtr XMLCALL + xmlDictCreate (void); +XMLPUBFUN xmlDictPtr XMLCALL + xmlDictCreateSub(xmlDictPtr sub); +XMLPUBFUN int XMLCALL + xmlDictReference(xmlDictPtr dict); +XMLPUBFUN void XMLCALL + xmlDictFree (xmlDictPtr dict); + +/* + * Lookup of entry in the dictionnary. + */ +XMLPUBFUN const xmlChar * XMLCALL + xmlDictLookup (xmlDictPtr dict, + const xmlChar *name, + int len); +XMLPUBFUN const xmlChar * XMLCALL + xmlDictExists (xmlDictPtr dict, + const xmlChar *name, + int len); +XMLPUBFUN const xmlChar * XMLCALL + xmlDictQLookup (xmlDictPtr dict, + const xmlChar *prefix, + const xmlChar *name); +XMLPUBFUN int XMLCALL + xmlDictOwns (xmlDictPtr dict, + const xmlChar *str); +XMLPUBFUN int XMLCALL + xmlDictSize (xmlDictPtr dict); + +/* + * Cleanup function + */ +XMLPUBFUN void XMLCALL + xmlDictCleanup (void); + +#ifdef __cplusplus +} +#endif +#endif /* ! __XML_DICT_H__ */ diff --git a/lib/libxml2/include/libxml/encoding.h b/lib/libxml2/include/libxml/encoding.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/encoding.h @@ -0,0 +1,226 @@ +/* + * Summary: interface for the encoding conversion functions + * Description: interface for the encoding conversion functions needed for + * XML basic encoding and iconv() support. + * + * Related specs are + * rfc2044 (UTF-8 and UTF-16) F. Yergeau Alis Technologies + * [ISO-10646] UTF-8 and UTF-16 in Annexes + * [ISO-8859-1] ISO Latin-1 characters codes. + * [UNICODE] The Unicode Consortium, "The Unicode Standard -- + * Worldwide Character Encoding -- Version 1.0", Addison- + * Wesley, Volume 1, 1991, Volume 2, 1992. UTF-8 is + * described in Unicode Technical Report #4. + * [US-ASCII] Coded Character Set--7-bit American Standard Code for + * Information Interchange, ANSI X3.4-1986. + * + * Copy: See Copyright for the status of this software. + * + * Author: Daniel Veillard + */ + +#ifndef __XML_CHAR_ENCODING_H__ +#define __XML_CHAR_ENCODING_H__ + +#include + +#ifdef LIBXML_ICONV_ENABLED +#include +#endif +#ifdef __cplusplus +extern "C" { +#endif + +/* + * xmlCharEncoding: + * + * Predefined values for some standard encodings. + * Libxml does not do beforehand translation on UTF8 and ISOLatinX. + * It also supports ASCII, ISO-8859-1, and UTF16 (LE and BE) by default. + * + * Anything else would have to be translated to UTF8 before being + * given to the parser itself. The BOM for UTF16 and the encoding + * declaration are looked at and a converter is looked for at that + * point. If not found the parser stops here as asked by the XML REC. A + * converter can be registered by the user using xmlRegisterCharEncodingHandler + * but the current form doesn't allow stateful transcoding (a serious + * problem agreed !). If iconv has been found it will be used + * automatically and allow stateful transcoding, the simplest is then + * to be sure to enable iconv and to provide iconv libs for the encoding + * support needed. + * + * Note that the generic "UTF-16" is not a predefined value. Instead, only + * the specific UTF-16LE and UTF-16BE are present. + */ +typedef enum { + XML_CHAR_ENCODING_ERROR= -1, /* No char encoding detected */ + XML_CHAR_ENCODING_NONE= 0, /* No char encoding detected */ + XML_CHAR_ENCODING_UTF8= 1, /* UTF-8 */ + XML_CHAR_ENCODING_UTF16LE= 2, /* UTF-16 little endian */ + XML_CHAR_ENCODING_UTF16BE= 3, /* UTF-16 big endian */ + XML_CHAR_ENCODING_UCS4LE= 4, /* UCS-4 little endian */ + XML_CHAR_ENCODING_UCS4BE= 5, /* UCS-4 big endian */ + XML_CHAR_ENCODING_EBCDIC= 6, /* EBCDIC uh! */ + XML_CHAR_ENCODING_UCS4_2143=7, /* UCS-4 unusual ordering */ + XML_CHAR_ENCODING_UCS4_3412=8, /* UCS-4 unusual ordering */ + XML_CHAR_ENCODING_UCS2= 9, /* UCS-2 */ + XML_CHAR_ENCODING_8859_1= 10,/* ISO-8859-1 ISO Latin 1 */ + XML_CHAR_ENCODING_8859_2= 11,/* ISO-8859-2 ISO Latin 2 */ + XML_CHAR_ENCODING_8859_3= 12,/* ISO-8859-3 */ + XML_CHAR_ENCODING_8859_4= 13,/* ISO-8859-4 */ + XML_CHAR_ENCODING_8859_5= 14,/* ISO-8859-5 */ + XML_CHAR_ENCODING_8859_6= 15,/* ISO-8859-6 */ + XML_CHAR_ENCODING_8859_7= 16,/* ISO-8859-7 */ + XML_CHAR_ENCODING_8859_8= 17,/* ISO-8859-8 */ + XML_CHAR_ENCODING_8859_9= 18,/* ISO-8859-9 */ + XML_CHAR_ENCODING_2022_JP= 19,/* ISO-2022-JP */ + XML_CHAR_ENCODING_SHIFT_JIS=20,/* Shift_JIS */ + XML_CHAR_ENCODING_EUC_JP= 21,/* EUC-JP */ + XML_CHAR_ENCODING_ASCII= 22 /* pure ASCII */ +} xmlCharEncoding; + +/** + * xmlCharEncodingInputFunc: + * @out: a pointer to an array of bytes to store the UTF-8 result + * @outlen: the length of @out + * @in: a pointer to an array of chars in the original encoding + * @inlen: the length of @in + * + * Take a block of chars in the original encoding and try to convert + * it to an UTF-8 block of chars out. + * + * Returns the number of bytes written, -1 if lack of space, or -2 + * if the transcoding failed. + * The value of @inlen after return is the number of octets consumed + * if the return value is positive, else unpredictiable. + * The value of @outlen after return is the number of octets consumed. + */ +typedef int (* xmlCharEncodingInputFunc)(unsigned char *out, int *outlen, + const unsigned char *in, int *inlen); + + +/** + * xmlCharEncodingOutputFunc: + * @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 + * + * Take a block of UTF-8 chars in and try to convert it to another + * encoding. + * Note: a first call designed to produce heading info is called with + * in = NULL. If stateful this should also initialize the encoder state. + * + * Returns the number of bytes written, -1 if lack of space, or -2 + * if the transcoding failed. + * The value of @inlen after return is the number of octets consumed + * if the return value is positive, else unpredictiable. + * The value of @outlen after return is the number of octets produced. + */ +typedef int (* xmlCharEncodingOutputFunc)(unsigned char *out, int *outlen, + const unsigned char *in, int *inlen); + + +/* + * Block defining the handlers for non UTF-8 encodings. + * If iconv is supported, there are two extra fields. + */ + +typedef struct _xmlCharEncodingHandler xmlCharEncodingHandler; +typedef xmlCharEncodingHandler *xmlCharEncodingHandlerPtr; +struct _xmlCharEncodingHandler { + char *name; + xmlCharEncodingInputFunc input; + xmlCharEncodingOutputFunc output; +#ifdef LIBXML_ICONV_ENABLED + iconv_t iconv_in; + iconv_t iconv_out; +#endif /* LIBXML_ICONV_ENABLED */ +}; + +#ifdef __cplusplus +} +#endif +#include +#ifdef __cplusplus +extern "C" { +#endif + +/* + * Interfaces for encoding handlers. + */ +XMLPUBFUN void XMLCALL + xmlInitCharEncodingHandlers (void); +XMLPUBFUN void XMLCALL + xmlCleanupCharEncodingHandlers (void); +XMLPUBFUN void XMLCALL + xmlRegisterCharEncodingHandler (xmlCharEncodingHandlerPtr handler); +XMLPUBFUN xmlCharEncodingHandlerPtr XMLCALL + xmlGetCharEncodingHandler (xmlCharEncoding enc); +XMLPUBFUN xmlCharEncodingHandlerPtr XMLCALL + xmlFindCharEncodingHandler (const char *name); +XMLPUBFUN xmlCharEncodingHandlerPtr XMLCALL + xmlNewCharEncodingHandler (const char *name, + xmlCharEncodingInputFunc input, + xmlCharEncodingOutputFunc output); + +/* + * Interfaces for encoding names and aliases. + */ +XMLPUBFUN int XMLCALL + xmlAddEncodingAlias (const char *name, + const char *alias); +XMLPUBFUN int XMLCALL + xmlDelEncodingAlias (const char *alias); +XMLPUBFUN const char * XMLCALL + xmlGetEncodingAlias (const char *alias); +XMLPUBFUN void XMLCALL + xmlCleanupEncodingAliases (void); +XMLPUBFUN xmlCharEncoding XMLCALL + xmlParseCharEncoding (const char *name); +XMLPUBFUN const char * XMLCALL + xmlGetCharEncodingName (xmlCharEncoding enc); + +/* + * Interfaces directly used by the parsers. + */ +XMLPUBFUN xmlCharEncoding XMLCALL + xmlDetectCharEncoding (const unsigned char *in, + int len); + +XMLPUBFUN int XMLCALL + xmlCharEncOutFunc (xmlCharEncodingHandler *handler, + xmlBufferPtr out, + xmlBufferPtr in); + +XMLPUBFUN int XMLCALL + xmlCharEncInFunc (xmlCharEncodingHandler *handler, + xmlBufferPtr out, + xmlBufferPtr in); +XMLPUBFUN int XMLCALL + xmlCharEncFirstLine (xmlCharEncodingHandler *handler, + xmlBufferPtr out, + xmlBufferPtr in); +XMLPUBFUN int XMLCALL + xmlCharEncCloseFunc (xmlCharEncodingHandler *handler); + +/* + * Export a few useful functions + */ +#ifdef LIBXML_OUTPUT_ENABLED +XMLPUBFUN int XMLCALL + UTF8Toisolat1 (unsigned char *out, + int *outlen, + const unsigned char *in, + int *inlen); +#endif /* LIBXML_OUTPUT_ENABLED */ +XMLPUBFUN int XMLCALL + isolat1ToUTF8 (unsigned char *out, + int *outlen, + const unsigned char *in, + int *inlen); +#ifdef __cplusplus +} +#endif + +#endif /* __XML_CHAR_ENCODING_H__ */ diff --git a/lib/libxml2/include/libxml/entities.h b/lib/libxml2/include/libxml/entities.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/entities.h @@ -0,0 +1,150 @@ +/* + * Summary: interface for the XML entities handling + * Description: this module provides some of the entity API needed + * for the parser and applications. + * + * Copy: See Copyright for the status of this software. + * + * Author: Daniel Veillard + */ + +#ifndef __XML_ENTITIES_H__ +#define __XML_ENTITIES_H__ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * The different valid entity types. + */ +typedef enum { + XML_INTERNAL_GENERAL_ENTITY = 1, + XML_EXTERNAL_GENERAL_PARSED_ENTITY = 2, + XML_EXTERNAL_GENERAL_UNPARSED_ENTITY = 3, + XML_INTERNAL_PARAMETER_ENTITY = 4, + XML_EXTERNAL_PARAMETER_ENTITY = 5, + XML_INTERNAL_PREDEFINED_ENTITY = 6 +} xmlEntityType; + +/* + * An unit of storage for an entity, contains the string, the value + * and the linkind data needed for the linking in the hash table. + */ + +struct _xmlEntity { + void *_private; /* application data */ + xmlElementType type; /* XML_ENTITY_DECL, must be second ! */ + const xmlChar *name; /* Entity name */ + struct _xmlNode *children; /* First child link */ + struct _xmlNode *last; /* Last child link */ + struct _xmlDtd *parent; /* -> DTD */ + struct _xmlNode *next; /* next sibling link */ + struct _xmlNode *prev; /* previous sibling link */ + struct _xmlDoc *doc; /* the containing document */ + + xmlChar *orig; /* content without ref substitution */ + xmlChar *content; /* content or ndata if unparsed */ + int length; /* the content length */ + xmlEntityType etype; /* The entity type */ + const xmlChar *ExternalID; /* External identifier for PUBLIC */ + const xmlChar *SystemID; /* URI for a SYSTEM or PUBLIC Entity */ + + struct _xmlEntity *nexte; /* unused */ + const xmlChar *URI; /* the full URI as computed */ + int owner; /* does the entity own the childrens */ + int checked; /* was the entity content checked */ + /* this is also used to count entites + * references done from that entity */ +}; + +/* + * All entities are stored in an hash table. + * There is 2 separate hash tables for global and parameter entities. + */ + +typedef struct _xmlHashTable xmlEntitiesTable; +typedef xmlEntitiesTable *xmlEntitiesTablePtr; + +/* + * External functions: + */ + +#ifdef LIBXML_LEGACY_ENABLED +XMLPUBFUN void XMLCALL + xmlInitializePredefinedEntities (void); +#endif /* LIBXML_LEGACY_ENABLED */ + +XMLPUBFUN xmlEntityPtr XMLCALL + xmlNewEntity (xmlDocPtr doc, + const xmlChar *name, + int type, + const xmlChar *ExternalID, + const xmlChar *SystemID, + const xmlChar *content); +XMLPUBFUN xmlEntityPtr XMLCALL + xmlAddDocEntity (xmlDocPtr doc, + const xmlChar *name, + int type, + const xmlChar *ExternalID, + const xmlChar *SystemID, + const xmlChar *content); +XMLPUBFUN xmlEntityPtr XMLCALL + xmlAddDtdEntity (xmlDocPtr doc, + const xmlChar *name, + int type, + const xmlChar *ExternalID, + const xmlChar *SystemID, + const xmlChar *content); +XMLPUBFUN xmlEntityPtr XMLCALL + xmlGetPredefinedEntity (const xmlChar *name); +XMLPUBFUN xmlEntityPtr XMLCALL + xmlGetDocEntity (xmlDocPtr doc, + const xmlChar *name); +XMLPUBFUN xmlEntityPtr XMLCALL + xmlGetDtdEntity (xmlDocPtr doc, + const xmlChar *name); +XMLPUBFUN xmlEntityPtr XMLCALL + xmlGetParameterEntity (xmlDocPtr doc, + const xmlChar *name); +#ifdef LIBXML_LEGACY_ENABLED +XMLPUBFUN const xmlChar * XMLCALL + xmlEncodeEntities (xmlDocPtr doc, + const xmlChar *input); +#endif /* LIBXML_LEGACY_ENABLED */ +XMLPUBFUN xmlChar * XMLCALL + xmlEncodeEntitiesReentrant(xmlDocPtr doc, + const xmlChar *input); +XMLPUBFUN xmlChar * XMLCALL + xmlEncodeSpecialChars (xmlDocPtr doc, + const xmlChar *input); +XMLPUBFUN xmlEntitiesTablePtr XMLCALL + xmlCreateEntitiesTable (void); +#ifdef LIBXML_TREE_ENABLED +XMLPUBFUN xmlEntitiesTablePtr XMLCALL + xmlCopyEntitiesTable (xmlEntitiesTablePtr table); +#endif /* LIBXML_TREE_ENABLED */ +XMLPUBFUN void XMLCALL + xmlFreeEntitiesTable (xmlEntitiesTablePtr table); +#ifdef LIBXML_OUTPUT_ENABLED +XMLPUBFUN void XMLCALL + xmlDumpEntitiesTable (xmlBufferPtr buf, + xmlEntitiesTablePtr table); +XMLPUBFUN void XMLCALL + xmlDumpEntityDecl (xmlBufferPtr buf, + xmlEntityPtr ent); +#endif /* LIBXML_OUTPUT_ENABLED */ +#ifdef LIBXML_LEGACY_ENABLED +XMLPUBFUN void XMLCALL + xmlCleanupPredefinedEntities(void); +#endif /* LIBXML_LEGACY_ENABLED */ + + +#ifdef __cplusplus +} +#endif + +# endif /* __XML_ENTITIES_H__ */ diff --git a/lib/libxml2/include/libxml/globals.h b/lib/libxml2/include/libxml/globals.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/globals.h @@ -0,0 +1,502 @@ +/* + * Summary: interface for all global variables of the library + * Description: all the global variables and thread handling for + * those variables is handled by this module. + * + * The bottom of this file is automatically generated by build_glob.py + * based on the description file global.data + * + * Copy: See Copyright for the status of this software. + * + * Author: Gary Pennington , Daniel Veillard + */ + +#ifndef __XML_GLOBALS_H +#define __XML_GLOBALS_H + +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +XMLPUBFUN void XMLCALL xmlInitGlobals(void); +XMLPUBFUN void XMLCALL xmlCleanupGlobals(void); + +/** + * xmlParserInputBufferCreateFilenameFunc: + * @URI: the URI to read from + * @enc: the requested source encoding + * + * Signature for the function doing the lookup for a suitable input method + * corresponding to an URI. + * + * Returns the new xmlParserInputBufferPtr in case of success or NULL if no + * method was found. + */ +typedef xmlParserInputBufferPtr (*xmlParserInputBufferCreateFilenameFunc) (const char *URI, xmlCharEncoding enc); + +/** + * xmlOutputBufferCreateFilenameFunc: + * @URI: the URI to write to + * @enc: the requested target encoding + * + * Signature for the function doing the lookup for a suitable output method + * corresponding to an URI. + * + * Returns the new xmlOutputBufferPtr in case of success or NULL if no + * method was found. + */ +typedef xmlOutputBufferPtr (*xmlOutputBufferCreateFilenameFunc) (const char *URI, xmlCharEncodingHandlerPtr encoder, int compression); + +XMLPUBFUN xmlParserInputBufferCreateFilenameFunc +XMLCALL xmlParserInputBufferCreateFilenameDefault (xmlParserInputBufferCreateFilenameFunc func); +XMLPUBFUN xmlOutputBufferCreateFilenameFunc +XMLCALL xmlOutputBufferCreateFilenameDefault (xmlOutputBufferCreateFilenameFunc func); + +/* + * Externally global symbols which need to be protected for backwards + * compatibility support. + */ + +#undef docbDefaultSAXHandler +#undef htmlDefaultSAXHandler +#undef oldXMLWDcompatibility +#undef xmlBufferAllocScheme +#undef xmlDefaultBufferSize +#undef xmlDefaultSAXHandler +#undef xmlDefaultSAXLocator +#undef xmlDoValidityCheckingDefaultValue +#undef xmlFree +#undef xmlGenericError +#undef xmlStructuredError +#undef xmlGenericErrorContext +#undef xmlStructuredErrorContext +#undef xmlGetWarningsDefaultValue +#undef xmlIndentTreeOutput +#undef xmlTreeIndentString +#undef xmlKeepBlanksDefaultValue +#undef xmlLineNumbersDefaultValue +#undef xmlLoadExtDtdDefaultValue +#undef xmlMalloc +#undef xmlMallocAtomic +#undef xmlMemStrdup +#undef xmlParserDebugEntities +#undef xmlParserVersion +#undef xmlPedanticParserDefaultValue +#undef xmlRealloc +#undef xmlSaveNoEmptyTags +#undef xmlSubstituteEntitiesDefaultValue +#undef xmlRegisterNodeDefaultValue +#undef xmlDeregisterNodeDefaultValue +#undef xmlLastError +#undef xmlParserInputBufferCreateFilenameValue +#undef xmlOutputBufferCreateFilenameValue + +/** + * xmlRegisterNodeFunc: + * @node: the current node + * + * Signature for the registration callback of a created node + */ +typedef void (*xmlRegisterNodeFunc) (xmlNodePtr node); +/** + * xmlDeregisterNodeFunc: + * @node: the current node + * + * Signature for the deregistration callback of a discarded node + */ +typedef void (*xmlDeregisterNodeFunc) (xmlNodePtr node); + +typedef struct _xmlGlobalState xmlGlobalState; +typedef xmlGlobalState *xmlGlobalStatePtr; +struct _xmlGlobalState +{ + const char *xmlParserVersion; + + xmlSAXLocator xmlDefaultSAXLocator; + xmlSAXHandlerV1 xmlDefaultSAXHandler; + xmlSAXHandlerV1 docbDefaultSAXHandler; + xmlSAXHandlerV1 htmlDefaultSAXHandler; + + xmlFreeFunc xmlFree; + xmlMallocFunc xmlMalloc; + xmlStrdupFunc xmlMemStrdup; + xmlReallocFunc xmlRealloc; + + xmlGenericErrorFunc xmlGenericError; + xmlStructuredErrorFunc xmlStructuredError; + void *xmlGenericErrorContext; + + int oldXMLWDcompatibility; + + xmlBufferAllocationScheme xmlBufferAllocScheme; + int xmlDefaultBufferSize; + + int xmlSubstituteEntitiesDefaultValue; + int xmlDoValidityCheckingDefaultValue; + int xmlGetWarningsDefaultValue; + int xmlKeepBlanksDefaultValue; + int xmlLineNumbersDefaultValue; + int xmlLoadExtDtdDefaultValue; + int xmlParserDebugEntities; + int xmlPedanticParserDefaultValue; + + int xmlSaveNoEmptyTags; + int xmlIndentTreeOutput; + const char *xmlTreeIndentString; + + xmlRegisterNodeFunc xmlRegisterNodeDefaultValue; + xmlDeregisterNodeFunc xmlDeregisterNodeDefaultValue; + + xmlMallocFunc xmlMallocAtomic; + xmlError xmlLastError; + + xmlParserInputBufferCreateFilenameFunc xmlParserInputBufferCreateFilenameValue; + xmlOutputBufferCreateFilenameFunc xmlOutputBufferCreateFilenameValue; + + void *xmlStructuredErrorContext; +}; + +#ifdef __cplusplus +} +#endif +#include +#ifdef __cplusplus +extern "C" { +#endif + +XMLPUBFUN void XMLCALL xmlInitializeGlobalState(xmlGlobalStatePtr gs); + +XMLPUBFUN void XMLCALL xmlThrDefSetGenericErrorFunc(void *ctx, xmlGenericErrorFunc handler); + +XMLPUBFUN void XMLCALL xmlThrDefSetStructuredErrorFunc(void *ctx, xmlStructuredErrorFunc handler); + +XMLPUBFUN xmlRegisterNodeFunc XMLCALL xmlRegisterNodeDefault(xmlRegisterNodeFunc func); +XMLPUBFUN xmlRegisterNodeFunc XMLCALL xmlThrDefRegisterNodeDefault(xmlRegisterNodeFunc func); +XMLPUBFUN xmlDeregisterNodeFunc XMLCALL xmlDeregisterNodeDefault(xmlDeregisterNodeFunc func); +XMLPUBFUN xmlDeregisterNodeFunc XMLCALL xmlThrDefDeregisterNodeDefault(xmlDeregisterNodeFunc func); + +XMLPUBFUN xmlOutputBufferCreateFilenameFunc XMLCALL + xmlThrDefOutputBufferCreateFilenameDefault(xmlOutputBufferCreateFilenameFunc func); +XMLPUBFUN xmlParserInputBufferCreateFilenameFunc XMLCALL + xmlThrDefParserInputBufferCreateFilenameDefault(xmlParserInputBufferCreateFilenameFunc func); + +/** DOC_DISABLE */ +/* + * In general the memory allocation entry points are not kept + * thread specific but this can be overridden by LIBXML_THREAD_ALLOC_ENABLED + * - xmlMalloc + * - xmlMallocAtomic + * - xmlRealloc + * - xmlMemStrdup + * - xmlFree + */ + +#ifdef LIBXML_THREAD_ALLOC_ENABLED +#ifdef LIBXML_THREAD_ENABLED +XMLPUBFUN xmlMallocFunc * XMLCALL __xmlMalloc(void); +#define xmlMalloc \ +(*(__xmlMalloc())) +#else +XMLPUBVAR xmlMallocFunc xmlMalloc; +#endif + +#ifdef LIBXML_THREAD_ENABLED +XMLPUBFUN xmlMallocFunc * XMLCALL __xmlMallocAtomic(void); +#define xmlMallocAtomic \ +(*(__xmlMallocAtomic())) +#else +XMLPUBVAR xmlMallocFunc xmlMallocAtomic; +#endif + +#ifdef LIBXML_THREAD_ENABLED +XMLPUBFUN xmlReallocFunc * XMLCALL __xmlRealloc(void); +#define xmlRealloc \ +(*(__xmlRealloc())) +#else +XMLPUBVAR xmlReallocFunc xmlRealloc; +#endif + +#ifdef LIBXML_THREAD_ENABLED +XMLPUBFUN xmlFreeFunc * XMLCALL __xmlFree(void); +#define xmlFree \ +(*(__xmlFree())) +#else +XMLPUBVAR xmlFreeFunc xmlFree; +#endif + +#ifdef LIBXML_THREAD_ENABLED +XMLPUBFUN xmlStrdupFunc * XMLCALL __xmlMemStrdup(void); +#define xmlMemStrdup \ +(*(__xmlMemStrdup())) +#else +XMLPUBVAR xmlStrdupFunc xmlMemStrdup; +#endif + +#else /* !LIBXML_THREAD_ALLOC_ENABLED */ +XMLPUBVAR xmlMallocFunc xmlMalloc; +XMLPUBVAR xmlMallocFunc xmlMallocAtomic; +XMLPUBVAR xmlReallocFunc xmlRealloc; +XMLPUBVAR xmlFreeFunc xmlFree; +XMLPUBVAR xmlStrdupFunc xmlMemStrdup; +#endif /* LIBXML_THREAD_ALLOC_ENABLED */ + +#ifdef LIBXML_DOCB_ENABLED +XMLPUBFUN xmlSAXHandlerV1 * XMLCALL __docbDefaultSAXHandler(void); +#ifdef LIBXML_THREAD_ENABLED +#define docbDefaultSAXHandler \ +(*(__docbDefaultSAXHandler())) +#else +XMLPUBVAR xmlSAXHandlerV1 docbDefaultSAXHandler; +#endif +#endif + +#ifdef LIBXML_HTML_ENABLED +XMLPUBFUN xmlSAXHandlerV1 * XMLCALL __htmlDefaultSAXHandler(void); +#ifdef LIBXML_THREAD_ENABLED +#define htmlDefaultSAXHandler \ +(*(__htmlDefaultSAXHandler())) +#else +XMLPUBVAR xmlSAXHandlerV1 htmlDefaultSAXHandler; +#endif +#endif + +XMLPUBFUN xmlError * XMLCALL __xmlLastError(void); +#ifdef LIBXML_THREAD_ENABLED +#define xmlLastError \ +(*(__xmlLastError())) +#else +XMLPUBVAR xmlError xmlLastError; +#endif + +/* + * Everything starting from the line below is + * Automatically generated by build_glob.py. + * Do not modify the previous line. + */ + + +XMLPUBFUN int * XMLCALL __oldXMLWDcompatibility(void); +#ifdef LIBXML_THREAD_ENABLED +#define oldXMLWDcompatibility \ +(*(__oldXMLWDcompatibility())) +#else +XMLPUBVAR int oldXMLWDcompatibility; +#endif + +XMLPUBFUN xmlBufferAllocationScheme * XMLCALL __xmlBufferAllocScheme(void); +#ifdef LIBXML_THREAD_ENABLED +#define xmlBufferAllocScheme \ +(*(__xmlBufferAllocScheme())) +#else +XMLPUBVAR xmlBufferAllocationScheme xmlBufferAllocScheme; +#endif +XMLPUBFUN xmlBufferAllocationScheme XMLCALL xmlThrDefBufferAllocScheme(xmlBufferAllocationScheme v); + +XMLPUBFUN int * XMLCALL __xmlDefaultBufferSize(void); +#ifdef LIBXML_THREAD_ENABLED +#define xmlDefaultBufferSize \ +(*(__xmlDefaultBufferSize())) +#else +XMLPUBVAR int xmlDefaultBufferSize; +#endif +XMLPUBFUN int XMLCALL xmlThrDefDefaultBufferSize(int v); + +XMLPUBFUN xmlSAXHandlerV1 * XMLCALL __xmlDefaultSAXHandler(void); +#ifdef LIBXML_THREAD_ENABLED +#define xmlDefaultSAXHandler \ +(*(__xmlDefaultSAXHandler())) +#else +XMLPUBVAR xmlSAXHandlerV1 xmlDefaultSAXHandler; +#endif + +XMLPUBFUN xmlSAXLocator * XMLCALL __xmlDefaultSAXLocator(void); +#ifdef LIBXML_THREAD_ENABLED +#define xmlDefaultSAXLocator \ +(*(__xmlDefaultSAXLocator())) +#else +XMLPUBVAR xmlSAXLocator xmlDefaultSAXLocator; +#endif + +XMLPUBFUN int * XMLCALL __xmlDoValidityCheckingDefaultValue(void); +#ifdef LIBXML_THREAD_ENABLED +#define xmlDoValidityCheckingDefaultValue \ +(*(__xmlDoValidityCheckingDefaultValue())) +#else +XMLPUBVAR int xmlDoValidityCheckingDefaultValue; +#endif +XMLPUBFUN int XMLCALL xmlThrDefDoValidityCheckingDefaultValue(int v); + +XMLPUBFUN xmlGenericErrorFunc * XMLCALL __xmlGenericError(void); +#ifdef LIBXML_THREAD_ENABLED +#define xmlGenericError \ +(*(__xmlGenericError())) +#else +XMLPUBVAR xmlGenericErrorFunc xmlGenericError; +#endif + +XMLPUBFUN xmlStructuredErrorFunc * XMLCALL __xmlStructuredError(void); +#ifdef LIBXML_THREAD_ENABLED +#define xmlStructuredError \ +(*(__xmlStructuredError())) +#else +XMLPUBVAR xmlStructuredErrorFunc xmlStructuredError; +#endif + +XMLPUBFUN void * * XMLCALL __xmlGenericErrorContext(void); +#ifdef LIBXML_THREAD_ENABLED +#define xmlGenericErrorContext \ +(*(__xmlGenericErrorContext())) +#else +XMLPUBVAR void * xmlGenericErrorContext; +#endif + +XMLPUBFUN void * * XMLCALL __xmlStructuredErrorContext(void); +#ifdef LIBXML_THREAD_ENABLED +#define xmlStructuredErrorContext \ +(*(__xmlStructuredErrorContext())) +#else +XMLPUBVAR void * xmlStructuredErrorContext; +#endif + +XMLPUBFUN int * XMLCALL __xmlGetWarningsDefaultValue(void); +#ifdef LIBXML_THREAD_ENABLED +#define xmlGetWarningsDefaultValue \ +(*(__xmlGetWarningsDefaultValue())) +#else +XMLPUBVAR int xmlGetWarningsDefaultValue; +#endif +XMLPUBFUN int XMLCALL xmlThrDefGetWarningsDefaultValue(int v); + +XMLPUBFUN int * XMLCALL __xmlIndentTreeOutput(void); +#ifdef LIBXML_THREAD_ENABLED +#define xmlIndentTreeOutput \ +(*(__xmlIndentTreeOutput())) +#else +XMLPUBVAR int xmlIndentTreeOutput; +#endif +XMLPUBFUN int XMLCALL xmlThrDefIndentTreeOutput(int v); + +XMLPUBFUN const char * * XMLCALL __xmlTreeIndentString(void); +#ifdef LIBXML_THREAD_ENABLED +#define xmlTreeIndentString \ +(*(__xmlTreeIndentString())) +#else +XMLPUBVAR const char * xmlTreeIndentString; +#endif +XMLPUBFUN const char * XMLCALL xmlThrDefTreeIndentString(const char * v); + +XMLPUBFUN int * XMLCALL __xmlKeepBlanksDefaultValue(void); +#ifdef LIBXML_THREAD_ENABLED +#define xmlKeepBlanksDefaultValue \ +(*(__xmlKeepBlanksDefaultValue())) +#else +XMLPUBVAR int xmlKeepBlanksDefaultValue; +#endif +XMLPUBFUN int XMLCALL xmlThrDefKeepBlanksDefaultValue(int v); + +XMLPUBFUN int * XMLCALL __xmlLineNumbersDefaultValue(void); +#ifdef LIBXML_THREAD_ENABLED +#define xmlLineNumbersDefaultValue \ +(*(__xmlLineNumbersDefaultValue())) +#else +XMLPUBVAR int xmlLineNumbersDefaultValue; +#endif +XMLPUBFUN int XMLCALL xmlThrDefLineNumbersDefaultValue(int v); + +XMLPUBFUN int * XMLCALL __xmlLoadExtDtdDefaultValue(void); +#ifdef LIBXML_THREAD_ENABLED +#define xmlLoadExtDtdDefaultValue \ +(*(__xmlLoadExtDtdDefaultValue())) +#else +XMLPUBVAR int xmlLoadExtDtdDefaultValue; +#endif +XMLPUBFUN int XMLCALL xmlThrDefLoadExtDtdDefaultValue(int v); + +XMLPUBFUN int * XMLCALL __xmlParserDebugEntities(void); +#ifdef LIBXML_THREAD_ENABLED +#define xmlParserDebugEntities \ +(*(__xmlParserDebugEntities())) +#else +XMLPUBVAR int xmlParserDebugEntities; +#endif +XMLPUBFUN int XMLCALL xmlThrDefParserDebugEntities(int v); + +XMLPUBFUN const char * * XMLCALL __xmlParserVersion(void); +#ifdef LIBXML_THREAD_ENABLED +#define xmlParserVersion \ +(*(__xmlParserVersion())) +#else +XMLPUBVAR const char * xmlParserVersion; +#endif + +XMLPUBFUN int * XMLCALL __xmlPedanticParserDefaultValue(void); +#ifdef LIBXML_THREAD_ENABLED +#define xmlPedanticParserDefaultValue \ +(*(__xmlPedanticParserDefaultValue())) +#else +XMLPUBVAR int xmlPedanticParserDefaultValue; +#endif +XMLPUBFUN int XMLCALL xmlThrDefPedanticParserDefaultValue(int v); + +XMLPUBFUN int * XMLCALL __xmlSaveNoEmptyTags(void); +#ifdef LIBXML_THREAD_ENABLED +#define xmlSaveNoEmptyTags \ +(*(__xmlSaveNoEmptyTags())) +#else +XMLPUBVAR int xmlSaveNoEmptyTags; +#endif +XMLPUBFUN int XMLCALL xmlThrDefSaveNoEmptyTags(int v); + +XMLPUBFUN int * XMLCALL __xmlSubstituteEntitiesDefaultValue(void); +#ifdef LIBXML_THREAD_ENABLED +#define xmlSubstituteEntitiesDefaultValue \ +(*(__xmlSubstituteEntitiesDefaultValue())) +#else +XMLPUBVAR int xmlSubstituteEntitiesDefaultValue; +#endif +XMLPUBFUN int XMLCALL xmlThrDefSubstituteEntitiesDefaultValue(int v); + +XMLPUBFUN xmlRegisterNodeFunc * XMLCALL __xmlRegisterNodeDefaultValue(void); +#ifdef LIBXML_THREAD_ENABLED +#define xmlRegisterNodeDefaultValue \ +(*(__xmlRegisterNodeDefaultValue())) +#else +XMLPUBVAR xmlRegisterNodeFunc xmlRegisterNodeDefaultValue; +#endif + +XMLPUBFUN xmlDeregisterNodeFunc * XMLCALL __xmlDeregisterNodeDefaultValue(void); +#ifdef LIBXML_THREAD_ENABLED +#define xmlDeregisterNodeDefaultValue \ +(*(__xmlDeregisterNodeDefaultValue())) +#else +XMLPUBVAR xmlDeregisterNodeFunc xmlDeregisterNodeDefaultValue; +#endif + +XMLPUBFUN xmlParserInputBufferCreateFilenameFunc * XMLCALL __xmlParserInputBufferCreateFilenameValue(void); +#ifdef LIBXML_THREAD_ENABLED +#define xmlParserInputBufferCreateFilenameValue \ +(*(__xmlParserInputBufferCreateFilenameValue())) +#else +XMLPUBVAR xmlParserInputBufferCreateFilenameFunc xmlParserInputBufferCreateFilenameValue; +#endif + +XMLPUBFUN xmlOutputBufferCreateFilenameFunc * XMLCALL __xmlOutputBufferCreateFilenameValue(void); +#ifdef LIBXML_THREAD_ENABLED +#define xmlOutputBufferCreateFilenameValue \ +(*(__xmlOutputBufferCreateFilenameValue())) +#else +XMLPUBVAR xmlOutputBufferCreateFilenameFunc xmlOutputBufferCreateFilenameValue; +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* __XML_GLOBALS_H */ diff --git a/lib/libxml2/include/libxml/hash.h b/lib/libxml2/include/libxml/hash.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/hash.h @@ -0,0 +1,233 @@ +/* + * Summary: Chained hash tables + * Description: This module implements the hash table support used in + * various places in the library. + * + * Copy: See Copyright for the status of this software. + * + * Author: Bjorn Reese + */ + +#ifndef __XML_HASH_H__ +#define __XML_HASH_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * The hash table. + */ +typedef struct _xmlHashTable xmlHashTable; +typedef xmlHashTable *xmlHashTablePtr; + +#ifdef __cplusplus +} +#endif + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * Recent version of gcc produce a warning when a function pointer is assigned + * to an object pointer, or vice versa. The following macro is a dirty hack + * to allow suppression of the warning. If your architecture has function + * pointers which are a different size than a void pointer, there may be some + * serious trouble within the library. + */ +/** + * XML_CAST_FPTR: + * @fptr: pointer to a function + * + * Macro to do a casting from an object pointer to a + * function pointer without encountering a warning from + * gcc + * + * #define XML_CAST_FPTR(fptr) (*(void **)(&fptr)) + * This macro violated ISO C aliasing rules (gcc4 on s390 broke) + * so it is disabled now + */ + +#define XML_CAST_FPTR(fptr) fptr + + +/* + * function types: + */ +/** + * xmlHashDeallocator: + * @payload: the data in the hash + * @name: the name associated + * + * Callback to free data from a hash. + */ +typedef void (*xmlHashDeallocator)(void *payload, xmlChar *name); +/** + * xmlHashCopier: + * @payload: the data in the hash + * @name: the name associated + * + * Callback to copy data from a hash. + * + * Returns a copy of the data or NULL in case of error. + */ +typedef void *(*xmlHashCopier)(void *payload, xmlChar *name); +/** + * xmlHashScanner: + * @payload: the data in the hash + * @data: extra scannner data + * @name: the name associated + * + * Callback when scanning data in a hash with the simple scanner. + */ +typedef void (*xmlHashScanner)(void *payload, void *data, xmlChar *name); +/** + * xmlHashScannerFull: + * @payload: the data in the hash + * @data: extra scannner data + * @name: the name associated + * @name2: the second name associated + * @name3: the third name associated + * + * Callback when scanning data in a hash with the full scanner. + */ +typedef void (*xmlHashScannerFull)(void *payload, void *data, + const xmlChar *name, const xmlChar *name2, + const xmlChar *name3); + +/* + * Constructor and destructor. + */ +XMLPUBFUN xmlHashTablePtr XMLCALL + xmlHashCreate (int size); +XMLPUBFUN xmlHashTablePtr XMLCALL + xmlHashCreateDict(int size, + xmlDictPtr dict); +XMLPUBFUN void XMLCALL + xmlHashFree (xmlHashTablePtr table, + xmlHashDeallocator f); + +/* + * Add a new entry to the hash table. + */ +XMLPUBFUN int XMLCALL + xmlHashAddEntry (xmlHashTablePtr table, + const xmlChar *name, + void *userdata); +XMLPUBFUN int XMLCALL + xmlHashUpdateEntry(xmlHashTablePtr table, + const xmlChar *name, + void *userdata, + xmlHashDeallocator f); +XMLPUBFUN int XMLCALL + xmlHashAddEntry2(xmlHashTablePtr table, + const xmlChar *name, + const xmlChar *name2, + void *userdata); +XMLPUBFUN int XMLCALL + xmlHashUpdateEntry2(xmlHashTablePtr table, + const xmlChar *name, + const xmlChar *name2, + void *userdata, + xmlHashDeallocator f); +XMLPUBFUN int XMLCALL + xmlHashAddEntry3(xmlHashTablePtr table, + const xmlChar *name, + const xmlChar *name2, + const xmlChar *name3, + void *userdata); +XMLPUBFUN int XMLCALL + xmlHashUpdateEntry3(xmlHashTablePtr table, + const xmlChar *name, + const xmlChar *name2, + const xmlChar *name3, + void *userdata, + xmlHashDeallocator f); + +/* + * Remove an entry from the hash table. + */ +XMLPUBFUN int XMLCALL + xmlHashRemoveEntry(xmlHashTablePtr table, const xmlChar *name, + xmlHashDeallocator f); +XMLPUBFUN int XMLCALL + xmlHashRemoveEntry2(xmlHashTablePtr table, const xmlChar *name, + const xmlChar *name2, xmlHashDeallocator f); +XMLPUBFUN int XMLCALL + xmlHashRemoveEntry3(xmlHashTablePtr table, const xmlChar *name, + const xmlChar *name2, const xmlChar *name3, + xmlHashDeallocator f); + +/* + * Retrieve the userdata. + */ +XMLPUBFUN void * XMLCALL + xmlHashLookup (xmlHashTablePtr table, + const xmlChar *name); +XMLPUBFUN void * XMLCALL + xmlHashLookup2 (xmlHashTablePtr table, + const xmlChar *name, + const xmlChar *name2); +XMLPUBFUN void * XMLCALL + xmlHashLookup3 (xmlHashTablePtr table, + const xmlChar *name, + const xmlChar *name2, + const xmlChar *name3); +XMLPUBFUN void * XMLCALL + xmlHashQLookup (xmlHashTablePtr table, + const xmlChar *name, + const xmlChar *prefix); +XMLPUBFUN void * XMLCALL + xmlHashQLookup2 (xmlHashTablePtr table, + const xmlChar *name, + const xmlChar *prefix, + const xmlChar *name2, + const xmlChar *prefix2); +XMLPUBFUN void * XMLCALL + xmlHashQLookup3 (xmlHashTablePtr table, + const xmlChar *name, + const xmlChar *prefix, + const xmlChar *name2, + const xmlChar *prefix2, + const xmlChar *name3, + const xmlChar *prefix3); + +/* + * Helpers. + */ +XMLPUBFUN xmlHashTablePtr XMLCALL + xmlHashCopy (xmlHashTablePtr table, + xmlHashCopier f); +XMLPUBFUN int XMLCALL + xmlHashSize (xmlHashTablePtr table); +XMLPUBFUN void XMLCALL + xmlHashScan (xmlHashTablePtr table, + xmlHashScanner f, + void *data); +XMLPUBFUN void XMLCALL + xmlHashScan3 (xmlHashTablePtr table, + const xmlChar *name, + const xmlChar *name2, + const xmlChar *name3, + xmlHashScanner f, + void *data); +XMLPUBFUN void XMLCALL + xmlHashScanFull (xmlHashTablePtr table, + xmlHashScannerFull f, + void *data); +XMLPUBFUN void XMLCALL + xmlHashScanFull3(xmlHashTablePtr table, + const xmlChar *name, + const xmlChar *name2, + const xmlChar *name3, + xmlHashScannerFull f, + void *data); +#ifdef __cplusplus +} +#endif +#endif /* ! __XML_HASH_H__ */ diff --git a/lib/libxml2/include/libxml/list.h b/lib/libxml2/include/libxml/list.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/list.h @@ -0,0 +1,137 @@ +/* + * Summary: lists interfaces + * Description: this module implement the list support used in + * various place in the library. + * + * Copy: See Copyright for the status of this software. + * + * Author: Gary Pennington + */ + +#ifndef __XML_LINK_INCLUDE__ +#define __XML_LINK_INCLUDE__ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct _xmlLink xmlLink; +typedef xmlLink *xmlLinkPtr; + +typedef struct _xmlList xmlList; +typedef xmlList *xmlListPtr; + +/** + * xmlListDeallocator: + * @lk: the data to deallocate + * + * Callback function used to free data from a list. + */ +typedef void (*xmlListDeallocator) (xmlLinkPtr lk); +/** + * xmlListDataCompare: + * @data0: the first data + * @data1: the second data + * + * Callback function used to compare 2 data. + * + * Returns 0 is equality, -1 or 1 otherwise depending on the ordering. + */ +typedef int (*xmlListDataCompare) (const void *data0, const void *data1); +/** + * xmlListWalker: + * @data: the data found in the list + * @user: extra user provided data to the walker + * + * Callback function used when walking a list with xmlListWalk(). + * + * Returns 0 to stop walking the list, 1 otherwise. + */ +typedef int (*xmlListWalker) (const void *data, const void *user); + +/* Creation/Deletion */ +XMLPUBFUN xmlListPtr XMLCALL + xmlListCreate (xmlListDeallocator deallocator, + xmlListDataCompare compare); +XMLPUBFUN void XMLCALL + xmlListDelete (xmlListPtr l); + +/* Basic Operators */ +XMLPUBFUN void * XMLCALL + xmlListSearch (xmlListPtr l, + void *data); +XMLPUBFUN void * XMLCALL + xmlListReverseSearch (xmlListPtr l, + void *data); +XMLPUBFUN int XMLCALL + xmlListInsert (xmlListPtr l, + void *data) ; +XMLPUBFUN int XMLCALL + xmlListAppend (xmlListPtr l, + void *data) ; +XMLPUBFUN int XMLCALL + xmlListRemoveFirst (xmlListPtr l, + void *data); +XMLPUBFUN int XMLCALL + xmlListRemoveLast (xmlListPtr l, + void *data); +XMLPUBFUN int XMLCALL + xmlListRemoveAll (xmlListPtr l, + void *data); +XMLPUBFUN void XMLCALL + xmlListClear (xmlListPtr l); +XMLPUBFUN int XMLCALL + xmlListEmpty (xmlListPtr l); +XMLPUBFUN xmlLinkPtr XMLCALL + xmlListFront (xmlListPtr l); +XMLPUBFUN xmlLinkPtr XMLCALL + xmlListEnd (xmlListPtr l); +XMLPUBFUN int XMLCALL + xmlListSize (xmlListPtr l); + +XMLPUBFUN void XMLCALL + xmlListPopFront (xmlListPtr l); +XMLPUBFUN void XMLCALL + xmlListPopBack (xmlListPtr l); +XMLPUBFUN int XMLCALL + xmlListPushFront (xmlListPtr l, + void *data); +XMLPUBFUN int XMLCALL + xmlListPushBack (xmlListPtr l, + void *data); + +/* Advanced Operators */ +XMLPUBFUN void XMLCALL + xmlListReverse (xmlListPtr l); +XMLPUBFUN void XMLCALL + xmlListSort (xmlListPtr l); +XMLPUBFUN void XMLCALL + xmlListWalk (xmlListPtr l, + xmlListWalker walker, + const void *user); +XMLPUBFUN void XMLCALL + xmlListReverseWalk (xmlListPtr l, + xmlListWalker walker, + const void *user); +XMLPUBFUN void XMLCALL + xmlListMerge (xmlListPtr l1, + xmlListPtr l2); +XMLPUBFUN xmlListPtr XMLCALL + xmlListDup (const xmlListPtr old); +XMLPUBFUN int XMLCALL + xmlListCopy (xmlListPtr cur, + const xmlListPtr old); +/* Link operators */ +XMLPUBFUN void * XMLCALL + xmlLinkGetData (xmlLinkPtr lk); + +/* xmlListUnique() */ +/* xmlListSwap */ + +#ifdef __cplusplus +} +#endif + +#endif /* __XML_LINK_INCLUDE__ */ diff --git a/lib/libxml2/include/libxml/nanoftp.h b/lib/libxml2/include/libxml/nanoftp.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/nanoftp.h @@ -0,0 +1,143 @@ +/* + * Summary: minimal FTP implementation + * Description: minimal FTP implementation allowing to fetch resources + * like external subset. + * + * Copy: See Copyright for the status of this software. + * + * Author: Daniel Veillard + */ + +#ifndef __NANO_FTP_H__ +#define __NANO_FTP_H__ + +#include + +#ifdef LIBXML_FTP_ENABLED + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * ftpListCallback: + * @userData: user provided data for the callback + * @filename: the file name (including "->" when links are shown) + * @attrib: the attribute string + * @owner: the owner string + * @group: the group string + * @size: the file size + * @links: the link count + * @year: the year + * @month: the month + * @day: the day + * @hour: the hour + * @minute: the minute + * + * A callback for the xmlNanoFTPList command. + * Note that only one of year and day:minute are specified. + */ +typedef void (*ftpListCallback) (void *userData, + const char *filename, const char *attrib, + const char *owner, const char *group, + unsigned long size, int links, int year, + const char *month, int day, int hour, + int minute); +/** + * ftpDataCallback: + * @userData: the user provided context + * @data: the data received + * @len: its size in bytes + * + * A callback for the xmlNanoFTPGet command. + */ +typedef void (*ftpDataCallback) (void *userData, + const char *data, + int len); + +/* + * Init + */ +XMLPUBFUN void XMLCALL + xmlNanoFTPInit (void); +XMLPUBFUN void XMLCALL + xmlNanoFTPCleanup (void); + +/* + * Creating/freeing contexts. + */ +XMLPUBFUN void * XMLCALL + xmlNanoFTPNewCtxt (const char *URL); +XMLPUBFUN void XMLCALL + xmlNanoFTPFreeCtxt (void * ctx); +XMLPUBFUN void * XMLCALL + xmlNanoFTPConnectTo (const char *server, + int port); +/* + * Opening/closing session connections. + */ +XMLPUBFUN void * XMLCALL + xmlNanoFTPOpen (const char *URL); +XMLPUBFUN int XMLCALL + xmlNanoFTPConnect (void *ctx); +XMLPUBFUN int XMLCALL + xmlNanoFTPClose (void *ctx); +XMLPUBFUN int XMLCALL + xmlNanoFTPQuit (void *ctx); +XMLPUBFUN void XMLCALL + xmlNanoFTPScanProxy (const char *URL); +XMLPUBFUN void XMLCALL + xmlNanoFTPProxy (const char *host, + int port, + const char *user, + const char *passwd, + int type); +XMLPUBFUN int XMLCALL + xmlNanoFTPUpdateURL (void *ctx, + const char *URL); + +/* + * Rather internal commands. + */ +XMLPUBFUN int XMLCALL + xmlNanoFTPGetResponse (void *ctx); +XMLPUBFUN int XMLCALL + xmlNanoFTPCheckResponse (void *ctx); + +/* + * CD/DIR/GET handlers. + */ +XMLPUBFUN int XMLCALL + xmlNanoFTPCwd (void *ctx, + const char *directory); +XMLPUBFUN int XMLCALL + xmlNanoFTPDele (void *ctx, + const char *file); + +XMLPUBFUN int XMLCALL + xmlNanoFTPGetConnection (void *ctx); +XMLPUBFUN int XMLCALL + xmlNanoFTPCloseConnection(void *ctx); +XMLPUBFUN int XMLCALL + xmlNanoFTPList (void *ctx, + ftpListCallback callback, + void *userData, + const char *filename); +XMLPUBFUN int XMLCALL + xmlNanoFTPGetSocket (void *ctx, + const char *filename); +XMLPUBFUN int XMLCALL + xmlNanoFTPGet (void *ctx, + ftpDataCallback callback, + void *userData, + const char *filename); +XMLPUBFUN int XMLCALL + xmlNanoFTPRead (void *ctx, + void *dest, + int len); + +#ifdef __cplusplus +} +#endif +#endif /* LIBXML_FTP_ENABLED */ +#endif /* __NANO_FTP_H__ */ diff --git a/lib/libxml2/include/libxml/nanohttp.h b/lib/libxml2/include/libxml/nanohttp.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/nanohttp.h @@ -0,0 +1,81 @@ +/* + * Summary: minimal HTTP implementation + * Description: minimal HTTP implementation allowing to fetch resources + * like external subset. + * + * Copy: See Copyright for the status of this software. + * + * Author: Daniel Veillard + */ + +#ifndef __NANO_HTTP_H__ +#define __NANO_HTTP_H__ + +#include + +#ifdef LIBXML_HTTP_ENABLED + +#ifdef __cplusplus +extern "C" { +#endif +XMLPUBFUN void XMLCALL + xmlNanoHTTPInit (void); +XMLPUBFUN void XMLCALL + xmlNanoHTTPCleanup (void); +XMLPUBFUN void XMLCALL + xmlNanoHTTPScanProxy (const char *URL); +XMLPUBFUN int XMLCALL + xmlNanoHTTPFetch (const char *URL, + const char *filename, + char **contentType); +XMLPUBFUN void * XMLCALL + xmlNanoHTTPMethod (const char *URL, + const char *method, + const char *input, + char **contentType, + const char *headers, + int ilen); +XMLPUBFUN void * XMLCALL + xmlNanoHTTPMethodRedir (const char *URL, + const char *method, + const char *input, + char **contentType, + char **redir, + const char *headers, + int ilen); +XMLPUBFUN void * XMLCALL + xmlNanoHTTPOpen (const char *URL, + char **contentType); +XMLPUBFUN void * XMLCALL + xmlNanoHTTPOpenRedir (const char *URL, + char **contentType, + char **redir); +XMLPUBFUN int XMLCALL + xmlNanoHTTPReturnCode (void *ctx); +XMLPUBFUN const char * XMLCALL + xmlNanoHTTPAuthHeader (void *ctx); +XMLPUBFUN const char * XMLCALL + xmlNanoHTTPRedir (void *ctx); +XMLPUBFUN int XMLCALL + xmlNanoHTTPContentLength( void * ctx ); +XMLPUBFUN const char * XMLCALL + xmlNanoHTTPEncoding (void *ctx); +XMLPUBFUN const char * XMLCALL + xmlNanoHTTPMimeType (void *ctx); +XMLPUBFUN int XMLCALL + xmlNanoHTTPRead (void *ctx, + void *dest, + int len); +#ifdef LIBXML_OUTPUT_ENABLED +XMLPUBFUN int XMLCALL + xmlNanoHTTPSave (void *ctxt, + const char *filename); +#endif /* LIBXML_OUTPUT_ENABLED */ +XMLPUBFUN void XMLCALL + xmlNanoHTTPClose (void *ctx); +#ifdef __cplusplus +} +#endif + +#endif /* LIBXML_HTTP_ENABLED */ +#endif /* __NANO_HTTP_H__ */ diff --git a/lib/libxml2/include/libxml/parser.h b/lib/libxml2/include/libxml/parser.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/parser.h @@ -0,0 +1,1235 @@ +/* + * Summary: the core parser module + * Description: Interfaces, constants and types related to the XML parser + * + * Copy: See Copyright for the status of this software. + * + * Author: Daniel Veillard + */ + +#ifndef __XML_PARSER_H__ +#define __XML_PARSER_H__ + +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * XML_DEFAULT_VERSION: + * + * The default version of XML used: 1.0 + */ +#define XML_DEFAULT_VERSION "1.0" + +/** + * xmlParserInput: + * + * An xmlParserInput is an input flow for the XML processor. + * Each entity parsed is associated an xmlParserInput (except the + * few predefined ones). This is the case both for internal entities + * - in which case the flow is already completely in memory - or + * external entities - in which case we use the buf structure for + * progressive reading and I18N conversions to the internal UTF-8 format. + */ + +/** + * xmlParserInputDeallocate: + * @str: the string to deallocate + * + * Callback for freeing some parser input allocations. + */ +typedef void (* xmlParserInputDeallocate)(xmlChar *str); + +struct _xmlParserInput { + /* Input buffer */ + xmlParserInputBufferPtr buf; /* UTF-8 encoded buffer */ + + const char *filename; /* The file analyzed, if any */ + const char *directory; /* the directory/base of the file */ + const xmlChar *base; /* Base of the array to parse */ + const xmlChar *cur; /* Current char being parsed */ + const xmlChar *end; /* end of the array to parse */ + int length; /* length if known */ + int line; /* Current line */ + int col; /* Current column */ + /* + * NOTE: consumed is only tested for equality in the parser code, + * so even if there is an overflow this should not give troubles + * for parsing very large instances. + */ + unsigned long consumed; /* How many xmlChars already consumed */ + xmlParserInputDeallocate free; /* function to deallocate the base */ + const xmlChar *encoding; /* the encoding string for entity */ + const xmlChar *version; /* the version string for entity */ + int standalone; /* Was that entity marked standalone */ + int id; /* an unique identifier for the entity */ +}; + +/** + * xmlParserNodeInfo: + * + * The parser can be asked to collect Node informations, i.e. at what + * place in the file they were detected. + * NOTE: This is off by default and not very well tested. + */ +typedef struct _xmlParserNodeInfo xmlParserNodeInfo; +typedef xmlParserNodeInfo *xmlParserNodeInfoPtr; + +struct _xmlParserNodeInfo { + const struct _xmlNode* node; + /* Position & line # that text that created the node begins & ends on */ + unsigned long begin_pos; + unsigned long begin_line; + unsigned long end_pos; + unsigned long end_line; +}; + +typedef struct _xmlParserNodeInfoSeq xmlParserNodeInfoSeq; +typedef xmlParserNodeInfoSeq *xmlParserNodeInfoSeqPtr; +struct _xmlParserNodeInfoSeq { + unsigned long maximum; + unsigned long length; + xmlParserNodeInfo* buffer; +}; + +/** + * xmlParserInputState: + * + * The parser is now working also as a state based parser. + * The recursive one use the state info for entities processing. + */ +typedef enum { + XML_PARSER_EOF = -1, /* nothing is to be parsed */ + XML_PARSER_START = 0, /* nothing has been parsed */ + XML_PARSER_MISC, /* Misc* before int subset */ + XML_PARSER_PI, /* Within a processing instruction */ + XML_PARSER_DTD, /* within some DTD content */ + XML_PARSER_PROLOG, /* Misc* after internal subset */ + XML_PARSER_COMMENT, /* within a comment */ + XML_PARSER_START_TAG, /* within a start tag */ + XML_PARSER_CONTENT, /* within the content */ + XML_PARSER_CDATA_SECTION, /* within a CDATA section */ + XML_PARSER_END_TAG, /* within a closing tag */ + XML_PARSER_ENTITY_DECL, /* within an entity declaration */ + XML_PARSER_ENTITY_VALUE, /* within an entity value in a decl */ + XML_PARSER_ATTRIBUTE_VALUE, /* within an attribute value */ + XML_PARSER_SYSTEM_LITERAL, /* within a SYSTEM value */ + XML_PARSER_EPILOG, /* the Misc* after the last end tag */ + XML_PARSER_IGNORE, /* within an IGNORED section */ + XML_PARSER_PUBLIC_LITERAL /* within a PUBLIC value */ +} xmlParserInputState; + +/** + * XML_DETECT_IDS: + * + * Bit in the loadsubset context field to tell to do ID/REFs lookups. + * Use it to initialize xmlLoadExtDtdDefaultValue. + */ +#define XML_DETECT_IDS 2 + +/** + * XML_COMPLETE_ATTRS: + * + * Bit in the loadsubset context field to tell to do complete the + * elements attributes lists with the ones defaulted from the DTDs. + * Use it to initialize xmlLoadExtDtdDefaultValue. + */ +#define XML_COMPLETE_ATTRS 4 + +/** + * XML_SKIP_IDS: + * + * Bit in the loadsubset context field to tell to not do ID/REFs registration. + * Used to initialize xmlLoadExtDtdDefaultValue in some special cases. + */ +#define XML_SKIP_IDS 8 + +/** + * xmlParserMode: + * + * A parser can operate in various modes + */ +typedef enum { + XML_PARSE_UNKNOWN = 0, + XML_PARSE_DOM = 1, + XML_PARSE_SAX = 2, + XML_PARSE_PUSH_DOM = 3, + XML_PARSE_PUSH_SAX = 4, + XML_PARSE_READER = 5 +} xmlParserMode; + +/** + * xmlParserCtxt: + * + * The parser context. + * NOTE This doesn't completely define the parser state, the (current ?) + * design of the parser uses recursive function calls since this allow + * and easy mapping from the production rules of the specification + * to the actual code. The drawback is that the actual function call + * also reflect the parser state. However most of the parsing routines + * takes as the only argument the parser context pointer, so migrating + * to a state based parser for progressive parsing shouldn't be too hard. + */ +struct _xmlParserCtxt { + struct _xmlSAXHandler *sax; /* The SAX handler */ + void *userData; /* For SAX interface only, used by DOM build */ + xmlDocPtr myDoc; /* the document being built */ + int wellFormed; /* is the document well formed */ + int replaceEntities; /* shall we replace entities ? */ + const xmlChar *version; /* the XML version string */ + const xmlChar *encoding; /* the declared encoding, if any */ + int standalone; /* standalone document */ + int html; /* an HTML(1)/Docbook(2) document + * 3 is HTML after + * 10 is HTML after + */ + + /* Input stream stack */ + xmlParserInputPtr input; /* Current input stream */ + int inputNr; /* Number of current input streams */ + int inputMax; /* Max number of input streams */ + xmlParserInputPtr *inputTab; /* stack of inputs */ + + /* Node analysis stack only used for DOM building */ + xmlNodePtr node; /* Current parsed Node */ + int nodeNr; /* Depth of the parsing stack */ + int nodeMax; /* Max depth of the parsing stack */ + xmlNodePtr *nodeTab; /* array of nodes */ + + int record_info; /* Whether node info should be kept */ + xmlParserNodeInfoSeq node_seq; /* info about each node parsed */ + + int errNo; /* error code */ + + int hasExternalSubset; /* reference and external subset */ + int hasPErefs; /* the internal subset has PE refs */ + int external; /* are we parsing an external entity */ + + int valid; /* is the document valid */ + int validate; /* shall we try to validate ? */ + xmlValidCtxt vctxt; /* The validity context */ + + xmlParserInputState instate; /* current type of input */ + int token; /* next char look-ahead */ + + char *directory; /* the data directory */ + + /* Node name stack */ + const xmlChar *name; /* Current parsed Node */ + int nameNr; /* Depth of the parsing stack */ + int nameMax; /* Max depth of the parsing stack */ + const xmlChar * *nameTab; /* array of nodes */ + + long nbChars; /* number of xmlChar processed */ + long checkIndex; /* used by progressive parsing lookup */ + int keepBlanks; /* ugly but ... */ + int disableSAX; /* SAX callbacks are disabled */ + int inSubset; /* Parsing is in int 1/ext 2 subset */ + const xmlChar * intSubName; /* name of subset */ + xmlChar * extSubURI; /* URI of external subset */ + xmlChar * extSubSystem; /* SYSTEM ID of external subset */ + + /* xml:space values */ + int * space; /* Should the parser preserve spaces */ + int spaceNr; /* Depth of the parsing stack */ + int spaceMax; /* Max depth of the parsing stack */ + int * spaceTab; /* array of space infos */ + + int depth; /* to prevent entity substitution loops */ + xmlParserInputPtr entity; /* used to check entities boundaries */ + int charset; /* encoding of the in-memory content + actually an xmlCharEncoding */ + int nodelen; /* Those two fields are there to */ + int nodemem; /* Speed up large node parsing */ + int pedantic; /* signal pedantic warnings */ + void *_private; /* For user data, libxml won't touch it */ + + int loadsubset; /* should the external subset be loaded */ + int linenumbers; /* set line number in element content */ + void *catalogs; /* document's own catalog */ + int recovery; /* run in recovery mode */ + int progressive; /* is this a progressive parsing */ + xmlDictPtr dict; /* dictionnary for the parser */ + const xmlChar * *atts; /* array for the attributes callbacks */ + int maxatts; /* the size of the array */ + int docdict; /* use strings from dict to build tree */ + + /* + * pre-interned strings + */ + const xmlChar *str_xml; + const xmlChar *str_xmlns; + const xmlChar *str_xml_ns; + + /* + * Everything below is used only by the new SAX mode + */ + int sax2; /* operating in the new SAX mode */ + int nsNr; /* the number of inherited namespaces */ + int nsMax; /* the size of the arrays */ + const xmlChar * *nsTab; /* the array of prefix/namespace name */ + int *attallocs; /* which attribute were allocated */ + void * *pushTab; /* array of data for push */ + xmlHashTablePtr attsDefault; /* defaulted attributes if any */ + xmlHashTablePtr attsSpecial; /* non-CDATA attributes if any */ + int nsWellFormed; /* is the document XML Nanespace okay */ + int options; /* Extra options */ + + /* + * Those fields are needed only for treaming parsing so far + */ + int dictNames; /* Use dictionary names for the tree */ + int freeElemsNr; /* number of freed element nodes */ + xmlNodePtr freeElems; /* List of freed element nodes */ + int freeAttrsNr; /* number of freed attributes nodes */ + xmlAttrPtr freeAttrs; /* List of freed attributes nodes */ + + /* + * the complete error informations for the last error. + */ + xmlError lastError; + xmlParserMode parseMode; /* the parser mode */ + unsigned long nbentities; /* number of entities references */ + unsigned long sizeentities; /* size of parsed entities */ + + /* for use by HTML non-recursive parser */ + xmlParserNodeInfo *nodeInfo; /* Current NodeInfo */ + int nodeInfoNr; /* Depth of the parsing stack */ + int nodeInfoMax; /* Max depth of the parsing stack */ + xmlParserNodeInfo *nodeInfoTab; /* array of nodeInfos */ +}; + +/** + * xmlSAXLocator: + * + * A SAX Locator. + */ +struct _xmlSAXLocator { + const xmlChar *(*getPublicId)(void *ctx); + const xmlChar *(*getSystemId)(void *ctx); + int (*getLineNumber)(void *ctx); + int (*getColumnNumber)(void *ctx); +}; + +/** + * xmlSAXHandler: + * + * A SAX handler is bunch of callbacks called by the parser when processing + * of the input generate data or structure informations. + */ + +/** + * resolveEntitySAXFunc: + * @ctx: the user data (XML parser context) + * @publicId: The public ID of the entity + * @systemId: The system ID of the entity + * + * Callback: + * The entity loader, to control the loading of external entities, + * the application can either: + * - override this resolveEntity() callback in the SAX block + * - or better use the xmlSetExternalEntityLoader() function to + * set up it's own entity resolution routine + * + * Returns the xmlParserInputPtr if inlined or NULL for DOM behaviour. + */ +typedef xmlParserInputPtr (*resolveEntitySAXFunc) (void *ctx, + const xmlChar *publicId, + const xmlChar *systemId); +/** + * internalSubsetSAXFunc: + * @ctx: the user data (XML parser context) + * @name: the root element name + * @ExternalID: the external ID + * @SystemID: the SYSTEM ID (e.g. filename or URL) + * + * Callback on internal subset declaration. + */ +typedef void (*internalSubsetSAXFunc) (void *ctx, + const xmlChar *name, + const xmlChar *ExternalID, + const xmlChar *SystemID); +/** + * externalSubsetSAXFunc: + * @ctx: the user data (XML parser context) + * @name: the root element name + * @ExternalID: the external ID + * @SystemID: the SYSTEM ID (e.g. filename or URL) + * + * Callback on external subset declaration. + */ +typedef void (*externalSubsetSAXFunc) (void *ctx, + const xmlChar *name, + const xmlChar *ExternalID, + const xmlChar *SystemID); +/** + * getEntitySAXFunc: + * @ctx: the user data (XML parser context) + * @name: The entity name + * + * Get an entity by name. + * + * Returns the xmlEntityPtr if found. + */ +typedef xmlEntityPtr (*getEntitySAXFunc) (void *ctx, + const xmlChar *name); +/** + * getParameterEntitySAXFunc: + * @ctx: the user data (XML parser context) + * @name: The entity name + * + * Get a parameter entity by name. + * + * Returns the xmlEntityPtr if found. + */ +typedef xmlEntityPtr (*getParameterEntitySAXFunc) (void *ctx, + const xmlChar *name); +/** + * entityDeclSAXFunc: + * @ctx: the user data (XML parser context) + * @name: the entity name + * @type: the entity type + * @publicId: The public ID of the entity + * @systemId: The system ID of the entity + * @content: the entity value (without processing). + * + * An entity definition has been parsed. + */ +typedef void (*entityDeclSAXFunc) (void *ctx, + const xmlChar *name, + int type, + const xmlChar *publicId, + const xmlChar *systemId, + xmlChar *content); +/** + * notationDeclSAXFunc: + * @ctx: the user data (XML parser context) + * @name: The name of the notation + * @publicId: The public ID of the entity + * @systemId: The system ID of the entity + * + * What to do when a notation declaration has been parsed. + */ +typedef void (*notationDeclSAXFunc)(void *ctx, + const xmlChar *name, + const xmlChar *publicId, + const xmlChar *systemId); +/** + * attributeDeclSAXFunc: + * @ctx: the user data (XML parser context) + * @elem: the name of the element + * @fullname: the attribute name + * @type: the attribute type + * @def: the type of default value + * @defaultValue: the attribute default value + * @tree: the tree of enumerated value set + * + * An attribute definition has been parsed. + */ +typedef void (*attributeDeclSAXFunc)(void *ctx, + const xmlChar *elem, + const xmlChar *fullname, + int type, + int def, + const xmlChar *defaultValue, + xmlEnumerationPtr tree); +/** + * elementDeclSAXFunc: + * @ctx: the user data (XML parser context) + * @name: the element name + * @type: the element type + * @content: the element value tree + * + * An element definition has been parsed. + */ +typedef void (*elementDeclSAXFunc)(void *ctx, + const xmlChar *name, + int type, + xmlElementContentPtr content); +/** + * unparsedEntityDeclSAXFunc: + * @ctx: the user data (XML parser context) + * @name: The name of the entity + * @publicId: The public ID of the entity + * @systemId: The system ID of the entity + * @notationName: the name of the notation + * + * What to do when an unparsed entity declaration is parsed. + */ +typedef void (*unparsedEntityDeclSAXFunc)(void *ctx, + const xmlChar *name, + const xmlChar *publicId, + const xmlChar *systemId, + const xmlChar *notationName); +/** + * setDocumentLocatorSAXFunc: + * @ctx: the user data (XML parser context) + * @loc: A SAX Locator + * + * Receive the document locator at startup, actually xmlDefaultSAXLocator. + * Everything is available on the context, so this is useless in our case. + */ +typedef void (*setDocumentLocatorSAXFunc) (void *ctx, + xmlSAXLocatorPtr loc); +/** + * startDocumentSAXFunc: + * @ctx: the user data (XML parser context) + * + * Called when the document start being processed. + */ +typedef void (*startDocumentSAXFunc) (void *ctx); +/** + * endDocumentSAXFunc: + * @ctx: the user data (XML parser context) + * + * Called when the document end has been detected. + */ +typedef void (*endDocumentSAXFunc) (void *ctx); +/** + * startElementSAXFunc: + * @ctx: the user data (XML parser context) + * @name: The element name, including namespace prefix + * @atts: An array of name/value attributes pairs, NULL terminated + * + * Called when an opening tag has been processed. + */ +typedef void (*startElementSAXFunc) (void *ctx, + const xmlChar *name, + const xmlChar **atts); +/** + * endElementSAXFunc: + * @ctx: the user data (XML parser context) + * @name: The element name + * + * Called when the end of an element has been detected. + */ +typedef void (*endElementSAXFunc) (void *ctx, + const xmlChar *name); +/** + * attributeSAXFunc: + * @ctx: the user data (XML parser context) + * @name: The attribute name, including namespace prefix + * @value: The attribute value + * + * Handle an attribute that has been read by the parser. + * The default handling is to convert the attribute into an + * DOM subtree and past it in a new xmlAttr element added to + * the element. + */ +typedef void (*attributeSAXFunc) (void *ctx, + const xmlChar *name, + const xmlChar *value); +/** + * referenceSAXFunc: + * @ctx: the user data (XML parser context) + * @name: The entity name + * + * Called when an entity reference is detected. + */ +typedef void (*referenceSAXFunc) (void *ctx, + const xmlChar *name); +/** + * charactersSAXFunc: + * @ctx: the user data (XML parser context) + * @ch: a xmlChar string + * @len: the number of xmlChar + * + * Receiving some chars from the parser. + */ +typedef void (*charactersSAXFunc) (void *ctx, + const xmlChar *ch, + int len); +/** + * ignorableWhitespaceSAXFunc: + * @ctx: the user data (XML parser context) + * @ch: a xmlChar string + * @len: the number of xmlChar + * + * Receiving some ignorable whitespaces from the parser. + * UNUSED: by default the DOM building will use characters. + */ +typedef void (*ignorableWhitespaceSAXFunc) (void *ctx, + const xmlChar *ch, + int len); +/** + * processingInstructionSAXFunc: + * @ctx: the user data (XML parser context) + * @target: the target name + * @data: the PI data's + * + * A processing instruction has been parsed. + */ +typedef void (*processingInstructionSAXFunc) (void *ctx, + const xmlChar *target, + const xmlChar *data); +/** + * commentSAXFunc: + * @ctx: the user data (XML parser context) + * @value: the comment content + * + * A comment has been parsed. + */ +typedef void (*commentSAXFunc) (void *ctx, + const xmlChar *value); +/** + * cdataBlockSAXFunc: + * @ctx: the user data (XML parser context) + * @value: The pcdata content + * @len: the block length + * + * Called when a pcdata block has been parsed. + */ +typedef void (*cdataBlockSAXFunc) ( + void *ctx, + const xmlChar *value, + int len); +/** + * warningSAXFunc: + * @ctx: an XML parser context + * @msg: the message to display/transmit + * @...: extra parameters for the message display + * + * Display and format a warning messages, callback. + */ +typedef void (XMLCDECL *warningSAXFunc) (void *ctx, + const char *msg, ...) LIBXML_ATTR_FORMAT(2,3); +/** + * errorSAXFunc: + * @ctx: an XML parser context + * @msg: the message to display/transmit + * @...: extra parameters for the message display + * + * Display and format an error messages, callback. + */ +typedef void (XMLCDECL *errorSAXFunc) (void *ctx, + const char *msg, ...) LIBXML_ATTR_FORMAT(2,3); +/** + * fatalErrorSAXFunc: + * @ctx: an XML parser context + * @msg: the message to display/transmit + * @...: extra parameters for the message display + * + * Display and format fatal error messages, callback. + * Note: so far fatalError() SAX callbacks are not used, error() + * get all the callbacks for errors. + */ +typedef void (XMLCDECL *fatalErrorSAXFunc) (void *ctx, + const char *msg, ...) LIBXML_ATTR_FORMAT(2,3); +/** + * isStandaloneSAXFunc: + * @ctx: the user data (XML parser context) + * + * Is this document tagged standalone? + * + * Returns 1 if true + */ +typedef int (*isStandaloneSAXFunc) (void *ctx); +/** + * hasInternalSubsetSAXFunc: + * @ctx: the user data (XML parser context) + * + * Does this document has an internal subset. + * + * Returns 1 if true + */ +typedef int (*hasInternalSubsetSAXFunc) (void *ctx); + +/** + * hasExternalSubsetSAXFunc: + * @ctx: the user data (XML parser context) + * + * Does this document has an external subset? + * + * Returns 1 if true + */ +typedef int (*hasExternalSubsetSAXFunc) (void *ctx); + +/************************************************************************ + * * + * The SAX version 2 API extensions * + * * + ************************************************************************/ +/** + * XML_SAX2_MAGIC: + * + * Special constant found in SAX2 blocks initialized fields + */ +#define XML_SAX2_MAGIC 0xDEEDBEAF + +/** + * startElementNsSAX2Func: + * @ctx: the user data (XML parser context) + * @localname: the local name of the element + * @prefix: the element namespace prefix if available + * @URI: the element namespace name if available + * @nb_namespaces: number of namespace definitions on that node + * @namespaces: pointer to the array of prefix/URI pairs namespace definitions + * @nb_attributes: the number of attributes on that node + * @nb_defaulted: the number of defaulted attributes. The defaulted + * ones are at the end of the array + * @attributes: pointer to the array of (localname/prefix/URI/value/end) + * attribute values. + * + * SAX2 callback when an element start has been detected by the parser. + * It provides the namespace informations for the element, as well as + * the new namespace declarations on the element. + */ + +typedef void (*startElementNsSAX2Func) (void *ctx, + const xmlChar *localname, + const xmlChar *prefix, + const xmlChar *URI, + int nb_namespaces, + const xmlChar **namespaces, + int nb_attributes, + int nb_defaulted, + const xmlChar **attributes); + +/** + * endElementNsSAX2Func: + * @ctx: the user data (XML parser context) + * @localname: the local name of the element + * @prefix: the element namespace prefix if available + * @URI: the element namespace name if available + * + * SAX2 callback when an element end has been detected by the parser. + * It provides the namespace informations for the element. + */ + +typedef void (*endElementNsSAX2Func) (void *ctx, + const xmlChar *localname, + const xmlChar *prefix, + const xmlChar *URI); + + +struct _xmlSAXHandler { + internalSubsetSAXFunc internalSubset; + isStandaloneSAXFunc isStandalone; + hasInternalSubsetSAXFunc hasInternalSubset; + hasExternalSubsetSAXFunc hasExternalSubset; + resolveEntitySAXFunc resolveEntity; + getEntitySAXFunc getEntity; + entityDeclSAXFunc entityDecl; + notationDeclSAXFunc notationDecl; + attributeDeclSAXFunc attributeDecl; + elementDeclSAXFunc elementDecl; + unparsedEntityDeclSAXFunc unparsedEntityDecl; + setDocumentLocatorSAXFunc setDocumentLocator; + startDocumentSAXFunc startDocument; + endDocumentSAXFunc endDocument; + startElementSAXFunc startElement; + endElementSAXFunc endElement; + referenceSAXFunc reference; + charactersSAXFunc characters; + ignorableWhitespaceSAXFunc ignorableWhitespace; + processingInstructionSAXFunc processingInstruction; + commentSAXFunc comment; + warningSAXFunc warning; + errorSAXFunc error; + fatalErrorSAXFunc fatalError; /* unused error() get all the errors */ + getParameterEntitySAXFunc getParameterEntity; + cdataBlockSAXFunc cdataBlock; + externalSubsetSAXFunc externalSubset; + unsigned int initialized; + /* The following fields are extensions available only on version 2 */ + void *_private; + startElementNsSAX2Func startElementNs; + endElementNsSAX2Func endElementNs; + xmlStructuredErrorFunc serror; +}; + +/* + * SAX Version 1 + */ +typedef struct _xmlSAXHandlerV1 xmlSAXHandlerV1; +typedef xmlSAXHandlerV1 *xmlSAXHandlerV1Ptr; +struct _xmlSAXHandlerV1 { + internalSubsetSAXFunc internalSubset; + isStandaloneSAXFunc isStandalone; + hasInternalSubsetSAXFunc hasInternalSubset; + hasExternalSubsetSAXFunc hasExternalSubset; + resolveEntitySAXFunc resolveEntity; + getEntitySAXFunc getEntity; + entityDeclSAXFunc entityDecl; + notationDeclSAXFunc notationDecl; + attributeDeclSAXFunc attributeDecl; + elementDeclSAXFunc elementDecl; + unparsedEntityDeclSAXFunc unparsedEntityDecl; + setDocumentLocatorSAXFunc setDocumentLocator; + startDocumentSAXFunc startDocument; + endDocumentSAXFunc endDocument; + startElementSAXFunc startElement; + endElementSAXFunc endElement; + referenceSAXFunc reference; + charactersSAXFunc characters; + ignorableWhitespaceSAXFunc ignorableWhitespace; + processingInstructionSAXFunc processingInstruction; + commentSAXFunc comment; + warningSAXFunc warning; + errorSAXFunc error; + fatalErrorSAXFunc fatalError; /* unused error() get all the errors */ + getParameterEntitySAXFunc getParameterEntity; + cdataBlockSAXFunc cdataBlock; + externalSubsetSAXFunc externalSubset; + unsigned int initialized; +}; + + +/** + * xmlExternalEntityLoader: + * @URL: The System ID of the resource requested + * @ID: The Public ID of the resource requested + * @context: the XML parser context + * + * External entity loaders types. + * + * Returns the entity input parser. + */ +typedef xmlParserInputPtr (*xmlExternalEntityLoader) (const char *URL, + const char *ID, + xmlParserCtxtPtr context); + +#ifdef __cplusplus +} +#endif + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + + +/* + * Init/Cleanup + */ +XMLPUBFUN void XMLCALL + xmlInitParser (void); +XMLPUBFUN void XMLCALL + xmlCleanupParser (void); + +/* + * Input functions + */ +XMLPUBFUN int XMLCALL + xmlParserInputRead (xmlParserInputPtr in, + int len); +XMLPUBFUN int XMLCALL + xmlParserInputGrow (xmlParserInputPtr in, + int len); + +/* + * Basic parsing Interfaces + */ +#ifdef LIBXML_SAX1_ENABLED +XMLPUBFUN xmlDocPtr XMLCALL + xmlParseDoc (const xmlChar *cur); +XMLPUBFUN xmlDocPtr XMLCALL + xmlParseFile (const char *filename); +XMLPUBFUN xmlDocPtr XMLCALL + xmlParseMemory (const char *buffer, + int size); +#endif /* LIBXML_SAX1_ENABLED */ +XMLPUBFUN int XMLCALL + xmlSubstituteEntitiesDefault(int val); +XMLPUBFUN int XMLCALL + xmlKeepBlanksDefault (int val); +XMLPUBFUN void XMLCALL + xmlStopParser (xmlParserCtxtPtr ctxt); +XMLPUBFUN int XMLCALL + xmlPedanticParserDefault(int val); +XMLPUBFUN int XMLCALL + xmlLineNumbersDefault (int val); + +#ifdef LIBXML_SAX1_ENABLED +/* + * Recovery mode + */ +XMLPUBFUN xmlDocPtr XMLCALL + xmlRecoverDoc (const xmlChar *cur); +XMLPUBFUN xmlDocPtr XMLCALL + xmlRecoverMemory (const char *buffer, + int size); +XMLPUBFUN xmlDocPtr XMLCALL + xmlRecoverFile (const char *filename); +#endif /* LIBXML_SAX1_ENABLED */ + +/* + * Less common routines and SAX interfaces + */ +XMLPUBFUN int XMLCALL + xmlParseDocument (xmlParserCtxtPtr ctxt); +XMLPUBFUN int XMLCALL + xmlParseExtParsedEnt (xmlParserCtxtPtr ctxt); +#ifdef LIBXML_SAX1_ENABLED +XMLPUBFUN int XMLCALL + xmlSAXUserParseFile (xmlSAXHandlerPtr sax, + void *user_data, + const char *filename); +XMLPUBFUN int XMLCALL + xmlSAXUserParseMemory (xmlSAXHandlerPtr sax, + void *user_data, + const char *buffer, + int size); +XMLPUBFUN xmlDocPtr XMLCALL + xmlSAXParseDoc (xmlSAXHandlerPtr sax, + const xmlChar *cur, + int recovery); +XMLPUBFUN xmlDocPtr XMLCALL + xmlSAXParseMemory (xmlSAXHandlerPtr sax, + const char *buffer, + int size, + int recovery); +XMLPUBFUN xmlDocPtr XMLCALL + xmlSAXParseMemoryWithData (xmlSAXHandlerPtr sax, + const char *buffer, + int size, + int recovery, + void *data); +XMLPUBFUN xmlDocPtr XMLCALL + xmlSAXParseFile (xmlSAXHandlerPtr sax, + const char *filename, + int recovery); +XMLPUBFUN xmlDocPtr XMLCALL + xmlSAXParseFileWithData (xmlSAXHandlerPtr sax, + const char *filename, + int recovery, + void *data); +XMLPUBFUN xmlDocPtr XMLCALL + xmlSAXParseEntity (xmlSAXHandlerPtr sax, + const char *filename); +XMLPUBFUN xmlDocPtr XMLCALL + xmlParseEntity (const char *filename); +#endif /* LIBXML_SAX1_ENABLED */ + +#ifdef LIBXML_VALID_ENABLED +XMLPUBFUN xmlDtdPtr XMLCALL + xmlSAXParseDTD (xmlSAXHandlerPtr sax, + const xmlChar *ExternalID, + const xmlChar *SystemID); +XMLPUBFUN xmlDtdPtr XMLCALL + xmlParseDTD (const xmlChar *ExternalID, + const xmlChar *SystemID); +XMLPUBFUN xmlDtdPtr XMLCALL + xmlIOParseDTD (xmlSAXHandlerPtr sax, + xmlParserInputBufferPtr input, + xmlCharEncoding enc); +#endif /* LIBXML_VALID_ENABLE */ +#ifdef LIBXML_SAX1_ENABLED +XMLPUBFUN int XMLCALL + xmlParseBalancedChunkMemory(xmlDocPtr doc, + xmlSAXHandlerPtr sax, + void *user_data, + int depth, + const xmlChar *string, + xmlNodePtr *lst); +#endif /* LIBXML_SAX1_ENABLED */ +XMLPUBFUN xmlParserErrors XMLCALL + xmlParseInNodeContext (xmlNodePtr node, + const char *data, + int datalen, + int options, + xmlNodePtr *lst); +#ifdef LIBXML_SAX1_ENABLED +XMLPUBFUN int XMLCALL + xmlParseBalancedChunkMemoryRecover(xmlDocPtr doc, + xmlSAXHandlerPtr sax, + void *user_data, + int depth, + const xmlChar *string, + xmlNodePtr *lst, + int recover); +XMLPUBFUN int XMLCALL + xmlParseExternalEntity (xmlDocPtr doc, + xmlSAXHandlerPtr sax, + void *user_data, + int depth, + const xmlChar *URL, + const xmlChar *ID, + xmlNodePtr *lst); +#endif /* LIBXML_SAX1_ENABLED */ +XMLPUBFUN int XMLCALL + xmlParseCtxtExternalEntity(xmlParserCtxtPtr ctx, + const xmlChar *URL, + const xmlChar *ID, + xmlNodePtr *lst); + +/* + * Parser contexts handling. + */ +XMLPUBFUN xmlParserCtxtPtr XMLCALL + xmlNewParserCtxt (void); +XMLPUBFUN int XMLCALL + xmlInitParserCtxt (xmlParserCtxtPtr ctxt); +XMLPUBFUN void XMLCALL + xmlClearParserCtxt (xmlParserCtxtPtr ctxt); +XMLPUBFUN void XMLCALL + xmlFreeParserCtxt (xmlParserCtxtPtr ctxt); +#ifdef LIBXML_SAX1_ENABLED +XMLPUBFUN void XMLCALL + xmlSetupParserForBuffer (xmlParserCtxtPtr ctxt, + const xmlChar* buffer, + const char *filename); +#endif /* LIBXML_SAX1_ENABLED */ +XMLPUBFUN xmlParserCtxtPtr XMLCALL + xmlCreateDocParserCtxt (const xmlChar *cur); + +#ifdef LIBXML_LEGACY_ENABLED +/* + * Reading/setting optional parsing features. + */ +XMLPUBFUN int XMLCALL + xmlGetFeaturesList (int *len, + const char **result); +XMLPUBFUN int XMLCALL + xmlGetFeature (xmlParserCtxtPtr ctxt, + const char *name, + void *result); +XMLPUBFUN int XMLCALL + xmlSetFeature (xmlParserCtxtPtr ctxt, + const char *name, + void *value); +#endif /* LIBXML_LEGACY_ENABLED */ + +#ifdef LIBXML_PUSH_ENABLED +/* + * Interfaces for the Push mode. + */ +XMLPUBFUN xmlParserCtxtPtr XMLCALL + xmlCreatePushParserCtxt(xmlSAXHandlerPtr sax, + void *user_data, + const char *chunk, + int size, + const char *filename); +XMLPUBFUN int XMLCALL + xmlParseChunk (xmlParserCtxtPtr ctxt, + const char *chunk, + int size, + int terminate); +#endif /* LIBXML_PUSH_ENABLED */ + +/* + * Special I/O mode. + */ + +XMLPUBFUN xmlParserCtxtPtr XMLCALL + xmlCreateIOParserCtxt (xmlSAXHandlerPtr sax, + void *user_data, + xmlInputReadCallback ioread, + xmlInputCloseCallback ioclose, + void *ioctx, + xmlCharEncoding enc); + +XMLPUBFUN xmlParserInputPtr XMLCALL + xmlNewIOInputStream (xmlParserCtxtPtr ctxt, + xmlParserInputBufferPtr input, + xmlCharEncoding enc); + +/* + * Node infos. + */ +XMLPUBFUN const xmlParserNodeInfo* XMLCALL + xmlParserFindNodeInfo (const xmlParserCtxtPtr ctxt, + const xmlNodePtr node); +XMLPUBFUN void XMLCALL + xmlInitNodeInfoSeq (xmlParserNodeInfoSeqPtr seq); +XMLPUBFUN void XMLCALL + xmlClearNodeInfoSeq (xmlParserNodeInfoSeqPtr seq); +XMLPUBFUN unsigned long XMLCALL + xmlParserFindNodeInfoIndex(const xmlParserNodeInfoSeqPtr seq, + const xmlNodePtr node); +XMLPUBFUN void XMLCALL + xmlParserAddNodeInfo (xmlParserCtxtPtr ctxt, + const xmlParserNodeInfoPtr info); + +/* + * External entities handling actually implemented in xmlIO. + */ + +XMLPUBFUN void XMLCALL + xmlSetExternalEntityLoader(xmlExternalEntityLoader f); +XMLPUBFUN xmlExternalEntityLoader XMLCALL + xmlGetExternalEntityLoader(void); +XMLPUBFUN xmlParserInputPtr XMLCALL + xmlLoadExternalEntity (const char *URL, + const char *ID, + xmlParserCtxtPtr ctxt); + +/* + * Index lookup, actually implemented in the encoding module + */ +XMLPUBFUN long XMLCALL + xmlByteConsumed (xmlParserCtxtPtr ctxt); + +/* + * New set of simpler/more flexible APIs + */ +/** + * xmlParserOption: + * + * This is the set of XML parser options that can be passed down + * to the xmlReadDoc() and similar calls. + */ +typedef enum { + XML_PARSE_RECOVER = 1<<0, /* recover on errors */ + XML_PARSE_NOENT = 1<<1, /* substitute entities */ + XML_PARSE_DTDLOAD = 1<<2, /* load the external subset */ + XML_PARSE_DTDATTR = 1<<3, /* default DTD attributes */ + XML_PARSE_DTDVALID = 1<<4, /* validate with the DTD */ + XML_PARSE_NOERROR = 1<<5, /* suppress error reports */ + XML_PARSE_NOWARNING = 1<<6, /* suppress warning reports */ + XML_PARSE_PEDANTIC = 1<<7, /* pedantic error reporting */ + XML_PARSE_NOBLANKS = 1<<8, /* remove blank nodes */ + XML_PARSE_SAX1 = 1<<9, /* use the SAX1 interface internally */ + XML_PARSE_XINCLUDE = 1<<10,/* Implement XInclude substitition */ + XML_PARSE_NONET = 1<<11,/* Forbid network access */ + XML_PARSE_NODICT = 1<<12,/* Do not reuse the context dictionnary */ + XML_PARSE_NSCLEAN = 1<<13,/* remove redundant namespaces declarations */ + XML_PARSE_NOCDATA = 1<<14,/* merge CDATA as text nodes */ + XML_PARSE_NOXINCNODE= 1<<15,/* do not generate XINCLUDE START/END nodes */ + XML_PARSE_COMPACT = 1<<16,/* compact small text nodes; no modification of + the tree allowed afterwards (will possibly + crash if you try to modify the tree) */ + XML_PARSE_OLD10 = 1<<17,/* parse using XML-1.0 before update 5 */ + XML_PARSE_NOBASEFIX = 1<<18,/* do not fixup XINCLUDE xml:base uris */ + XML_PARSE_HUGE = 1<<19, /* relax any hardcoded limit from the parser */ + XML_PARSE_OLDSAX = 1<<20 /* parse using SAX2 interface from before 2.7.0 */ +} xmlParserOption; + +XMLPUBFUN void XMLCALL + xmlCtxtReset (xmlParserCtxtPtr ctxt); +XMLPUBFUN int XMLCALL + xmlCtxtResetPush (xmlParserCtxtPtr ctxt, + const char *chunk, + int size, + const char *filename, + const char *encoding); +XMLPUBFUN int XMLCALL + xmlCtxtUseOptions (xmlParserCtxtPtr ctxt, + int options); +XMLPUBFUN xmlDocPtr XMLCALL + xmlReadDoc (const xmlChar *cur, + const char *URL, + const char *encoding, + int options); +XMLPUBFUN xmlDocPtr XMLCALL + xmlReadFile (const char *URL, + const char *encoding, + int options); +XMLPUBFUN xmlDocPtr XMLCALL + xmlReadMemory (const char *buffer, + int size, + const char *URL, + const char *encoding, + int options); +XMLPUBFUN xmlDocPtr XMLCALL + xmlReadFd (int fd, + const char *URL, + const char *encoding, + int options); +XMLPUBFUN xmlDocPtr XMLCALL + xmlReadIO (xmlInputReadCallback ioread, + xmlInputCloseCallback ioclose, + void *ioctx, + const char *URL, + const char *encoding, + int options); +XMLPUBFUN xmlDocPtr XMLCALL + xmlCtxtReadDoc (xmlParserCtxtPtr ctxt, + const xmlChar *cur, + const char *URL, + const char *encoding, + int options); +XMLPUBFUN xmlDocPtr XMLCALL + xmlCtxtReadFile (xmlParserCtxtPtr ctxt, + const char *filename, + const char *encoding, + int options); +XMLPUBFUN xmlDocPtr XMLCALL + xmlCtxtReadMemory (xmlParserCtxtPtr ctxt, + const char *buffer, + int size, + const char *URL, + const char *encoding, + int options); +XMLPUBFUN xmlDocPtr XMLCALL + xmlCtxtReadFd (xmlParserCtxtPtr ctxt, + int fd, + const char *URL, + const char *encoding, + int options); +XMLPUBFUN xmlDocPtr XMLCALL + xmlCtxtReadIO (xmlParserCtxtPtr ctxt, + xmlInputReadCallback ioread, + xmlInputCloseCallback ioclose, + void *ioctx, + const char *URL, + const char *encoding, + int options); + +/* + * Library wide options + */ +/** + * xmlFeature: + * + * Used to examine the existance of features that can be enabled + * or disabled at compile-time. + * They used to be called XML_FEATURE_xxx but this clashed with Expat + */ +typedef enum { + XML_WITH_THREAD = 1, + XML_WITH_TREE = 2, + XML_WITH_OUTPUT = 3, + XML_WITH_PUSH = 4, + XML_WITH_READER = 5, + XML_WITH_PATTERN = 6, + XML_WITH_WRITER = 7, + XML_WITH_SAX1 = 8, + XML_WITH_FTP = 9, + XML_WITH_HTTP = 10, + XML_WITH_VALID = 11, + XML_WITH_HTML = 12, + XML_WITH_LEGACY = 13, + XML_WITH_C14N = 14, + XML_WITH_CATALOG = 15, + XML_WITH_XPATH = 16, + XML_WITH_XPTR = 17, + XML_WITH_XINCLUDE = 18, + XML_WITH_ICONV = 19, + XML_WITH_ISO8859X = 20, + XML_WITH_UNICODE = 21, + XML_WITH_REGEXP = 22, + XML_WITH_AUTOMATA = 23, + XML_WITH_EXPR = 24, + XML_WITH_SCHEMAS = 25, + XML_WITH_SCHEMATRON = 26, + XML_WITH_MODULES = 27, + XML_WITH_DEBUG = 28, + XML_WITH_DEBUG_MEM = 29, + XML_WITH_DEBUG_RUN = 30, + XML_WITH_ZLIB = 31, + XML_WITH_NONE = 99999 /* just to be sure of allocation size */ +} xmlFeature; + +XMLPUBFUN int XMLCALL + xmlHasFeature (xmlFeature feature); + +#ifdef __cplusplus +} +#endif +#endif /* __XML_PARSER_H__ */ + diff --git a/lib/libxml2/include/libxml/parserInternals.h b/lib/libxml2/include/libxml/parserInternals.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/parserInternals.h @@ -0,0 +1,611 @@ +/* + * Summary: internals routines exported by the parser. + * Description: this module exports a number of internal parsing routines + * they are not really all intended for applications but + * can prove useful doing low level processing. + * + * Copy: See Copyright for the status of this software. + * + * Author: Daniel Veillard + */ + +#ifndef __XML_PARSER_INTERNALS_H__ +#define __XML_PARSER_INTERNALS_H__ + +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * xmlParserMaxDepth: + * + * arbitrary depth limit for the XML documents that we allow to + * process. This is not a limitation of the parser but a safety + * boundary feature, use XML_PARSE_HUGE option to override it. + */ +XMLPUBVAR unsigned int xmlParserMaxDepth; + +/** + * XML_MAX_TEXT_LENGTH: + * + * Maximum size allowed for a single text node when building a tree. + * This is not a limitation of the parser but a safety boundary feature, + * use XML_PARSE_HUGE option to override it. + */ +#define XML_MAX_TEXT_LENGTH 10000000 + +/** + * XML_MAX_NAMELEN: + * + * Identifiers can be longer, but this will be more costly + * at runtime. + */ +#define XML_MAX_NAMELEN 100 + +/** + * INPUT_CHUNK: + * + * The parser tries to always have that amount of input ready. + * One of the point is providing context when reporting errors. + */ +#define INPUT_CHUNK 250 + +/************************************************************************ + * * + * UNICODE version of the macros. * + * * + ************************************************************************/ +/** + * IS_BYTE_CHAR: + * @c: an byte value (int) + * + * Macro to check the following production in the XML spec: + * + * [2] Char ::= #x9 | #xA | #xD | [#x20...] + * any byte character in the accepted range + */ +#define IS_BYTE_CHAR(c) xmlIsChar_ch(c) + +/** + * IS_CHAR: + * @c: an UNICODE value (int) + * + * Macro to check the following production in the XML spec: + * + * [2] Char ::= #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] + * | [#x10000-#x10FFFF] + * any Unicode character, excluding the surrogate blocks, FFFE, and FFFF. + */ +#define IS_CHAR(c) xmlIsCharQ(c) + +/** + * IS_CHAR_CH: + * @c: an xmlChar (usually an unsigned char) + * + * Behaves like IS_CHAR on single-byte value + */ +#define IS_CHAR_CH(c) xmlIsChar_ch(c) + +/** + * IS_BLANK: + * @c: an UNICODE value (int) + * + * Macro to check the following production in the XML spec: + * + * [3] S ::= (#x20 | #x9 | #xD | #xA)+ + */ +#define IS_BLANK(c) xmlIsBlankQ(c) + +/** + * IS_BLANK_CH: + * @c: an xmlChar value (normally unsigned char) + * + * Behaviour same as IS_BLANK + */ +#define IS_BLANK_CH(c) xmlIsBlank_ch(c) + +/** + * IS_BASECHAR: + * @c: an UNICODE value (int) + * + * Macro to check the following production in the XML spec: + * + * [85] BaseChar ::= ... long list see REC ... + */ +#define IS_BASECHAR(c) xmlIsBaseCharQ(c) + +/** + * IS_DIGIT: + * @c: an UNICODE value (int) + * + * Macro to check the following production in the XML spec: + * + * [88] Digit ::= ... long list see REC ... + */ +#define IS_DIGIT(c) xmlIsDigitQ(c) + +/** + * IS_DIGIT_CH: + * @c: an xmlChar value (usually an unsigned char) + * + * Behaves like IS_DIGIT but with a single byte argument + */ +#define IS_DIGIT_CH(c) xmlIsDigit_ch(c) + +/** + * IS_COMBINING: + * @c: an UNICODE value (int) + * + * Macro to check the following production in the XML spec: + * + * [87] CombiningChar ::= ... long list see REC ... + */ +#define IS_COMBINING(c) xmlIsCombiningQ(c) + +/** + * IS_COMBINING_CH: + * @c: an xmlChar (usually an unsigned char) + * + * Always false (all combining chars > 0xff) + */ +#define IS_COMBINING_CH(c) 0 + +/** + * IS_EXTENDER: + * @c: an UNICODE value (int) + * + * Macro to check the following production in the XML spec: + * + * + * [89] Extender ::= #x00B7 | #x02D0 | #x02D1 | #x0387 | #x0640 | + * #x0E46 | #x0EC6 | #x3005 | [#x3031-#x3035] | + * [#x309D-#x309E] | [#x30FC-#x30FE] + */ +#define IS_EXTENDER(c) xmlIsExtenderQ(c) + +/** + * IS_EXTENDER_CH: + * @c: an xmlChar value (usually an unsigned char) + * + * Behaves like IS_EXTENDER but with a single-byte argument + */ +#define IS_EXTENDER_CH(c) xmlIsExtender_ch(c) + +/** + * IS_IDEOGRAPHIC: + * @c: an UNICODE value (int) + * + * Macro to check the following production in the XML spec: + * + * + * [86] Ideographic ::= [#x4E00-#x9FA5] | #x3007 | [#x3021-#x3029] + */ +#define IS_IDEOGRAPHIC(c) xmlIsIdeographicQ(c) + +/** + * IS_LETTER: + * @c: an UNICODE value (int) + * + * Macro to check the following production in the XML spec: + * + * + * [84] Letter ::= BaseChar | Ideographic + */ +#define IS_LETTER(c) (IS_BASECHAR(c) || IS_IDEOGRAPHIC(c)) + +/** + * IS_LETTER_CH: + * @c: an xmlChar value (normally unsigned char) + * + * Macro behaves like IS_LETTER, but only check base chars + * + */ +#define IS_LETTER_CH(c) xmlIsBaseChar_ch(c) + +/** + * IS_ASCII_LETTER: + * @c: an xmlChar value + * + * Macro to check [a-zA-Z] + * + */ +#define IS_ASCII_LETTER(c) (((0x41 <= (c)) && ((c) <= 0x5a)) || \ + ((0x61 <= (c)) && ((c) <= 0x7a))) + +/** + * IS_ASCII_DIGIT: + * @c: an xmlChar value + * + * Macro to check [0-9] + * + */ +#define IS_ASCII_DIGIT(c) ((0x30 <= (c)) && ((c) <= 0x39)) + +/** + * IS_PUBIDCHAR: + * @c: an UNICODE value (int) + * + * Macro to check the following production in the XML spec: + * + * + * [13] PubidChar ::= #x20 | #xD | #xA | [a-zA-Z0-9] | [-'()+,./:=?;!*#@$_%] + */ +#define IS_PUBIDCHAR(c) xmlIsPubidCharQ(c) + +/** + * IS_PUBIDCHAR_CH: + * @c: an xmlChar value (normally unsigned char) + * + * Same as IS_PUBIDCHAR but for single-byte value + */ +#define IS_PUBIDCHAR_CH(c) xmlIsPubidChar_ch(c) + +/** + * SKIP_EOL: + * @p: and UTF8 string pointer + * + * Skips the end of line chars. + */ +#define SKIP_EOL(p) \ + if (*(p) == 0x13) { p++ ; if (*(p) == 0x10) p++; } \ + if (*(p) == 0x10) { p++ ; if (*(p) == 0x13) p++; } + +/** + * MOVETO_ENDTAG: + * @p: and UTF8 string pointer + * + * Skips to the next '>' char. + */ +#define MOVETO_ENDTAG(p) \ + while ((*p) && (*(p) != '>')) (p)++ + +/** + * MOVETO_STARTTAG: + * @p: and UTF8 string pointer + * + * Skips to the next '<' char. + */ +#define MOVETO_STARTTAG(p) \ + while ((*p) && (*(p) != '<')) (p)++ + +/** + * Global variables used for predefined strings. + */ +XMLPUBVAR const xmlChar xmlStringText[]; +XMLPUBVAR const xmlChar xmlStringTextNoenc[]; +XMLPUBVAR const xmlChar xmlStringComment[]; + +/* + * Function to finish the work of the macros where needed. + */ +XMLPUBFUN int XMLCALL xmlIsLetter (int c); + +/** + * Parser context. + */ +XMLPUBFUN xmlParserCtxtPtr XMLCALL + xmlCreateFileParserCtxt (const char *filename); +XMLPUBFUN xmlParserCtxtPtr XMLCALL + xmlCreateURLParserCtxt (const char *filename, + int options); +XMLPUBFUN xmlParserCtxtPtr XMLCALL + xmlCreateMemoryParserCtxt(const char *buffer, + int size); +XMLPUBFUN xmlParserCtxtPtr XMLCALL + xmlCreateEntityParserCtxt(const xmlChar *URL, + const xmlChar *ID, + const xmlChar *base); +XMLPUBFUN int XMLCALL + xmlSwitchEncoding (xmlParserCtxtPtr ctxt, + xmlCharEncoding enc); +XMLPUBFUN int XMLCALL + xmlSwitchToEncoding (xmlParserCtxtPtr ctxt, + xmlCharEncodingHandlerPtr handler); +XMLPUBFUN int XMLCALL + xmlSwitchInputEncoding (xmlParserCtxtPtr ctxt, + xmlParserInputPtr input, + xmlCharEncodingHandlerPtr handler); + +#ifdef IN_LIBXML +/* internal error reporting */ +XMLPUBFUN void XMLCALL + __xmlErrEncoding (xmlParserCtxtPtr ctxt, + xmlParserErrors xmlerr, + const char *msg, + const xmlChar * str1, + const xmlChar * str2); +#endif + +/** + * Input Streams. + */ +XMLPUBFUN xmlParserInputPtr XMLCALL + xmlNewStringInputStream (xmlParserCtxtPtr ctxt, + const xmlChar *buffer); +XMLPUBFUN xmlParserInputPtr XMLCALL + xmlNewEntityInputStream (xmlParserCtxtPtr ctxt, + xmlEntityPtr entity); +XMLPUBFUN int XMLCALL + xmlPushInput (xmlParserCtxtPtr ctxt, + xmlParserInputPtr input); +XMLPUBFUN xmlChar XMLCALL + xmlPopInput (xmlParserCtxtPtr ctxt); +XMLPUBFUN void XMLCALL + xmlFreeInputStream (xmlParserInputPtr input); +XMLPUBFUN xmlParserInputPtr XMLCALL + xmlNewInputFromFile (xmlParserCtxtPtr ctxt, + const char *filename); +XMLPUBFUN xmlParserInputPtr XMLCALL + xmlNewInputStream (xmlParserCtxtPtr ctxt); + +/** + * Namespaces. + */ +XMLPUBFUN xmlChar * XMLCALL + xmlSplitQName (xmlParserCtxtPtr ctxt, + const xmlChar *name, + xmlChar **prefix); + +/** + * Generic production rules. + */ +XMLPUBFUN const xmlChar * XMLCALL + xmlParseName (xmlParserCtxtPtr ctxt); +XMLPUBFUN xmlChar * XMLCALL + xmlParseNmtoken (xmlParserCtxtPtr ctxt); +XMLPUBFUN xmlChar * XMLCALL + xmlParseEntityValue (xmlParserCtxtPtr ctxt, + xmlChar **orig); +XMLPUBFUN xmlChar * XMLCALL + xmlParseAttValue (xmlParserCtxtPtr ctxt); +XMLPUBFUN xmlChar * XMLCALL + xmlParseSystemLiteral (xmlParserCtxtPtr ctxt); +XMLPUBFUN xmlChar * XMLCALL + xmlParsePubidLiteral (xmlParserCtxtPtr ctxt); +XMLPUBFUN void XMLCALL + xmlParseCharData (xmlParserCtxtPtr ctxt, + int cdata); +XMLPUBFUN xmlChar * XMLCALL + xmlParseExternalID (xmlParserCtxtPtr ctxt, + xmlChar **publicID, + int strict); +XMLPUBFUN void XMLCALL + xmlParseComment (xmlParserCtxtPtr ctxt); +XMLPUBFUN const xmlChar * XMLCALL + xmlParsePITarget (xmlParserCtxtPtr ctxt); +XMLPUBFUN void XMLCALL + xmlParsePI (xmlParserCtxtPtr ctxt); +XMLPUBFUN void XMLCALL + xmlParseNotationDecl (xmlParserCtxtPtr ctxt); +XMLPUBFUN void XMLCALL + xmlParseEntityDecl (xmlParserCtxtPtr ctxt); +XMLPUBFUN int XMLCALL + xmlParseDefaultDecl (xmlParserCtxtPtr ctxt, + xmlChar **value); +XMLPUBFUN xmlEnumerationPtr XMLCALL + xmlParseNotationType (xmlParserCtxtPtr ctxt); +XMLPUBFUN xmlEnumerationPtr XMLCALL + xmlParseEnumerationType (xmlParserCtxtPtr ctxt); +XMLPUBFUN int XMLCALL + xmlParseEnumeratedType (xmlParserCtxtPtr ctxt, + xmlEnumerationPtr *tree); +XMLPUBFUN int XMLCALL + xmlParseAttributeType (xmlParserCtxtPtr ctxt, + xmlEnumerationPtr *tree); +XMLPUBFUN void XMLCALL + xmlParseAttributeListDecl(xmlParserCtxtPtr ctxt); +XMLPUBFUN xmlElementContentPtr XMLCALL + xmlParseElementMixedContentDecl + (xmlParserCtxtPtr ctxt, + int inputchk); +XMLPUBFUN xmlElementContentPtr XMLCALL + xmlParseElementChildrenContentDecl + (xmlParserCtxtPtr ctxt, + int inputchk); +XMLPUBFUN int XMLCALL + xmlParseElementContentDecl(xmlParserCtxtPtr ctxt, + const xmlChar *name, + xmlElementContentPtr *result); +XMLPUBFUN int XMLCALL + xmlParseElementDecl (xmlParserCtxtPtr ctxt); +XMLPUBFUN void XMLCALL + xmlParseMarkupDecl (xmlParserCtxtPtr ctxt); +XMLPUBFUN int XMLCALL + xmlParseCharRef (xmlParserCtxtPtr ctxt); +XMLPUBFUN xmlEntityPtr XMLCALL + xmlParseEntityRef (xmlParserCtxtPtr ctxt); +XMLPUBFUN void XMLCALL + xmlParseReference (xmlParserCtxtPtr ctxt); +XMLPUBFUN void XMLCALL + xmlParsePEReference (xmlParserCtxtPtr ctxt); +XMLPUBFUN void XMLCALL + xmlParseDocTypeDecl (xmlParserCtxtPtr ctxt); +#ifdef LIBXML_SAX1_ENABLED +XMLPUBFUN const xmlChar * XMLCALL + xmlParseAttribute (xmlParserCtxtPtr ctxt, + xmlChar **value); +XMLPUBFUN const xmlChar * XMLCALL + xmlParseStartTag (xmlParserCtxtPtr ctxt); +XMLPUBFUN void XMLCALL + xmlParseEndTag (xmlParserCtxtPtr ctxt); +#endif /* LIBXML_SAX1_ENABLED */ +XMLPUBFUN void XMLCALL + xmlParseCDSect (xmlParserCtxtPtr ctxt); +XMLPUBFUN void XMLCALL + xmlParseContent (xmlParserCtxtPtr ctxt); +XMLPUBFUN void XMLCALL + xmlParseElement (xmlParserCtxtPtr ctxt); +XMLPUBFUN xmlChar * XMLCALL + xmlParseVersionNum (xmlParserCtxtPtr ctxt); +XMLPUBFUN xmlChar * XMLCALL + xmlParseVersionInfo (xmlParserCtxtPtr ctxt); +XMLPUBFUN xmlChar * XMLCALL + xmlParseEncName (xmlParserCtxtPtr ctxt); +XMLPUBFUN const xmlChar * XMLCALL + xmlParseEncodingDecl (xmlParserCtxtPtr ctxt); +XMLPUBFUN int XMLCALL + xmlParseSDDecl (xmlParserCtxtPtr ctxt); +XMLPUBFUN void XMLCALL + xmlParseXMLDecl (xmlParserCtxtPtr ctxt); +XMLPUBFUN void XMLCALL + xmlParseTextDecl (xmlParserCtxtPtr ctxt); +XMLPUBFUN void XMLCALL + xmlParseMisc (xmlParserCtxtPtr ctxt); +XMLPUBFUN void XMLCALL + xmlParseExternalSubset (xmlParserCtxtPtr ctxt, + const xmlChar *ExternalID, + const xmlChar *SystemID); +/** + * XML_SUBSTITUTE_NONE: + * + * If no entities need to be substituted. + */ +#define XML_SUBSTITUTE_NONE 0 +/** + * XML_SUBSTITUTE_REF: + * + * Whether general entities need to be substituted. + */ +#define XML_SUBSTITUTE_REF 1 +/** + * XML_SUBSTITUTE_PEREF: + * + * Whether parameter entities need to be substituted. + */ +#define XML_SUBSTITUTE_PEREF 2 +/** + * XML_SUBSTITUTE_BOTH: + * + * Both general and parameter entities need to be substituted. + */ +#define XML_SUBSTITUTE_BOTH 3 + +XMLPUBFUN xmlChar * XMLCALL + xmlStringDecodeEntities (xmlParserCtxtPtr ctxt, + const xmlChar *str, + int what, + xmlChar end, + xmlChar end2, + xmlChar end3); +XMLPUBFUN xmlChar * XMLCALL + xmlStringLenDecodeEntities (xmlParserCtxtPtr ctxt, + const xmlChar *str, + int len, + int what, + xmlChar end, + xmlChar end2, + xmlChar end3); + +/* + * Generated by MACROS on top of parser.c c.f. PUSH_AND_POP. + */ +XMLPUBFUN int XMLCALL nodePush (xmlParserCtxtPtr ctxt, + xmlNodePtr value); +XMLPUBFUN xmlNodePtr XMLCALL nodePop (xmlParserCtxtPtr ctxt); +XMLPUBFUN int XMLCALL inputPush (xmlParserCtxtPtr ctxt, + xmlParserInputPtr value); +XMLPUBFUN xmlParserInputPtr XMLCALL inputPop (xmlParserCtxtPtr ctxt); +XMLPUBFUN const xmlChar * XMLCALL namePop (xmlParserCtxtPtr ctxt); +XMLPUBFUN int XMLCALL namePush (xmlParserCtxtPtr ctxt, + const xmlChar *value); + +/* + * other commodities shared between parser.c and parserInternals. + */ +XMLPUBFUN int XMLCALL xmlSkipBlankChars (xmlParserCtxtPtr ctxt); +XMLPUBFUN int XMLCALL xmlStringCurrentChar (xmlParserCtxtPtr ctxt, + const xmlChar *cur, + int *len); +XMLPUBFUN void XMLCALL xmlParserHandlePEReference(xmlParserCtxtPtr ctxt); +XMLPUBFUN int XMLCALL xmlCheckLanguageID (const xmlChar *lang); + +/* + * Really core function shared with HTML parser. + */ +XMLPUBFUN int XMLCALL xmlCurrentChar (xmlParserCtxtPtr ctxt, + int *len); +XMLPUBFUN int XMLCALL xmlCopyCharMultiByte (xmlChar *out, + int val); +XMLPUBFUN int XMLCALL xmlCopyChar (int len, + xmlChar *out, + int val); +XMLPUBFUN void XMLCALL xmlNextChar (xmlParserCtxtPtr ctxt); +XMLPUBFUN void XMLCALL xmlParserInputShrink (xmlParserInputPtr in); + +#ifdef LIBXML_HTML_ENABLED +/* + * Actually comes from the HTML parser but launched from the init stuff. + */ +XMLPUBFUN void XMLCALL htmlInitAutoClose (void); +XMLPUBFUN htmlParserCtxtPtr XMLCALL htmlCreateFileParserCtxt(const char *filename, + const char *encoding); +#endif + +/* + * Specific function to keep track of entities references + * and used by the XSLT debugger. + */ +#ifdef LIBXML_LEGACY_ENABLED +/** + * xmlEntityReferenceFunc: + * @ent: the entity + * @firstNode: the fist node in the chunk + * @lastNode: the last nod in the chunk + * + * Callback function used when one needs to be able to track back the + * provenance of a chunk of nodes inherited from an entity replacement. + */ +typedef void (*xmlEntityReferenceFunc) (xmlEntityPtr ent, + xmlNodePtr firstNode, + xmlNodePtr lastNode); + +XMLPUBFUN void XMLCALL xmlSetEntityReferenceFunc (xmlEntityReferenceFunc func); + +XMLPUBFUN xmlChar * XMLCALL + xmlParseQuotedString (xmlParserCtxtPtr ctxt); +XMLPUBFUN void XMLCALL + xmlParseNamespace (xmlParserCtxtPtr ctxt); +XMLPUBFUN xmlChar * XMLCALL + xmlNamespaceParseNSDef (xmlParserCtxtPtr ctxt); +XMLPUBFUN xmlChar * XMLCALL + xmlScanName (xmlParserCtxtPtr ctxt); +XMLPUBFUN xmlChar * XMLCALL + xmlNamespaceParseNCName (xmlParserCtxtPtr ctxt); +XMLPUBFUN void XMLCALL xmlParserHandleReference(xmlParserCtxtPtr ctxt); +XMLPUBFUN xmlChar * XMLCALL + xmlNamespaceParseQName (xmlParserCtxtPtr ctxt, + xmlChar **prefix); +/** + * Entities + */ +XMLPUBFUN xmlChar * XMLCALL + xmlDecodeEntities (xmlParserCtxtPtr ctxt, + int len, + int what, + xmlChar end, + xmlChar end2, + xmlChar end3); +XMLPUBFUN void XMLCALL + xmlHandleEntity (xmlParserCtxtPtr ctxt, + xmlEntityPtr entity); + +#endif /* LIBXML_LEGACY_ENABLED */ + +#ifdef IN_LIBXML +/* + * internal only + */ +XMLPUBFUN void XMLCALL + xmlErrMemory (xmlParserCtxtPtr ctxt, + const char *extra); +#endif + +#ifdef __cplusplus +} +#endif +#endif /* __XML_PARSER_INTERNALS_H__ */ diff --git a/lib/libxml2/include/libxml/pattern.h b/lib/libxml2/include/libxml/pattern.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/pattern.h @@ -0,0 +1,100 @@ +/* + * Summary: pattern expression handling + * Description: allows to compile and test pattern expressions for nodes + * either in a tree or based on a parser state. + * + * Copy: See Copyright for the status of this software. + * + * Author: Daniel Veillard + */ + +#ifndef __XML_PATTERN_H__ +#define __XML_PATTERN_H__ + +#include +#include +#include + +#ifdef LIBXML_PATTERN_ENABLED + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * xmlPattern: + * + * A compiled (XPath based) pattern to select nodes + */ +typedef struct _xmlPattern xmlPattern; +typedef xmlPattern *xmlPatternPtr; + +/** + * xmlPatternFlags: + * + * This is the set of options affecting the behaviour of pattern + * matching with this module + * + */ +typedef enum { + XML_PATTERN_DEFAULT = 0, /* simple pattern match */ + XML_PATTERN_XPATH = 1<<0, /* standard XPath pattern */ + XML_PATTERN_XSSEL = 1<<1, /* XPath subset for schema selector */ + XML_PATTERN_XSFIELD = 1<<2 /* XPath subset for schema field */ +} xmlPatternFlags; + +XMLPUBFUN void XMLCALL + xmlFreePattern (xmlPatternPtr comp); + +XMLPUBFUN void XMLCALL + xmlFreePatternList (xmlPatternPtr comp); + +XMLPUBFUN xmlPatternPtr XMLCALL + xmlPatterncompile (const xmlChar *pattern, + xmlDict *dict, + int flags, + const xmlChar **namespaces); +XMLPUBFUN int XMLCALL + xmlPatternMatch (xmlPatternPtr comp, + xmlNodePtr node); + +/* streaming interfaces */ +typedef struct _xmlStreamCtxt xmlStreamCtxt; +typedef xmlStreamCtxt *xmlStreamCtxtPtr; + +XMLPUBFUN int XMLCALL + xmlPatternStreamable (xmlPatternPtr comp); +XMLPUBFUN int XMLCALL + xmlPatternMaxDepth (xmlPatternPtr comp); +XMLPUBFUN int XMLCALL + xmlPatternMinDepth (xmlPatternPtr comp); +XMLPUBFUN int XMLCALL + xmlPatternFromRoot (xmlPatternPtr comp); +XMLPUBFUN xmlStreamCtxtPtr XMLCALL + xmlPatternGetStreamCtxt (xmlPatternPtr comp); +XMLPUBFUN void XMLCALL + xmlFreeStreamCtxt (xmlStreamCtxtPtr stream); +XMLPUBFUN int XMLCALL + xmlStreamPushNode (xmlStreamCtxtPtr stream, + const xmlChar *name, + const xmlChar *ns, + int nodeType); +XMLPUBFUN int XMLCALL + xmlStreamPush (xmlStreamCtxtPtr stream, + const xmlChar *name, + const xmlChar *ns); +XMLPUBFUN int XMLCALL + xmlStreamPushAttr (xmlStreamCtxtPtr stream, + const xmlChar *name, + const xmlChar *ns); +XMLPUBFUN int XMLCALL + xmlStreamPop (xmlStreamCtxtPtr stream); +XMLPUBFUN int XMLCALL + xmlStreamWantsAnyNode (xmlStreamCtxtPtr stream); +#ifdef __cplusplus +} +#endif + +#endif /* LIBXML_PATTERN_ENABLED */ + +#endif /* __XML_PATTERN_H__ */ diff --git a/lib/libxml2/include/libxml/relaxng.h b/lib/libxml2/include/libxml/relaxng.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/relaxng.h @@ -0,0 +1,213 @@ +/* + * Summary: implementation of the Relax-NG validation + * Description: implementation of the Relax-NG validation + * + * Copy: See Copyright for the status of this software. + * + * Author: Daniel Veillard + */ + +#ifndef __XML_RELAX_NG__ +#define __XML_RELAX_NG__ + +#include +#include +#include + +#ifdef LIBXML_SCHEMAS_ENABLED + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct _xmlRelaxNG xmlRelaxNG; +typedef xmlRelaxNG *xmlRelaxNGPtr; + + +/** + * xmlRelaxNGValidityErrorFunc: + * @ctx: the validation context + * @msg: the message + * @...: extra arguments + * + * Signature of an error callback from a Relax-NG validation + */ +typedef void (XMLCDECL *xmlRelaxNGValidityErrorFunc) (void *ctx, const char *msg, ...) LIBXML_ATTR_FORMAT(2,3); + +/** + * xmlRelaxNGValidityWarningFunc: + * @ctx: the validation context + * @msg: the message + * @...: extra arguments + * + * Signature of a warning callback from a Relax-NG validation + */ +typedef void (XMLCDECL *xmlRelaxNGValidityWarningFunc) (void *ctx, const char *msg, ...) LIBXML_ATTR_FORMAT(2,3); + +/** + * A schemas validation context + */ +typedef struct _xmlRelaxNGParserCtxt xmlRelaxNGParserCtxt; +typedef xmlRelaxNGParserCtxt *xmlRelaxNGParserCtxtPtr; + +typedef struct _xmlRelaxNGValidCtxt xmlRelaxNGValidCtxt; +typedef xmlRelaxNGValidCtxt *xmlRelaxNGValidCtxtPtr; + +/* + * xmlRelaxNGValidErr: + * + * List of possible Relax NG validation errors + */ +typedef enum { + XML_RELAXNG_OK = 0, + XML_RELAXNG_ERR_MEMORY, + XML_RELAXNG_ERR_TYPE, + XML_RELAXNG_ERR_TYPEVAL, + XML_RELAXNG_ERR_DUPID, + XML_RELAXNG_ERR_TYPECMP, + XML_RELAXNG_ERR_NOSTATE, + XML_RELAXNG_ERR_NODEFINE, + XML_RELAXNG_ERR_LISTEXTRA, + XML_RELAXNG_ERR_LISTEMPTY, + XML_RELAXNG_ERR_INTERNODATA, + XML_RELAXNG_ERR_INTERSEQ, + XML_RELAXNG_ERR_INTEREXTRA, + XML_RELAXNG_ERR_ELEMNAME, + XML_RELAXNG_ERR_ATTRNAME, + XML_RELAXNG_ERR_ELEMNONS, + XML_RELAXNG_ERR_ATTRNONS, + XML_RELAXNG_ERR_ELEMWRONGNS, + XML_RELAXNG_ERR_ATTRWRONGNS, + XML_RELAXNG_ERR_ELEMEXTRANS, + XML_RELAXNG_ERR_ATTREXTRANS, + XML_RELAXNG_ERR_ELEMNOTEMPTY, + XML_RELAXNG_ERR_NOELEM, + XML_RELAXNG_ERR_NOTELEM, + XML_RELAXNG_ERR_ATTRVALID, + XML_RELAXNG_ERR_CONTENTVALID, + XML_RELAXNG_ERR_EXTRACONTENT, + XML_RELAXNG_ERR_INVALIDATTR, + XML_RELAXNG_ERR_DATAELEM, + XML_RELAXNG_ERR_VALELEM, + XML_RELAXNG_ERR_LISTELEM, + XML_RELAXNG_ERR_DATATYPE, + XML_RELAXNG_ERR_VALUE, + XML_RELAXNG_ERR_LIST, + XML_RELAXNG_ERR_NOGRAMMAR, + XML_RELAXNG_ERR_EXTRADATA, + XML_RELAXNG_ERR_LACKDATA, + XML_RELAXNG_ERR_INTERNAL, + XML_RELAXNG_ERR_ELEMWRONG, + XML_RELAXNG_ERR_TEXTWRONG +} xmlRelaxNGValidErr; + +/* + * xmlRelaxNGParserFlags: + * + * List of possible Relax NG Parser flags + */ +typedef enum { + XML_RELAXNGP_NONE = 0, + XML_RELAXNGP_FREE_DOC = 1, + XML_RELAXNGP_CRNG = 2 +} xmlRelaxNGParserFlag; + +XMLPUBFUN int XMLCALL + xmlRelaxNGInitTypes (void); +XMLPUBFUN void XMLCALL + xmlRelaxNGCleanupTypes (void); + +/* + * Interfaces for parsing. + */ +XMLPUBFUN xmlRelaxNGParserCtxtPtr XMLCALL + xmlRelaxNGNewParserCtxt (const char *URL); +XMLPUBFUN xmlRelaxNGParserCtxtPtr XMLCALL + xmlRelaxNGNewMemParserCtxt (const char *buffer, + int size); +XMLPUBFUN xmlRelaxNGParserCtxtPtr XMLCALL + xmlRelaxNGNewDocParserCtxt (xmlDocPtr doc); + +XMLPUBFUN int XMLCALL + xmlRelaxParserSetFlag (xmlRelaxNGParserCtxtPtr ctxt, + int flag); + +XMLPUBFUN void XMLCALL + xmlRelaxNGFreeParserCtxt (xmlRelaxNGParserCtxtPtr ctxt); +XMLPUBFUN void XMLCALL + xmlRelaxNGSetParserErrors(xmlRelaxNGParserCtxtPtr ctxt, + xmlRelaxNGValidityErrorFunc err, + xmlRelaxNGValidityWarningFunc warn, + void *ctx); +XMLPUBFUN int XMLCALL + xmlRelaxNGGetParserErrors(xmlRelaxNGParserCtxtPtr ctxt, + xmlRelaxNGValidityErrorFunc *err, + xmlRelaxNGValidityWarningFunc *warn, + void **ctx); +XMLPUBFUN void XMLCALL + xmlRelaxNGSetParserStructuredErrors( + xmlRelaxNGParserCtxtPtr ctxt, + xmlStructuredErrorFunc serror, + void *ctx); +XMLPUBFUN xmlRelaxNGPtr XMLCALL + xmlRelaxNGParse (xmlRelaxNGParserCtxtPtr ctxt); +XMLPUBFUN void XMLCALL + xmlRelaxNGFree (xmlRelaxNGPtr schema); +#ifdef LIBXML_OUTPUT_ENABLED +XMLPUBFUN void XMLCALL + xmlRelaxNGDump (FILE *output, + xmlRelaxNGPtr schema); +XMLPUBFUN void XMLCALL + xmlRelaxNGDumpTree (FILE * output, + xmlRelaxNGPtr schema); +#endif /* LIBXML_OUTPUT_ENABLED */ +/* + * Interfaces for validating + */ +XMLPUBFUN void XMLCALL + xmlRelaxNGSetValidErrors(xmlRelaxNGValidCtxtPtr ctxt, + xmlRelaxNGValidityErrorFunc err, + xmlRelaxNGValidityWarningFunc warn, + void *ctx); +XMLPUBFUN int XMLCALL + xmlRelaxNGGetValidErrors(xmlRelaxNGValidCtxtPtr ctxt, + xmlRelaxNGValidityErrorFunc *err, + xmlRelaxNGValidityWarningFunc *warn, + void **ctx); +XMLPUBFUN void XMLCALL + xmlRelaxNGSetValidStructuredErrors(xmlRelaxNGValidCtxtPtr ctxt, + xmlStructuredErrorFunc serror, void *ctx); +XMLPUBFUN xmlRelaxNGValidCtxtPtr XMLCALL + xmlRelaxNGNewValidCtxt (xmlRelaxNGPtr schema); +XMLPUBFUN void XMLCALL + xmlRelaxNGFreeValidCtxt (xmlRelaxNGValidCtxtPtr ctxt); +XMLPUBFUN int XMLCALL + xmlRelaxNGValidateDoc (xmlRelaxNGValidCtxtPtr ctxt, + xmlDocPtr doc); +/* + * Interfaces for progressive validation when possible + */ +XMLPUBFUN int XMLCALL + xmlRelaxNGValidatePushElement (xmlRelaxNGValidCtxtPtr ctxt, + xmlDocPtr doc, + xmlNodePtr elem); +XMLPUBFUN int XMLCALL + xmlRelaxNGValidatePushCData (xmlRelaxNGValidCtxtPtr ctxt, + const xmlChar *data, + int len); +XMLPUBFUN int XMLCALL + xmlRelaxNGValidatePopElement (xmlRelaxNGValidCtxtPtr ctxt, + xmlDocPtr doc, + xmlNodePtr elem); +XMLPUBFUN int XMLCALL + xmlRelaxNGValidateFullElement (xmlRelaxNGValidCtxtPtr ctxt, + xmlDocPtr doc, + xmlNodePtr elem); + +#ifdef __cplusplus +} +#endif + +#endif /* LIBXML_SCHEMAS_ENABLED */ + +#endif /* __XML_RELAX_NG__ */ diff --git a/lib/libxml2/include/libxml/schemasInternals.h b/lib/libxml2/include/libxml/schemasInternals.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/schemasInternals.h @@ -0,0 +1,958 @@ +/* + * Summary: internal interfaces for XML Schemas + * Description: internal interfaces for the XML Schemas handling + * and schema validity checking + * The Schemas development is a Work In Progress. + * Some of those interfaces are not garanteed to be API or ABI stable ! + * + * Copy: See Copyright for the status of this software. + * + * Author: Daniel Veillard + */ + + +#ifndef __XML_SCHEMA_INTERNALS_H__ +#define __XML_SCHEMA_INTERNALS_H__ + +#include + +#ifdef LIBXML_SCHEMAS_ENABLED + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum { + XML_SCHEMAS_UNKNOWN = 0, + XML_SCHEMAS_STRING, + XML_SCHEMAS_NORMSTRING, + XML_SCHEMAS_DECIMAL, + XML_SCHEMAS_TIME, + XML_SCHEMAS_GDAY, + XML_SCHEMAS_GMONTH, + XML_SCHEMAS_GMONTHDAY, + XML_SCHEMAS_GYEAR, + XML_SCHEMAS_GYEARMONTH, + XML_SCHEMAS_DATE, + XML_SCHEMAS_DATETIME, + XML_SCHEMAS_DURATION, + XML_SCHEMAS_FLOAT, + XML_SCHEMAS_DOUBLE, + XML_SCHEMAS_BOOLEAN, + XML_SCHEMAS_TOKEN, + XML_SCHEMAS_LANGUAGE, + XML_SCHEMAS_NMTOKEN, + XML_SCHEMAS_NMTOKENS, + XML_SCHEMAS_NAME, + XML_SCHEMAS_QNAME, + XML_SCHEMAS_NCNAME, + XML_SCHEMAS_ID, + XML_SCHEMAS_IDREF, + XML_SCHEMAS_IDREFS, + XML_SCHEMAS_ENTITY, + XML_SCHEMAS_ENTITIES, + XML_SCHEMAS_NOTATION, + XML_SCHEMAS_ANYURI, + XML_SCHEMAS_INTEGER, + XML_SCHEMAS_NPINTEGER, + XML_SCHEMAS_NINTEGER, + XML_SCHEMAS_NNINTEGER, + XML_SCHEMAS_PINTEGER, + XML_SCHEMAS_INT, + XML_SCHEMAS_UINT, + XML_SCHEMAS_LONG, + XML_SCHEMAS_ULONG, + XML_SCHEMAS_SHORT, + XML_SCHEMAS_USHORT, + XML_SCHEMAS_BYTE, + XML_SCHEMAS_UBYTE, + XML_SCHEMAS_HEXBINARY, + XML_SCHEMAS_BASE64BINARY, + XML_SCHEMAS_ANYTYPE, + XML_SCHEMAS_ANYSIMPLETYPE +} xmlSchemaValType; + +/* + * XML Schemas defines multiple type of types. + */ +typedef enum { + XML_SCHEMA_TYPE_BASIC = 1, /* A built-in datatype */ + XML_SCHEMA_TYPE_ANY, + XML_SCHEMA_TYPE_FACET, + XML_SCHEMA_TYPE_SIMPLE, + XML_SCHEMA_TYPE_COMPLEX, + XML_SCHEMA_TYPE_SEQUENCE = 6, + XML_SCHEMA_TYPE_CHOICE, + XML_SCHEMA_TYPE_ALL, + XML_SCHEMA_TYPE_SIMPLE_CONTENT, + XML_SCHEMA_TYPE_COMPLEX_CONTENT, + XML_SCHEMA_TYPE_UR, + XML_SCHEMA_TYPE_RESTRICTION, + XML_SCHEMA_TYPE_EXTENSION, + XML_SCHEMA_TYPE_ELEMENT, + XML_SCHEMA_TYPE_ATTRIBUTE, + XML_SCHEMA_TYPE_ATTRIBUTEGROUP, + XML_SCHEMA_TYPE_GROUP, + XML_SCHEMA_TYPE_NOTATION, + XML_SCHEMA_TYPE_LIST, + XML_SCHEMA_TYPE_UNION, + XML_SCHEMA_TYPE_ANY_ATTRIBUTE, + XML_SCHEMA_TYPE_IDC_UNIQUE, + XML_SCHEMA_TYPE_IDC_KEY, + XML_SCHEMA_TYPE_IDC_KEYREF, + XML_SCHEMA_TYPE_PARTICLE = 25, + XML_SCHEMA_TYPE_ATTRIBUTE_USE, + XML_SCHEMA_FACET_MININCLUSIVE = 1000, + XML_SCHEMA_FACET_MINEXCLUSIVE, + XML_SCHEMA_FACET_MAXINCLUSIVE, + XML_SCHEMA_FACET_MAXEXCLUSIVE, + XML_SCHEMA_FACET_TOTALDIGITS, + XML_SCHEMA_FACET_FRACTIONDIGITS, + XML_SCHEMA_FACET_PATTERN, + XML_SCHEMA_FACET_ENUMERATION, + XML_SCHEMA_FACET_WHITESPACE, + XML_SCHEMA_FACET_LENGTH, + XML_SCHEMA_FACET_MAXLENGTH, + XML_SCHEMA_FACET_MINLENGTH, + XML_SCHEMA_EXTRA_QNAMEREF = 2000, + XML_SCHEMA_EXTRA_ATTR_USE_PROHIB +} xmlSchemaTypeType; + +typedef enum { + XML_SCHEMA_CONTENT_UNKNOWN = 0, + XML_SCHEMA_CONTENT_EMPTY = 1, + XML_SCHEMA_CONTENT_ELEMENTS, + XML_SCHEMA_CONTENT_MIXED, + XML_SCHEMA_CONTENT_SIMPLE, + XML_SCHEMA_CONTENT_MIXED_OR_ELEMENTS, /* Obsolete */ + XML_SCHEMA_CONTENT_BASIC, + XML_SCHEMA_CONTENT_ANY +} xmlSchemaContentType; + +typedef struct _xmlSchemaVal xmlSchemaVal; +typedef xmlSchemaVal *xmlSchemaValPtr; + +typedef struct _xmlSchemaType xmlSchemaType; +typedef xmlSchemaType *xmlSchemaTypePtr; + +typedef struct _xmlSchemaFacet xmlSchemaFacet; +typedef xmlSchemaFacet *xmlSchemaFacetPtr; + +/** + * Annotation + */ +typedef struct _xmlSchemaAnnot xmlSchemaAnnot; +typedef xmlSchemaAnnot *xmlSchemaAnnotPtr; +struct _xmlSchemaAnnot { + struct _xmlSchemaAnnot *next; + xmlNodePtr content; /* the annotation */ +}; + +/** + * XML_SCHEMAS_ANYATTR_SKIP: + * + * Skip unknown attribute from validation + * Obsolete, not used anymore. + */ +#define XML_SCHEMAS_ANYATTR_SKIP 1 +/** + * XML_SCHEMAS_ANYATTR_LAX: + * + * Ignore validation non definition on attributes + * Obsolete, not used anymore. + */ +#define XML_SCHEMAS_ANYATTR_LAX 2 +/** + * XML_SCHEMAS_ANYATTR_STRICT: + * + * Apply strict validation rules on attributes + * Obsolete, not used anymore. + */ +#define XML_SCHEMAS_ANYATTR_STRICT 3 +/** + * XML_SCHEMAS_ANY_SKIP: + * + * Skip unknown attribute from validation + */ +#define XML_SCHEMAS_ANY_SKIP 1 +/** + * XML_SCHEMAS_ANY_LAX: + * + * Used by wildcards. + * Validate if type found, don't worry if not found + */ +#define XML_SCHEMAS_ANY_LAX 2 +/** + * XML_SCHEMAS_ANY_STRICT: + * + * Used by wildcards. + * Apply strict validation rules + */ +#define XML_SCHEMAS_ANY_STRICT 3 +/** + * XML_SCHEMAS_ATTR_USE_PROHIBITED: + * + * Used by wildcards. + * The attribute is prohibited. + */ +#define XML_SCHEMAS_ATTR_USE_PROHIBITED 0 +/** + * XML_SCHEMAS_ATTR_USE_REQUIRED: + * + * The attribute is required. + */ +#define XML_SCHEMAS_ATTR_USE_REQUIRED 1 +/** + * XML_SCHEMAS_ATTR_USE_OPTIONAL: + * + * The attribute is optional. + */ +#define XML_SCHEMAS_ATTR_USE_OPTIONAL 2 +/** + * XML_SCHEMAS_ATTR_GLOBAL: + * + * allow elements in no namespace + */ +#define XML_SCHEMAS_ATTR_GLOBAL 1 << 0 +/** + * XML_SCHEMAS_ATTR_NSDEFAULT: + * + * allow elements in no namespace + */ +#define XML_SCHEMAS_ATTR_NSDEFAULT 1 << 7 +/** + * XML_SCHEMAS_ATTR_INTERNAL_RESOLVED: + * + * this is set when the "type" and "ref" references + * have been resolved. + */ +#define XML_SCHEMAS_ATTR_INTERNAL_RESOLVED 1 << 8 +/** + * XML_SCHEMAS_ATTR_FIXED: + * + * the attribute has a fixed value + */ +#define XML_SCHEMAS_ATTR_FIXED 1 << 9 + +/** + * xmlSchemaAttribute: + * An attribute definition. + */ + +typedef struct _xmlSchemaAttribute xmlSchemaAttribute; +typedef xmlSchemaAttribute *xmlSchemaAttributePtr; +struct _xmlSchemaAttribute { + xmlSchemaTypeType type; + struct _xmlSchemaAttribute *next; /* the next attribute (not used?) */ + const xmlChar *name; /* the name of the declaration */ + const xmlChar *id; /* Deprecated; not used */ + const xmlChar *ref; /* Deprecated; not used */ + const xmlChar *refNs; /* Deprecated; not used */ + const xmlChar *typeName; /* the local name of the type definition */ + const xmlChar *typeNs; /* the ns URI of the type definition */ + xmlSchemaAnnotPtr annot; + + xmlSchemaTypePtr base; /* Deprecated; not used */ + int occurs; /* Deprecated; not used */ + const xmlChar *defValue; /* The initial value of the value constraint */ + xmlSchemaTypePtr subtypes; /* the type definition */ + xmlNodePtr node; + const xmlChar *targetNamespace; + int flags; + const xmlChar *refPrefix; /* Deprecated; not used */ + xmlSchemaValPtr defVal; /* The compiled value constraint */ + xmlSchemaAttributePtr refDecl; /* Deprecated; not used */ +}; + +/** + * xmlSchemaAttributeLink: + * Used to build a list of attribute uses on complexType definitions. + * WARNING: Deprecated; not used. + */ +typedef struct _xmlSchemaAttributeLink xmlSchemaAttributeLink; +typedef xmlSchemaAttributeLink *xmlSchemaAttributeLinkPtr; +struct _xmlSchemaAttributeLink { + struct _xmlSchemaAttributeLink *next;/* the next attribute link ... */ + struct _xmlSchemaAttribute *attr;/* the linked attribute */ +}; + +/** + * XML_SCHEMAS_WILDCARD_COMPLETE: + * + * If the wildcard is complete. + */ +#define XML_SCHEMAS_WILDCARD_COMPLETE 1 << 0 + +/** + * xmlSchemaCharValueLink: + * Used to build a list of namespaces on wildcards. + */ +typedef struct _xmlSchemaWildcardNs xmlSchemaWildcardNs; +typedef xmlSchemaWildcardNs *xmlSchemaWildcardNsPtr; +struct _xmlSchemaWildcardNs { + struct _xmlSchemaWildcardNs *next;/* the next constraint link ... */ + const xmlChar *value;/* the value */ +}; + +/** + * xmlSchemaWildcard. + * A wildcard. + */ +typedef struct _xmlSchemaWildcard xmlSchemaWildcard; +typedef xmlSchemaWildcard *xmlSchemaWildcardPtr; +struct _xmlSchemaWildcard { + xmlSchemaTypeType type; /* The kind of type */ + const xmlChar *id; /* Deprecated; not used */ + xmlSchemaAnnotPtr annot; + xmlNodePtr node; + int minOccurs; /* Deprecated; not used */ + int maxOccurs; /* Deprecated; not used */ + int processContents; + int any; /* Indicates if the ns constraint is of ##any */ + xmlSchemaWildcardNsPtr nsSet; /* The list of allowed namespaces */ + xmlSchemaWildcardNsPtr negNsSet; /* The negated namespace */ + int flags; +}; + +/** + * XML_SCHEMAS_ATTRGROUP_WILDCARD_BUILDED: + * + * The attribute wildcard has been already builded. + */ +#define XML_SCHEMAS_ATTRGROUP_WILDCARD_BUILDED 1 << 0 +/** + * XML_SCHEMAS_ATTRGROUP_GLOBAL: + * + * The attribute wildcard has been already builded. + */ +#define XML_SCHEMAS_ATTRGROUP_GLOBAL 1 << 1 +/** + * XML_SCHEMAS_ATTRGROUP_MARKED: + * + * Marks the attr group as marked; used for circular checks. + */ +#define XML_SCHEMAS_ATTRGROUP_MARKED 1 << 2 + +/** + * XML_SCHEMAS_ATTRGROUP_REDEFINED: + * + * The attr group was redefined. + */ +#define XML_SCHEMAS_ATTRGROUP_REDEFINED 1 << 3 +/** + * XML_SCHEMAS_ATTRGROUP_HAS_REFS: + * + * Whether this attr. group contains attr. group references. + */ +#define XML_SCHEMAS_ATTRGROUP_HAS_REFS 1 << 4 + +/** + * An attribute group definition. + * + * xmlSchemaAttribute and xmlSchemaAttributeGroup start of structures + * must be kept similar + */ +typedef struct _xmlSchemaAttributeGroup xmlSchemaAttributeGroup; +typedef xmlSchemaAttributeGroup *xmlSchemaAttributeGroupPtr; +struct _xmlSchemaAttributeGroup { + xmlSchemaTypeType type; /* The kind of type */ + struct _xmlSchemaAttribute *next;/* the next attribute if in a group ... */ + const xmlChar *name; + const xmlChar *id; + const xmlChar *ref; /* Deprecated; not used */ + const xmlChar *refNs; /* Deprecated; not used */ + xmlSchemaAnnotPtr annot; + + xmlSchemaAttributePtr attributes; /* Deprecated; not used */ + xmlNodePtr node; + int flags; + xmlSchemaWildcardPtr attributeWildcard; + const xmlChar *refPrefix; /* Deprecated; not used */ + xmlSchemaAttributeGroupPtr refItem; /* Deprecated; not used */ + const xmlChar *targetNamespace; + void *attrUses; +}; + +/** + * xmlSchemaTypeLink: + * Used to build a list of types (e.g. member types of + * simpleType with variety "union"). + */ +typedef struct _xmlSchemaTypeLink xmlSchemaTypeLink; +typedef xmlSchemaTypeLink *xmlSchemaTypeLinkPtr; +struct _xmlSchemaTypeLink { + struct _xmlSchemaTypeLink *next;/* the next type link ... */ + xmlSchemaTypePtr type;/* the linked type */ +}; + +/** + * xmlSchemaFacetLink: + * Used to build a list of facets. + */ +typedef struct _xmlSchemaFacetLink xmlSchemaFacetLink; +typedef xmlSchemaFacetLink *xmlSchemaFacetLinkPtr; +struct _xmlSchemaFacetLink { + struct _xmlSchemaFacetLink *next;/* the next facet link ... */ + xmlSchemaFacetPtr facet;/* the linked facet */ +}; + +/** + * XML_SCHEMAS_TYPE_MIXED: + * + * the element content type is mixed + */ +#define XML_SCHEMAS_TYPE_MIXED 1 << 0 +/** + * XML_SCHEMAS_TYPE_DERIVATION_METHOD_EXTENSION: + * + * the simple or complex type has a derivation method of "extension". + */ +#define XML_SCHEMAS_TYPE_DERIVATION_METHOD_EXTENSION 1 << 1 +/** + * XML_SCHEMAS_TYPE_DERIVATION_METHOD_RESTRICTION: + * + * the simple or complex type has a derivation method of "restriction". + */ +#define XML_SCHEMAS_TYPE_DERIVATION_METHOD_RESTRICTION 1 << 2 +/** + * XML_SCHEMAS_TYPE_GLOBAL: + * + * the type is global + */ +#define XML_SCHEMAS_TYPE_GLOBAL 1 << 3 +/** + * XML_SCHEMAS_TYPE_OWNED_ATTR_WILDCARD: + * + * the complexType owns an attribute wildcard, i.e. + * it can be freed by the complexType + */ +#define XML_SCHEMAS_TYPE_OWNED_ATTR_WILDCARD 1 << 4 /* Obsolete. */ +/** + * XML_SCHEMAS_TYPE_VARIETY_ABSENT: + * + * the simpleType has a variety of "absent". + * TODO: Actually not necessary :-/, since if + * none of the variety flags occur then it's + * automatically absent. + */ +#define XML_SCHEMAS_TYPE_VARIETY_ABSENT 1 << 5 +/** + * XML_SCHEMAS_TYPE_VARIETY_LIST: + * + * the simpleType has a variety of "list". + */ +#define XML_SCHEMAS_TYPE_VARIETY_LIST 1 << 6 +/** + * XML_SCHEMAS_TYPE_VARIETY_UNION: + * + * the simpleType has a variety of "union". + */ +#define XML_SCHEMAS_TYPE_VARIETY_UNION 1 << 7 +/** + * XML_SCHEMAS_TYPE_VARIETY_ATOMIC: + * + * the simpleType has a variety of "union". + */ +#define XML_SCHEMAS_TYPE_VARIETY_ATOMIC 1 << 8 +/** + * XML_SCHEMAS_TYPE_FINAL_EXTENSION: + * + * the complexType has a final of "extension". + */ +#define XML_SCHEMAS_TYPE_FINAL_EXTENSION 1 << 9 +/** + * XML_SCHEMAS_TYPE_FINAL_RESTRICTION: + * + * the simpleType/complexType has a final of "restriction". + */ +#define XML_SCHEMAS_TYPE_FINAL_RESTRICTION 1 << 10 +/** + * XML_SCHEMAS_TYPE_FINAL_LIST: + * + * the simpleType has a final of "list". + */ +#define XML_SCHEMAS_TYPE_FINAL_LIST 1 << 11 +/** + * XML_SCHEMAS_TYPE_FINAL_UNION: + * + * the simpleType has a final of "union". + */ +#define XML_SCHEMAS_TYPE_FINAL_UNION 1 << 12 +/** + * XML_SCHEMAS_TYPE_FINAL_DEFAULT: + * + * the simpleType has a final of "default". + */ +#define XML_SCHEMAS_TYPE_FINAL_DEFAULT 1 << 13 +/** + * XML_SCHEMAS_TYPE_BUILTIN_PRIMITIVE: + * + * Marks the item as a builtin primitive. + */ +#define XML_SCHEMAS_TYPE_BUILTIN_PRIMITIVE 1 << 14 +/** + * XML_SCHEMAS_TYPE_MARKED: + * + * Marks the item as marked; used for circular checks. + */ +#define XML_SCHEMAS_TYPE_MARKED 1 << 16 +/** + * XML_SCHEMAS_TYPE_BLOCK_DEFAULT: + * + * the complexType did not specify 'block' so use the default of the + * item. + */ +#define XML_SCHEMAS_TYPE_BLOCK_DEFAULT 1 << 17 +/** + * XML_SCHEMAS_TYPE_BLOCK_EXTENSION: + * + * the complexType has a 'block' of "extension". + */ +#define XML_SCHEMAS_TYPE_BLOCK_EXTENSION 1 << 18 +/** + * XML_SCHEMAS_TYPE_BLOCK_RESTRICTION: + * + * the complexType has a 'block' of "restriction". + */ +#define XML_SCHEMAS_TYPE_BLOCK_RESTRICTION 1 << 19 +/** + * XML_SCHEMAS_TYPE_ABSTRACT: + * + * the simple/complexType is abstract. + */ +#define XML_SCHEMAS_TYPE_ABSTRACT 1 << 20 +/** + * XML_SCHEMAS_TYPE_FACETSNEEDVALUE: + * + * indicates if the facets need a computed value + */ +#define XML_SCHEMAS_TYPE_FACETSNEEDVALUE 1 << 21 +/** + * XML_SCHEMAS_TYPE_INTERNAL_RESOLVED: + * + * indicates that the type was typefixed + */ +#define XML_SCHEMAS_TYPE_INTERNAL_RESOLVED 1 << 22 +/** + * XML_SCHEMAS_TYPE_INTERNAL_INVALID: + * + * indicates that the type is invalid + */ +#define XML_SCHEMAS_TYPE_INTERNAL_INVALID 1 << 23 +/** + * XML_SCHEMAS_TYPE_WHITESPACE_PRESERVE: + * + * a whitespace-facet value of "preserve" + */ +#define XML_SCHEMAS_TYPE_WHITESPACE_PRESERVE 1 << 24 +/** + * XML_SCHEMAS_TYPE_WHITESPACE_REPLACE: + * + * a whitespace-facet value of "replace" + */ +#define XML_SCHEMAS_TYPE_WHITESPACE_REPLACE 1 << 25 +/** + * XML_SCHEMAS_TYPE_WHITESPACE_COLLAPSE: + * + * a whitespace-facet value of "collapse" + */ +#define XML_SCHEMAS_TYPE_WHITESPACE_COLLAPSE 1 << 26 +/** + * XML_SCHEMAS_TYPE_HAS_FACETS: + * + * has facets + */ +#define XML_SCHEMAS_TYPE_HAS_FACETS 1 << 27 +/** + * XML_SCHEMAS_TYPE_NORMVALUENEEDED: + * + * indicates if the facets (pattern) need a normalized value + */ +#define XML_SCHEMAS_TYPE_NORMVALUENEEDED 1 << 28 + +/** + * XML_SCHEMAS_TYPE_FIXUP_1: + * + * First stage of fixup was done. + */ +#define XML_SCHEMAS_TYPE_FIXUP_1 1 << 29 + +/** + * XML_SCHEMAS_TYPE_REDEFINED: + * + * The type was redefined. + */ +#define XML_SCHEMAS_TYPE_REDEFINED 1 << 30 +/** + * XML_SCHEMAS_TYPE_REDEFINING: + * + * The type redefines an other type. + */ +/* #define XML_SCHEMAS_TYPE_REDEFINING 1 << 31 */ + +/** + * _xmlSchemaType: + * + * Schemas type definition. + */ +struct _xmlSchemaType { + xmlSchemaTypeType type; /* The kind of type */ + struct _xmlSchemaType *next; /* the next type if in a sequence ... */ + const xmlChar *name; + const xmlChar *id ; /* Deprecated; not used */ + const xmlChar *ref; /* Deprecated; not used */ + const xmlChar *refNs; /* Deprecated; not used */ + xmlSchemaAnnotPtr annot; + xmlSchemaTypePtr subtypes; + xmlSchemaAttributePtr attributes; /* Deprecated; not used */ + xmlNodePtr node; + int minOccurs; /* Deprecated; not used */ + int maxOccurs; /* Deprecated; not used */ + + int flags; + xmlSchemaContentType contentType; + const xmlChar *base; /* Base type's local name */ + const xmlChar *baseNs; /* Base type's target namespace */ + xmlSchemaTypePtr baseType; /* The base type component */ + xmlSchemaFacetPtr facets; /* Local facets */ + struct _xmlSchemaType *redef; /* Deprecated; not used */ + int recurse; /* Obsolete */ + xmlSchemaAttributeLinkPtr *attributeUses; /* Deprecated; not used */ + xmlSchemaWildcardPtr attributeWildcard; + int builtInType; /* Type of built-in types. */ + xmlSchemaTypeLinkPtr memberTypes; /* member-types if a union type. */ + xmlSchemaFacetLinkPtr facetSet; /* All facets (incl. inherited) */ + const xmlChar *refPrefix; /* Deprecated; not used */ + xmlSchemaTypePtr contentTypeDef; /* Used for the simple content of complex types. + Could we use @subtypes for this? */ + xmlRegexpPtr contModel; /* Holds the automaton of the content model */ + const xmlChar *targetNamespace; + void *attrUses; +}; + +/* + * xmlSchemaElement: + * An element definition. + * + * xmlSchemaType, xmlSchemaFacet and xmlSchemaElement start of + * structures must be kept similar + */ +/** + * XML_SCHEMAS_ELEM_NILLABLE: + * + * the element is nillable + */ +#define XML_SCHEMAS_ELEM_NILLABLE 1 << 0 +/** + * XML_SCHEMAS_ELEM_GLOBAL: + * + * the element is global + */ +#define XML_SCHEMAS_ELEM_GLOBAL 1 << 1 +/** + * XML_SCHEMAS_ELEM_DEFAULT: + * + * the element has a default value + */ +#define XML_SCHEMAS_ELEM_DEFAULT 1 << 2 +/** + * XML_SCHEMAS_ELEM_FIXED: + * + * the element has a fixed value + */ +#define XML_SCHEMAS_ELEM_FIXED 1 << 3 +/** + * XML_SCHEMAS_ELEM_ABSTRACT: + * + * the element is abstract + */ +#define XML_SCHEMAS_ELEM_ABSTRACT 1 << 4 +/** + * XML_SCHEMAS_ELEM_TOPLEVEL: + * + * the element is top level + * obsolete: use XML_SCHEMAS_ELEM_GLOBAL instead + */ +#define XML_SCHEMAS_ELEM_TOPLEVEL 1 << 5 +/** + * XML_SCHEMAS_ELEM_REF: + * + * the element is a reference to a type + */ +#define XML_SCHEMAS_ELEM_REF 1 << 6 +/** + * XML_SCHEMAS_ELEM_NSDEFAULT: + * + * allow elements in no namespace + * Obsolete, not used anymore. + */ +#define XML_SCHEMAS_ELEM_NSDEFAULT 1 << 7 +/** + * XML_SCHEMAS_ELEM_INTERNAL_RESOLVED: + * + * this is set when "type", "ref", "substitutionGroup" + * references have been resolved. + */ +#define XML_SCHEMAS_ELEM_INTERNAL_RESOLVED 1 << 8 + /** + * XML_SCHEMAS_ELEM_CIRCULAR: + * + * a helper flag for the search of circular references. + */ +#define XML_SCHEMAS_ELEM_CIRCULAR 1 << 9 +/** + * XML_SCHEMAS_ELEM_BLOCK_ABSENT: + * + * the "block" attribute is absent + */ +#define XML_SCHEMAS_ELEM_BLOCK_ABSENT 1 << 10 +/** + * XML_SCHEMAS_ELEM_BLOCK_EXTENSION: + * + * disallowed substitutions are absent + */ +#define XML_SCHEMAS_ELEM_BLOCK_EXTENSION 1 << 11 +/** + * XML_SCHEMAS_ELEM_BLOCK_RESTRICTION: + * + * disallowed substitutions: "restriction" + */ +#define XML_SCHEMAS_ELEM_BLOCK_RESTRICTION 1 << 12 +/** + * XML_SCHEMAS_ELEM_BLOCK_SUBSTITUTION: + * + * disallowed substitutions: "substituion" + */ +#define XML_SCHEMAS_ELEM_BLOCK_SUBSTITUTION 1 << 13 +/** + * XML_SCHEMAS_ELEM_FINAL_ABSENT: + * + * substitution group exclusions are absent + */ +#define XML_SCHEMAS_ELEM_FINAL_ABSENT 1 << 14 +/** + * XML_SCHEMAS_ELEM_FINAL_EXTENSION: + * + * substitution group exclusions: "extension" + */ +#define XML_SCHEMAS_ELEM_FINAL_EXTENSION 1 << 15 +/** + * XML_SCHEMAS_ELEM_FINAL_RESTRICTION: + * + * substitution group exclusions: "restriction" + */ +#define XML_SCHEMAS_ELEM_FINAL_RESTRICTION 1 << 16 +/** + * XML_SCHEMAS_ELEM_SUBST_GROUP_HEAD: + * + * the declaration is a substitution group head + */ +#define XML_SCHEMAS_ELEM_SUBST_GROUP_HEAD 1 << 17 +/** + * XML_SCHEMAS_ELEM_INTERNAL_CHECKED: + * + * this is set when the elem decl has been checked against + * all constraints + */ +#define XML_SCHEMAS_ELEM_INTERNAL_CHECKED 1 << 18 + +typedef struct _xmlSchemaElement xmlSchemaElement; +typedef xmlSchemaElement *xmlSchemaElementPtr; +struct _xmlSchemaElement { + xmlSchemaTypeType type; /* The kind of type */ + struct _xmlSchemaType *next; /* Not used? */ + const xmlChar *name; + const xmlChar *id; /* Deprecated; not used */ + const xmlChar *ref; /* Deprecated; not used */ + const xmlChar *refNs; /* Deprecated; not used */ + xmlSchemaAnnotPtr annot; + xmlSchemaTypePtr subtypes; /* the type definition */ + xmlSchemaAttributePtr attributes; + xmlNodePtr node; + int minOccurs; /* Deprecated; not used */ + int maxOccurs; /* Deprecated; not used */ + + int flags; + const xmlChar *targetNamespace; + const xmlChar *namedType; + const xmlChar *namedTypeNs; + const xmlChar *substGroup; + const xmlChar *substGroupNs; + const xmlChar *scope; + const xmlChar *value; /* The original value of the value constraint. */ + struct _xmlSchemaElement *refDecl; /* This will now be used for the + substitution group affiliation */ + xmlRegexpPtr contModel; /* Obsolete for WXS, maybe used for RelaxNG */ + xmlSchemaContentType contentType; + const xmlChar *refPrefix; /* Deprecated; not used */ + xmlSchemaValPtr defVal; /* The compiled value contraint. */ + void *idcs; /* The identity-constraint defs */ +}; + +/* + * XML_SCHEMAS_FACET_UNKNOWN: + * + * unknown facet handling + */ +#define XML_SCHEMAS_FACET_UNKNOWN 0 +/* + * XML_SCHEMAS_FACET_PRESERVE: + * + * preserve the type of the facet + */ +#define XML_SCHEMAS_FACET_PRESERVE 1 +/* + * XML_SCHEMAS_FACET_REPLACE: + * + * replace the type of the facet + */ +#define XML_SCHEMAS_FACET_REPLACE 2 +/* + * XML_SCHEMAS_FACET_COLLAPSE: + * + * collapse the types of the facet + */ +#define XML_SCHEMAS_FACET_COLLAPSE 3 +/** + * A facet definition. + */ +struct _xmlSchemaFacet { + xmlSchemaTypeType type; /* The kind of type */ + struct _xmlSchemaFacet *next;/* the next type if in a sequence ... */ + const xmlChar *value; /* The original value */ + const xmlChar *id; /* Obsolete */ + xmlSchemaAnnotPtr annot; + xmlNodePtr node; + int fixed; /* XML_SCHEMAS_FACET_PRESERVE, etc. */ + int whitespace; + xmlSchemaValPtr val; /* The compiled value */ + xmlRegexpPtr regexp; /* The regex for patterns */ +}; + +/** + * A notation definition. + */ +typedef struct _xmlSchemaNotation xmlSchemaNotation; +typedef xmlSchemaNotation *xmlSchemaNotationPtr; +struct _xmlSchemaNotation { + xmlSchemaTypeType type; /* The kind of type */ + const xmlChar *name; + xmlSchemaAnnotPtr annot; + const xmlChar *identifier; + const xmlChar *targetNamespace; +}; + +/* +* TODO: Actually all those flags used for the schema should sit +* on the schema parser context, since they are used only +* during parsing an XML schema document, and not available +* on the component level as per spec. +*/ +/** + * XML_SCHEMAS_QUALIF_ELEM: + * + * Reflects elementFormDefault == qualified in + * an XML schema document. + */ +#define XML_SCHEMAS_QUALIF_ELEM 1 << 0 +/** + * XML_SCHEMAS_QUALIF_ATTR: + * + * Reflects attributeFormDefault == qualified in + * an XML schema document. + */ +#define XML_SCHEMAS_QUALIF_ATTR 1 << 1 +/** + * XML_SCHEMAS_FINAL_DEFAULT_EXTENSION: + * + * the schema has "extension" in the set of finalDefault. + */ +#define XML_SCHEMAS_FINAL_DEFAULT_EXTENSION 1 << 2 +/** + * XML_SCHEMAS_FINAL_DEFAULT_RESTRICTION: + * + * the schema has "restriction" in the set of finalDefault. + */ +#define XML_SCHEMAS_FINAL_DEFAULT_RESTRICTION 1 << 3 +/** + * XML_SCHEMAS_FINAL_DEFAULT_LIST: + * + * the cshema has "list" in the set of finalDefault. + */ +#define XML_SCHEMAS_FINAL_DEFAULT_LIST 1 << 4 +/** + * XML_SCHEMAS_FINAL_DEFAULT_UNION: + * + * the schema has "union" in the set of finalDefault. + */ +#define XML_SCHEMAS_FINAL_DEFAULT_UNION 1 << 5 +/** + * XML_SCHEMAS_BLOCK_DEFAULT_EXTENSION: + * + * the schema has "extension" in the set of blockDefault. + */ +#define XML_SCHEMAS_BLOCK_DEFAULT_EXTENSION 1 << 6 +/** + * XML_SCHEMAS_BLOCK_DEFAULT_RESTRICTION: + * + * the schema has "restriction" in the set of blockDefault. + */ +#define XML_SCHEMAS_BLOCK_DEFAULT_RESTRICTION 1 << 7 +/** + * XML_SCHEMAS_BLOCK_DEFAULT_SUBSTITUTION: + * + * the schema has "substitution" in the set of blockDefault. + */ +#define XML_SCHEMAS_BLOCK_DEFAULT_SUBSTITUTION 1 << 8 +/** + * XML_SCHEMAS_INCLUDING_CONVERT_NS: + * + * the schema is currently including an other schema with + * no target namespace. + */ +#define XML_SCHEMAS_INCLUDING_CONVERT_NS 1 << 9 +/** + * _xmlSchema: + * + * A Schemas definition + */ +struct _xmlSchema { + const xmlChar *name; /* schema name */ + const xmlChar *targetNamespace; /* the target namespace */ + const xmlChar *version; + const xmlChar *id; /* Obsolete */ + xmlDocPtr doc; + xmlSchemaAnnotPtr annot; + int flags; + + xmlHashTablePtr typeDecl; + xmlHashTablePtr attrDecl; + xmlHashTablePtr attrgrpDecl; + xmlHashTablePtr elemDecl; + xmlHashTablePtr notaDecl; + + xmlHashTablePtr schemasImports; + + void *_private; /* unused by the library for users or bindings */ + xmlHashTablePtr groupDecl; + xmlDictPtr dict; + void *includes; /* the includes, this is opaque for now */ + int preserve; /* whether to free the document */ + int counter; /* used to give ononymous components unique names */ + xmlHashTablePtr idcDef; /* All identity-constraint defs. */ + void *volatiles; /* Obsolete */ +}; + +XMLPUBFUN void XMLCALL xmlSchemaFreeType (xmlSchemaTypePtr type); +XMLPUBFUN void XMLCALL xmlSchemaFreeWildcard(xmlSchemaWildcardPtr wildcard); + +#ifdef __cplusplus +} +#endif + +#endif /* LIBXML_SCHEMAS_ENABLED */ +#endif /* __XML_SCHEMA_INTERNALS_H__ */ diff --git a/lib/libxml2/include/libxml/schematron.h b/lib/libxml2/include/libxml/schematron.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/schematron.h @@ -0,0 +1,142 @@ +/* + * Summary: XML Schemastron implementation + * Description: interface to the XML Schematron validity checking. + * + * Copy: See Copyright for the status of this software. + * + * Author: Daniel Veillard + */ + + +#ifndef __XML_SCHEMATRON_H__ +#define __XML_SCHEMATRON_H__ + +#include + +#ifdef LIBXML_SCHEMATRON_ENABLED + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum { + XML_SCHEMATRON_OUT_QUIET = 1 << 0, /* quiet no report */ + XML_SCHEMATRON_OUT_TEXT = 1 << 1, /* build a textual report */ + XML_SCHEMATRON_OUT_XML = 1 << 2, /* output SVRL */ + XML_SCHEMATRON_OUT_ERROR = 1 << 3, /* output via xmlStructuredErrorFunc */ + XML_SCHEMATRON_OUT_FILE = 1 << 8, /* output to a file descriptor */ + XML_SCHEMATRON_OUT_BUFFER = 1 << 9, /* output to a buffer */ + XML_SCHEMATRON_OUT_IO = 1 << 10 /* output to I/O mechanism */ +} xmlSchematronValidOptions; + +/** + * The schemas related types are kept internal + */ +typedef struct _xmlSchematron xmlSchematron; +typedef xmlSchematron *xmlSchematronPtr; + +/** + * xmlSchematronValidityErrorFunc: + * @ctx: the validation context + * @msg: the message + * @...: extra arguments + * + * Signature of an error callback from a Schematron validation + */ +typedef void (*xmlSchematronValidityErrorFunc) (void *ctx, const char *msg, ...); + +/** + * xmlSchematronValidityWarningFunc: + * @ctx: the validation context + * @msg: the message + * @...: extra arguments + * + * Signature of a warning callback from a Schematron validation + */ +typedef void (*xmlSchematronValidityWarningFunc) (void *ctx, const char *msg, ...); + +/** + * A schemas validation context + */ +typedef struct _xmlSchematronParserCtxt xmlSchematronParserCtxt; +typedef xmlSchematronParserCtxt *xmlSchematronParserCtxtPtr; + +typedef struct _xmlSchematronValidCtxt xmlSchematronValidCtxt; +typedef xmlSchematronValidCtxt *xmlSchematronValidCtxtPtr; + +/* + * Interfaces for parsing. + */ +XMLPUBFUN xmlSchematronParserCtxtPtr XMLCALL + xmlSchematronNewParserCtxt (const char *URL); +XMLPUBFUN xmlSchematronParserCtxtPtr XMLCALL + xmlSchematronNewMemParserCtxt(const char *buffer, + int size); +XMLPUBFUN xmlSchematronParserCtxtPtr XMLCALL + xmlSchematronNewDocParserCtxt(xmlDocPtr doc); +XMLPUBFUN void XMLCALL + xmlSchematronFreeParserCtxt (xmlSchematronParserCtxtPtr ctxt); +/***** +XMLPUBFUN void XMLCALL + xmlSchematronSetParserErrors(xmlSchematronParserCtxtPtr ctxt, + xmlSchematronValidityErrorFunc err, + xmlSchematronValidityWarningFunc warn, + void *ctx); +XMLPUBFUN int XMLCALL + xmlSchematronGetParserErrors(xmlSchematronParserCtxtPtr ctxt, + xmlSchematronValidityErrorFunc * err, + xmlSchematronValidityWarningFunc * warn, + void **ctx); +XMLPUBFUN int XMLCALL + xmlSchematronIsValid (xmlSchematronValidCtxtPtr ctxt); + *****/ +XMLPUBFUN xmlSchematronPtr XMLCALL + xmlSchematronParse (xmlSchematronParserCtxtPtr ctxt); +XMLPUBFUN void XMLCALL + xmlSchematronFree (xmlSchematronPtr schema); +/* + * Interfaces for validating + */ +XMLPUBFUN void XMLCALL + xmlSchematronSetValidStructuredErrors( + xmlSchematronValidCtxtPtr ctxt, + xmlStructuredErrorFunc serror, + void *ctx); +/****** +XMLPUBFUN void XMLCALL + xmlSchematronSetValidErrors (xmlSchematronValidCtxtPtr ctxt, + xmlSchematronValidityErrorFunc err, + xmlSchematronValidityWarningFunc warn, + void *ctx); +XMLPUBFUN int XMLCALL + xmlSchematronGetValidErrors (xmlSchematronValidCtxtPtr ctxt, + xmlSchematronValidityErrorFunc *err, + xmlSchematronValidityWarningFunc *warn, + void **ctx); +XMLPUBFUN int XMLCALL + xmlSchematronSetValidOptions(xmlSchematronValidCtxtPtr ctxt, + int options); +XMLPUBFUN int XMLCALL + xmlSchematronValidCtxtGetOptions(xmlSchematronValidCtxtPtr ctxt); +XMLPUBFUN int XMLCALL + xmlSchematronValidateOneElement (xmlSchematronValidCtxtPtr ctxt, + xmlNodePtr elem); + *******/ + +XMLPUBFUN xmlSchematronValidCtxtPtr XMLCALL + xmlSchematronNewValidCtxt (xmlSchematronPtr schema, + int options); +XMLPUBFUN void XMLCALL + xmlSchematronFreeValidCtxt (xmlSchematronValidCtxtPtr ctxt); +XMLPUBFUN int XMLCALL + xmlSchematronValidateDoc (xmlSchematronValidCtxtPtr ctxt, + xmlDocPtr instance); + +#ifdef __cplusplus +} +#endif + +#endif /* LIBXML_SCHEMATRON_ENABLED */ +#endif /* __XML_SCHEMATRON_H__ */ diff --git a/lib/libxml2/include/libxml/threads.h b/lib/libxml2/include/libxml/threads.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/threads.h @@ -0,0 +1,84 @@ +/** + * Summary: interfaces for thread handling + * Description: set of generic threading related routines + * should work with pthreads, Windows native or TLS threads + * + * Copy: See Copyright for the status of this software. + * + * Author: Daniel Veillard + */ + +#ifndef __XML_THREADS_H__ +#define __XML_THREADS_H__ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * xmlMutex are a simple mutual exception locks. + */ +typedef struct _xmlMutex xmlMutex; +typedef xmlMutex *xmlMutexPtr; + +/* + * xmlRMutex are reentrant mutual exception locks. + */ +typedef struct _xmlRMutex xmlRMutex; +typedef xmlRMutex *xmlRMutexPtr; + +#ifdef __cplusplus +} +#endif +#include +#ifdef __cplusplus +extern "C" { +#endif +XMLPUBFUN xmlMutexPtr XMLCALL + xmlNewMutex (void); +XMLPUBFUN void XMLCALL + xmlMutexLock (xmlMutexPtr tok); +XMLPUBFUN void XMLCALL + xmlMutexUnlock (xmlMutexPtr tok); +XMLPUBFUN void XMLCALL + xmlFreeMutex (xmlMutexPtr tok); + +XMLPUBFUN xmlRMutexPtr XMLCALL + xmlNewRMutex (void); +XMLPUBFUN void XMLCALL + xmlRMutexLock (xmlRMutexPtr tok); +XMLPUBFUN void XMLCALL + xmlRMutexUnlock (xmlRMutexPtr tok); +XMLPUBFUN void XMLCALL + xmlFreeRMutex (xmlRMutexPtr tok); + +/* + * Library wide APIs. + */ +XMLPUBFUN void XMLCALL + xmlInitThreads (void); +XMLPUBFUN void XMLCALL + xmlLockLibrary (void); +XMLPUBFUN void XMLCALL + xmlUnlockLibrary(void); +XMLPUBFUN int XMLCALL + xmlGetThreadId (void); +XMLPUBFUN int XMLCALL + xmlIsMainThread (void); +XMLPUBFUN void XMLCALL + xmlCleanupThreads(void); +XMLPUBFUN xmlGlobalStatePtr XMLCALL + xmlGetGlobalState(void); + +#if defined(HAVE_WIN32_THREADS) && !defined(HAVE_COMPILER_TLS) && defined(LIBXML_STATIC_FOR_DLL) +int XMLCALL xmlDllMain(void *hinstDLL, unsigned long fdwReason, void *lpvReserved); +#endif + +#ifdef __cplusplus +} +#endif + + +#endif /* __XML_THREADS_H__ */ diff --git a/lib/libxml2/include/libxml/tree.h b/lib/libxml2/include/libxml/tree.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/tree.h @@ -0,0 +1,1252 @@ +/* + * Summary: interfaces for tree manipulation + * Description: this module describes the structures found in an tree resulting + * from an XML or HTML parsing, as well as the API provided for + * various processing on that tree + * + * Copy: See Copyright for the status of this software. + * + * Author: Daniel Veillard + */ + +#ifndef __XML_TREE_H__ +#define __XML_TREE_H__ + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * Some of the basic types pointer to structures: + */ +/* xmlIO.h */ +typedef struct _xmlParserInputBuffer xmlParserInputBuffer; +typedef xmlParserInputBuffer *xmlParserInputBufferPtr; + +typedef struct _xmlOutputBuffer xmlOutputBuffer; +typedef xmlOutputBuffer *xmlOutputBufferPtr; + +/* parser.h */ +typedef struct _xmlParserInput xmlParserInput; +typedef xmlParserInput *xmlParserInputPtr; + +typedef struct _xmlParserCtxt xmlParserCtxt; +typedef xmlParserCtxt *xmlParserCtxtPtr; + +typedef struct _xmlSAXLocator xmlSAXLocator; +typedef xmlSAXLocator *xmlSAXLocatorPtr; + +typedef struct _xmlSAXHandler xmlSAXHandler; +typedef xmlSAXHandler *xmlSAXHandlerPtr; + +/* entities.h */ +typedef struct _xmlEntity xmlEntity; +typedef xmlEntity *xmlEntityPtr; + +/** + * BASE_BUFFER_SIZE: + * + * default buffer size 4000. + */ +#define BASE_BUFFER_SIZE 4096 + +/** + * LIBXML_NAMESPACE_DICT: + * + * Defines experimental behaviour: + * 1) xmlNs gets an additional field @context (a xmlDoc) + * 2) when creating a tree, xmlNs->href is stored in the dict of xmlDoc. + */ +/* #define LIBXML_NAMESPACE_DICT */ + +/** + * xmlBufferAllocationScheme: + * + * A buffer allocation scheme can be defined to either match exactly the + * need or double it's allocated size each time it is found too small. + */ + +typedef enum { + XML_BUFFER_ALLOC_DOUBLEIT, /* double each time one need to grow */ + XML_BUFFER_ALLOC_EXACT, /* grow only to the minimal size */ + XML_BUFFER_ALLOC_IMMUTABLE, /* immutable buffer */ + XML_BUFFER_ALLOC_IO /* special allocation scheme used for I/O */ +} xmlBufferAllocationScheme; + +/** + * xmlBuffer: + * + * A buffer structure. + */ +typedef struct _xmlBuffer xmlBuffer; +typedef xmlBuffer *xmlBufferPtr; +struct _xmlBuffer { + xmlChar *content; /* The buffer content UTF8 */ + unsigned int use; /* The buffer size used */ + unsigned int size; /* The buffer size */ + xmlBufferAllocationScheme alloc; /* The realloc method */ + xmlChar *contentIO; /* in IO mode we may have a different base */ +}; + +/** + * XML_XML_NAMESPACE: + * + * This is the namespace for the special xml: prefix predefined in the + * XML Namespace specification. + */ +#define XML_XML_NAMESPACE \ + (const xmlChar *) "http://www.w3.org/XML/1998/namespace" + +/** + * XML_XML_ID: + * + * This is the name for the special xml:id attribute + */ +#define XML_XML_ID (const xmlChar *) "xml:id" + +/* + * The different element types carried by an XML tree. + * + * NOTE: This is synchronized with DOM Level1 values + * See http://www.w3.org/TR/REC-DOM-Level-1/ + * + * Actually this had diverged a bit, and now XML_DOCUMENT_TYPE_NODE should + * be deprecated to use an XML_DTD_NODE. + */ +typedef enum { + XML_ELEMENT_NODE= 1, + XML_ATTRIBUTE_NODE= 2, + XML_TEXT_NODE= 3, + XML_CDATA_SECTION_NODE= 4, + XML_ENTITY_REF_NODE= 5, + XML_ENTITY_NODE= 6, + XML_PI_NODE= 7, + XML_COMMENT_NODE= 8, + XML_DOCUMENT_NODE= 9, + XML_DOCUMENT_TYPE_NODE= 10, + XML_DOCUMENT_FRAG_NODE= 11, + XML_NOTATION_NODE= 12, + XML_HTML_DOCUMENT_NODE= 13, + XML_DTD_NODE= 14, + XML_ELEMENT_DECL= 15, + XML_ATTRIBUTE_DECL= 16, + XML_ENTITY_DECL= 17, + XML_NAMESPACE_DECL= 18, + XML_XINCLUDE_START= 19, + XML_XINCLUDE_END= 20 +#ifdef LIBXML_DOCB_ENABLED + ,XML_DOCB_DOCUMENT_NODE= 21 +#endif +} xmlElementType; + + +/** + * xmlNotation: + * + * A DTD Notation definition. + */ + +typedef struct _xmlNotation xmlNotation; +typedef xmlNotation *xmlNotationPtr; +struct _xmlNotation { + const xmlChar *name; /* Notation name */ + const xmlChar *PublicID; /* Public identifier, if any */ + const xmlChar *SystemID; /* System identifier, if any */ +}; + +/** + * xmlAttributeType: + * + * A DTD Attribute type definition. + */ + +typedef enum { + XML_ATTRIBUTE_CDATA = 1, + XML_ATTRIBUTE_ID, + XML_ATTRIBUTE_IDREF , + XML_ATTRIBUTE_IDREFS, + XML_ATTRIBUTE_ENTITY, + XML_ATTRIBUTE_ENTITIES, + XML_ATTRIBUTE_NMTOKEN, + XML_ATTRIBUTE_NMTOKENS, + XML_ATTRIBUTE_ENUMERATION, + XML_ATTRIBUTE_NOTATION +} xmlAttributeType; + +/** + * xmlAttributeDefault: + * + * A DTD Attribute default definition. + */ + +typedef enum { + XML_ATTRIBUTE_NONE = 1, + XML_ATTRIBUTE_REQUIRED, + XML_ATTRIBUTE_IMPLIED, + XML_ATTRIBUTE_FIXED +} xmlAttributeDefault; + +/** + * xmlEnumeration: + * + * List structure used when there is an enumeration in DTDs. + */ + +typedef struct _xmlEnumeration xmlEnumeration; +typedef xmlEnumeration *xmlEnumerationPtr; +struct _xmlEnumeration { + struct _xmlEnumeration *next; /* next one */ + const xmlChar *name; /* Enumeration name */ +}; + +/** + * xmlAttribute: + * + * An Attribute declaration in a DTD. + */ + +typedef struct _xmlAttribute xmlAttribute; +typedef xmlAttribute *xmlAttributePtr; +struct _xmlAttribute { + void *_private; /* application data */ + xmlElementType type; /* XML_ATTRIBUTE_DECL, must be second ! */ + const xmlChar *name; /* Attribute name */ + struct _xmlNode *children; /* NULL */ + struct _xmlNode *last; /* NULL */ + struct _xmlDtd *parent; /* -> DTD */ + struct _xmlNode *next; /* next sibling link */ + struct _xmlNode *prev; /* previous sibling link */ + struct _xmlDoc *doc; /* the containing document */ + + struct _xmlAttribute *nexth; /* next in hash table */ + xmlAttributeType atype; /* The attribute type */ + xmlAttributeDefault def; /* the default */ + const xmlChar *defaultValue; /* or the default value */ + xmlEnumerationPtr tree; /* or the enumeration tree if any */ + const xmlChar *prefix; /* the namespace prefix if any */ + const xmlChar *elem; /* Element holding the attribute */ +}; + +/** + * xmlElementContentType: + * + * Possible definitions of element content types. + */ +typedef enum { + XML_ELEMENT_CONTENT_PCDATA = 1, + XML_ELEMENT_CONTENT_ELEMENT, + XML_ELEMENT_CONTENT_SEQ, + XML_ELEMENT_CONTENT_OR +} xmlElementContentType; + +/** + * xmlElementContentOccur: + * + * Possible definitions of element content occurrences. + */ +typedef enum { + XML_ELEMENT_CONTENT_ONCE = 1, + XML_ELEMENT_CONTENT_OPT, + XML_ELEMENT_CONTENT_MULT, + XML_ELEMENT_CONTENT_PLUS +} xmlElementContentOccur; + +/** + * xmlElementContent: + * + * An XML Element content as stored after parsing an element definition + * in a DTD. + */ + +typedef struct _xmlElementContent xmlElementContent; +typedef xmlElementContent *xmlElementContentPtr; +struct _xmlElementContent { + xmlElementContentType type; /* PCDATA, ELEMENT, SEQ or OR */ + xmlElementContentOccur ocur; /* ONCE, OPT, MULT or PLUS */ + const xmlChar *name; /* Element name */ + struct _xmlElementContent *c1; /* first child */ + struct _xmlElementContent *c2; /* second child */ + struct _xmlElementContent *parent; /* parent */ + const xmlChar *prefix; /* Namespace prefix */ +}; + +/** + * xmlElementTypeVal: + * + * The different possibilities for an element content type. + */ + +typedef enum { + XML_ELEMENT_TYPE_UNDEFINED = 0, + XML_ELEMENT_TYPE_EMPTY = 1, + XML_ELEMENT_TYPE_ANY, + XML_ELEMENT_TYPE_MIXED, + XML_ELEMENT_TYPE_ELEMENT +} xmlElementTypeVal; + +#ifdef __cplusplus +} +#endif +#include +#ifdef __cplusplus +extern "C" { +#endif + +/** + * xmlElement: + * + * An XML Element declaration from a DTD. + */ + +typedef struct _xmlElement xmlElement; +typedef xmlElement *xmlElementPtr; +struct _xmlElement { + void *_private; /* application data */ + xmlElementType type; /* XML_ELEMENT_DECL, must be second ! */ + const xmlChar *name; /* Element name */ + struct _xmlNode *children; /* NULL */ + struct _xmlNode *last; /* NULL */ + struct _xmlDtd *parent; /* -> DTD */ + struct _xmlNode *next; /* next sibling link */ + struct _xmlNode *prev; /* previous sibling link */ + struct _xmlDoc *doc; /* the containing document */ + + xmlElementTypeVal etype; /* The type */ + xmlElementContentPtr content; /* the allowed element content */ + xmlAttributePtr attributes; /* List of the declared attributes */ + const xmlChar *prefix; /* the namespace prefix if any */ +#ifdef LIBXML_REGEXP_ENABLED + xmlRegexpPtr contModel; /* the validating regexp */ +#else + void *contModel; +#endif +}; + + +/** + * XML_LOCAL_NAMESPACE: + * + * A namespace declaration node. + */ +#define XML_LOCAL_NAMESPACE XML_NAMESPACE_DECL +typedef xmlElementType xmlNsType; + +/** + * xmlNs: + * + * An XML namespace. + * Note that prefix == NULL is valid, it defines the default namespace + * within the subtree (until overridden). + * + * xmlNsType is unified with xmlElementType. + */ + +typedef struct _xmlNs xmlNs; +typedef xmlNs *xmlNsPtr; +struct _xmlNs { + struct _xmlNs *next; /* next Ns link for this node */ + xmlNsType type; /* global or local */ + const xmlChar *href; /* URL for the namespace */ + const xmlChar *prefix; /* prefix for the namespace */ + void *_private; /* application data */ + struct _xmlDoc *context; /* normally an xmlDoc */ +}; + +/** + * xmlDtd: + * + * An XML DTD, as defined by parent link */ + struct _xmlNode *next; /* next sibling link */ + struct _xmlNode *prev; /* previous sibling link */ + struct _xmlDoc *doc; /* the containing document */ + + /* End of common part */ + void *notations; /* Hash table for notations if any */ + void *elements; /* Hash table for elements if any */ + void *attributes; /* Hash table for attributes if any */ + void *entities; /* Hash table for entities if any */ + const xmlChar *ExternalID; /* External identifier for PUBLIC DTD */ + const xmlChar *SystemID; /* URI for a SYSTEM or PUBLIC DTD */ + void *pentities; /* Hash table for param entities if any */ +}; + +/** + * xmlAttr: + * + * An attribute on an XML node. + */ +typedef struct _xmlAttr xmlAttr; +typedef xmlAttr *xmlAttrPtr; +struct _xmlAttr { + void *_private; /* application data */ + xmlElementType type; /* XML_ATTRIBUTE_NODE, must be second ! */ + const xmlChar *name; /* the name of the property */ + struct _xmlNode *children; /* the value of the property */ + struct _xmlNode *last; /* NULL */ + struct _xmlNode *parent; /* child->parent link */ + struct _xmlAttr *next; /* next sibling link */ + struct _xmlAttr *prev; /* previous sibling link */ + struct _xmlDoc *doc; /* the containing document */ + xmlNs *ns; /* pointer to the associated namespace */ + xmlAttributeType atype; /* the attribute type if validating */ + void *psvi; /* for type/PSVI informations */ +}; + +/** + * xmlID: + * + * An XML ID instance. + */ + +typedef struct _xmlID xmlID; +typedef xmlID *xmlIDPtr; +struct _xmlID { + struct _xmlID *next; /* next ID */ + const xmlChar *value; /* The ID name */ + xmlAttrPtr attr; /* The attribute holding it */ + const xmlChar *name; /* The attribute if attr is not available */ + int lineno; /* The line number if attr is not available */ + struct _xmlDoc *doc; /* The document holding the ID */ +}; + +/** + * xmlRef: + * + * An XML IDREF instance. + */ + +typedef struct _xmlRef xmlRef; +typedef xmlRef *xmlRefPtr; +struct _xmlRef { + struct _xmlRef *next; /* next Ref */ + const xmlChar *value; /* The Ref name */ + xmlAttrPtr attr; /* The attribute holding it */ + const xmlChar *name; /* The attribute if attr is not available */ + int lineno; /* The line number if attr is not available */ +}; + +/** + * xmlNode: + * + * A node in an XML tree. + */ +typedef struct _xmlNode xmlNode; +typedef xmlNode *xmlNodePtr; +struct _xmlNode { + void *_private; /* application data */ + xmlElementType type; /* type number, must be second ! */ + const xmlChar *name; /* the name of the node, or the entity */ + struct _xmlNode *children; /* parent->childs link */ + struct _xmlNode *last; /* last child link */ + struct _xmlNode *parent; /* child->parent link */ + struct _xmlNode *next; /* next sibling link */ + struct _xmlNode *prev; /* previous sibling link */ + struct _xmlDoc *doc; /* the containing document */ + + /* End of common part */ + xmlNs *ns; /* pointer to the associated namespace */ + xmlChar *content; /* the content */ + struct _xmlAttr *properties;/* properties list */ + xmlNs *nsDef; /* namespace definitions on this node */ + void *psvi; /* for type/PSVI informations */ + unsigned short line; /* line number */ + unsigned short extra; /* extra data for XPath/XSLT */ +}; + +/** + * XML_GET_CONTENT: + * + * Macro to extract the content pointer of a node. + */ +#define XML_GET_CONTENT(n) \ + ((n)->type == XML_ELEMENT_NODE ? NULL : (n)->content) + +/** + * XML_GET_LINE: + * + * Macro to extract the line number of an element node. + */ +#define XML_GET_LINE(n) \ + (xmlGetLineNo(n)) + +/** + * xmlDocProperty + * + * Set of properties of the document as found by the parser + * Some of them are linked to similary named xmlParserOption + */ +typedef enum { + XML_DOC_WELLFORMED = 1<<0, /* document is XML well formed */ + XML_DOC_NSVALID = 1<<1, /* document is Namespace valid */ + XML_DOC_OLD10 = 1<<2, /* parsed with old XML-1.0 parser */ + XML_DOC_DTDVALID = 1<<3, /* DTD validation was successful */ + XML_DOC_XINCLUDE = 1<<4, /* XInclude substitution was done */ + XML_DOC_USERBUILT = 1<<5, /* Document was built using the API + and not by parsing an instance */ + XML_DOC_INTERNAL = 1<<6, /* built for internal processing */ + XML_DOC_HTML = 1<<7 /* parsed or built HTML document */ +} xmlDocProperties; + +/** + * xmlDoc: + * + * An XML document. + */ +typedef struct _xmlDoc xmlDoc; +typedef xmlDoc *xmlDocPtr; +struct _xmlDoc { + void *_private; /* application data */ + xmlElementType type; /* XML_DOCUMENT_NODE, must be second ! */ + char *name; /* name/filename/URI of the document */ + struct _xmlNode *children; /* the document tree */ + struct _xmlNode *last; /* last child link */ + struct _xmlNode *parent; /* child->parent link */ + struct _xmlNode *next; /* next sibling link */ + struct _xmlNode *prev; /* previous sibling link */ + struct _xmlDoc *doc; /* autoreference to itself */ + + /* End of common part */ + int compression;/* level of zlib compression */ + int standalone; /* standalone document (no external refs) + 1 if standalone="yes" + 0 if standalone="no" + -1 if there is no XML declaration + -2 if there is an XML declaration, but no + standalone attribute was specified */ + struct _xmlDtd *intSubset; /* the document internal subset */ + struct _xmlDtd *extSubset; /* the document external subset */ + struct _xmlNs *oldNs; /* Global namespace, the old way */ + const xmlChar *version; /* the XML version string */ + const xmlChar *encoding; /* external initial encoding, if any */ + void *ids; /* Hash table for ID attributes if any */ + void *refs; /* Hash table for IDREFs attributes if any */ + const xmlChar *URL; /* The URI for that document */ + int charset; /* encoding of the in-memory content + actually an xmlCharEncoding */ + struct _xmlDict *dict; /* dict used to allocate names or NULL */ + void *psvi; /* for type/PSVI informations */ + int parseFlags; /* set of xmlParserOption used to parse the + document */ + int properties; /* set of xmlDocProperties for this document + set at the end of parsing */ +}; + + +typedef struct _xmlDOMWrapCtxt xmlDOMWrapCtxt; +typedef xmlDOMWrapCtxt *xmlDOMWrapCtxtPtr; + +/** + * xmlDOMWrapAcquireNsFunction: + * @ctxt: a DOM wrapper context + * @node: the context node (element or attribute) + * @nsName: the requested namespace name + * @nsPrefix: the requested namespace prefix + * + * A function called to acquire namespaces (xmlNs) from the wrapper. + * + * Returns an xmlNsPtr or NULL in case of an error. + */ +typedef xmlNsPtr (*xmlDOMWrapAcquireNsFunction) (xmlDOMWrapCtxtPtr ctxt, + xmlNodePtr node, + const xmlChar *nsName, + const xmlChar *nsPrefix); + +/** + * xmlDOMWrapCtxt: + * + * Context for DOM wrapper-operations. + */ +struct _xmlDOMWrapCtxt { + void * _private; + /* + * The type of this context, just in case we need specialized + * contexts in the future. + */ + int type; + /* + * Internal namespace map used for various operations. + */ + void * namespaceMap; + /* + * Use this one to acquire an xmlNsPtr intended for node->ns. + * (Note that this is not intended for elem->nsDef). + */ + xmlDOMWrapAcquireNsFunction getNsForNodeFunc; +}; + +/** + * xmlChildrenNode: + * + * Macro for compatibility naming layer with libxml1. Maps + * to "children." + */ +#ifndef xmlChildrenNode +#define xmlChildrenNode children +#endif + +/** + * xmlRootNode: + * + * Macro for compatibility naming layer with libxml1. Maps + * to "children". + */ +#ifndef xmlRootNode +#define xmlRootNode children +#endif + +/* + * Variables. + */ + +/* + * Some helper functions + */ +#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_DEBUG_ENABLED) || defined (LIBXML_HTML_ENABLED) || defined(LIBXML_SAX1_ENABLED) || defined(LIBXML_HTML_ENABLED) || defined(LIBXML_WRITER_ENABLED) || defined(LIBXML_DOCB_ENABLED) +XMLPUBFUN int XMLCALL + xmlValidateNCName (const xmlChar *value, + int space); +#endif + +#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) +XMLPUBFUN int XMLCALL + xmlValidateQName (const xmlChar *value, + int space); +XMLPUBFUN int XMLCALL + xmlValidateName (const xmlChar *value, + int space); +XMLPUBFUN int XMLCALL + xmlValidateNMToken (const xmlChar *value, + int space); +#endif + +XMLPUBFUN xmlChar * XMLCALL + xmlBuildQName (const xmlChar *ncname, + const xmlChar *prefix, + xmlChar *memory, + int len); +XMLPUBFUN xmlChar * XMLCALL + xmlSplitQName2 (const xmlChar *name, + xmlChar **prefix); +XMLPUBFUN const xmlChar * XMLCALL + xmlSplitQName3 (const xmlChar *name, + int *len); + +/* + * Handling Buffers. + */ + +XMLPUBFUN void XMLCALL + xmlSetBufferAllocationScheme(xmlBufferAllocationScheme scheme); +XMLPUBFUN xmlBufferAllocationScheme XMLCALL + xmlGetBufferAllocationScheme(void); + +XMLPUBFUN xmlBufferPtr XMLCALL + xmlBufferCreate (void); +XMLPUBFUN xmlBufferPtr XMLCALL + xmlBufferCreateSize (size_t size); +XMLPUBFUN xmlBufferPtr XMLCALL + xmlBufferCreateStatic (void *mem, + size_t size); +XMLPUBFUN int XMLCALL + xmlBufferResize (xmlBufferPtr buf, + unsigned int size); +XMLPUBFUN void XMLCALL + xmlBufferFree (xmlBufferPtr buf); +XMLPUBFUN int XMLCALL + xmlBufferDump (FILE *file, + xmlBufferPtr buf); +XMLPUBFUN int XMLCALL + xmlBufferAdd (xmlBufferPtr buf, + const xmlChar *str, + int len); +XMLPUBFUN int XMLCALL + xmlBufferAddHead (xmlBufferPtr buf, + const xmlChar *str, + int len); +XMLPUBFUN int XMLCALL + xmlBufferCat (xmlBufferPtr buf, + const xmlChar *str); +XMLPUBFUN int XMLCALL + xmlBufferCCat (xmlBufferPtr buf, + const char *str); +XMLPUBFUN int XMLCALL + xmlBufferShrink (xmlBufferPtr buf, + unsigned int len); +XMLPUBFUN int XMLCALL + xmlBufferGrow (xmlBufferPtr buf, + unsigned int len); +XMLPUBFUN void XMLCALL + xmlBufferEmpty (xmlBufferPtr buf); +XMLPUBFUN const xmlChar* XMLCALL + xmlBufferContent (const xmlBufferPtr buf); +XMLPUBFUN void XMLCALL + xmlBufferSetAllocationScheme(xmlBufferPtr buf, + xmlBufferAllocationScheme scheme); +XMLPUBFUN int XMLCALL + xmlBufferLength (const xmlBufferPtr buf); + +/* + * Creating/freeing new structures. + */ +XMLPUBFUN xmlDtdPtr XMLCALL + xmlCreateIntSubset (xmlDocPtr doc, + const xmlChar *name, + const xmlChar *ExternalID, + const xmlChar *SystemID); +XMLPUBFUN xmlDtdPtr XMLCALL + xmlNewDtd (xmlDocPtr doc, + const xmlChar *name, + const xmlChar *ExternalID, + const xmlChar *SystemID); +XMLPUBFUN xmlDtdPtr XMLCALL + xmlGetIntSubset (xmlDocPtr doc); +XMLPUBFUN void XMLCALL + xmlFreeDtd (xmlDtdPtr cur); +#ifdef LIBXML_LEGACY_ENABLED +XMLPUBFUN xmlNsPtr XMLCALL + xmlNewGlobalNs (xmlDocPtr doc, + const xmlChar *href, + const xmlChar *prefix); +#endif /* LIBXML_LEGACY_ENABLED */ +XMLPUBFUN xmlNsPtr XMLCALL + xmlNewNs (xmlNodePtr node, + const xmlChar *href, + const xmlChar *prefix); +XMLPUBFUN void XMLCALL + xmlFreeNs (xmlNsPtr cur); +XMLPUBFUN void XMLCALL + xmlFreeNsList (xmlNsPtr cur); +XMLPUBFUN xmlDocPtr XMLCALL + xmlNewDoc (const xmlChar *version); +XMLPUBFUN void XMLCALL + xmlFreeDoc (xmlDocPtr cur); +XMLPUBFUN xmlAttrPtr XMLCALL + xmlNewDocProp (xmlDocPtr doc, + const xmlChar *name, + const xmlChar *value); +#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || \ + defined(LIBXML_SCHEMAS_ENABLED) +XMLPUBFUN xmlAttrPtr XMLCALL + xmlNewProp (xmlNodePtr node, + const xmlChar *name, + const xmlChar *value); +#endif +XMLPUBFUN xmlAttrPtr XMLCALL + xmlNewNsProp (xmlNodePtr node, + xmlNsPtr ns, + const xmlChar *name, + const xmlChar *value); +XMLPUBFUN xmlAttrPtr XMLCALL + xmlNewNsPropEatName (xmlNodePtr node, + xmlNsPtr ns, + xmlChar *name, + const xmlChar *value); +XMLPUBFUN void XMLCALL + xmlFreePropList (xmlAttrPtr cur); +XMLPUBFUN void XMLCALL + xmlFreeProp (xmlAttrPtr cur); +XMLPUBFUN xmlAttrPtr XMLCALL + xmlCopyProp (xmlNodePtr target, + xmlAttrPtr cur); +XMLPUBFUN xmlAttrPtr XMLCALL + xmlCopyPropList (xmlNodePtr target, + xmlAttrPtr cur); +#ifdef LIBXML_TREE_ENABLED +XMLPUBFUN xmlDtdPtr XMLCALL + xmlCopyDtd (xmlDtdPtr dtd); +#endif /* LIBXML_TREE_ENABLED */ +#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) +XMLPUBFUN xmlDocPtr XMLCALL + xmlCopyDoc (xmlDocPtr doc, + int recursive); +#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */ +/* + * Creating new nodes. + */ +XMLPUBFUN xmlNodePtr XMLCALL + xmlNewDocNode (xmlDocPtr doc, + xmlNsPtr ns, + const xmlChar *name, + const xmlChar *content); +XMLPUBFUN xmlNodePtr XMLCALL + xmlNewDocNodeEatName (xmlDocPtr doc, + xmlNsPtr ns, + xmlChar *name, + const xmlChar *content); +XMLPUBFUN xmlNodePtr XMLCALL + xmlNewNode (xmlNsPtr ns, + const xmlChar *name); +XMLPUBFUN xmlNodePtr XMLCALL + xmlNewNodeEatName (xmlNsPtr ns, + xmlChar *name); +#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) +XMLPUBFUN xmlNodePtr XMLCALL + xmlNewChild (xmlNodePtr parent, + xmlNsPtr ns, + const xmlChar *name, + const xmlChar *content); +#endif +XMLPUBFUN xmlNodePtr XMLCALL + xmlNewDocText (xmlDocPtr doc, + const xmlChar *content); +XMLPUBFUN xmlNodePtr XMLCALL + xmlNewText (const xmlChar *content); +XMLPUBFUN xmlNodePtr XMLCALL + xmlNewDocPI (xmlDocPtr doc, + const xmlChar *name, + const xmlChar *content); +XMLPUBFUN xmlNodePtr XMLCALL + xmlNewPI (const xmlChar *name, + const xmlChar *content); +XMLPUBFUN xmlNodePtr XMLCALL + xmlNewDocTextLen (xmlDocPtr doc, + const xmlChar *content, + int len); +XMLPUBFUN xmlNodePtr XMLCALL + xmlNewTextLen (const xmlChar *content, + int len); +XMLPUBFUN xmlNodePtr XMLCALL + xmlNewDocComment (xmlDocPtr doc, + const xmlChar *content); +XMLPUBFUN xmlNodePtr XMLCALL + xmlNewComment (const xmlChar *content); +XMLPUBFUN xmlNodePtr XMLCALL + xmlNewCDataBlock (xmlDocPtr doc, + const xmlChar *content, + int len); +XMLPUBFUN xmlNodePtr XMLCALL + xmlNewCharRef (xmlDocPtr doc, + const xmlChar *name); +XMLPUBFUN xmlNodePtr XMLCALL + xmlNewReference (xmlDocPtr doc, + const xmlChar *name); +XMLPUBFUN xmlNodePtr XMLCALL + xmlCopyNode (const xmlNodePtr node, + int recursive); +XMLPUBFUN xmlNodePtr XMLCALL + xmlDocCopyNode (const xmlNodePtr node, + xmlDocPtr doc, + int recursive); +XMLPUBFUN xmlNodePtr XMLCALL + xmlDocCopyNodeList (xmlDocPtr doc, + const xmlNodePtr node); +XMLPUBFUN xmlNodePtr XMLCALL + xmlCopyNodeList (const xmlNodePtr node); +#ifdef LIBXML_TREE_ENABLED +XMLPUBFUN xmlNodePtr XMLCALL + xmlNewTextChild (xmlNodePtr parent, + xmlNsPtr ns, + const xmlChar *name, + const xmlChar *content); +XMLPUBFUN xmlNodePtr XMLCALL + xmlNewDocRawNode (xmlDocPtr doc, + xmlNsPtr ns, + const xmlChar *name, + const xmlChar *content); +XMLPUBFUN xmlNodePtr XMLCALL + xmlNewDocFragment (xmlDocPtr doc); +#endif /* LIBXML_TREE_ENABLED */ + +/* + * Navigating. + */ +XMLPUBFUN long XMLCALL + xmlGetLineNo (xmlNodePtr node); +#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED) +XMLPUBFUN xmlChar * XMLCALL + xmlGetNodePath (xmlNodePtr node); +#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_DEBUG_ENABLED) */ +XMLPUBFUN xmlNodePtr XMLCALL + xmlDocGetRootElement (xmlDocPtr doc); +XMLPUBFUN xmlNodePtr XMLCALL + xmlGetLastChild (xmlNodePtr parent); +XMLPUBFUN int XMLCALL + xmlNodeIsText (xmlNodePtr node); +XMLPUBFUN int XMLCALL + xmlIsBlankNode (xmlNodePtr node); + +/* + * Changing the structure. + */ +#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) +XMLPUBFUN xmlNodePtr XMLCALL + xmlDocSetRootElement (xmlDocPtr doc, + xmlNodePtr root); +#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) */ +#ifdef LIBXML_TREE_ENABLED +XMLPUBFUN void XMLCALL + xmlNodeSetName (xmlNodePtr cur, + const xmlChar *name); +#endif /* LIBXML_TREE_ENABLED */ +XMLPUBFUN xmlNodePtr XMLCALL + xmlAddChild (xmlNodePtr parent, + xmlNodePtr cur); +XMLPUBFUN xmlNodePtr XMLCALL + xmlAddChildList (xmlNodePtr parent, + xmlNodePtr cur); +#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) +XMLPUBFUN xmlNodePtr XMLCALL + xmlReplaceNode (xmlNodePtr old, + xmlNodePtr cur); +#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_WRITER_ENABLED) */ +#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_HTML_ENABLED) || \ + defined(LIBXML_SCHEMAS_ENABLED) +XMLPUBFUN xmlNodePtr XMLCALL + xmlAddPrevSibling (xmlNodePtr cur, + xmlNodePtr elem); +#endif /* LIBXML_TREE_ENABLED || LIBXML_HTML_ENABLED || LIBXML_SCHEMAS_ENABLED */ +XMLPUBFUN xmlNodePtr XMLCALL + xmlAddSibling (xmlNodePtr cur, + xmlNodePtr elem); +XMLPUBFUN xmlNodePtr XMLCALL + xmlAddNextSibling (xmlNodePtr cur, + xmlNodePtr elem); +XMLPUBFUN void XMLCALL + xmlUnlinkNode (xmlNodePtr cur); +XMLPUBFUN xmlNodePtr XMLCALL + xmlTextMerge (xmlNodePtr first, + xmlNodePtr second); +XMLPUBFUN int XMLCALL + xmlTextConcat (xmlNodePtr node, + const xmlChar *content, + int len); +XMLPUBFUN void XMLCALL + xmlFreeNodeList (xmlNodePtr cur); +XMLPUBFUN void XMLCALL + xmlFreeNode (xmlNodePtr cur); +XMLPUBFUN void XMLCALL + xmlSetTreeDoc (xmlNodePtr tree, + xmlDocPtr doc); +XMLPUBFUN void XMLCALL + xmlSetListDoc (xmlNodePtr list, + xmlDocPtr doc); +/* + * Namespaces. + */ +XMLPUBFUN xmlNsPtr XMLCALL + xmlSearchNs (xmlDocPtr doc, + xmlNodePtr node, + const xmlChar *nameSpace); +XMLPUBFUN xmlNsPtr XMLCALL + xmlSearchNsByHref (xmlDocPtr doc, + xmlNodePtr node, + const xmlChar *href); +#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) +XMLPUBFUN xmlNsPtr * XMLCALL + xmlGetNsList (xmlDocPtr doc, + xmlNodePtr node); +#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XPATH_ENABLED) */ + +XMLPUBFUN void XMLCALL + xmlSetNs (xmlNodePtr node, + xmlNsPtr ns); +XMLPUBFUN xmlNsPtr XMLCALL + xmlCopyNamespace (xmlNsPtr cur); +XMLPUBFUN xmlNsPtr XMLCALL + xmlCopyNamespaceList (xmlNsPtr cur); + +/* + * Changing the content. + */ +#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED) +XMLPUBFUN xmlAttrPtr XMLCALL + xmlSetProp (xmlNodePtr node, + const xmlChar *name, + const xmlChar *value); +XMLPUBFUN xmlAttrPtr XMLCALL + xmlSetNsProp (xmlNodePtr node, + xmlNsPtr ns, + const xmlChar *name, + const xmlChar *value); +#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) || defined(LIBXML_HTML_ENABLED) */ +XMLPUBFUN xmlChar * XMLCALL + xmlGetNoNsProp (xmlNodePtr node, + const xmlChar *name); +XMLPUBFUN xmlChar * XMLCALL + xmlGetProp (xmlNodePtr node, + const xmlChar *name); +XMLPUBFUN xmlAttrPtr XMLCALL + xmlHasProp (xmlNodePtr node, + const xmlChar *name); +XMLPUBFUN xmlAttrPtr XMLCALL + xmlHasNsProp (xmlNodePtr node, + const xmlChar *name, + const xmlChar *nameSpace); +XMLPUBFUN xmlChar * XMLCALL + xmlGetNsProp (xmlNodePtr node, + const xmlChar *name, + const xmlChar *nameSpace); +XMLPUBFUN xmlNodePtr XMLCALL + xmlStringGetNodeList (xmlDocPtr doc, + const xmlChar *value); +XMLPUBFUN xmlNodePtr XMLCALL + xmlStringLenGetNodeList (xmlDocPtr doc, + const xmlChar *value, + int len); +XMLPUBFUN xmlChar * XMLCALL + xmlNodeListGetString (xmlDocPtr doc, + xmlNodePtr list, + int inLine); +#ifdef LIBXML_TREE_ENABLED +XMLPUBFUN xmlChar * XMLCALL + xmlNodeListGetRawString (xmlDocPtr doc, + xmlNodePtr list, + int inLine); +#endif /* LIBXML_TREE_ENABLED */ +XMLPUBFUN void XMLCALL + xmlNodeSetContent (xmlNodePtr cur, + const xmlChar *content); +#ifdef LIBXML_TREE_ENABLED +XMLPUBFUN void XMLCALL + xmlNodeSetContentLen (xmlNodePtr cur, + const xmlChar *content, + int len); +#endif /* LIBXML_TREE_ENABLED */ +XMLPUBFUN void XMLCALL + xmlNodeAddContent (xmlNodePtr cur, + const xmlChar *content); +XMLPUBFUN void XMLCALL + xmlNodeAddContentLen (xmlNodePtr cur, + const xmlChar *content, + int len); +XMLPUBFUN xmlChar * XMLCALL + xmlNodeGetContent (xmlNodePtr cur); +XMLPUBFUN int XMLCALL + xmlNodeBufGetContent (xmlBufferPtr buffer, + xmlNodePtr cur); +XMLPUBFUN xmlChar * XMLCALL + xmlNodeGetLang (xmlNodePtr cur); +XMLPUBFUN int XMLCALL + xmlNodeGetSpacePreserve (xmlNodePtr cur); +#ifdef LIBXML_TREE_ENABLED +XMLPUBFUN void XMLCALL + xmlNodeSetLang (xmlNodePtr cur, + const xmlChar *lang); +XMLPUBFUN void XMLCALL + xmlNodeSetSpacePreserve (xmlNodePtr cur, + int val); +#endif /* LIBXML_TREE_ENABLED */ +XMLPUBFUN xmlChar * XMLCALL + xmlNodeGetBase (xmlDocPtr doc, + xmlNodePtr cur); +#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_XINCLUDE_ENABLED) +XMLPUBFUN void XMLCALL + xmlNodeSetBase (xmlNodePtr cur, + const xmlChar *uri); +#endif + +/* + * Removing content. + */ +XMLPUBFUN int XMLCALL + xmlRemoveProp (xmlAttrPtr cur); +#if defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) +XMLPUBFUN int XMLCALL + xmlUnsetNsProp (xmlNodePtr node, + xmlNsPtr ns, + const xmlChar *name); +XMLPUBFUN int XMLCALL + xmlUnsetProp (xmlNodePtr node, + const xmlChar *name); +#endif /* defined(LIBXML_TREE_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) */ + +/* + * Internal, don't use. + */ +XMLPUBFUN void XMLCALL + xmlBufferWriteCHAR (xmlBufferPtr buf, + const xmlChar *string); +XMLPUBFUN void XMLCALL + xmlBufferWriteChar (xmlBufferPtr buf, + const char *string); +XMLPUBFUN void XMLCALL + xmlBufferWriteQuotedString(xmlBufferPtr buf, + const xmlChar *string); + +#ifdef LIBXML_OUTPUT_ENABLED +XMLPUBFUN void xmlAttrSerializeTxtContent(xmlBufferPtr buf, + xmlDocPtr doc, + xmlAttrPtr attr, + const xmlChar *string); +#endif /* LIBXML_OUTPUT_ENABLED */ + +#ifdef LIBXML_TREE_ENABLED +/* + * Namespace handling. + */ +XMLPUBFUN int XMLCALL + xmlReconciliateNs (xmlDocPtr doc, + xmlNodePtr tree); +#endif + +#ifdef LIBXML_OUTPUT_ENABLED +/* + * Saving. + */ +XMLPUBFUN void XMLCALL + xmlDocDumpFormatMemory (xmlDocPtr cur, + xmlChar **mem, + int *size, + int format); +XMLPUBFUN void XMLCALL + xmlDocDumpMemory (xmlDocPtr cur, + xmlChar **mem, + int *size); +XMLPUBFUN void XMLCALL + xmlDocDumpMemoryEnc (xmlDocPtr out_doc, + xmlChar **doc_txt_ptr, + int * doc_txt_len, + const char *txt_encoding); +XMLPUBFUN void XMLCALL + xmlDocDumpFormatMemoryEnc(xmlDocPtr out_doc, + xmlChar **doc_txt_ptr, + int * doc_txt_len, + const char *txt_encoding, + int format); +XMLPUBFUN int XMLCALL + xmlDocFormatDump (FILE *f, + xmlDocPtr cur, + int format); +XMLPUBFUN int XMLCALL + xmlDocDump (FILE *f, + xmlDocPtr cur); +XMLPUBFUN void XMLCALL + xmlElemDump (FILE *f, + xmlDocPtr doc, + xmlNodePtr cur); +XMLPUBFUN int XMLCALL + xmlSaveFile (const char *filename, + xmlDocPtr cur); +XMLPUBFUN int XMLCALL + xmlSaveFormatFile (const char *filename, + xmlDocPtr cur, + int format); +XMLPUBFUN int XMLCALL + xmlNodeDump (xmlBufferPtr buf, + xmlDocPtr doc, + xmlNodePtr cur, + int level, + int format); + +XMLPUBFUN int XMLCALL + xmlSaveFileTo (xmlOutputBufferPtr buf, + xmlDocPtr cur, + const char *encoding); +XMLPUBFUN int XMLCALL + xmlSaveFormatFileTo (xmlOutputBufferPtr buf, + xmlDocPtr cur, + const char *encoding, + int format); +XMLPUBFUN void XMLCALL + xmlNodeDumpOutput (xmlOutputBufferPtr buf, + xmlDocPtr doc, + xmlNodePtr cur, + int level, + int format, + const char *encoding); + +XMLPUBFUN int XMLCALL + xmlSaveFormatFileEnc (const char *filename, + xmlDocPtr cur, + const char *encoding, + int format); + +XMLPUBFUN int XMLCALL + xmlSaveFileEnc (const char *filename, + xmlDocPtr cur, + const char *encoding); + +#endif /* LIBXML_OUTPUT_ENABLED */ +/* + * XHTML + */ +XMLPUBFUN int XMLCALL + xmlIsXHTML (const xmlChar *systemID, + const xmlChar *publicID); + +/* + * Compression. + */ +XMLPUBFUN int XMLCALL + xmlGetDocCompressMode (xmlDocPtr doc); +XMLPUBFUN void XMLCALL + xmlSetDocCompressMode (xmlDocPtr doc, + int mode); +XMLPUBFUN int XMLCALL + xmlGetCompressMode (void); +XMLPUBFUN void XMLCALL + xmlSetCompressMode (int mode); + +/* +* DOM-wrapper helper functions. +*/ +XMLPUBFUN xmlDOMWrapCtxtPtr XMLCALL + xmlDOMWrapNewCtxt (void); +XMLPUBFUN void XMLCALL + xmlDOMWrapFreeCtxt (xmlDOMWrapCtxtPtr ctxt); +XMLPUBFUN int XMLCALL + xmlDOMWrapReconcileNamespaces(xmlDOMWrapCtxtPtr ctxt, + xmlNodePtr elem, + int options); +XMLPUBFUN int XMLCALL + xmlDOMWrapAdoptNode (xmlDOMWrapCtxtPtr ctxt, + xmlDocPtr sourceDoc, + xmlNodePtr node, + xmlDocPtr destDoc, + xmlNodePtr destParent, + int options); +XMLPUBFUN int XMLCALL + xmlDOMWrapRemoveNode (xmlDOMWrapCtxtPtr ctxt, + xmlDocPtr doc, + xmlNodePtr node, + int options); +XMLPUBFUN int XMLCALL + xmlDOMWrapCloneNode (xmlDOMWrapCtxtPtr ctxt, + xmlDocPtr sourceDoc, + xmlNodePtr node, + xmlNodePtr *clonedNode, + xmlDocPtr destDoc, + xmlNodePtr destParent, + int deep, + int options); + +#ifdef LIBXML_TREE_ENABLED +/* + * 5 interfaces from DOM ElementTraversal, but different in entities + * traversal. + */ +XMLPUBFUN unsigned long XMLCALL + xmlChildElementCount (xmlNodePtr parent); +XMLPUBFUN xmlNodePtr XMLCALL + xmlNextElementSibling (xmlNodePtr node); +XMLPUBFUN xmlNodePtr XMLCALL + xmlFirstElementChild (xmlNodePtr parent); +XMLPUBFUN xmlNodePtr XMLCALL + xmlLastElementChild (xmlNodePtr parent); +XMLPUBFUN xmlNodePtr XMLCALL + xmlPreviousElementSibling (xmlNodePtr node); +#endif +#ifdef __cplusplus +} +#endif +#ifndef __XML_PARSER_H__ +#include +#endif + +#endif /* __XML_TREE_H__ */ + diff --git a/lib/libxml2/include/libxml/uri.h b/lib/libxml2/include/libxml/uri.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/uri.h @@ -0,0 +1,94 @@ +/** + * Summary: library of generic URI related routines + * Description: library of generic URI related routines + * Implements RFC 2396 + * + * Copy: See Copyright for the status of this software. + * + * Author: Daniel Veillard + */ + +#ifndef __XML_URI_H__ +#define __XML_URI_H__ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * xmlURI: + * + * A parsed URI reference. This is a struct containing the various fields + * as described in RFC 2396 but separated for further processing. + * + * Note: query is a deprecated field which is incorrectly unescaped. + * query_raw takes precedence over query if the former is set. + * See: http://mail.gnome.org/archives/xml/2007-April/thread.html#00127 + */ +typedef struct _xmlURI xmlURI; +typedef xmlURI *xmlURIPtr; +struct _xmlURI { + char *scheme; /* the URI scheme */ + char *opaque; /* opaque part */ + char *authority; /* the authority part */ + char *server; /* the server part */ + char *user; /* the user part */ + int port; /* the port number */ + char *path; /* the path string */ + char *query; /* the query string (deprecated - use with caution) */ + char *fragment; /* the fragment identifier */ + int cleanup; /* parsing potentially unclean URI */ + char *query_raw; /* the query string (as it appears in the URI) */ +}; + +/* + * This function is in tree.h: + * xmlChar * xmlNodeGetBase (xmlDocPtr doc, + * xmlNodePtr cur); + */ +XMLPUBFUN xmlURIPtr XMLCALL + xmlCreateURI (void); +XMLPUBFUN xmlChar * XMLCALL + xmlBuildURI (const xmlChar *URI, + const xmlChar *base); +XMLPUBFUN xmlChar * XMLCALL + xmlBuildRelativeURI (const xmlChar *URI, + const xmlChar *base); +XMLPUBFUN xmlURIPtr XMLCALL + xmlParseURI (const char *str); +XMLPUBFUN xmlURIPtr XMLCALL + xmlParseURIRaw (const char *str, + int raw); +XMLPUBFUN int XMLCALL + xmlParseURIReference (xmlURIPtr uri, + const char *str); +XMLPUBFUN xmlChar * XMLCALL + xmlSaveUri (xmlURIPtr uri); +XMLPUBFUN void XMLCALL + xmlPrintURI (FILE *stream, + xmlURIPtr uri); +XMLPUBFUN xmlChar * XMLCALL + xmlURIEscapeStr (const xmlChar *str, + const xmlChar *list); +XMLPUBFUN char * XMLCALL + xmlURIUnescapeString (const char *str, + int len, + char *target); +XMLPUBFUN int XMLCALL + xmlNormalizeURIPath (char *path); +XMLPUBFUN xmlChar * XMLCALL + xmlURIEscape (const xmlChar *str); +XMLPUBFUN void XMLCALL + xmlFreeURI (xmlURIPtr uri); +XMLPUBFUN xmlChar* XMLCALL + xmlCanonicPath (const xmlChar *path); +XMLPUBFUN xmlChar* XMLCALL + xmlPathToURI (const xmlChar *path); + +#ifdef __cplusplus +} +#endif +#endif /* __XML_URI_H__ */ diff --git a/lib/libxml2/include/libxml/valid.h b/lib/libxml2/include/libxml/valid.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/valid.h @@ -0,0 +1,458 @@ +/* + * Summary: The DTD validation + * Description: API for the DTD handling and the validity checking + * + * Copy: See Copyright for the status of this software. + * + * Author: Daniel Veillard + */ + + +#ifndef __XML_VALID_H__ +#define __XML_VALID_H__ + +#include +#include +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * Validation state added for non-determinist content model. + */ +typedef struct _xmlValidState xmlValidState; +typedef xmlValidState *xmlValidStatePtr; + +/** + * xmlValidityErrorFunc: + * @ctx: usually an xmlValidCtxtPtr to a validity error context, + * but comes from ctxt->userData (which normally contains such + * a pointer); ctxt->userData can be changed by the user. + * @msg: the string to format *printf like vararg + * @...: remaining arguments to the format + * + * Callback called when a validity error is found. This is a message + * oriented function similar to an *printf function. + */ +typedef void (XMLCDECL *xmlValidityErrorFunc) (void *ctx, + const char *msg, + ...) LIBXML_ATTR_FORMAT(2,3); + +/** + * xmlValidityWarningFunc: + * @ctx: usually an xmlValidCtxtPtr to a validity error context, + * but comes from ctxt->userData (which normally contains such + * a pointer); ctxt->userData can be changed by the user. + * @msg: the string to format *printf like vararg + * @...: remaining arguments to the format + * + * Callback called when a validity warning is found. This is a message + * oriented function similar to an *printf function. + */ +typedef void (XMLCDECL *xmlValidityWarningFunc) (void *ctx, + const char *msg, + ...) LIBXML_ATTR_FORMAT(2,3); + +#ifdef IN_LIBXML +/** + * XML_CTXT_FINISH_DTD_0: + * + * Special value for finishDtd field when embedded in an xmlParserCtxt + */ +#define XML_CTXT_FINISH_DTD_0 0xabcd1234 +/** + * XML_CTXT_FINISH_DTD_1: + * + * Special value for finishDtd field when embedded in an xmlParserCtxt + */ +#define XML_CTXT_FINISH_DTD_1 0xabcd1235 +#endif + +/* + * xmlValidCtxt: + * An xmlValidCtxt is used for error reporting when validating. + */ +typedef struct _xmlValidCtxt xmlValidCtxt; +typedef xmlValidCtxt *xmlValidCtxtPtr; +struct _xmlValidCtxt { + void *userData; /* user specific data block */ + xmlValidityErrorFunc error; /* the callback in case of errors */ + xmlValidityWarningFunc warning; /* the callback in case of warning */ + + /* Node analysis stack used when validating within entities */ + xmlNodePtr node; /* Current parsed Node */ + int nodeNr; /* Depth of the parsing stack */ + int nodeMax; /* Max depth of the parsing stack */ + xmlNodePtr *nodeTab; /* array of nodes */ + + unsigned int finishDtd; /* finished validating the Dtd ? */ + xmlDocPtr doc; /* the document */ + int valid; /* temporary validity check result */ + + /* state state used for non-determinist content validation */ + xmlValidState *vstate; /* current state */ + int vstateNr; /* Depth of the validation stack */ + int vstateMax; /* Max depth of the validation stack */ + xmlValidState *vstateTab; /* array of validation states */ + +#ifdef LIBXML_REGEXP_ENABLED + xmlAutomataPtr am; /* the automata */ + xmlAutomataStatePtr state; /* used to build the automata */ +#else + void *am; + void *state; +#endif +}; + +/* + * ALL notation declarations are stored in a table. + * There is one table per DTD. + */ + +typedef struct _xmlHashTable xmlNotationTable; +typedef xmlNotationTable *xmlNotationTablePtr; + +/* + * ALL element declarations are stored in a table. + * There is one table per DTD. + */ + +typedef struct _xmlHashTable xmlElementTable; +typedef xmlElementTable *xmlElementTablePtr; + +/* + * ALL attribute declarations are stored in a table. + * There is one table per DTD. + */ + +typedef struct _xmlHashTable xmlAttributeTable; +typedef xmlAttributeTable *xmlAttributeTablePtr; + +/* + * ALL IDs attributes are stored in a table. + * There is one table per document. + */ + +typedef struct _xmlHashTable xmlIDTable; +typedef xmlIDTable *xmlIDTablePtr; + +/* + * ALL Refs attributes are stored in a table. + * There is one table per document. + */ + +typedef struct _xmlHashTable xmlRefTable; +typedef xmlRefTable *xmlRefTablePtr; + +/* Notation */ +XMLPUBFUN xmlNotationPtr XMLCALL + xmlAddNotationDecl (xmlValidCtxtPtr ctxt, + xmlDtdPtr dtd, + const xmlChar *name, + const xmlChar *PublicID, + const xmlChar *SystemID); +#ifdef LIBXML_TREE_ENABLED +XMLPUBFUN xmlNotationTablePtr XMLCALL + xmlCopyNotationTable (xmlNotationTablePtr table); +#endif /* LIBXML_TREE_ENABLED */ +XMLPUBFUN void XMLCALL + xmlFreeNotationTable (xmlNotationTablePtr table); +#ifdef LIBXML_OUTPUT_ENABLED +XMLPUBFUN void XMLCALL + xmlDumpNotationDecl (xmlBufferPtr buf, + xmlNotationPtr nota); +XMLPUBFUN void XMLCALL + xmlDumpNotationTable (xmlBufferPtr buf, + xmlNotationTablePtr table); +#endif /* LIBXML_OUTPUT_ENABLED */ + +/* Element Content */ +/* the non Doc version are being deprecated */ +XMLPUBFUN xmlElementContentPtr XMLCALL + xmlNewElementContent (const xmlChar *name, + xmlElementContentType type); +XMLPUBFUN xmlElementContentPtr XMLCALL + xmlCopyElementContent (xmlElementContentPtr content); +XMLPUBFUN void XMLCALL + xmlFreeElementContent (xmlElementContentPtr cur); +/* the new versions with doc argument */ +XMLPUBFUN xmlElementContentPtr XMLCALL + xmlNewDocElementContent (xmlDocPtr doc, + const xmlChar *name, + xmlElementContentType type); +XMLPUBFUN xmlElementContentPtr XMLCALL + xmlCopyDocElementContent(xmlDocPtr doc, + xmlElementContentPtr content); +XMLPUBFUN void XMLCALL + xmlFreeDocElementContent(xmlDocPtr doc, + xmlElementContentPtr cur); +XMLPUBFUN void XMLCALL + xmlSnprintfElementContent(char *buf, + int size, + xmlElementContentPtr content, + int englob); +#ifdef LIBXML_OUTPUT_ENABLED +/* DEPRECATED */ +XMLPUBFUN void XMLCALL + xmlSprintfElementContent(char *buf, + xmlElementContentPtr content, + int englob); +#endif /* LIBXML_OUTPUT_ENABLED */ +/* DEPRECATED */ + +/* Element */ +XMLPUBFUN xmlElementPtr XMLCALL + xmlAddElementDecl (xmlValidCtxtPtr ctxt, + xmlDtdPtr dtd, + const xmlChar *name, + xmlElementTypeVal type, + xmlElementContentPtr content); +#ifdef LIBXML_TREE_ENABLED +XMLPUBFUN xmlElementTablePtr XMLCALL + xmlCopyElementTable (xmlElementTablePtr table); +#endif /* LIBXML_TREE_ENABLED */ +XMLPUBFUN void XMLCALL + xmlFreeElementTable (xmlElementTablePtr table); +#ifdef LIBXML_OUTPUT_ENABLED +XMLPUBFUN void XMLCALL + xmlDumpElementTable (xmlBufferPtr buf, + xmlElementTablePtr table); +XMLPUBFUN void XMLCALL + xmlDumpElementDecl (xmlBufferPtr buf, + xmlElementPtr elem); +#endif /* LIBXML_OUTPUT_ENABLED */ + +/* Enumeration */ +XMLPUBFUN xmlEnumerationPtr XMLCALL + xmlCreateEnumeration (const xmlChar *name); +XMLPUBFUN void XMLCALL + xmlFreeEnumeration (xmlEnumerationPtr cur); +#ifdef LIBXML_TREE_ENABLED +XMLPUBFUN xmlEnumerationPtr XMLCALL + xmlCopyEnumeration (xmlEnumerationPtr cur); +#endif /* LIBXML_TREE_ENABLED */ + +/* Attribute */ +XMLPUBFUN xmlAttributePtr XMLCALL + xmlAddAttributeDecl (xmlValidCtxtPtr ctxt, + xmlDtdPtr dtd, + const xmlChar *elem, + const xmlChar *name, + const xmlChar *ns, + xmlAttributeType type, + xmlAttributeDefault def, + const xmlChar *defaultValue, + xmlEnumerationPtr tree); +#ifdef LIBXML_TREE_ENABLED +XMLPUBFUN xmlAttributeTablePtr XMLCALL + xmlCopyAttributeTable (xmlAttributeTablePtr table); +#endif /* LIBXML_TREE_ENABLED */ +XMLPUBFUN void XMLCALL + xmlFreeAttributeTable (xmlAttributeTablePtr table); +#ifdef LIBXML_OUTPUT_ENABLED +XMLPUBFUN void XMLCALL + xmlDumpAttributeTable (xmlBufferPtr buf, + xmlAttributeTablePtr table); +XMLPUBFUN void XMLCALL + xmlDumpAttributeDecl (xmlBufferPtr buf, + xmlAttributePtr attr); +#endif /* LIBXML_OUTPUT_ENABLED */ + +/* IDs */ +XMLPUBFUN xmlIDPtr XMLCALL + xmlAddID (xmlValidCtxtPtr ctxt, + xmlDocPtr doc, + const xmlChar *value, + xmlAttrPtr attr); +XMLPUBFUN void XMLCALL + xmlFreeIDTable (xmlIDTablePtr table); +XMLPUBFUN xmlAttrPtr XMLCALL + xmlGetID (xmlDocPtr doc, + const xmlChar *ID); +XMLPUBFUN int XMLCALL + xmlIsID (xmlDocPtr doc, + xmlNodePtr elem, + xmlAttrPtr attr); +XMLPUBFUN int XMLCALL + xmlRemoveID (xmlDocPtr doc, + xmlAttrPtr attr); + +/* IDREFs */ +XMLPUBFUN xmlRefPtr XMLCALL + xmlAddRef (xmlValidCtxtPtr ctxt, + xmlDocPtr doc, + const xmlChar *value, + xmlAttrPtr attr); +XMLPUBFUN void XMLCALL + xmlFreeRefTable (xmlRefTablePtr table); +XMLPUBFUN int XMLCALL + xmlIsRef (xmlDocPtr doc, + xmlNodePtr elem, + xmlAttrPtr attr); +XMLPUBFUN int XMLCALL + xmlRemoveRef (xmlDocPtr doc, + xmlAttrPtr attr); +XMLPUBFUN xmlListPtr XMLCALL + xmlGetRefs (xmlDocPtr doc, + const xmlChar *ID); + +/** + * The public function calls related to validity checking. + */ +#ifdef LIBXML_VALID_ENABLED +/* Allocate/Release Validation Contexts */ +XMLPUBFUN xmlValidCtxtPtr XMLCALL + xmlNewValidCtxt(void); +XMLPUBFUN void XMLCALL + xmlFreeValidCtxt(xmlValidCtxtPtr); + +XMLPUBFUN int XMLCALL + xmlValidateRoot (xmlValidCtxtPtr ctxt, + xmlDocPtr doc); +XMLPUBFUN int XMLCALL + xmlValidateElementDecl (xmlValidCtxtPtr ctxt, + xmlDocPtr doc, + xmlElementPtr elem); +XMLPUBFUN xmlChar * XMLCALL + xmlValidNormalizeAttributeValue(xmlDocPtr doc, + xmlNodePtr elem, + const xmlChar *name, + const xmlChar *value); +XMLPUBFUN xmlChar * XMLCALL + xmlValidCtxtNormalizeAttributeValue(xmlValidCtxtPtr ctxt, + xmlDocPtr doc, + xmlNodePtr elem, + const xmlChar *name, + const xmlChar *value); +XMLPUBFUN int XMLCALL + xmlValidateAttributeDecl(xmlValidCtxtPtr ctxt, + xmlDocPtr doc, + xmlAttributePtr attr); +XMLPUBFUN int XMLCALL + xmlValidateAttributeValue(xmlAttributeType type, + const xmlChar *value); +XMLPUBFUN int XMLCALL + xmlValidateNotationDecl (xmlValidCtxtPtr ctxt, + xmlDocPtr doc, + xmlNotationPtr nota); +XMLPUBFUN int XMLCALL + xmlValidateDtd (xmlValidCtxtPtr ctxt, + xmlDocPtr doc, + xmlDtdPtr dtd); +XMLPUBFUN int XMLCALL + xmlValidateDtdFinal (xmlValidCtxtPtr ctxt, + xmlDocPtr doc); +XMLPUBFUN int XMLCALL + xmlValidateDocument (xmlValidCtxtPtr ctxt, + xmlDocPtr doc); +XMLPUBFUN int XMLCALL + xmlValidateElement (xmlValidCtxtPtr ctxt, + xmlDocPtr doc, + xmlNodePtr elem); +XMLPUBFUN int XMLCALL + xmlValidateOneElement (xmlValidCtxtPtr ctxt, + xmlDocPtr doc, + xmlNodePtr elem); +XMLPUBFUN int XMLCALL + xmlValidateOneAttribute (xmlValidCtxtPtr ctxt, + xmlDocPtr doc, + xmlNodePtr elem, + xmlAttrPtr attr, + const xmlChar *value); +XMLPUBFUN int XMLCALL + xmlValidateOneNamespace (xmlValidCtxtPtr ctxt, + xmlDocPtr doc, + xmlNodePtr elem, + const xmlChar *prefix, + xmlNsPtr ns, + const xmlChar *value); +XMLPUBFUN int XMLCALL + xmlValidateDocumentFinal(xmlValidCtxtPtr ctxt, + xmlDocPtr doc); +#endif /* LIBXML_VALID_ENABLED */ + +#if defined(LIBXML_VALID_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) +XMLPUBFUN int XMLCALL + xmlValidateNotationUse (xmlValidCtxtPtr ctxt, + xmlDocPtr doc, + const xmlChar *notationName); +#endif /* LIBXML_VALID_ENABLED or LIBXML_SCHEMAS_ENABLED */ + +XMLPUBFUN int XMLCALL + xmlIsMixedElement (xmlDocPtr doc, + const xmlChar *name); +XMLPUBFUN xmlAttributePtr XMLCALL + xmlGetDtdAttrDesc (xmlDtdPtr dtd, + const xmlChar *elem, + const xmlChar *name); +XMLPUBFUN xmlAttributePtr XMLCALL + xmlGetDtdQAttrDesc (xmlDtdPtr dtd, + const xmlChar *elem, + const xmlChar *name, + const xmlChar *prefix); +XMLPUBFUN xmlNotationPtr XMLCALL + xmlGetDtdNotationDesc (xmlDtdPtr dtd, + const xmlChar *name); +XMLPUBFUN xmlElementPtr XMLCALL + xmlGetDtdQElementDesc (xmlDtdPtr dtd, + const xmlChar *name, + const xmlChar *prefix); +XMLPUBFUN xmlElementPtr XMLCALL + xmlGetDtdElementDesc (xmlDtdPtr dtd, + const xmlChar *name); + +#ifdef LIBXML_VALID_ENABLED + +XMLPUBFUN int XMLCALL + xmlValidGetPotentialChildren(xmlElementContent *ctree, + const xmlChar **names, + int *len, + int max); + +XMLPUBFUN int XMLCALL + xmlValidGetValidElements(xmlNode *prev, + xmlNode *next, + const xmlChar **names, + int max); +XMLPUBFUN int XMLCALL + xmlValidateNameValue (const xmlChar *value); +XMLPUBFUN int XMLCALL + xmlValidateNamesValue (const xmlChar *value); +XMLPUBFUN int XMLCALL + xmlValidateNmtokenValue (const xmlChar *value); +XMLPUBFUN int XMLCALL + xmlValidateNmtokensValue(const xmlChar *value); + +#ifdef LIBXML_REGEXP_ENABLED +/* + * Validation based on the regexp support + */ +XMLPUBFUN int XMLCALL + xmlValidBuildContentModel(xmlValidCtxtPtr ctxt, + xmlElementPtr elem); + +XMLPUBFUN int XMLCALL + xmlValidatePushElement (xmlValidCtxtPtr ctxt, + xmlDocPtr doc, + xmlNodePtr elem, + const xmlChar *qname); +XMLPUBFUN int XMLCALL + xmlValidatePushCData (xmlValidCtxtPtr ctxt, + const xmlChar *data, + int len); +XMLPUBFUN int XMLCALL + xmlValidatePopElement (xmlValidCtxtPtr ctxt, + xmlDocPtr doc, + xmlNodePtr elem, + const xmlChar *qname); +#endif /* LIBXML_REGEXP_ENABLED */ +#endif /* LIBXML_VALID_ENABLED */ +#ifdef __cplusplus +} +#endif +#endif /* __XML_VALID_H__ */ diff --git a/lib/libxml2/include/libxml/xinclude.h b/lib/libxml2/include/libxml/xinclude.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/xinclude.h @@ -0,0 +1,129 @@ +/* + * Summary: implementation of XInclude + * Description: API to handle XInclude processing, + * implements the + * World Wide Web Consortium Last Call Working Draft 10 November 2003 + * http://www.w3.org/TR/2003/WD-xinclude-20031110 + * + * Copy: See Copyright for the status of this software. + * + * Author: Daniel Veillard + */ + +#ifndef __XML_XINCLUDE_H__ +#define __XML_XINCLUDE_H__ + +#include +#include + +#ifdef LIBXML_XINCLUDE_ENABLED + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * XINCLUDE_NS: + * + * Macro defining the Xinclude namespace: http://www.w3.org/2003/XInclude + */ +#define XINCLUDE_NS (const xmlChar *) "http://www.w3.org/2003/XInclude" +/** + * XINCLUDE_OLD_NS: + * + * Macro defining the draft Xinclude namespace: http://www.w3.org/2001/XInclude + */ +#define XINCLUDE_OLD_NS (const xmlChar *) "http://www.w3.org/2001/XInclude" +/** + * XINCLUDE_NODE: + * + * Macro defining "include" + */ +#define XINCLUDE_NODE (const xmlChar *) "include" +/** + * XINCLUDE_FALLBACK: + * + * Macro defining "fallback" + */ +#define XINCLUDE_FALLBACK (const xmlChar *) "fallback" +/** + * XINCLUDE_HREF: + * + * Macro defining "href" + */ +#define XINCLUDE_HREF (const xmlChar *) "href" +/** + * XINCLUDE_PARSE: + * + * Macro defining "parse" + */ +#define XINCLUDE_PARSE (const xmlChar *) "parse" +/** + * XINCLUDE_PARSE_XML: + * + * Macro defining "xml" + */ +#define XINCLUDE_PARSE_XML (const xmlChar *) "xml" +/** + * XINCLUDE_PARSE_TEXT: + * + * Macro defining "text" + */ +#define XINCLUDE_PARSE_TEXT (const xmlChar *) "text" +/** + * XINCLUDE_PARSE_ENCODING: + * + * Macro defining "encoding" + */ +#define XINCLUDE_PARSE_ENCODING (const xmlChar *) "encoding" +/** + * XINCLUDE_PARSE_XPOINTER: + * + * Macro defining "xpointer" + */ +#define XINCLUDE_PARSE_XPOINTER (const xmlChar *) "xpointer" + +typedef struct _xmlXIncludeCtxt xmlXIncludeCtxt; +typedef xmlXIncludeCtxt *xmlXIncludeCtxtPtr; + +/* + * standalone processing + */ +XMLPUBFUN int XMLCALL + xmlXIncludeProcess (xmlDocPtr doc); +XMLPUBFUN int XMLCALL + xmlXIncludeProcessFlags (xmlDocPtr doc, + int flags); +XMLPUBFUN int XMLCALL + xmlXIncludeProcessFlagsData(xmlDocPtr doc, + int flags, + void *data); +XMLPUBFUN int XMLCALL + xmlXIncludeProcessTreeFlagsData(xmlNodePtr tree, + int flags, + void *data); +XMLPUBFUN int XMLCALL + xmlXIncludeProcessTree (xmlNodePtr tree); +XMLPUBFUN int XMLCALL + xmlXIncludeProcessTreeFlags(xmlNodePtr tree, + int flags); +/* + * contextual processing + */ +XMLPUBFUN xmlXIncludeCtxtPtr XMLCALL + xmlXIncludeNewContext (xmlDocPtr doc); +XMLPUBFUN int XMLCALL + xmlXIncludeSetFlags (xmlXIncludeCtxtPtr ctxt, + int flags); +XMLPUBFUN void XMLCALL + xmlXIncludeFreeContext (xmlXIncludeCtxtPtr ctxt); +XMLPUBFUN int XMLCALL + xmlXIncludeProcessNode (xmlXIncludeCtxtPtr ctxt, + xmlNodePtr tree); +#ifdef __cplusplus +} +#endif + +#endif /* LIBXML_XINCLUDE_ENABLED */ + +#endif /* __XML_XINCLUDE_H__ */ diff --git a/lib/libxml2/include/libxml/xlink.h b/lib/libxml2/include/libxml/xlink.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/xlink.h @@ -0,0 +1,189 @@ +/* + * Summary: unfinished XLink detection module + * Description: unfinished XLink detection module + * + * Copy: See Copyright for the status of this software. + * + * Author: Daniel Veillard + */ + +#ifndef __XML_XLINK_H__ +#define __XML_XLINK_H__ + +#include +#include + +#ifdef LIBXML_XPTR_ENABLED + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * Various defines for the various Link properties. + * + * NOTE: the link detection layer will try to resolve QName expansion + * of namespaces. If "foo" is the prefix for "http://foo.com/" + * then the link detection layer will expand role="foo:myrole" + * to "http://foo.com/:myrole". + * NOTE: the link detection layer will expand URI-Refences found on + * href attributes by using the base mechanism if found. + */ +typedef xmlChar *xlinkHRef; +typedef xmlChar *xlinkRole; +typedef xmlChar *xlinkTitle; + +typedef enum { + XLINK_TYPE_NONE = 0, + XLINK_TYPE_SIMPLE, + XLINK_TYPE_EXTENDED, + XLINK_TYPE_EXTENDED_SET +} xlinkType; + +typedef enum { + XLINK_SHOW_NONE = 0, + XLINK_SHOW_NEW, + XLINK_SHOW_EMBED, + XLINK_SHOW_REPLACE +} xlinkShow; + +typedef enum { + XLINK_ACTUATE_NONE = 0, + XLINK_ACTUATE_AUTO, + XLINK_ACTUATE_ONREQUEST +} xlinkActuate; + +/** + * xlinkNodeDetectFunc: + * @ctx: user data pointer + * @node: the node to check + * + * This is the prototype for the link detection routine. + * It calls the default link detection callbacks upon link detection. + */ +typedef void (*xlinkNodeDetectFunc) (void *ctx, xmlNodePtr node); + +/* + * The link detection module interact with the upper layers using + * a set of callback registered at parsing time. + */ + +/** + * xlinkSimpleLinkFunk: + * @ctx: user data pointer + * @node: the node carrying the link + * @href: the target of the link + * @role: the role string + * @title: the link title + * + * This is the prototype for a simple link detection callback. + */ +typedef void +(*xlinkSimpleLinkFunk) (void *ctx, + xmlNodePtr node, + const xlinkHRef href, + const xlinkRole role, + const xlinkTitle title); + +/** + * xlinkExtendedLinkFunk: + * @ctx: user data pointer + * @node: the node carrying the link + * @nbLocators: the number of locators detected on the link + * @hrefs: pointer to the array of locator hrefs + * @roles: pointer to the array of locator roles + * @nbArcs: the number of arcs detected on the link + * @from: pointer to the array of source roles found on the arcs + * @to: pointer to the array of target roles found on the arcs + * @show: array of values for the show attributes found on the arcs + * @actuate: array of values for the actuate attributes found on the arcs + * @nbTitles: the number of titles detected on the link + * @title: array of titles detected on the link + * @langs: array of xml:lang values for the titles + * + * This is the prototype for a extended link detection callback. + */ +typedef void +(*xlinkExtendedLinkFunk)(void *ctx, + xmlNodePtr node, + int nbLocators, + const xlinkHRef *hrefs, + const xlinkRole *roles, + int nbArcs, + const xlinkRole *from, + const xlinkRole *to, + xlinkShow *show, + xlinkActuate *actuate, + int nbTitles, + const xlinkTitle *titles, + const xmlChar **langs); + +/** + * xlinkExtendedLinkSetFunk: + * @ctx: user data pointer + * @node: the node carrying the link + * @nbLocators: the number of locators detected on the link + * @hrefs: pointer to the array of locator hrefs + * @roles: pointer to the array of locator roles + * @nbTitles: the number of titles detected on the link + * @title: array of titles detected on the link + * @langs: array of xml:lang values for the titles + * + * This is the prototype for a extended link set detection callback. + */ +typedef void +(*xlinkExtendedLinkSetFunk) (void *ctx, + xmlNodePtr node, + int nbLocators, + const xlinkHRef *hrefs, + const xlinkRole *roles, + int nbTitles, + const xlinkTitle *titles, + const xmlChar **langs); + +/** + * This is the structure containing a set of Links detection callbacks. + * + * There is no default xlink callbacks, if one want to get link + * recognition activated, those call backs must be provided before parsing. + */ +typedef struct _xlinkHandler xlinkHandler; +typedef xlinkHandler *xlinkHandlerPtr; +struct _xlinkHandler { + xlinkSimpleLinkFunk simple; + xlinkExtendedLinkFunk extended; + xlinkExtendedLinkSetFunk set; +}; + +/* + * The default detection routine, can be overridden, they call the default + * detection callbacks. + */ + +XMLPUBFUN xlinkNodeDetectFunc XMLCALL + xlinkGetDefaultDetect (void); +XMLPUBFUN void XMLCALL + xlinkSetDefaultDetect (xlinkNodeDetectFunc func); + +/* + * Routines to set/get the default handlers. + */ +XMLPUBFUN xlinkHandlerPtr XMLCALL + xlinkGetDefaultHandler (void); +XMLPUBFUN void XMLCALL + xlinkSetDefaultHandler (xlinkHandlerPtr handler); + +/* + * Link detection module itself. + */ +XMLPUBFUN xlinkType XMLCALL + xlinkIsLink (xmlDocPtr doc, + xmlNodePtr node); + +#ifdef __cplusplus +} +#endif + +#endif /* LIBXML_XPTR_ENABLED */ + +#endif /* __XML_XLINK_H__ */ diff --git a/lib/libxml2/include/libxml/xmlIO.h b/lib/libxml2/include/libxml/xmlIO.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/xmlIO.h @@ -0,0 +1,360 @@ +/* + * Summary: interface for the I/O interfaces used by the parser + * Description: interface for the I/O interfaces used by the parser + * + * Copy: See Copyright for the status of this software. + * + * Author: Daniel Veillard + */ + +#ifndef __XML_IO_H__ +#define __XML_IO_H__ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * Those are the functions and datatypes for the parser input + * I/O structures. + */ + +/** + * xmlInputMatchCallback: + * @filename: the filename or URI + * + * Callback used in the I/O Input API to detect if the current handler + * can provide input fonctionnalities for this resource. + * + * Returns 1 if yes and 0 if another Input module should be used + */ +typedef int (XMLCALL *xmlInputMatchCallback) (char const *filename); +/** + * xmlInputOpenCallback: + * @filename: the filename or URI + * + * Callback used in the I/O Input API to open the resource + * + * Returns an Input context or NULL in case or error + */ +typedef void * (XMLCALL *xmlInputOpenCallback) (char const *filename); +/** + * xmlInputReadCallback: + * @context: an Input context + * @buffer: the buffer to store data read + * @len: the length of the buffer in bytes + * + * Callback used in the I/O Input API to read the resource + * + * Returns the number of bytes read or -1 in case of error + */ +typedef int (XMLCALL *xmlInputReadCallback) (void * context, char * buffer, int len); +/** + * xmlInputCloseCallback: + * @context: an Input context + * + * Callback used in the I/O Input API to close the resource + * + * Returns 0 or -1 in case of error + */ +typedef int (XMLCALL *xmlInputCloseCallback) (void * context); + +#ifdef LIBXML_OUTPUT_ENABLED +/* + * Those are the functions and datatypes for the library output + * I/O structures. + */ + +/** + * xmlOutputMatchCallback: + * @filename: the filename or URI + * + * Callback used in the I/O Output API to detect if the current handler + * can provide output fonctionnalities for this resource. + * + * Returns 1 if yes and 0 if another Output module should be used + */ +typedef int (XMLCALL *xmlOutputMatchCallback) (char const *filename); +/** + * xmlOutputOpenCallback: + * @filename: the filename or URI + * + * Callback used in the I/O Output API to open the resource + * + * Returns an Output context or NULL in case or error + */ +typedef void * (XMLCALL *xmlOutputOpenCallback) (char const *filename); +/** + * xmlOutputWriteCallback: + * @context: an Output context + * @buffer: the buffer of data to write + * @len: the length of the buffer in bytes + * + * Callback used in the I/O Output API to write to the resource + * + * Returns the number of bytes written or -1 in case of error + */ +typedef int (XMLCALL *xmlOutputWriteCallback) (void * context, const char * buffer, + int len); +/** + * xmlOutputCloseCallback: + * @context: an Output context + * + * Callback used in the I/O Output API to close the resource + * + * Returns 0 or -1 in case of error + */ +typedef int (XMLCALL *xmlOutputCloseCallback) (void * context); +#endif /* LIBXML_OUTPUT_ENABLED */ + +#ifdef __cplusplus +} +#endif + +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif +struct _xmlParserInputBuffer { + void* context; + xmlInputReadCallback readcallback; + xmlInputCloseCallback closecallback; + + xmlCharEncodingHandlerPtr encoder; /* I18N conversions to UTF-8 */ + + xmlBufferPtr buffer; /* Local buffer encoded in UTF-8 */ + xmlBufferPtr raw; /* if encoder != NULL buffer for raw input */ + int compressed; /* -1=unknown, 0=not compressed, 1=compressed */ + int error; + unsigned long rawconsumed;/* amount consumed from raw */ +}; + + +#ifdef LIBXML_OUTPUT_ENABLED +struct _xmlOutputBuffer { + void* context; + xmlOutputWriteCallback writecallback; + xmlOutputCloseCallback closecallback; + + xmlCharEncodingHandlerPtr encoder; /* I18N conversions to UTF-8 */ + + xmlBufferPtr buffer; /* Local buffer encoded in UTF-8 or ISOLatin */ + xmlBufferPtr conv; /* if encoder != NULL buffer for output */ + int written; /* total number of byte written */ + int error; +}; +#endif /* LIBXML_OUTPUT_ENABLED */ + +/* + * Interfaces for input + */ +XMLPUBFUN void XMLCALL + xmlCleanupInputCallbacks (void); + +XMLPUBFUN int XMLCALL + xmlPopInputCallbacks (void); + +XMLPUBFUN void XMLCALL + xmlRegisterDefaultInputCallbacks (void); +XMLPUBFUN xmlParserInputBufferPtr XMLCALL + xmlAllocParserInputBuffer (xmlCharEncoding enc); + +XMLPUBFUN xmlParserInputBufferPtr XMLCALL + xmlParserInputBufferCreateFilename (const char *URI, + xmlCharEncoding enc); +XMLPUBFUN xmlParserInputBufferPtr XMLCALL + xmlParserInputBufferCreateFile (FILE *file, + xmlCharEncoding enc); +XMLPUBFUN xmlParserInputBufferPtr XMLCALL + xmlParserInputBufferCreateFd (int fd, + xmlCharEncoding enc); +XMLPUBFUN xmlParserInputBufferPtr XMLCALL + xmlParserInputBufferCreateMem (const char *mem, int size, + xmlCharEncoding enc); +XMLPUBFUN xmlParserInputBufferPtr XMLCALL + xmlParserInputBufferCreateStatic (const char *mem, int size, + xmlCharEncoding enc); +XMLPUBFUN xmlParserInputBufferPtr XMLCALL + xmlParserInputBufferCreateIO (xmlInputReadCallback ioread, + xmlInputCloseCallback ioclose, + void *ioctx, + xmlCharEncoding enc); +XMLPUBFUN int XMLCALL + xmlParserInputBufferRead (xmlParserInputBufferPtr in, + int len); +XMLPUBFUN int XMLCALL + xmlParserInputBufferGrow (xmlParserInputBufferPtr in, + int len); +XMLPUBFUN int XMLCALL + xmlParserInputBufferPush (xmlParserInputBufferPtr in, + int len, + const char *buf); +XMLPUBFUN void XMLCALL + xmlFreeParserInputBuffer (xmlParserInputBufferPtr in); +XMLPUBFUN char * XMLCALL + xmlParserGetDirectory (const char *filename); + +XMLPUBFUN int XMLCALL + xmlRegisterInputCallbacks (xmlInputMatchCallback matchFunc, + xmlInputOpenCallback openFunc, + xmlInputReadCallback readFunc, + xmlInputCloseCallback closeFunc); + +xmlParserInputBufferPtr + __xmlParserInputBufferCreateFilename(const char *URI, + xmlCharEncoding enc); + +#ifdef LIBXML_OUTPUT_ENABLED +/* + * Interfaces for output + */ +XMLPUBFUN void XMLCALL + xmlCleanupOutputCallbacks (void); +XMLPUBFUN void XMLCALL + xmlRegisterDefaultOutputCallbacks(void); +XMLPUBFUN xmlOutputBufferPtr XMLCALL + xmlAllocOutputBuffer (xmlCharEncodingHandlerPtr encoder); + +XMLPUBFUN xmlOutputBufferPtr XMLCALL + xmlOutputBufferCreateFilename (const char *URI, + xmlCharEncodingHandlerPtr encoder, + int compression); + +XMLPUBFUN xmlOutputBufferPtr XMLCALL + xmlOutputBufferCreateFile (FILE *file, + xmlCharEncodingHandlerPtr encoder); + +XMLPUBFUN xmlOutputBufferPtr XMLCALL + xmlOutputBufferCreateBuffer (xmlBufferPtr buffer, + xmlCharEncodingHandlerPtr encoder); + +XMLPUBFUN xmlOutputBufferPtr XMLCALL + xmlOutputBufferCreateFd (int fd, + xmlCharEncodingHandlerPtr encoder); + +XMLPUBFUN xmlOutputBufferPtr XMLCALL + xmlOutputBufferCreateIO (xmlOutputWriteCallback iowrite, + xmlOutputCloseCallback ioclose, + void *ioctx, + xmlCharEncodingHandlerPtr encoder); + +XMLPUBFUN int XMLCALL + xmlOutputBufferWrite (xmlOutputBufferPtr out, + int len, + const char *buf); +XMLPUBFUN int XMLCALL + xmlOutputBufferWriteString (xmlOutputBufferPtr out, + const char *str); +XMLPUBFUN int XMLCALL + xmlOutputBufferWriteEscape (xmlOutputBufferPtr out, + const xmlChar *str, + xmlCharEncodingOutputFunc escaping); + +XMLPUBFUN int XMLCALL + xmlOutputBufferFlush (xmlOutputBufferPtr out); +XMLPUBFUN int XMLCALL + xmlOutputBufferClose (xmlOutputBufferPtr out); + +XMLPUBFUN int XMLCALL + xmlRegisterOutputCallbacks (xmlOutputMatchCallback matchFunc, + xmlOutputOpenCallback openFunc, + xmlOutputWriteCallback writeFunc, + xmlOutputCloseCallback closeFunc); + +xmlOutputBufferPtr + __xmlOutputBufferCreateFilename(const char *URI, + xmlCharEncodingHandlerPtr encoder, + int compression); + +#ifdef LIBXML_HTTP_ENABLED +/* This function only exists if HTTP support built into the library */ +XMLPUBFUN void XMLCALL + xmlRegisterHTTPPostCallbacks (void ); +#endif /* LIBXML_HTTP_ENABLED */ + +#endif /* LIBXML_OUTPUT_ENABLED */ + +XMLPUBFUN xmlParserInputPtr XMLCALL + xmlCheckHTTPInput (xmlParserCtxtPtr ctxt, + xmlParserInputPtr ret); + +/* + * A predefined entity loader disabling network accesses + */ +XMLPUBFUN xmlParserInputPtr XMLCALL + xmlNoNetExternalEntityLoader (const char *URL, + const char *ID, + xmlParserCtxtPtr ctxt); + +/* + * xmlNormalizeWindowsPath is obsolete, don't use it. + * Check xmlCanonicPath in uri.h for a better alternative. + */ +XMLPUBFUN xmlChar * XMLCALL + xmlNormalizeWindowsPath (const xmlChar *path); + +XMLPUBFUN int XMLCALL + xmlCheckFilename (const char *path); +/** + * Default 'file://' protocol callbacks + */ +XMLPUBFUN int XMLCALL + xmlFileMatch (const char *filename); +XMLPUBFUN void * XMLCALL + xmlFileOpen (const char *filename); +XMLPUBFUN int XMLCALL + xmlFileRead (void * context, + char * buffer, + int len); +XMLPUBFUN int XMLCALL + xmlFileClose (void * context); + +/** + * Default 'http://' protocol callbacks + */ +#ifdef LIBXML_HTTP_ENABLED +XMLPUBFUN int XMLCALL + xmlIOHTTPMatch (const char *filename); +XMLPUBFUN void * XMLCALL + xmlIOHTTPOpen (const char *filename); +#ifdef LIBXML_OUTPUT_ENABLED +XMLPUBFUN void * XMLCALL + xmlIOHTTPOpenW (const char * post_uri, + int compression ); +#endif /* LIBXML_OUTPUT_ENABLED */ +XMLPUBFUN int XMLCALL + xmlIOHTTPRead (void * context, + char * buffer, + int len); +XMLPUBFUN int XMLCALL + xmlIOHTTPClose (void * context); +#endif /* LIBXML_HTTP_ENABLED */ + +/** + * Default 'ftp://' protocol callbacks + */ +#ifdef LIBXML_FTP_ENABLED +XMLPUBFUN int XMLCALL + xmlIOFTPMatch (const char *filename); +XMLPUBFUN void * XMLCALL + xmlIOFTPOpen (const char *filename); +XMLPUBFUN int XMLCALL + xmlIOFTPRead (void * context, + char * buffer, + int len); +XMLPUBFUN int XMLCALL + xmlIOFTPClose (void * context); +#endif /* LIBXML_FTP_ENABLED */ + +#ifdef __cplusplus +} +#endif + +#endif /* __XML_IO_H__ */ diff --git a/lib/libxml2/include/libxml/xmlautomata.h b/lib/libxml2/include/libxml/xmlautomata.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/xmlautomata.h @@ -0,0 +1,146 @@ +/* + * Summary: API to build regexp automata + * Description: the API to build regexp automata + * + * Copy: See Copyright for the status of this software. + * + * Author: Daniel Veillard + */ + +#ifndef __XML_AUTOMATA_H__ +#define __XML_AUTOMATA_H__ + +#include +#include + +#ifdef LIBXML_REGEXP_ENABLED +#ifdef LIBXML_AUTOMATA_ENABLED +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * xmlAutomataPtr: + * + * A libxml automata description, It can be compiled into a regexp + */ +typedef struct _xmlAutomata xmlAutomata; +typedef xmlAutomata *xmlAutomataPtr; + +/** + * xmlAutomataStatePtr: + * + * A state int the automata description, + */ +typedef struct _xmlAutomataState xmlAutomataState; +typedef xmlAutomataState *xmlAutomataStatePtr; + +/* + * Building API + */ +XMLPUBFUN xmlAutomataPtr XMLCALL + xmlNewAutomata (void); +XMLPUBFUN void XMLCALL + xmlFreeAutomata (xmlAutomataPtr am); + +XMLPUBFUN xmlAutomataStatePtr XMLCALL + xmlAutomataGetInitState (xmlAutomataPtr am); +XMLPUBFUN int XMLCALL + xmlAutomataSetFinalState (xmlAutomataPtr am, + xmlAutomataStatePtr state); +XMLPUBFUN xmlAutomataStatePtr XMLCALL + xmlAutomataNewState (xmlAutomataPtr am); +XMLPUBFUN xmlAutomataStatePtr XMLCALL + xmlAutomataNewTransition (xmlAutomataPtr am, + xmlAutomataStatePtr from, + xmlAutomataStatePtr to, + const xmlChar *token, + void *data); +XMLPUBFUN xmlAutomataStatePtr XMLCALL + xmlAutomataNewTransition2 (xmlAutomataPtr am, + xmlAutomataStatePtr from, + xmlAutomataStatePtr to, + const xmlChar *token, + const xmlChar *token2, + void *data); +XMLPUBFUN xmlAutomataStatePtr XMLCALL + xmlAutomataNewNegTrans (xmlAutomataPtr am, + xmlAutomataStatePtr from, + xmlAutomataStatePtr to, + const xmlChar *token, + const xmlChar *token2, + void *data); + +XMLPUBFUN xmlAutomataStatePtr XMLCALL + xmlAutomataNewCountTrans (xmlAutomataPtr am, + xmlAutomataStatePtr from, + xmlAutomataStatePtr to, + const xmlChar *token, + int min, + int max, + void *data); +XMLPUBFUN xmlAutomataStatePtr XMLCALL + xmlAutomataNewCountTrans2 (xmlAutomataPtr am, + xmlAutomataStatePtr from, + xmlAutomataStatePtr to, + const xmlChar *token, + const xmlChar *token2, + int min, + int max, + void *data); +XMLPUBFUN xmlAutomataStatePtr XMLCALL + xmlAutomataNewOnceTrans (xmlAutomataPtr am, + xmlAutomataStatePtr from, + xmlAutomataStatePtr to, + const xmlChar *token, + int min, + int max, + void *data); +XMLPUBFUN xmlAutomataStatePtr XMLCALL + xmlAutomataNewOnceTrans2 (xmlAutomataPtr am, + xmlAutomataStatePtr from, + xmlAutomataStatePtr to, + const xmlChar *token, + const xmlChar *token2, + int min, + int max, + void *data); +XMLPUBFUN xmlAutomataStatePtr XMLCALL + xmlAutomataNewAllTrans (xmlAutomataPtr am, + xmlAutomataStatePtr from, + xmlAutomataStatePtr to, + int lax); +XMLPUBFUN xmlAutomataStatePtr XMLCALL + xmlAutomataNewEpsilon (xmlAutomataPtr am, + xmlAutomataStatePtr from, + xmlAutomataStatePtr to); +XMLPUBFUN xmlAutomataStatePtr XMLCALL + xmlAutomataNewCountedTrans (xmlAutomataPtr am, + xmlAutomataStatePtr from, + xmlAutomataStatePtr to, + int counter); +XMLPUBFUN xmlAutomataStatePtr XMLCALL + xmlAutomataNewCounterTrans (xmlAutomataPtr am, + xmlAutomataStatePtr from, + xmlAutomataStatePtr to, + int counter); +XMLPUBFUN int XMLCALL + xmlAutomataNewCounter (xmlAutomataPtr am, + int min, + int max); + +XMLPUBFUN xmlRegexpPtr XMLCALL + xmlAutomataCompile (xmlAutomataPtr am); +XMLPUBFUN int XMLCALL + xmlAutomataIsDeterminist (xmlAutomataPtr am); + +#ifdef __cplusplus +} +#endif + +#endif /* LIBXML_AUTOMATA_ENABLED */ +#endif /* LIBXML_REGEXP_ENABLED */ + +#endif /* __XML_AUTOMATA_H__ */ diff --git a/lib/libxml2/include/libxml/xmlerror.h b/lib/libxml2/include/libxml/xmlerror.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/xmlerror.h @@ -0,0 +1,944 @@ +/* + * Summary: error handling + * Description: the API used to report errors + * + * Copy: See Copyright for the status of this software. + * + * Author: Daniel Veillard + */ + +#include + +#ifndef __XML_ERROR_H__ +#define __XML_ERROR_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * xmlErrorLevel: + * + * Indicates the level of an error + */ +typedef enum { + XML_ERR_NONE = 0, + XML_ERR_WARNING = 1, /* A simple warning */ + XML_ERR_ERROR = 2, /* A recoverable error */ + XML_ERR_FATAL = 3 /* A fatal error */ +} xmlErrorLevel; + +/** + * xmlErrorDomain: + * + * Indicates where an error may have come from + */ +typedef enum { + XML_FROM_NONE = 0, + XML_FROM_PARSER, /* The XML parser */ + XML_FROM_TREE, /* The tree module */ + XML_FROM_NAMESPACE, /* The XML Namespace module */ + XML_FROM_DTD, /* The XML DTD validation with parser context*/ + XML_FROM_HTML, /* The HTML parser */ + XML_FROM_MEMORY, /* The memory allocator */ + XML_FROM_OUTPUT, /* The serialization code */ + XML_FROM_IO, /* The Input/Output stack */ + XML_FROM_FTP, /* The FTP module */ + XML_FROM_HTTP, /* The HTTP module */ + XML_FROM_XINCLUDE, /* The XInclude processing */ + XML_FROM_XPATH, /* The XPath module */ + XML_FROM_XPOINTER, /* The XPointer module */ + XML_FROM_REGEXP, /* The regular expressions module */ + XML_FROM_DATATYPE, /* The W3C XML Schemas Datatype module */ + XML_FROM_SCHEMASP, /* The W3C XML Schemas parser module */ + XML_FROM_SCHEMASV, /* The W3C XML Schemas validation module */ + XML_FROM_RELAXNGP, /* The Relax-NG parser module */ + XML_FROM_RELAXNGV, /* The Relax-NG validator module */ + XML_FROM_CATALOG, /* The Catalog module */ + XML_FROM_C14N, /* The Canonicalization module */ + XML_FROM_XSLT, /* The XSLT engine from libxslt */ + XML_FROM_VALID, /* The XML DTD validation with valid context */ + XML_FROM_CHECK, /* The error checking module */ + XML_FROM_WRITER, /* The xmlwriter module */ + XML_FROM_MODULE, /* The dynamically loaded module module*/ + XML_FROM_I18N, /* The module handling character conversion */ + XML_FROM_SCHEMATRONV /* The Schematron validator module */ +} xmlErrorDomain; + +/** + * xmlError: + * + * An XML Error instance. + */ + +typedef struct _xmlError xmlError; +typedef xmlError *xmlErrorPtr; +struct _xmlError { + int domain; /* What part of the library raised this error */ + int code; /* The error code, e.g. an xmlParserError */ + char *message;/* human-readable informative error message */ + xmlErrorLevel level;/* how consequent is the error */ + char *file; /* the filename */ + int line; /* the line number if available */ + char *str1; /* extra string information */ + char *str2; /* extra string information */ + char *str3; /* extra string information */ + int int1; /* extra number information */ + int int2; /* column number of the error or 0 if N/A (todo: rename this field when we would break ABI) */ + void *ctxt; /* the parser context if available */ + void *node; /* the node in the tree */ +}; + +/** + * xmlParserError: + * + * This is an error that the XML (or HTML) parser can generate + */ +typedef enum { + XML_ERR_OK = 0, + XML_ERR_INTERNAL_ERROR, /* 1 */ + XML_ERR_NO_MEMORY, /* 2 */ + XML_ERR_DOCUMENT_START, /* 3 */ + XML_ERR_DOCUMENT_EMPTY, /* 4 */ + XML_ERR_DOCUMENT_END, /* 5 */ + XML_ERR_INVALID_HEX_CHARREF, /* 6 */ + XML_ERR_INVALID_DEC_CHARREF, /* 7 */ + XML_ERR_INVALID_CHARREF, /* 8 */ + XML_ERR_INVALID_CHAR, /* 9 */ + XML_ERR_CHARREF_AT_EOF, /* 10 */ + XML_ERR_CHARREF_IN_PROLOG, /* 11 */ + XML_ERR_CHARREF_IN_EPILOG, /* 12 */ + XML_ERR_CHARREF_IN_DTD, /* 13 */ + XML_ERR_ENTITYREF_AT_EOF, /* 14 */ + XML_ERR_ENTITYREF_IN_PROLOG, /* 15 */ + XML_ERR_ENTITYREF_IN_EPILOG, /* 16 */ + XML_ERR_ENTITYREF_IN_DTD, /* 17 */ + XML_ERR_PEREF_AT_EOF, /* 18 */ + XML_ERR_PEREF_IN_PROLOG, /* 19 */ + XML_ERR_PEREF_IN_EPILOG, /* 20 */ + XML_ERR_PEREF_IN_INT_SUBSET, /* 21 */ + XML_ERR_ENTITYREF_NO_NAME, /* 22 */ + XML_ERR_ENTITYREF_SEMICOL_MISSING, /* 23 */ + XML_ERR_PEREF_NO_NAME, /* 24 */ + XML_ERR_PEREF_SEMICOL_MISSING, /* 25 */ + XML_ERR_UNDECLARED_ENTITY, /* 26 */ + XML_WAR_UNDECLARED_ENTITY, /* 27 */ + XML_ERR_UNPARSED_ENTITY, /* 28 */ + XML_ERR_ENTITY_IS_EXTERNAL, /* 29 */ + XML_ERR_ENTITY_IS_PARAMETER, /* 30 */ + XML_ERR_UNKNOWN_ENCODING, /* 31 */ + XML_ERR_UNSUPPORTED_ENCODING, /* 32 */ + XML_ERR_STRING_NOT_STARTED, /* 33 */ + XML_ERR_STRING_NOT_CLOSED, /* 34 */ + XML_ERR_NS_DECL_ERROR, /* 35 */ + XML_ERR_ENTITY_NOT_STARTED, /* 36 */ + XML_ERR_ENTITY_NOT_FINISHED, /* 37 */ + XML_ERR_LT_IN_ATTRIBUTE, /* 38 */ + XML_ERR_ATTRIBUTE_NOT_STARTED, /* 39 */ + XML_ERR_ATTRIBUTE_NOT_FINISHED, /* 40 */ + XML_ERR_ATTRIBUTE_WITHOUT_VALUE, /* 41 */ + XML_ERR_ATTRIBUTE_REDEFINED, /* 42 */ + XML_ERR_LITERAL_NOT_STARTED, /* 43 */ + XML_ERR_LITERAL_NOT_FINISHED, /* 44 */ + XML_ERR_COMMENT_NOT_FINISHED, /* 45 */ + XML_ERR_PI_NOT_STARTED, /* 46 */ + XML_ERR_PI_NOT_FINISHED, /* 47 */ + XML_ERR_NOTATION_NOT_STARTED, /* 48 */ + XML_ERR_NOTATION_NOT_FINISHED, /* 49 */ + XML_ERR_ATTLIST_NOT_STARTED, /* 50 */ + XML_ERR_ATTLIST_NOT_FINISHED, /* 51 */ + XML_ERR_MIXED_NOT_STARTED, /* 52 */ + XML_ERR_MIXED_NOT_FINISHED, /* 53 */ + XML_ERR_ELEMCONTENT_NOT_STARTED, /* 54 */ + XML_ERR_ELEMCONTENT_NOT_FINISHED, /* 55 */ + XML_ERR_XMLDECL_NOT_STARTED, /* 56 */ + XML_ERR_XMLDECL_NOT_FINISHED, /* 57 */ + XML_ERR_CONDSEC_NOT_STARTED, /* 58 */ + XML_ERR_CONDSEC_NOT_FINISHED, /* 59 */ + XML_ERR_EXT_SUBSET_NOT_FINISHED, /* 60 */ + XML_ERR_DOCTYPE_NOT_FINISHED, /* 61 */ + XML_ERR_MISPLACED_CDATA_END, /* 62 */ + XML_ERR_CDATA_NOT_FINISHED, /* 63 */ + XML_ERR_RESERVED_XML_NAME, /* 64 */ + XML_ERR_SPACE_REQUIRED, /* 65 */ + XML_ERR_SEPARATOR_REQUIRED, /* 66 */ + XML_ERR_NMTOKEN_REQUIRED, /* 67 */ + XML_ERR_NAME_REQUIRED, /* 68 */ + XML_ERR_PCDATA_REQUIRED, /* 69 */ + XML_ERR_URI_REQUIRED, /* 70 */ + XML_ERR_PUBID_REQUIRED, /* 71 */ + XML_ERR_LT_REQUIRED, /* 72 */ + XML_ERR_GT_REQUIRED, /* 73 */ + XML_ERR_LTSLASH_REQUIRED, /* 74 */ + XML_ERR_EQUAL_REQUIRED, /* 75 */ + XML_ERR_TAG_NAME_MISMATCH, /* 76 */ + XML_ERR_TAG_NOT_FINISHED, /* 77 */ + XML_ERR_STANDALONE_VALUE, /* 78 */ + XML_ERR_ENCODING_NAME, /* 79 */ + XML_ERR_HYPHEN_IN_COMMENT, /* 80 */ + XML_ERR_INVALID_ENCODING, /* 81 */ + XML_ERR_EXT_ENTITY_STANDALONE, /* 82 */ + XML_ERR_CONDSEC_INVALID, /* 83 */ + XML_ERR_VALUE_REQUIRED, /* 84 */ + XML_ERR_NOT_WELL_BALANCED, /* 85 */ + XML_ERR_EXTRA_CONTENT, /* 86 */ + XML_ERR_ENTITY_CHAR_ERROR, /* 87 */ + XML_ERR_ENTITY_PE_INTERNAL, /* 88 */ + XML_ERR_ENTITY_LOOP, /* 89 */ + XML_ERR_ENTITY_BOUNDARY, /* 90 */ + XML_ERR_INVALID_URI, /* 91 */ + XML_ERR_URI_FRAGMENT, /* 92 */ + XML_WAR_CATALOG_PI, /* 93 */ + XML_ERR_NO_DTD, /* 94 */ + XML_ERR_CONDSEC_INVALID_KEYWORD, /* 95 */ + XML_ERR_VERSION_MISSING, /* 96 */ + XML_WAR_UNKNOWN_VERSION, /* 97 */ + XML_WAR_LANG_VALUE, /* 98 */ + XML_WAR_NS_URI, /* 99 */ + XML_WAR_NS_URI_RELATIVE, /* 100 */ + XML_ERR_MISSING_ENCODING, /* 101 */ + XML_WAR_SPACE_VALUE, /* 102 */ + XML_ERR_NOT_STANDALONE, /* 103 */ + XML_ERR_ENTITY_PROCESSING, /* 104 */ + XML_ERR_NOTATION_PROCESSING, /* 105 */ + XML_WAR_NS_COLUMN, /* 106 */ + XML_WAR_ENTITY_REDEFINED, /* 107 */ + XML_ERR_UNKNOWN_VERSION, /* 108 */ + XML_ERR_VERSION_MISMATCH, /* 109 */ + XML_NS_ERR_XML_NAMESPACE = 200, + XML_NS_ERR_UNDEFINED_NAMESPACE, /* 201 */ + XML_NS_ERR_QNAME, /* 202 */ + XML_NS_ERR_ATTRIBUTE_REDEFINED, /* 203 */ + XML_NS_ERR_EMPTY, /* 204 */ + XML_NS_ERR_COLON, /* 205 */ + XML_DTD_ATTRIBUTE_DEFAULT = 500, + XML_DTD_ATTRIBUTE_REDEFINED, /* 501 */ + XML_DTD_ATTRIBUTE_VALUE, /* 502 */ + XML_DTD_CONTENT_ERROR, /* 503 */ + XML_DTD_CONTENT_MODEL, /* 504 */ + XML_DTD_CONTENT_NOT_DETERMINIST, /* 505 */ + XML_DTD_DIFFERENT_PREFIX, /* 506 */ + XML_DTD_ELEM_DEFAULT_NAMESPACE, /* 507 */ + XML_DTD_ELEM_NAMESPACE, /* 508 */ + XML_DTD_ELEM_REDEFINED, /* 509 */ + XML_DTD_EMPTY_NOTATION, /* 510 */ + XML_DTD_ENTITY_TYPE, /* 511 */ + XML_DTD_ID_FIXED, /* 512 */ + XML_DTD_ID_REDEFINED, /* 513 */ + XML_DTD_ID_SUBSET, /* 514 */ + XML_DTD_INVALID_CHILD, /* 515 */ + XML_DTD_INVALID_DEFAULT, /* 516 */ + XML_DTD_LOAD_ERROR, /* 517 */ + XML_DTD_MISSING_ATTRIBUTE, /* 518 */ + XML_DTD_MIXED_CORRUPT, /* 519 */ + XML_DTD_MULTIPLE_ID, /* 520 */ + XML_DTD_NO_DOC, /* 521 */ + XML_DTD_NO_DTD, /* 522 */ + XML_DTD_NO_ELEM_NAME, /* 523 */ + XML_DTD_NO_PREFIX, /* 524 */ + XML_DTD_NO_ROOT, /* 525 */ + XML_DTD_NOTATION_REDEFINED, /* 526 */ + XML_DTD_NOTATION_VALUE, /* 527 */ + XML_DTD_NOT_EMPTY, /* 528 */ + XML_DTD_NOT_PCDATA, /* 529 */ + XML_DTD_NOT_STANDALONE, /* 530 */ + XML_DTD_ROOT_NAME, /* 531 */ + XML_DTD_STANDALONE_WHITE_SPACE, /* 532 */ + XML_DTD_UNKNOWN_ATTRIBUTE, /* 533 */ + XML_DTD_UNKNOWN_ELEM, /* 534 */ + XML_DTD_UNKNOWN_ENTITY, /* 535 */ + XML_DTD_UNKNOWN_ID, /* 536 */ + XML_DTD_UNKNOWN_NOTATION, /* 537 */ + XML_DTD_STANDALONE_DEFAULTED, /* 538 */ + XML_DTD_XMLID_VALUE, /* 539 */ + XML_DTD_XMLID_TYPE, /* 540 */ + XML_DTD_DUP_TOKEN, /* 541 */ + XML_HTML_STRUCURE_ERROR = 800, + XML_HTML_UNKNOWN_TAG, /* 801 */ + XML_RNGP_ANYNAME_ATTR_ANCESTOR = 1000, + XML_RNGP_ATTR_CONFLICT, /* 1001 */ + XML_RNGP_ATTRIBUTE_CHILDREN, /* 1002 */ + XML_RNGP_ATTRIBUTE_CONTENT, /* 1003 */ + XML_RNGP_ATTRIBUTE_EMPTY, /* 1004 */ + XML_RNGP_ATTRIBUTE_NOOP, /* 1005 */ + XML_RNGP_CHOICE_CONTENT, /* 1006 */ + XML_RNGP_CHOICE_EMPTY, /* 1007 */ + XML_RNGP_CREATE_FAILURE, /* 1008 */ + XML_RNGP_DATA_CONTENT, /* 1009 */ + XML_RNGP_DEF_CHOICE_AND_INTERLEAVE, /* 1010 */ + XML_RNGP_DEFINE_CREATE_FAILED, /* 1011 */ + XML_RNGP_DEFINE_EMPTY, /* 1012 */ + XML_RNGP_DEFINE_MISSING, /* 1013 */ + XML_RNGP_DEFINE_NAME_MISSING, /* 1014 */ + XML_RNGP_ELEM_CONTENT_EMPTY, /* 1015 */ + XML_RNGP_ELEM_CONTENT_ERROR, /* 1016 */ + XML_RNGP_ELEMENT_EMPTY, /* 1017 */ + XML_RNGP_ELEMENT_CONTENT, /* 1018 */ + XML_RNGP_ELEMENT_NAME, /* 1019 */ + XML_RNGP_ELEMENT_NO_CONTENT, /* 1020 */ + XML_RNGP_ELEM_TEXT_CONFLICT, /* 1021 */ + XML_RNGP_EMPTY, /* 1022 */ + XML_RNGP_EMPTY_CONSTRUCT, /* 1023 */ + XML_RNGP_EMPTY_CONTENT, /* 1024 */ + XML_RNGP_EMPTY_NOT_EMPTY, /* 1025 */ + XML_RNGP_ERROR_TYPE_LIB, /* 1026 */ + XML_RNGP_EXCEPT_EMPTY, /* 1027 */ + XML_RNGP_EXCEPT_MISSING, /* 1028 */ + XML_RNGP_EXCEPT_MULTIPLE, /* 1029 */ + XML_RNGP_EXCEPT_NO_CONTENT, /* 1030 */ + XML_RNGP_EXTERNALREF_EMTPY, /* 1031 */ + XML_RNGP_EXTERNAL_REF_FAILURE, /* 1032 */ + XML_RNGP_EXTERNALREF_RECURSE, /* 1033 */ + XML_RNGP_FORBIDDEN_ATTRIBUTE, /* 1034 */ + XML_RNGP_FOREIGN_ELEMENT, /* 1035 */ + XML_RNGP_GRAMMAR_CONTENT, /* 1036 */ + XML_RNGP_GRAMMAR_EMPTY, /* 1037 */ + XML_RNGP_GRAMMAR_MISSING, /* 1038 */ + XML_RNGP_GRAMMAR_NO_START, /* 1039 */ + XML_RNGP_GROUP_ATTR_CONFLICT, /* 1040 */ + XML_RNGP_HREF_ERROR, /* 1041 */ + XML_RNGP_INCLUDE_EMPTY, /* 1042 */ + XML_RNGP_INCLUDE_FAILURE, /* 1043 */ + XML_RNGP_INCLUDE_RECURSE, /* 1044 */ + XML_RNGP_INTERLEAVE_ADD, /* 1045 */ + XML_RNGP_INTERLEAVE_CREATE_FAILED, /* 1046 */ + XML_RNGP_INTERLEAVE_EMPTY, /* 1047 */ + XML_RNGP_INTERLEAVE_NO_CONTENT, /* 1048 */ + XML_RNGP_INVALID_DEFINE_NAME, /* 1049 */ + XML_RNGP_INVALID_URI, /* 1050 */ + XML_RNGP_INVALID_VALUE, /* 1051 */ + XML_RNGP_MISSING_HREF, /* 1052 */ + XML_RNGP_NAME_MISSING, /* 1053 */ + XML_RNGP_NEED_COMBINE, /* 1054 */ + XML_RNGP_NOTALLOWED_NOT_EMPTY, /* 1055 */ + XML_RNGP_NSNAME_ATTR_ANCESTOR, /* 1056 */ + XML_RNGP_NSNAME_NO_NS, /* 1057 */ + XML_RNGP_PARAM_FORBIDDEN, /* 1058 */ + XML_RNGP_PARAM_NAME_MISSING, /* 1059 */ + XML_RNGP_PARENTREF_CREATE_FAILED, /* 1060 */ + XML_RNGP_PARENTREF_NAME_INVALID, /* 1061 */ + XML_RNGP_PARENTREF_NO_NAME, /* 1062 */ + XML_RNGP_PARENTREF_NO_PARENT, /* 1063 */ + XML_RNGP_PARENTREF_NOT_EMPTY, /* 1064 */ + XML_RNGP_PARSE_ERROR, /* 1065 */ + XML_RNGP_PAT_ANYNAME_EXCEPT_ANYNAME, /* 1066 */ + XML_RNGP_PAT_ATTR_ATTR, /* 1067 */ + XML_RNGP_PAT_ATTR_ELEM, /* 1068 */ + XML_RNGP_PAT_DATA_EXCEPT_ATTR, /* 1069 */ + XML_RNGP_PAT_DATA_EXCEPT_ELEM, /* 1070 */ + XML_RNGP_PAT_DATA_EXCEPT_EMPTY, /* 1071 */ + XML_RNGP_PAT_DATA_EXCEPT_GROUP, /* 1072 */ + XML_RNGP_PAT_DATA_EXCEPT_INTERLEAVE, /* 1073 */ + XML_RNGP_PAT_DATA_EXCEPT_LIST, /* 1074 */ + XML_RNGP_PAT_DATA_EXCEPT_ONEMORE, /* 1075 */ + XML_RNGP_PAT_DATA_EXCEPT_REF, /* 1076 */ + XML_RNGP_PAT_DATA_EXCEPT_TEXT, /* 1077 */ + XML_RNGP_PAT_LIST_ATTR, /* 1078 */ + XML_RNGP_PAT_LIST_ELEM, /* 1079 */ + XML_RNGP_PAT_LIST_INTERLEAVE, /* 1080 */ + XML_RNGP_PAT_LIST_LIST, /* 1081 */ + XML_RNGP_PAT_LIST_REF, /* 1082 */ + XML_RNGP_PAT_LIST_TEXT, /* 1083 */ + XML_RNGP_PAT_NSNAME_EXCEPT_ANYNAME, /* 1084 */ + XML_RNGP_PAT_NSNAME_EXCEPT_NSNAME, /* 1085 */ + XML_RNGP_PAT_ONEMORE_GROUP_ATTR, /* 1086 */ + XML_RNGP_PAT_ONEMORE_INTERLEAVE_ATTR, /* 1087 */ + XML_RNGP_PAT_START_ATTR, /* 1088 */ + XML_RNGP_PAT_START_DATA, /* 1089 */ + XML_RNGP_PAT_START_EMPTY, /* 1090 */ + XML_RNGP_PAT_START_GROUP, /* 1091 */ + XML_RNGP_PAT_START_INTERLEAVE, /* 1092 */ + XML_RNGP_PAT_START_LIST, /* 1093 */ + XML_RNGP_PAT_START_ONEMORE, /* 1094 */ + XML_RNGP_PAT_START_TEXT, /* 1095 */ + XML_RNGP_PAT_START_VALUE, /* 1096 */ + XML_RNGP_PREFIX_UNDEFINED, /* 1097 */ + XML_RNGP_REF_CREATE_FAILED, /* 1098 */ + XML_RNGP_REF_CYCLE, /* 1099 */ + XML_RNGP_REF_NAME_INVALID, /* 1100 */ + XML_RNGP_REF_NO_DEF, /* 1101 */ + XML_RNGP_REF_NO_NAME, /* 1102 */ + XML_RNGP_REF_NOT_EMPTY, /* 1103 */ + XML_RNGP_START_CHOICE_AND_INTERLEAVE, /* 1104 */ + XML_RNGP_START_CONTENT, /* 1105 */ + XML_RNGP_START_EMPTY, /* 1106 */ + XML_RNGP_START_MISSING, /* 1107 */ + XML_RNGP_TEXT_EXPECTED, /* 1108 */ + XML_RNGP_TEXT_HAS_CHILD, /* 1109 */ + XML_RNGP_TYPE_MISSING, /* 1110 */ + XML_RNGP_TYPE_NOT_FOUND, /* 1111 */ + XML_RNGP_TYPE_VALUE, /* 1112 */ + XML_RNGP_UNKNOWN_ATTRIBUTE, /* 1113 */ + XML_RNGP_UNKNOWN_COMBINE, /* 1114 */ + XML_RNGP_UNKNOWN_CONSTRUCT, /* 1115 */ + XML_RNGP_UNKNOWN_TYPE_LIB, /* 1116 */ + XML_RNGP_URI_FRAGMENT, /* 1117 */ + XML_RNGP_URI_NOT_ABSOLUTE, /* 1118 */ + XML_RNGP_VALUE_EMPTY, /* 1119 */ + XML_RNGP_VALUE_NO_CONTENT, /* 1120 */ + XML_RNGP_XMLNS_NAME, /* 1121 */ + XML_RNGP_XML_NS, /* 1122 */ + XML_XPATH_EXPRESSION_OK = 1200, + XML_XPATH_NUMBER_ERROR, /* 1201 */ + XML_XPATH_UNFINISHED_LITERAL_ERROR, /* 1202 */ + XML_XPATH_START_LITERAL_ERROR, /* 1203 */ + XML_XPATH_VARIABLE_REF_ERROR, /* 1204 */ + XML_XPATH_UNDEF_VARIABLE_ERROR, /* 1205 */ + XML_XPATH_INVALID_PREDICATE_ERROR, /* 1206 */ + XML_XPATH_EXPR_ERROR, /* 1207 */ + XML_XPATH_UNCLOSED_ERROR, /* 1208 */ + XML_XPATH_UNKNOWN_FUNC_ERROR, /* 1209 */ + XML_XPATH_INVALID_OPERAND, /* 1210 */ + XML_XPATH_INVALID_TYPE, /* 1211 */ + XML_XPATH_INVALID_ARITY, /* 1212 */ + XML_XPATH_INVALID_CTXT_SIZE, /* 1213 */ + XML_XPATH_INVALID_CTXT_POSITION, /* 1214 */ + XML_XPATH_MEMORY_ERROR, /* 1215 */ + XML_XPTR_SYNTAX_ERROR, /* 1216 */ + XML_XPTR_RESOURCE_ERROR, /* 1217 */ + XML_XPTR_SUB_RESOURCE_ERROR, /* 1218 */ + XML_XPATH_UNDEF_PREFIX_ERROR, /* 1219 */ + XML_XPATH_ENCODING_ERROR, /* 1220 */ + XML_XPATH_INVALID_CHAR_ERROR, /* 1221 */ + XML_TREE_INVALID_HEX = 1300, + XML_TREE_INVALID_DEC, /* 1301 */ + XML_TREE_UNTERMINATED_ENTITY, /* 1302 */ + XML_TREE_NOT_UTF8, /* 1303 */ + XML_SAVE_NOT_UTF8 = 1400, + XML_SAVE_CHAR_INVALID, /* 1401 */ + XML_SAVE_NO_DOCTYPE, /* 1402 */ + XML_SAVE_UNKNOWN_ENCODING, /* 1403 */ + XML_REGEXP_COMPILE_ERROR = 1450, + XML_IO_UNKNOWN = 1500, + XML_IO_EACCES, /* 1501 */ + XML_IO_EAGAIN, /* 1502 */ + XML_IO_EBADF, /* 1503 */ + XML_IO_EBADMSG, /* 1504 */ + XML_IO_EBUSY, /* 1505 */ + XML_IO_ECANCELED, /* 1506 */ + XML_IO_ECHILD, /* 1507 */ + XML_IO_EDEADLK, /* 1508 */ + XML_IO_EDOM, /* 1509 */ + XML_IO_EEXIST, /* 1510 */ + XML_IO_EFAULT, /* 1511 */ + XML_IO_EFBIG, /* 1512 */ + XML_IO_EINPROGRESS, /* 1513 */ + XML_IO_EINTR, /* 1514 */ + XML_IO_EINVAL, /* 1515 */ + XML_IO_EIO, /* 1516 */ + XML_IO_EISDIR, /* 1517 */ + XML_IO_EMFILE, /* 1518 */ + XML_IO_EMLINK, /* 1519 */ + XML_IO_EMSGSIZE, /* 1520 */ + XML_IO_ENAMETOOLONG, /* 1521 */ + XML_IO_ENFILE, /* 1522 */ + XML_IO_ENODEV, /* 1523 */ + XML_IO_ENOENT, /* 1524 */ + XML_IO_ENOEXEC, /* 1525 */ + XML_IO_ENOLCK, /* 1526 */ + XML_IO_ENOMEM, /* 1527 */ + XML_IO_ENOSPC, /* 1528 */ + XML_IO_ENOSYS, /* 1529 */ + XML_IO_ENOTDIR, /* 1530 */ + XML_IO_ENOTEMPTY, /* 1531 */ + XML_IO_ENOTSUP, /* 1532 */ + XML_IO_ENOTTY, /* 1533 */ + XML_IO_ENXIO, /* 1534 */ + XML_IO_EPERM, /* 1535 */ + XML_IO_EPIPE, /* 1536 */ + XML_IO_ERANGE, /* 1537 */ + XML_IO_EROFS, /* 1538 */ + XML_IO_ESPIPE, /* 1539 */ + XML_IO_ESRCH, /* 1540 */ + XML_IO_ETIMEDOUT, /* 1541 */ + XML_IO_EXDEV, /* 1542 */ + XML_IO_NETWORK_ATTEMPT, /* 1543 */ + XML_IO_ENCODER, /* 1544 */ + XML_IO_FLUSH, /* 1545 */ + XML_IO_WRITE, /* 1546 */ + XML_IO_NO_INPUT, /* 1547 */ + XML_IO_BUFFER_FULL, /* 1548 */ + XML_IO_LOAD_ERROR, /* 1549 */ + XML_IO_ENOTSOCK, /* 1550 */ + XML_IO_EISCONN, /* 1551 */ + XML_IO_ECONNREFUSED, /* 1552 */ + XML_IO_ENETUNREACH, /* 1553 */ + XML_IO_EADDRINUSE, /* 1554 */ + XML_IO_EALREADY, /* 1555 */ + XML_IO_EAFNOSUPPORT, /* 1556 */ + XML_XINCLUDE_RECURSION=1600, + XML_XINCLUDE_PARSE_VALUE, /* 1601 */ + XML_XINCLUDE_ENTITY_DEF_MISMATCH, /* 1602 */ + XML_XINCLUDE_NO_HREF, /* 1603 */ + XML_XINCLUDE_NO_FALLBACK, /* 1604 */ + XML_XINCLUDE_HREF_URI, /* 1605 */ + XML_XINCLUDE_TEXT_FRAGMENT, /* 1606 */ + XML_XINCLUDE_TEXT_DOCUMENT, /* 1607 */ + XML_XINCLUDE_INVALID_CHAR, /* 1608 */ + XML_XINCLUDE_BUILD_FAILED, /* 1609 */ + XML_XINCLUDE_UNKNOWN_ENCODING, /* 1610 */ + XML_XINCLUDE_MULTIPLE_ROOT, /* 1611 */ + XML_XINCLUDE_XPTR_FAILED, /* 1612 */ + XML_XINCLUDE_XPTR_RESULT, /* 1613 */ + XML_XINCLUDE_INCLUDE_IN_INCLUDE, /* 1614 */ + XML_XINCLUDE_FALLBACKS_IN_INCLUDE, /* 1615 */ + XML_XINCLUDE_FALLBACK_NOT_IN_INCLUDE, /* 1616 */ + XML_XINCLUDE_DEPRECATED_NS, /* 1617 */ + XML_XINCLUDE_FRAGMENT_ID, /* 1618 */ + XML_CATALOG_MISSING_ATTR = 1650, + XML_CATALOG_ENTRY_BROKEN, /* 1651 */ + XML_CATALOG_PREFER_VALUE, /* 1652 */ + XML_CATALOG_NOT_CATALOG, /* 1653 */ + XML_CATALOG_RECURSION, /* 1654 */ + XML_SCHEMAP_PREFIX_UNDEFINED = 1700, + XML_SCHEMAP_ATTRFORMDEFAULT_VALUE, /* 1701 */ + XML_SCHEMAP_ATTRGRP_NONAME_NOREF, /* 1702 */ + XML_SCHEMAP_ATTR_NONAME_NOREF, /* 1703 */ + XML_SCHEMAP_COMPLEXTYPE_NONAME_NOREF, /* 1704 */ + XML_SCHEMAP_ELEMFORMDEFAULT_VALUE, /* 1705 */ + XML_SCHEMAP_ELEM_NONAME_NOREF, /* 1706 */ + XML_SCHEMAP_EXTENSION_NO_BASE, /* 1707 */ + XML_SCHEMAP_FACET_NO_VALUE, /* 1708 */ + XML_SCHEMAP_FAILED_BUILD_IMPORT, /* 1709 */ + XML_SCHEMAP_GROUP_NONAME_NOREF, /* 1710 */ + XML_SCHEMAP_IMPORT_NAMESPACE_NOT_URI, /* 1711 */ + XML_SCHEMAP_IMPORT_REDEFINE_NSNAME, /* 1712 */ + XML_SCHEMAP_IMPORT_SCHEMA_NOT_URI, /* 1713 */ + XML_SCHEMAP_INVALID_BOOLEAN, /* 1714 */ + XML_SCHEMAP_INVALID_ENUM, /* 1715 */ + XML_SCHEMAP_INVALID_FACET, /* 1716 */ + XML_SCHEMAP_INVALID_FACET_VALUE, /* 1717 */ + XML_SCHEMAP_INVALID_MAXOCCURS, /* 1718 */ + XML_SCHEMAP_INVALID_MINOCCURS, /* 1719 */ + XML_SCHEMAP_INVALID_REF_AND_SUBTYPE, /* 1720 */ + XML_SCHEMAP_INVALID_WHITE_SPACE, /* 1721 */ + XML_SCHEMAP_NOATTR_NOREF, /* 1722 */ + XML_SCHEMAP_NOTATION_NO_NAME, /* 1723 */ + XML_SCHEMAP_NOTYPE_NOREF, /* 1724 */ + XML_SCHEMAP_REF_AND_SUBTYPE, /* 1725 */ + XML_SCHEMAP_RESTRICTION_NONAME_NOREF, /* 1726 */ + XML_SCHEMAP_SIMPLETYPE_NONAME, /* 1727 */ + XML_SCHEMAP_TYPE_AND_SUBTYPE, /* 1728 */ + XML_SCHEMAP_UNKNOWN_ALL_CHILD, /* 1729 */ + XML_SCHEMAP_UNKNOWN_ANYATTRIBUTE_CHILD, /* 1730 */ + XML_SCHEMAP_UNKNOWN_ATTR_CHILD, /* 1731 */ + XML_SCHEMAP_UNKNOWN_ATTRGRP_CHILD, /* 1732 */ + XML_SCHEMAP_UNKNOWN_ATTRIBUTE_GROUP, /* 1733 */ + XML_SCHEMAP_UNKNOWN_BASE_TYPE, /* 1734 */ + XML_SCHEMAP_UNKNOWN_CHOICE_CHILD, /* 1735 */ + XML_SCHEMAP_UNKNOWN_COMPLEXCONTENT_CHILD, /* 1736 */ + XML_SCHEMAP_UNKNOWN_COMPLEXTYPE_CHILD, /* 1737 */ + XML_SCHEMAP_UNKNOWN_ELEM_CHILD, /* 1738 */ + XML_SCHEMAP_UNKNOWN_EXTENSION_CHILD, /* 1739 */ + XML_SCHEMAP_UNKNOWN_FACET_CHILD, /* 1740 */ + XML_SCHEMAP_UNKNOWN_FACET_TYPE, /* 1741 */ + XML_SCHEMAP_UNKNOWN_GROUP_CHILD, /* 1742 */ + XML_SCHEMAP_UNKNOWN_IMPORT_CHILD, /* 1743 */ + XML_SCHEMAP_UNKNOWN_LIST_CHILD, /* 1744 */ + XML_SCHEMAP_UNKNOWN_NOTATION_CHILD, /* 1745 */ + XML_SCHEMAP_UNKNOWN_PROCESSCONTENT_CHILD, /* 1746 */ + XML_SCHEMAP_UNKNOWN_REF, /* 1747 */ + XML_SCHEMAP_UNKNOWN_RESTRICTION_CHILD, /* 1748 */ + XML_SCHEMAP_UNKNOWN_SCHEMAS_CHILD, /* 1749 */ + XML_SCHEMAP_UNKNOWN_SEQUENCE_CHILD, /* 1750 */ + XML_SCHEMAP_UNKNOWN_SIMPLECONTENT_CHILD, /* 1751 */ + XML_SCHEMAP_UNKNOWN_SIMPLETYPE_CHILD, /* 1752 */ + XML_SCHEMAP_UNKNOWN_TYPE, /* 1753 */ + XML_SCHEMAP_UNKNOWN_UNION_CHILD, /* 1754 */ + XML_SCHEMAP_ELEM_DEFAULT_FIXED, /* 1755 */ + XML_SCHEMAP_REGEXP_INVALID, /* 1756 */ + XML_SCHEMAP_FAILED_LOAD, /* 1757 */ + XML_SCHEMAP_NOTHING_TO_PARSE, /* 1758 */ + XML_SCHEMAP_NOROOT, /* 1759 */ + XML_SCHEMAP_REDEFINED_GROUP, /* 1760 */ + XML_SCHEMAP_REDEFINED_TYPE, /* 1761 */ + XML_SCHEMAP_REDEFINED_ELEMENT, /* 1762 */ + XML_SCHEMAP_REDEFINED_ATTRGROUP, /* 1763 */ + XML_SCHEMAP_REDEFINED_ATTR, /* 1764 */ + XML_SCHEMAP_REDEFINED_NOTATION, /* 1765 */ + XML_SCHEMAP_FAILED_PARSE, /* 1766 */ + XML_SCHEMAP_UNKNOWN_PREFIX, /* 1767 */ + XML_SCHEMAP_DEF_AND_PREFIX, /* 1768 */ + XML_SCHEMAP_UNKNOWN_INCLUDE_CHILD, /* 1769 */ + XML_SCHEMAP_INCLUDE_SCHEMA_NOT_URI, /* 1770 */ + XML_SCHEMAP_INCLUDE_SCHEMA_NO_URI, /* 1771 */ + XML_SCHEMAP_NOT_SCHEMA, /* 1772 */ + XML_SCHEMAP_UNKNOWN_MEMBER_TYPE, /* 1773 */ + XML_SCHEMAP_INVALID_ATTR_USE, /* 1774 */ + XML_SCHEMAP_RECURSIVE, /* 1775 */ + XML_SCHEMAP_SUPERNUMEROUS_LIST_ITEM_TYPE, /* 1776 */ + XML_SCHEMAP_INVALID_ATTR_COMBINATION, /* 1777 */ + XML_SCHEMAP_INVALID_ATTR_INLINE_COMBINATION, /* 1778 */ + XML_SCHEMAP_MISSING_SIMPLETYPE_CHILD, /* 1779 */ + XML_SCHEMAP_INVALID_ATTR_NAME, /* 1780 */ + XML_SCHEMAP_REF_AND_CONTENT, /* 1781 */ + XML_SCHEMAP_CT_PROPS_CORRECT_1, /* 1782 */ + XML_SCHEMAP_CT_PROPS_CORRECT_2, /* 1783 */ + XML_SCHEMAP_CT_PROPS_CORRECT_3, /* 1784 */ + XML_SCHEMAP_CT_PROPS_CORRECT_4, /* 1785 */ + XML_SCHEMAP_CT_PROPS_CORRECT_5, /* 1786 */ + XML_SCHEMAP_DERIVATION_OK_RESTRICTION_1, /* 1787 */ + XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_1, /* 1788 */ + XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_2, /* 1789 */ + XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_2, /* 1790 */ + XML_SCHEMAP_DERIVATION_OK_RESTRICTION_3, /* 1791 */ + XML_SCHEMAP_WILDCARD_INVALID_NS_MEMBER, /* 1792 */ + XML_SCHEMAP_INTERSECTION_NOT_EXPRESSIBLE, /* 1793 */ + XML_SCHEMAP_UNION_NOT_EXPRESSIBLE, /* 1794 */ + XML_SCHEMAP_SRC_IMPORT_3_1, /* 1795 */ + XML_SCHEMAP_SRC_IMPORT_3_2, /* 1796 */ + XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_1, /* 1797 */ + XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_2, /* 1798 */ + XML_SCHEMAP_DERIVATION_OK_RESTRICTION_4_3, /* 1799 */ + XML_SCHEMAP_COS_CT_EXTENDS_1_3, /* 1800 */ + XML_SCHEMAV_NOROOT = 1801, + XML_SCHEMAV_UNDECLAREDELEM, /* 1802 */ + XML_SCHEMAV_NOTTOPLEVEL, /* 1803 */ + XML_SCHEMAV_MISSING, /* 1804 */ + XML_SCHEMAV_WRONGELEM, /* 1805 */ + XML_SCHEMAV_NOTYPE, /* 1806 */ + XML_SCHEMAV_NOROLLBACK, /* 1807 */ + XML_SCHEMAV_ISABSTRACT, /* 1808 */ + XML_SCHEMAV_NOTEMPTY, /* 1809 */ + XML_SCHEMAV_ELEMCONT, /* 1810 */ + XML_SCHEMAV_HAVEDEFAULT, /* 1811 */ + XML_SCHEMAV_NOTNILLABLE, /* 1812 */ + XML_SCHEMAV_EXTRACONTENT, /* 1813 */ + XML_SCHEMAV_INVALIDATTR, /* 1814 */ + XML_SCHEMAV_INVALIDELEM, /* 1815 */ + XML_SCHEMAV_NOTDETERMINIST, /* 1816 */ + XML_SCHEMAV_CONSTRUCT, /* 1817 */ + XML_SCHEMAV_INTERNAL, /* 1818 */ + XML_SCHEMAV_NOTSIMPLE, /* 1819 */ + XML_SCHEMAV_ATTRUNKNOWN, /* 1820 */ + XML_SCHEMAV_ATTRINVALID, /* 1821 */ + XML_SCHEMAV_VALUE, /* 1822 */ + XML_SCHEMAV_FACET, /* 1823 */ + XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_1, /* 1824 */ + XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_2, /* 1825 */ + XML_SCHEMAV_CVC_DATATYPE_VALID_1_2_3, /* 1826 */ + XML_SCHEMAV_CVC_TYPE_3_1_1, /* 1827 */ + XML_SCHEMAV_CVC_TYPE_3_1_2, /* 1828 */ + XML_SCHEMAV_CVC_FACET_VALID, /* 1829 */ + XML_SCHEMAV_CVC_LENGTH_VALID, /* 1830 */ + XML_SCHEMAV_CVC_MINLENGTH_VALID, /* 1831 */ + XML_SCHEMAV_CVC_MAXLENGTH_VALID, /* 1832 */ + XML_SCHEMAV_CVC_MININCLUSIVE_VALID, /* 1833 */ + XML_SCHEMAV_CVC_MAXINCLUSIVE_VALID, /* 1834 */ + XML_SCHEMAV_CVC_MINEXCLUSIVE_VALID, /* 1835 */ + XML_SCHEMAV_CVC_MAXEXCLUSIVE_VALID, /* 1836 */ + XML_SCHEMAV_CVC_TOTALDIGITS_VALID, /* 1837 */ + XML_SCHEMAV_CVC_FRACTIONDIGITS_VALID, /* 1838 */ + XML_SCHEMAV_CVC_PATTERN_VALID, /* 1839 */ + XML_SCHEMAV_CVC_ENUMERATION_VALID, /* 1840 */ + XML_SCHEMAV_CVC_COMPLEX_TYPE_2_1, /* 1841 */ + XML_SCHEMAV_CVC_COMPLEX_TYPE_2_2, /* 1842 */ + XML_SCHEMAV_CVC_COMPLEX_TYPE_2_3, /* 1843 */ + XML_SCHEMAV_CVC_COMPLEX_TYPE_2_4, /* 1844 */ + XML_SCHEMAV_CVC_ELT_1, /* 1845 */ + XML_SCHEMAV_CVC_ELT_2, /* 1846 */ + XML_SCHEMAV_CVC_ELT_3_1, /* 1847 */ + XML_SCHEMAV_CVC_ELT_3_2_1, /* 1848 */ + XML_SCHEMAV_CVC_ELT_3_2_2, /* 1849 */ + XML_SCHEMAV_CVC_ELT_4_1, /* 1850 */ + XML_SCHEMAV_CVC_ELT_4_2, /* 1851 */ + XML_SCHEMAV_CVC_ELT_4_3, /* 1852 */ + XML_SCHEMAV_CVC_ELT_5_1_1, /* 1853 */ + XML_SCHEMAV_CVC_ELT_5_1_2, /* 1854 */ + XML_SCHEMAV_CVC_ELT_5_2_1, /* 1855 */ + XML_SCHEMAV_CVC_ELT_5_2_2_1, /* 1856 */ + XML_SCHEMAV_CVC_ELT_5_2_2_2_1, /* 1857 */ + XML_SCHEMAV_CVC_ELT_5_2_2_2_2, /* 1858 */ + XML_SCHEMAV_CVC_ELT_6, /* 1859 */ + XML_SCHEMAV_CVC_ELT_7, /* 1860 */ + XML_SCHEMAV_CVC_ATTRIBUTE_1, /* 1861 */ + XML_SCHEMAV_CVC_ATTRIBUTE_2, /* 1862 */ + XML_SCHEMAV_CVC_ATTRIBUTE_3, /* 1863 */ + XML_SCHEMAV_CVC_ATTRIBUTE_4, /* 1864 */ + XML_SCHEMAV_CVC_COMPLEX_TYPE_3_1, /* 1865 */ + XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_1, /* 1866 */ + XML_SCHEMAV_CVC_COMPLEX_TYPE_3_2_2, /* 1867 */ + XML_SCHEMAV_CVC_COMPLEX_TYPE_4, /* 1868 */ + XML_SCHEMAV_CVC_COMPLEX_TYPE_5_1, /* 1869 */ + XML_SCHEMAV_CVC_COMPLEX_TYPE_5_2, /* 1870 */ + XML_SCHEMAV_ELEMENT_CONTENT, /* 1871 */ + XML_SCHEMAV_DOCUMENT_ELEMENT_MISSING, /* 1872 */ + XML_SCHEMAV_CVC_COMPLEX_TYPE_1, /* 1873 */ + XML_SCHEMAV_CVC_AU, /* 1874 */ + XML_SCHEMAV_CVC_TYPE_1, /* 1875 */ + XML_SCHEMAV_CVC_TYPE_2, /* 1876 */ + XML_SCHEMAV_CVC_IDC, /* 1877 */ + XML_SCHEMAV_CVC_WILDCARD, /* 1878 */ + XML_SCHEMAV_MISC, /* 1879 */ + XML_XPTR_UNKNOWN_SCHEME = 1900, + XML_XPTR_CHILDSEQ_START, /* 1901 */ + XML_XPTR_EVAL_FAILED, /* 1902 */ + XML_XPTR_EXTRA_OBJECTS, /* 1903 */ + XML_C14N_CREATE_CTXT = 1950, + XML_C14N_REQUIRES_UTF8, /* 1951 */ + XML_C14N_CREATE_STACK, /* 1952 */ + XML_C14N_INVALID_NODE, /* 1953 */ + XML_C14N_UNKNOW_NODE, /* 1954 */ + XML_C14N_RELATIVE_NAMESPACE, /* 1955 */ + XML_FTP_PASV_ANSWER = 2000, + XML_FTP_EPSV_ANSWER, /* 2001 */ + XML_FTP_ACCNT, /* 2002 */ + XML_FTP_URL_SYNTAX, /* 2003 */ + XML_HTTP_URL_SYNTAX = 2020, + XML_HTTP_USE_IP, /* 2021 */ + XML_HTTP_UNKNOWN_HOST, /* 2022 */ + XML_SCHEMAP_SRC_SIMPLE_TYPE_1 = 3000, + XML_SCHEMAP_SRC_SIMPLE_TYPE_2, /* 3001 */ + XML_SCHEMAP_SRC_SIMPLE_TYPE_3, /* 3002 */ + XML_SCHEMAP_SRC_SIMPLE_TYPE_4, /* 3003 */ + XML_SCHEMAP_SRC_RESOLVE, /* 3004 */ + XML_SCHEMAP_SRC_RESTRICTION_BASE_OR_SIMPLETYPE, /* 3005 */ + XML_SCHEMAP_SRC_LIST_ITEMTYPE_OR_SIMPLETYPE, /* 3006 */ + XML_SCHEMAP_SRC_UNION_MEMBERTYPES_OR_SIMPLETYPES, /* 3007 */ + XML_SCHEMAP_ST_PROPS_CORRECT_1, /* 3008 */ + XML_SCHEMAP_ST_PROPS_CORRECT_2, /* 3009 */ + XML_SCHEMAP_ST_PROPS_CORRECT_3, /* 3010 */ + XML_SCHEMAP_COS_ST_RESTRICTS_1_1, /* 3011 */ + XML_SCHEMAP_COS_ST_RESTRICTS_1_2, /* 3012 */ + XML_SCHEMAP_COS_ST_RESTRICTS_1_3_1, /* 3013 */ + XML_SCHEMAP_COS_ST_RESTRICTS_1_3_2, /* 3014 */ + XML_SCHEMAP_COS_ST_RESTRICTS_2_1, /* 3015 */ + XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_1, /* 3016 */ + XML_SCHEMAP_COS_ST_RESTRICTS_2_3_1_2, /* 3017 */ + XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_1, /* 3018 */ + XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_2, /* 3019 */ + XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_3, /* 3020 */ + XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_4, /* 3021 */ + XML_SCHEMAP_COS_ST_RESTRICTS_2_3_2_5, /* 3022 */ + XML_SCHEMAP_COS_ST_RESTRICTS_3_1, /* 3023 */ + XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1, /* 3024 */ + XML_SCHEMAP_COS_ST_RESTRICTS_3_3_1_2, /* 3025 */ + XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_2, /* 3026 */ + XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_1, /* 3027 */ + XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_3, /* 3028 */ + XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_4, /* 3029 */ + XML_SCHEMAP_COS_ST_RESTRICTS_3_3_2_5, /* 3030 */ + XML_SCHEMAP_COS_ST_DERIVED_OK_2_1, /* 3031 */ + XML_SCHEMAP_COS_ST_DERIVED_OK_2_2, /* 3032 */ + XML_SCHEMAP_S4S_ELEM_NOT_ALLOWED, /* 3033 */ + XML_SCHEMAP_S4S_ELEM_MISSING, /* 3034 */ + XML_SCHEMAP_S4S_ATTR_NOT_ALLOWED, /* 3035 */ + XML_SCHEMAP_S4S_ATTR_MISSING, /* 3036 */ + XML_SCHEMAP_S4S_ATTR_INVALID_VALUE, /* 3037 */ + XML_SCHEMAP_SRC_ELEMENT_1, /* 3038 */ + XML_SCHEMAP_SRC_ELEMENT_2_1, /* 3039 */ + XML_SCHEMAP_SRC_ELEMENT_2_2, /* 3040 */ + XML_SCHEMAP_SRC_ELEMENT_3, /* 3041 */ + XML_SCHEMAP_P_PROPS_CORRECT_1, /* 3042 */ + XML_SCHEMAP_P_PROPS_CORRECT_2_1, /* 3043 */ + XML_SCHEMAP_P_PROPS_CORRECT_2_2, /* 3044 */ + XML_SCHEMAP_E_PROPS_CORRECT_2, /* 3045 */ + XML_SCHEMAP_E_PROPS_CORRECT_3, /* 3046 */ + XML_SCHEMAP_E_PROPS_CORRECT_4, /* 3047 */ + XML_SCHEMAP_E_PROPS_CORRECT_5, /* 3048 */ + XML_SCHEMAP_E_PROPS_CORRECT_6, /* 3049 */ + XML_SCHEMAP_SRC_INCLUDE, /* 3050 */ + XML_SCHEMAP_SRC_ATTRIBUTE_1, /* 3051 */ + XML_SCHEMAP_SRC_ATTRIBUTE_2, /* 3052 */ + XML_SCHEMAP_SRC_ATTRIBUTE_3_1, /* 3053 */ + XML_SCHEMAP_SRC_ATTRIBUTE_3_2, /* 3054 */ + XML_SCHEMAP_SRC_ATTRIBUTE_4, /* 3055 */ + XML_SCHEMAP_NO_XMLNS, /* 3056 */ + XML_SCHEMAP_NO_XSI, /* 3057 */ + XML_SCHEMAP_COS_VALID_DEFAULT_1, /* 3058 */ + XML_SCHEMAP_COS_VALID_DEFAULT_2_1, /* 3059 */ + XML_SCHEMAP_COS_VALID_DEFAULT_2_2_1, /* 3060 */ + XML_SCHEMAP_COS_VALID_DEFAULT_2_2_2, /* 3061 */ + XML_SCHEMAP_CVC_SIMPLE_TYPE, /* 3062 */ + XML_SCHEMAP_COS_CT_EXTENDS_1_1, /* 3063 */ + XML_SCHEMAP_SRC_IMPORT_1_1, /* 3064 */ + XML_SCHEMAP_SRC_IMPORT_1_2, /* 3065 */ + XML_SCHEMAP_SRC_IMPORT_2, /* 3066 */ + XML_SCHEMAP_SRC_IMPORT_2_1, /* 3067 */ + XML_SCHEMAP_SRC_IMPORT_2_2, /* 3068 */ + XML_SCHEMAP_INTERNAL, /* 3069 non-W3C */ + XML_SCHEMAP_NOT_DETERMINISTIC, /* 3070 non-W3C */ + XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_1, /* 3071 */ + XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_2, /* 3072 */ + XML_SCHEMAP_SRC_ATTRIBUTE_GROUP_3, /* 3073 */ + XML_SCHEMAP_MG_PROPS_CORRECT_1, /* 3074 */ + XML_SCHEMAP_MG_PROPS_CORRECT_2, /* 3075 */ + XML_SCHEMAP_SRC_CT_1, /* 3076 */ + XML_SCHEMAP_DERIVATION_OK_RESTRICTION_2_1_3, /* 3077 */ + XML_SCHEMAP_AU_PROPS_CORRECT_2, /* 3078 */ + XML_SCHEMAP_A_PROPS_CORRECT_2, /* 3079 */ + XML_SCHEMAP_C_PROPS_CORRECT, /* 3080 */ + XML_SCHEMAP_SRC_REDEFINE, /* 3081 */ + XML_SCHEMAP_SRC_IMPORT, /* 3082 */ + XML_SCHEMAP_WARN_SKIP_SCHEMA, /* 3083 */ + XML_SCHEMAP_WARN_UNLOCATED_SCHEMA, /* 3084 */ + XML_SCHEMAP_WARN_ATTR_REDECL_PROH, /* 3085 */ + XML_SCHEMAP_WARN_ATTR_POINTLESS_PROH, /* 3085 */ + XML_SCHEMAP_AG_PROPS_CORRECT, /* 3086 */ + XML_SCHEMAP_COS_CT_EXTENDS_1_2, /* 3087 */ + XML_SCHEMAP_AU_PROPS_CORRECT, /* 3088 */ + XML_SCHEMAP_A_PROPS_CORRECT_3, /* 3089 */ + XML_SCHEMAP_COS_ALL_LIMITED, /* 3090 */ + XML_SCHEMATRONV_ASSERT = 4000, /* 4000 */ + XML_SCHEMATRONV_REPORT, + XML_MODULE_OPEN = 4900, /* 4900 */ + XML_MODULE_CLOSE, /* 4901 */ + XML_CHECK_FOUND_ELEMENT = 5000, + XML_CHECK_FOUND_ATTRIBUTE, /* 5001 */ + XML_CHECK_FOUND_TEXT, /* 5002 */ + XML_CHECK_FOUND_CDATA, /* 5003 */ + XML_CHECK_FOUND_ENTITYREF, /* 5004 */ + XML_CHECK_FOUND_ENTITY, /* 5005 */ + XML_CHECK_FOUND_PI, /* 5006 */ + XML_CHECK_FOUND_COMMENT, /* 5007 */ + XML_CHECK_FOUND_DOCTYPE, /* 5008 */ + XML_CHECK_FOUND_FRAGMENT, /* 5009 */ + XML_CHECK_FOUND_NOTATION, /* 5010 */ + XML_CHECK_UNKNOWN_NODE, /* 5011 */ + XML_CHECK_ENTITY_TYPE, /* 5012 */ + XML_CHECK_NO_PARENT, /* 5013 */ + XML_CHECK_NO_DOC, /* 5014 */ + XML_CHECK_NO_NAME, /* 5015 */ + XML_CHECK_NO_ELEM, /* 5016 */ + XML_CHECK_WRONG_DOC, /* 5017 */ + XML_CHECK_NO_PREV, /* 5018 */ + XML_CHECK_WRONG_PREV, /* 5019 */ + XML_CHECK_NO_NEXT, /* 5020 */ + XML_CHECK_WRONG_NEXT, /* 5021 */ + XML_CHECK_NOT_DTD, /* 5022 */ + XML_CHECK_NOT_ATTR, /* 5023 */ + XML_CHECK_NOT_ATTR_DECL, /* 5024 */ + XML_CHECK_NOT_ELEM_DECL, /* 5025 */ + XML_CHECK_NOT_ENTITY_DECL, /* 5026 */ + XML_CHECK_NOT_NS_DECL, /* 5027 */ + XML_CHECK_NO_HREF, /* 5028 */ + XML_CHECK_WRONG_PARENT,/* 5029 */ + XML_CHECK_NS_SCOPE, /* 5030 */ + XML_CHECK_NS_ANCESTOR, /* 5031 */ + XML_CHECK_NOT_UTF8, /* 5032 */ + XML_CHECK_NO_DICT, /* 5033 */ + XML_CHECK_NOT_NCNAME, /* 5034 */ + XML_CHECK_OUTSIDE_DICT, /* 5035 */ + XML_CHECK_WRONG_NAME, /* 5036 */ + XML_CHECK_NAME_NOT_NULL, /* 5037 */ + XML_I18N_NO_NAME = 6000, + XML_I18N_NO_HANDLER, /* 6001 */ + XML_I18N_EXCESS_HANDLER, /* 6002 */ + XML_I18N_CONV_FAILED, /* 6003 */ + XML_I18N_NO_OUTPUT /* 6004 */ +#if 0 + XML_CHECK_, /* 5033 */ + XML_CHECK_X /* 503 */ +#endif +} xmlParserErrors; + +/** + * xmlGenericErrorFunc: + * @ctx: a parsing context + * @msg: the message + * @...: the extra arguments of the varags to format the message + * + * Signature of the function to use when there is an error and + * no parsing or validity context available . + */ +typedef void (XMLCDECL *xmlGenericErrorFunc) (void *ctx, + const char *msg, + ...) LIBXML_ATTR_FORMAT(2,3); +/** + * xmlStructuredErrorFunc: + * @userData: user provided data for the error callback + * @error: the error being raised. + * + * Signature of the function to use when there is an error and + * the module handles the new error reporting mechanism. + */ +typedef void (XMLCALL *xmlStructuredErrorFunc) (void *userData, xmlErrorPtr error); + +/* + * Use the following function to reset the two global variables + * xmlGenericError and xmlGenericErrorContext. + */ +XMLPUBFUN void XMLCALL + xmlSetGenericErrorFunc (void *ctx, + xmlGenericErrorFunc handler); +XMLPUBFUN void XMLCALL + initGenericErrorDefaultFunc (xmlGenericErrorFunc *handler); + +XMLPUBFUN void XMLCALL + xmlSetStructuredErrorFunc (void *ctx, + xmlStructuredErrorFunc handler); +/* + * Default message routines used by SAX and Valid context for error + * and warning reporting. + */ +XMLPUBFUN void XMLCDECL + xmlParserError (void *ctx, + const char *msg, + ...) LIBXML_ATTR_FORMAT(2,3); +XMLPUBFUN void XMLCDECL + xmlParserWarning (void *ctx, + const char *msg, + ...) LIBXML_ATTR_FORMAT(2,3); +XMLPUBFUN void XMLCDECL + xmlParserValidityError (void *ctx, + const char *msg, + ...) LIBXML_ATTR_FORMAT(2,3); +XMLPUBFUN void XMLCDECL + xmlParserValidityWarning (void *ctx, + const char *msg, + ...) LIBXML_ATTR_FORMAT(2,3); +XMLPUBFUN void XMLCALL + xmlParserPrintFileInfo (xmlParserInputPtr input); +XMLPUBFUN void XMLCALL + xmlParserPrintFileContext (xmlParserInputPtr input); + +/* + * Extended error information routines + */ +XMLPUBFUN xmlErrorPtr XMLCALL + xmlGetLastError (void); +XMLPUBFUN void XMLCALL + xmlResetLastError (void); +XMLPUBFUN xmlErrorPtr XMLCALL + xmlCtxtGetLastError (void *ctx); +XMLPUBFUN void XMLCALL + xmlCtxtResetLastError (void *ctx); +XMLPUBFUN void XMLCALL + xmlResetError (xmlErrorPtr err); +XMLPUBFUN int XMLCALL + xmlCopyError (xmlErrorPtr from, + xmlErrorPtr to); + +#ifdef IN_LIBXML +/* + * Internal callback reporting routine + */ +XMLPUBFUN void XMLCALL + __xmlRaiseError (xmlStructuredErrorFunc schannel, + xmlGenericErrorFunc channel, + void *data, + void *ctx, + void *node, + int domain, + int code, + xmlErrorLevel level, + const char *file, + int line, + const char *str1, + const char *str2, + const char *str3, + int int1, + int col, + const char *msg, + ...) LIBXML_ATTR_FORMAT(16,17); +XMLPUBFUN void XMLCALL + __xmlSimpleError (int domain, + int code, + xmlNodePtr node, + const char *msg, + const char *extra); +#endif +#ifdef __cplusplus +} +#endif +#endif /* __XML_ERROR_H__ */ diff --git a/lib/libxml2/include/libxml/xmlexports.h b/lib/libxml2/include/libxml/xmlexports.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/xmlexports.h @@ -0,0 +1,169 @@ +/* + * Summary: macros for marking symbols as exportable/importable. + * Description: macros for marking symbols as exportable/importable. + * + * Copy: See Copyright for the status of this software. + * + * Author: Igor Zlatovic + */ + +#ifndef __XML_EXPORTS_H__ +#define __XML_EXPORTS_H__ + +/** + * XMLPUBFUN, XMLPUBVAR, XMLCALL + * + * Macros which declare an exportable function, an exportable variable and + * the calling convention used for functions. + * + * Please use an extra block for every platform/compiler combination when + * modifying this, rather than overlong #ifdef lines. This helps + * readability as well as the fact that different compilers on the same + * platform might need different definitions. + */ + +/** + * XMLPUBFUN: + * + * Macros which declare an exportable function + */ +#define XMLPUBFUN +/** + * XMLPUBVAR: + * + * Macros which declare an exportable variable + */ +#define XMLPUBVAR extern +/** + * XMLCALL: + * + * Macros which declare the called convention for exported functions + */ +#define XMLCALL +/** + * XMLCDECL: + * + * Macro which declares the calling convention for exported functions that + * use '...'. + */ +#define XMLCDECL + +/** DOC_DISABLE */ + +/* Windows platform with MS compiler */ +#if defined(_WIN32) && defined(_MSC_VER) + #undef XMLPUBFUN + #undef XMLPUBVAR + #undef XMLCALL + #undef XMLCDECL + #if defined(IN_LIBXML) && !defined(LIBXML_STATIC) + #define XMLPUBFUN __declspec(dllexport) + #define XMLPUBVAR __declspec(dllexport) + #else + #define XMLPUBFUN + #if !defined(LIBXML_STATIC) + #define XMLPUBVAR __declspec(dllimport) extern + #else + #define XMLPUBVAR extern + #endif + #endif + #if defined(LIBXML_FASTCALL) + #define XMLCALL __fastcall + #else + #define XMLCALL __cdecl + #endif + #define XMLCDECL __cdecl + #if !defined _REENTRANT + #define _REENTRANT + #endif +#endif + +/* Windows platform with Borland compiler */ +#if defined(_WIN32) && defined(__BORLANDC__) + #undef XMLPUBFUN + #undef XMLPUBVAR + #undef XMLCALL + #undef XMLCDECL + #if defined(IN_LIBXML) && !defined(LIBXML_STATIC) + #define XMLPUBFUN __declspec(dllexport) + #define XMLPUBVAR __declspec(dllexport) extern + #else + #define XMLPUBFUN + #if !defined(LIBXML_STATIC) + #define XMLPUBVAR __declspec(dllimport) extern + #else + #define XMLPUBVAR extern + #endif + #endif + #define XMLCALL __cdecl + #define XMLCDECL __cdecl + #if !defined _REENTRANT + #define _REENTRANT + #endif +#endif + +/* Windows platform with GNU compiler (Mingw) */ + +/* https://bugzilla.gnome.org/show_bug.cgi?id=561340 */ +/* http://osdir.com/ml/gnome.lib.xml.general/2004-02/msg00007.html*/ + + +#if defined(_WIN32) && defined(__MINGW32__) + #undef XMLPUBFUN + #undef XMLPUBVAR + #undef XMLCALL + #undef XMLCDECL + /* + * if defined(IN_LIBXML) this raises problems on mingw with msys + * _imp__xmlFree listed as missing. Try to workaround the problem + * by also making that declaration when compiling client code. + */ + /* #if defined(IN_LIBXML) && !defined(LIBXML_STATIC)*/ + #if !defined(LIBXML_STATIC) + #define XMLPUBFUN __declspec(dllexport) + #define XMLPUBVAR __declspec(dllexport) + #else + #define XMLPUBFUN + #if !defined(LIBXML_STATIC) + #define XMLPUBVAR __declspec(dllimport) extern + #else + #define XMLPUBVAR extern + #endif + #endif + #define XMLCALL __cdecl + #define XMLCDECL __cdecl + #if !defined _REENTRANT + #define _REENTRANT + #endif +#endif + + +/* Cygwin platform, GNU compiler */ +#if defined(_WIN32) && defined(__CYGWIN__) + #undef XMLPUBFUN + #undef XMLPUBVAR + #undef XMLCALL + #undef XMLCDECL + #if defined(IN_LIBXML) && !defined(LIBXML_STATIC) + #define XMLPUBFUN __declspec(dllexport) + #define XMLPUBVAR __declspec(dllexport) + #else + #define XMLPUBFUN + #if !defined(LIBXML_STATIC) + #define XMLPUBVAR __declspec(dllimport) extern + #else + #define XMLPUBVAR + #endif + #endif + #define XMLCALL __cdecl + #define XMLCDECL __cdecl +#endif + +/* Compatibility */ +#if !defined(LIBXML_DLL_IMPORT) +#define LIBXML_DLL_IMPORT XMLPUBVAR +#endif + +#endif /* __XML_EXPORTS_H__ */ + + diff --git a/lib/libxml2/include/libxml/xmlmemory.h b/lib/libxml2/include/libxml/xmlmemory.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/xmlmemory.h @@ -0,0 +1,224 @@ +/* + * Summary: interface for the memory allocator + * Description: provides interfaces for the memory allocator, + * including debugging capabilities. + * + * Copy: See Copyright for the status of this software. + * + * Author: Daniel Veillard + */ + + +#ifndef __DEBUG_MEMORY_ALLOC__ +#define __DEBUG_MEMORY_ALLOC__ + +#include +#include + +/** + * DEBUG_MEMORY: + * + * DEBUG_MEMORY replaces the allocator with a collect and debug + * shell to the libc allocator. + * DEBUG_MEMORY should only be activated when debugging + * libxml i.e. if libxml has been configured with --with-debug-mem too. + */ +/* #define DEBUG_MEMORY_FREED */ +/* #define DEBUG_MEMORY_LOCATION */ + +#ifdef DEBUG +#ifndef DEBUG_MEMORY +#define DEBUG_MEMORY +#endif +#endif + +/** + * DEBUG_MEMORY_LOCATION: + * + * DEBUG_MEMORY_LOCATION should be activated only when debugging + * libxml i.e. if libxml has been configured with --with-debug-mem too. + */ +#ifdef DEBUG_MEMORY_LOCATION +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * The XML memory wrapper support 4 basic overloadable functions. + */ +/** + * xmlFreeFunc: + * @mem: an already allocated block of memory + * + * Signature for a free() implementation. + */ +typedef void (XMLCALL *xmlFreeFunc)(void *mem); +/** + * xmlMallocFunc: + * @size: the size requested in bytes + * + * Signature for a malloc() implementation. + * + * Returns a pointer to the newly allocated block or NULL in case of error. + */ +typedef void *(LIBXML_ATTR_ALLOC_SIZE(1) XMLCALL *xmlMallocFunc)(size_t size); + +/** + * xmlReallocFunc: + * @mem: an already allocated block of memory + * @size: the new size requested in bytes + * + * Signature for a realloc() implementation. + * + * Returns a pointer to the newly reallocated block or NULL in case of error. + */ +typedef void *(XMLCALL *xmlReallocFunc)(void *mem, size_t size); + +/** + * xmlStrdupFunc: + * @str: a zero terminated string + * + * Signature for an strdup() implementation. + * + * Returns the copy of the string or NULL in case of error. + */ +typedef char *(XMLCALL *xmlStrdupFunc)(const char *str); + +/* + * The 4 interfaces used for all memory handling within libxml. +LIBXML_DLL_IMPORT xmlFreeFunc xmlFree; +LIBXML_DLL_IMPORT xmlMallocFunc xmlMalloc; +LIBXML_DLL_IMPORT xmlMallocFunc xmlMallocAtomic; +LIBXML_DLL_IMPORT xmlReallocFunc xmlRealloc; +LIBXML_DLL_IMPORT xmlStrdupFunc xmlMemStrdup; + */ + +/* + * The way to overload the existing functions. + * The xmlGc function have an extra entry for atomic block + * allocations useful for garbage collected memory allocators + */ +XMLPUBFUN int XMLCALL + xmlMemSetup (xmlFreeFunc freeFunc, + xmlMallocFunc mallocFunc, + xmlReallocFunc reallocFunc, + xmlStrdupFunc strdupFunc); +XMLPUBFUN int XMLCALL + xmlMemGet (xmlFreeFunc *freeFunc, + xmlMallocFunc *mallocFunc, + xmlReallocFunc *reallocFunc, + xmlStrdupFunc *strdupFunc); +XMLPUBFUN int XMLCALL + xmlGcMemSetup (xmlFreeFunc freeFunc, + xmlMallocFunc mallocFunc, + xmlMallocFunc mallocAtomicFunc, + xmlReallocFunc reallocFunc, + xmlStrdupFunc strdupFunc); +XMLPUBFUN int XMLCALL + xmlGcMemGet (xmlFreeFunc *freeFunc, + xmlMallocFunc *mallocFunc, + xmlMallocFunc *mallocAtomicFunc, + xmlReallocFunc *reallocFunc, + xmlStrdupFunc *strdupFunc); + +/* + * Initialization of the memory layer. + */ +XMLPUBFUN int XMLCALL + xmlInitMemory (void); + +/* + * Cleanup of the memory layer. + */ +XMLPUBFUN void XMLCALL + xmlCleanupMemory (void); +/* + * These are specific to the XML debug memory wrapper. + */ +XMLPUBFUN int XMLCALL + xmlMemUsed (void); +XMLPUBFUN int XMLCALL + xmlMemBlocks (void); +XMLPUBFUN void XMLCALL + xmlMemDisplay (FILE *fp); +XMLPUBFUN void XMLCALL + xmlMemDisplayLast(FILE *fp, long nbBytes); +XMLPUBFUN void XMLCALL + xmlMemShow (FILE *fp, int nr); +XMLPUBFUN void XMLCALL + xmlMemoryDump (void); +XMLPUBFUN void * XMLCALL + xmlMemMalloc (size_t size) LIBXML_ATTR_ALLOC_SIZE(1); +XMLPUBFUN void * XMLCALL + xmlMemRealloc (void *ptr,size_t size); +XMLPUBFUN void XMLCALL + xmlMemFree (void *ptr); +XMLPUBFUN char * XMLCALL + xmlMemoryStrdup (const char *str); +XMLPUBFUN void * XMLCALL + xmlMallocLoc (size_t size, const char *file, int line) LIBXML_ATTR_ALLOC_SIZE(1); +XMLPUBFUN void * XMLCALL + xmlReallocLoc (void *ptr, size_t size, const char *file, int line); +XMLPUBFUN void * XMLCALL + xmlMallocAtomicLoc (size_t size, const char *file, int line) LIBXML_ATTR_ALLOC_SIZE(1); +XMLPUBFUN char * XMLCALL + xmlMemStrdupLoc (const char *str, const char *file, int line); + + +#ifdef DEBUG_MEMORY_LOCATION +/** + * xmlMalloc: + * @size: number of bytes to allocate + * + * Wrapper for the malloc() function used in the XML library. + * + * Returns the pointer to the allocated area or NULL in case of error. + */ +#define xmlMalloc(size) xmlMallocLoc((size), __FILE__, __LINE__) +/** + * xmlMallocAtomic: + * @size: number of bytes to allocate + * + * Wrapper for the malloc() function used in the XML library for allocation + * of block not containing pointers to other areas. + * + * Returns the pointer to the allocated area or NULL in case of error. + */ +#define xmlMallocAtomic(size) xmlMallocAtomicLoc((size), __FILE__, __LINE__) +/** + * xmlRealloc: + * @ptr: pointer to the existing allocated area + * @size: number of bytes to allocate + * + * Wrapper for the realloc() function used in the XML library. + * + * Returns the pointer to the allocated area or NULL in case of error. + */ +#define xmlRealloc(ptr, size) xmlReallocLoc((ptr), (size), __FILE__, __LINE__) +/** + * xmlMemStrdup: + * @str: pointer to the existing string + * + * Wrapper for the strdup() function, xmlStrdup() is usually preferred. + * + * Returns the pointer to the allocated area or NULL in case of error. + */ +#define xmlMemStrdup(str) xmlMemStrdupLoc((str), __FILE__, __LINE__) + +#endif /* DEBUG_MEMORY_LOCATION */ + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#ifndef __XML_GLOBALS_H +#ifndef __XML_THREADS_H__ +#include +#include +#endif +#endif + +#endif /* __DEBUG_MEMORY_ALLOC__ */ + diff --git a/lib/libxml2/include/libxml/xmlmodule.h b/lib/libxml2/include/libxml/xmlmodule.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/xmlmodule.h @@ -0,0 +1,57 @@ +/* + * Summary: dynamic module loading + * Description: basic API for dynamic module loading, used by + * libexslt added in 2.6.17 + * + * Copy: See Copyright for the status of this software. + * + * Author: Joel W. Reed + */ + +#ifndef __XML_MODULE_H__ +#define __XML_MODULE_H__ + +#include + +#ifdef LIBXML_MODULES_ENABLED + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * xmlModulePtr: + * + * A handle to a dynamically loaded module + */ +typedef struct _xmlModule xmlModule; +typedef xmlModule *xmlModulePtr; + +/** + * xmlModuleOption: + * + * enumeration of options that can be passed down to xmlModuleOpen() + */ +typedef enum { + XML_MODULE_LAZY = 1, /* lazy binding */ + XML_MODULE_LOCAL= 2 /* local binding */ +} xmlModuleOption; + +XMLPUBFUN xmlModulePtr XMLCALL xmlModuleOpen (const char *filename, + int options); + +XMLPUBFUN int XMLCALL xmlModuleSymbol (xmlModulePtr module, + const char* name, + void **result); + +XMLPUBFUN int XMLCALL xmlModuleClose (xmlModulePtr module); + +XMLPUBFUN int XMLCALL xmlModuleFree (xmlModulePtr module); + +#ifdef __cplusplus +} +#endif + +#endif /* LIBXML_MODULES_ENABLED */ + +#endif /*__XML_MODULE_H__ */ diff --git a/lib/libxml2/include/libxml/xmlreader.h b/lib/libxml2/include/libxml/xmlreader.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/xmlreader.h @@ -0,0 +1,424 @@ +/* + * Summary: the XMLReader implementation + * Description: API of the XML streaming API based on C# interfaces. + * + * Copy: See Copyright for the status of this software. + * + * Author: Daniel Veillard + */ + +#ifndef __XML_XMLREADER_H__ +#define __XML_XMLREADER_H__ + +#include +#include +#include +#ifdef LIBXML_SCHEMAS_ENABLED +#include +#include +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * xmlParserSeverities: + * + * How severe an error callback is when the per-reader error callback API + * is used. + */ +typedef enum { + XML_PARSER_SEVERITY_VALIDITY_WARNING = 1, + XML_PARSER_SEVERITY_VALIDITY_ERROR = 2, + XML_PARSER_SEVERITY_WARNING = 3, + XML_PARSER_SEVERITY_ERROR = 4 +} xmlParserSeverities; + +#ifdef LIBXML_READER_ENABLED + +/** + * xmlTextReaderMode: + * + * Internal state values for the reader. + */ +typedef enum { + XML_TEXTREADER_MODE_INITIAL = 0, + XML_TEXTREADER_MODE_INTERACTIVE = 1, + XML_TEXTREADER_MODE_ERROR = 2, + XML_TEXTREADER_MODE_EOF =3, + XML_TEXTREADER_MODE_CLOSED = 4, + XML_TEXTREADER_MODE_READING = 5 +} xmlTextReaderMode; + +/** + * xmlParserProperties: + * + * Some common options to use with xmlTextReaderSetParserProp, but it + * is better to use xmlParserOption and the xmlReaderNewxxx and + * xmlReaderForxxx APIs now. + */ +typedef enum { + XML_PARSER_LOADDTD = 1, + XML_PARSER_DEFAULTATTRS = 2, + XML_PARSER_VALIDATE = 3, + XML_PARSER_SUBST_ENTITIES = 4 +} xmlParserProperties; + +/** + * xmlReaderTypes: + * + * Predefined constants for the different types of nodes. + */ +typedef enum { + XML_READER_TYPE_NONE = 0, + XML_READER_TYPE_ELEMENT = 1, + XML_READER_TYPE_ATTRIBUTE = 2, + XML_READER_TYPE_TEXT = 3, + XML_READER_TYPE_CDATA = 4, + XML_READER_TYPE_ENTITY_REFERENCE = 5, + XML_READER_TYPE_ENTITY = 6, + XML_READER_TYPE_PROCESSING_INSTRUCTION = 7, + XML_READER_TYPE_COMMENT = 8, + XML_READER_TYPE_DOCUMENT = 9, + XML_READER_TYPE_DOCUMENT_TYPE = 10, + XML_READER_TYPE_DOCUMENT_FRAGMENT = 11, + XML_READER_TYPE_NOTATION = 12, + XML_READER_TYPE_WHITESPACE = 13, + XML_READER_TYPE_SIGNIFICANT_WHITESPACE = 14, + XML_READER_TYPE_END_ELEMENT = 15, + XML_READER_TYPE_END_ENTITY = 16, + XML_READER_TYPE_XML_DECLARATION = 17 +} xmlReaderTypes; + +/** + * xmlTextReader: + * + * Structure for an xmlReader context. + */ +typedef struct _xmlTextReader xmlTextReader; + +/** + * xmlTextReaderPtr: + * + * Pointer to an xmlReader context. + */ +typedef xmlTextReader *xmlTextReaderPtr; + +/* + * Constructors & Destructor + */ +XMLPUBFUN xmlTextReaderPtr XMLCALL + xmlNewTextReader (xmlParserInputBufferPtr input, + const char *URI); +XMLPUBFUN xmlTextReaderPtr XMLCALL + xmlNewTextReaderFilename(const char *URI); + +XMLPUBFUN void XMLCALL + xmlFreeTextReader (xmlTextReaderPtr reader); + +XMLPUBFUN int XMLCALL + xmlTextReaderSetup(xmlTextReaderPtr reader, + xmlParserInputBufferPtr input, const char *URL, + const char *encoding, int options); + +/* + * Iterators + */ +XMLPUBFUN int XMLCALL + xmlTextReaderRead (xmlTextReaderPtr reader); + +#ifdef LIBXML_WRITER_ENABLED +XMLPUBFUN xmlChar * XMLCALL + xmlTextReaderReadInnerXml (xmlTextReaderPtr reader); + +XMLPUBFUN xmlChar * XMLCALL + xmlTextReaderReadOuterXml (xmlTextReaderPtr reader); +#endif + +XMLPUBFUN xmlChar * XMLCALL + xmlTextReaderReadString (xmlTextReaderPtr reader); +XMLPUBFUN int XMLCALL + xmlTextReaderReadAttributeValue (xmlTextReaderPtr reader); + +/* + * Attributes of the node + */ +XMLPUBFUN int XMLCALL + xmlTextReaderAttributeCount(xmlTextReaderPtr reader); +XMLPUBFUN int XMLCALL + xmlTextReaderDepth (xmlTextReaderPtr reader); +XMLPUBFUN int XMLCALL + xmlTextReaderHasAttributes(xmlTextReaderPtr reader); +XMLPUBFUN int XMLCALL + xmlTextReaderHasValue(xmlTextReaderPtr reader); +XMLPUBFUN int XMLCALL + xmlTextReaderIsDefault (xmlTextReaderPtr reader); +XMLPUBFUN int XMLCALL + xmlTextReaderIsEmptyElement(xmlTextReaderPtr reader); +XMLPUBFUN int XMLCALL + xmlTextReaderNodeType (xmlTextReaderPtr reader); +XMLPUBFUN int XMLCALL + xmlTextReaderQuoteChar (xmlTextReaderPtr reader); +XMLPUBFUN int XMLCALL + xmlTextReaderReadState (xmlTextReaderPtr reader); +XMLPUBFUN int XMLCALL + xmlTextReaderIsNamespaceDecl(xmlTextReaderPtr reader); + +XMLPUBFUN const xmlChar * XMLCALL + xmlTextReaderConstBaseUri (xmlTextReaderPtr reader); +XMLPUBFUN const xmlChar * XMLCALL + xmlTextReaderConstLocalName (xmlTextReaderPtr reader); +XMLPUBFUN const xmlChar * XMLCALL + xmlTextReaderConstName (xmlTextReaderPtr reader); +XMLPUBFUN const xmlChar * XMLCALL + xmlTextReaderConstNamespaceUri(xmlTextReaderPtr reader); +XMLPUBFUN const xmlChar * XMLCALL + xmlTextReaderConstPrefix (xmlTextReaderPtr reader); +XMLPUBFUN const xmlChar * XMLCALL + xmlTextReaderConstXmlLang (xmlTextReaderPtr reader); +XMLPUBFUN const xmlChar * XMLCALL + xmlTextReaderConstString (xmlTextReaderPtr reader, + const xmlChar *str); +XMLPUBFUN const xmlChar * XMLCALL + xmlTextReaderConstValue (xmlTextReaderPtr reader); + +/* + * use the Const version of the routine for + * better performance and simpler code + */ +XMLPUBFUN xmlChar * XMLCALL + xmlTextReaderBaseUri (xmlTextReaderPtr reader); +XMLPUBFUN xmlChar * XMLCALL + xmlTextReaderLocalName (xmlTextReaderPtr reader); +XMLPUBFUN xmlChar * XMLCALL + xmlTextReaderName (xmlTextReaderPtr reader); +XMLPUBFUN xmlChar * XMLCALL + xmlTextReaderNamespaceUri(xmlTextReaderPtr reader); +XMLPUBFUN xmlChar * XMLCALL + xmlTextReaderPrefix (xmlTextReaderPtr reader); +XMLPUBFUN xmlChar * XMLCALL + xmlTextReaderXmlLang (xmlTextReaderPtr reader); +XMLPUBFUN xmlChar * XMLCALL + xmlTextReaderValue (xmlTextReaderPtr reader); + +/* + * Methods of the XmlTextReader + */ +XMLPUBFUN int XMLCALL + xmlTextReaderClose (xmlTextReaderPtr reader); +XMLPUBFUN xmlChar * XMLCALL + xmlTextReaderGetAttributeNo (xmlTextReaderPtr reader, + int no); +XMLPUBFUN xmlChar * XMLCALL + xmlTextReaderGetAttribute (xmlTextReaderPtr reader, + const xmlChar *name); +XMLPUBFUN xmlChar * XMLCALL + xmlTextReaderGetAttributeNs (xmlTextReaderPtr reader, + const xmlChar *localName, + const xmlChar *namespaceURI); +XMLPUBFUN xmlParserInputBufferPtr XMLCALL + xmlTextReaderGetRemainder (xmlTextReaderPtr reader); +XMLPUBFUN xmlChar * XMLCALL + xmlTextReaderLookupNamespace(xmlTextReaderPtr reader, + const xmlChar *prefix); +XMLPUBFUN int XMLCALL + xmlTextReaderMoveToAttributeNo(xmlTextReaderPtr reader, + int no); +XMLPUBFUN int XMLCALL + xmlTextReaderMoveToAttribute(xmlTextReaderPtr reader, + const xmlChar *name); +XMLPUBFUN int XMLCALL + xmlTextReaderMoveToAttributeNs(xmlTextReaderPtr reader, + const xmlChar *localName, + const xmlChar *namespaceURI); +XMLPUBFUN int XMLCALL + xmlTextReaderMoveToFirstAttribute(xmlTextReaderPtr reader); +XMLPUBFUN int XMLCALL + xmlTextReaderMoveToNextAttribute(xmlTextReaderPtr reader); +XMLPUBFUN int XMLCALL + xmlTextReaderMoveToElement (xmlTextReaderPtr reader); +XMLPUBFUN int XMLCALL + xmlTextReaderNormalization (xmlTextReaderPtr reader); +XMLPUBFUN const xmlChar * XMLCALL + xmlTextReaderConstEncoding (xmlTextReaderPtr reader); + +/* + * Extensions + */ +XMLPUBFUN int XMLCALL + xmlTextReaderSetParserProp (xmlTextReaderPtr reader, + int prop, + int value); +XMLPUBFUN int XMLCALL + xmlTextReaderGetParserProp (xmlTextReaderPtr reader, + int prop); +XMLPUBFUN xmlNodePtr XMLCALL + xmlTextReaderCurrentNode (xmlTextReaderPtr reader); + +XMLPUBFUN int XMLCALL + xmlTextReaderGetParserLineNumber(xmlTextReaderPtr reader); + +XMLPUBFUN int XMLCALL + xmlTextReaderGetParserColumnNumber(xmlTextReaderPtr reader); + +XMLPUBFUN xmlNodePtr XMLCALL + xmlTextReaderPreserve (xmlTextReaderPtr reader); +#ifdef LIBXML_PATTERN_ENABLED +XMLPUBFUN int XMLCALL + xmlTextReaderPreservePattern(xmlTextReaderPtr reader, + const xmlChar *pattern, + const xmlChar **namespaces); +#endif /* LIBXML_PATTERN_ENABLED */ +XMLPUBFUN xmlDocPtr XMLCALL + xmlTextReaderCurrentDoc (xmlTextReaderPtr reader); +XMLPUBFUN xmlNodePtr XMLCALL + xmlTextReaderExpand (xmlTextReaderPtr reader); +XMLPUBFUN int XMLCALL + xmlTextReaderNext (xmlTextReaderPtr reader); +XMLPUBFUN int XMLCALL + xmlTextReaderNextSibling (xmlTextReaderPtr reader); +XMLPUBFUN int XMLCALL + xmlTextReaderIsValid (xmlTextReaderPtr reader); +#ifdef LIBXML_SCHEMAS_ENABLED +XMLPUBFUN int XMLCALL + xmlTextReaderRelaxNGValidate(xmlTextReaderPtr reader, + const char *rng); +XMLPUBFUN int XMLCALL + xmlTextReaderRelaxNGSetSchema(xmlTextReaderPtr reader, + xmlRelaxNGPtr schema); +XMLPUBFUN int XMLCALL + xmlTextReaderSchemaValidate (xmlTextReaderPtr reader, + const char *xsd); +XMLPUBFUN int XMLCALL + xmlTextReaderSchemaValidateCtxt(xmlTextReaderPtr reader, + xmlSchemaValidCtxtPtr ctxt, + int options); +XMLPUBFUN int XMLCALL + xmlTextReaderSetSchema (xmlTextReaderPtr reader, + xmlSchemaPtr schema); +#endif +XMLPUBFUN const xmlChar * XMLCALL + xmlTextReaderConstXmlVersion(xmlTextReaderPtr reader); +XMLPUBFUN int XMLCALL + xmlTextReaderStandalone (xmlTextReaderPtr reader); + + +/* + * Index lookup + */ +XMLPUBFUN long XMLCALL + xmlTextReaderByteConsumed (xmlTextReaderPtr reader); + +/* + * New more complete APIs for simpler creation and reuse of readers + */ +XMLPUBFUN xmlTextReaderPtr XMLCALL + xmlReaderWalker (xmlDocPtr doc); +XMLPUBFUN xmlTextReaderPtr XMLCALL + xmlReaderForDoc (const xmlChar * cur, + const char *URL, + const char *encoding, + int options); +XMLPUBFUN xmlTextReaderPtr XMLCALL + xmlReaderForFile (const char *filename, + const char *encoding, + int options); +XMLPUBFUN xmlTextReaderPtr XMLCALL + xmlReaderForMemory (const char *buffer, + int size, + const char *URL, + const char *encoding, + int options); +XMLPUBFUN xmlTextReaderPtr XMLCALL + xmlReaderForFd (int fd, + const char *URL, + const char *encoding, + int options); +XMLPUBFUN xmlTextReaderPtr XMLCALL + xmlReaderForIO (xmlInputReadCallback ioread, + xmlInputCloseCallback ioclose, + void *ioctx, + const char *URL, + const char *encoding, + int options); + +XMLPUBFUN int XMLCALL + xmlReaderNewWalker (xmlTextReaderPtr reader, + xmlDocPtr doc); +XMLPUBFUN int XMLCALL + xmlReaderNewDoc (xmlTextReaderPtr reader, + const xmlChar * cur, + const char *URL, + const char *encoding, + int options); +XMLPUBFUN int XMLCALL + xmlReaderNewFile (xmlTextReaderPtr reader, + const char *filename, + const char *encoding, + int options); +XMLPUBFUN int XMLCALL + xmlReaderNewMemory (xmlTextReaderPtr reader, + const char *buffer, + int size, + const char *URL, + const char *encoding, + int options); +XMLPUBFUN int XMLCALL + xmlReaderNewFd (xmlTextReaderPtr reader, + int fd, + const char *URL, + const char *encoding, + int options); +XMLPUBFUN int XMLCALL + xmlReaderNewIO (xmlTextReaderPtr reader, + xmlInputReadCallback ioread, + xmlInputCloseCallback ioclose, + void *ioctx, + const char *URL, + const char *encoding, + int options); +/* + * Error handling extensions + */ +typedef void * xmlTextReaderLocatorPtr; + +/** + * xmlTextReaderErrorFunc: + * @arg: the user argument + * @msg: the message + * @severity: the severity of the error + * @locator: a locator indicating where the error occured + * + * Signature of an error callback from a reader parser + */ +typedef void (XMLCALL *xmlTextReaderErrorFunc)(void *arg, + const char *msg, + xmlParserSeverities severity, + xmlTextReaderLocatorPtr locator); +XMLPUBFUN int XMLCALL + xmlTextReaderLocatorLineNumber(xmlTextReaderLocatorPtr locator); +/*int xmlTextReaderLocatorLinePosition(xmlTextReaderLocatorPtr locator);*/ +XMLPUBFUN xmlChar * XMLCALL + xmlTextReaderLocatorBaseURI (xmlTextReaderLocatorPtr locator); +XMLPUBFUN void XMLCALL + xmlTextReaderSetErrorHandler(xmlTextReaderPtr reader, + xmlTextReaderErrorFunc f, + void *arg); +XMLPUBFUN void XMLCALL + xmlTextReaderSetStructuredErrorHandler(xmlTextReaderPtr reader, + xmlStructuredErrorFunc f, + void *arg); +XMLPUBFUN void XMLCALL + xmlTextReaderGetErrorHandler(xmlTextReaderPtr reader, + xmlTextReaderErrorFunc *f, + void **arg); + +#endif /* LIBXML_READER_ENABLED */ + +#ifdef __cplusplus +} +#endif + +#endif /* __XML_XMLREADER_H__ */ + diff --git a/lib/libxml2/include/libxml/xmlregexp.h b/lib/libxml2/include/libxml/xmlregexp.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/xmlregexp.h @@ -0,0 +1,222 @@ +/* + * Summary: regular expressions handling + * Description: basic API for libxml regular expressions handling used + * for XML Schemas and validation. + * + * Copy: See Copyright for the status of this software. + * + * Author: Daniel Veillard + */ + +#ifndef __XML_REGEXP_H__ +#define __XML_REGEXP_H__ + +#include + +#ifdef LIBXML_REGEXP_ENABLED + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * xmlRegexpPtr: + * + * A libxml regular expression, they can actually be far more complex + * thank the POSIX regex expressions. + */ +typedef struct _xmlRegexp xmlRegexp; +typedef xmlRegexp *xmlRegexpPtr; + +/** + * xmlRegExecCtxtPtr: + * + * A libxml progressive regular expression evaluation context + */ +typedef struct _xmlRegExecCtxt xmlRegExecCtxt; +typedef xmlRegExecCtxt *xmlRegExecCtxtPtr; + +#ifdef __cplusplus +} +#endif +#include +#include +#ifdef __cplusplus +extern "C" { +#endif + +/* + * The POSIX like API + */ +XMLPUBFUN xmlRegexpPtr XMLCALL + xmlRegexpCompile (const xmlChar *regexp); +XMLPUBFUN void XMLCALL xmlRegFreeRegexp(xmlRegexpPtr regexp); +XMLPUBFUN int XMLCALL + xmlRegexpExec (xmlRegexpPtr comp, + const xmlChar *value); +XMLPUBFUN void XMLCALL + xmlRegexpPrint (FILE *output, + xmlRegexpPtr regexp); +XMLPUBFUN int XMLCALL + xmlRegexpIsDeterminist(xmlRegexpPtr comp); + +/** + * xmlRegExecCallbacks: + * @exec: the regular expression context + * @token: the current token string + * @transdata: transition data + * @inputdata: input data + * + * Callback function when doing a transition in the automata + */ +typedef void (*xmlRegExecCallbacks) (xmlRegExecCtxtPtr exec, + const xmlChar *token, + void *transdata, + void *inputdata); + +/* + * The progressive API + */ +XMLPUBFUN xmlRegExecCtxtPtr XMLCALL + xmlRegNewExecCtxt (xmlRegexpPtr comp, + xmlRegExecCallbacks callback, + void *data); +XMLPUBFUN void XMLCALL + xmlRegFreeExecCtxt (xmlRegExecCtxtPtr exec); +XMLPUBFUN int XMLCALL + xmlRegExecPushString(xmlRegExecCtxtPtr exec, + const xmlChar *value, + void *data); +XMLPUBFUN int XMLCALL + xmlRegExecPushString2(xmlRegExecCtxtPtr exec, + const xmlChar *value, + const xmlChar *value2, + void *data); + +XMLPUBFUN int XMLCALL + xmlRegExecNextValues(xmlRegExecCtxtPtr exec, + int *nbval, + int *nbneg, + xmlChar **values, + int *terminal); +XMLPUBFUN int XMLCALL + xmlRegExecErrInfo (xmlRegExecCtxtPtr exec, + const xmlChar **string, + int *nbval, + int *nbneg, + xmlChar **values, + int *terminal); +#ifdef LIBXML_EXPR_ENABLED +/* + * Formal regular expression handling + * Its goal is to do some formal work on content models + */ + +/* expressions are used within a context */ +typedef struct _xmlExpCtxt xmlExpCtxt; +typedef xmlExpCtxt *xmlExpCtxtPtr; + +XMLPUBFUN void XMLCALL + xmlExpFreeCtxt (xmlExpCtxtPtr ctxt); +XMLPUBFUN xmlExpCtxtPtr XMLCALL + xmlExpNewCtxt (int maxNodes, + xmlDictPtr dict); + +XMLPUBFUN int XMLCALL + xmlExpCtxtNbNodes(xmlExpCtxtPtr ctxt); +XMLPUBFUN int XMLCALL + xmlExpCtxtNbCons(xmlExpCtxtPtr ctxt); + +/* Expressions are trees but the tree is opaque */ +typedef struct _xmlExpNode xmlExpNode; +typedef xmlExpNode *xmlExpNodePtr; + +typedef enum { + XML_EXP_EMPTY = 0, + XML_EXP_FORBID = 1, + XML_EXP_ATOM = 2, + XML_EXP_SEQ = 3, + XML_EXP_OR = 4, + XML_EXP_COUNT = 5 +} xmlExpNodeType; + +/* + * 2 core expressions shared by all for the empty language set + * and for the set with just the empty token + */ +XMLPUBVAR xmlExpNodePtr forbiddenExp; +XMLPUBVAR xmlExpNodePtr emptyExp; + +/* + * Expressions are reference counted internally + */ +XMLPUBFUN void XMLCALL + xmlExpFree (xmlExpCtxtPtr ctxt, + xmlExpNodePtr expr); +XMLPUBFUN void XMLCALL + xmlExpRef (xmlExpNodePtr expr); + +/* + * constructors can be either manual or from a string + */ +XMLPUBFUN xmlExpNodePtr XMLCALL + xmlExpParse (xmlExpCtxtPtr ctxt, + const char *expr); +XMLPUBFUN xmlExpNodePtr XMLCALL + xmlExpNewAtom (xmlExpCtxtPtr ctxt, + const xmlChar *name, + int len); +XMLPUBFUN xmlExpNodePtr XMLCALL + xmlExpNewOr (xmlExpCtxtPtr ctxt, + xmlExpNodePtr left, + xmlExpNodePtr right); +XMLPUBFUN xmlExpNodePtr XMLCALL + xmlExpNewSeq (xmlExpCtxtPtr ctxt, + xmlExpNodePtr left, + xmlExpNodePtr right); +XMLPUBFUN xmlExpNodePtr XMLCALL + xmlExpNewRange (xmlExpCtxtPtr ctxt, + xmlExpNodePtr subset, + int min, + int max); +/* + * The really interesting APIs + */ +XMLPUBFUN int XMLCALL + xmlExpIsNillable(xmlExpNodePtr expr); +XMLPUBFUN int XMLCALL + xmlExpMaxToken (xmlExpNodePtr expr); +XMLPUBFUN int XMLCALL + xmlExpGetLanguage(xmlExpCtxtPtr ctxt, + xmlExpNodePtr expr, + const xmlChar**langList, + int len); +XMLPUBFUN int XMLCALL + xmlExpGetStart (xmlExpCtxtPtr ctxt, + xmlExpNodePtr expr, + const xmlChar**tokList, + int len); +XMLPUBFUN xmlExpNodePtr XMLCALL + xmlExpStringDerive(xmlExpCtxtPtr ctxt, + xmlExpNodePtr expr, + const xmlChar *str, + int len); +XMLPUBFUN xmlExpNodePtr XMLCALL + xmlExpExpDerive (xmlExpCtxtPtr ctxt, + xmlExpNodePtr expr, + xmlExpNodePtr sub); +XMLPUBFUN int XMLCALL + xmlExpSubsume (xmlExpCtxtPtr ctxt, + xmlExpNodePtr expr, + xmlExpNodePtr sub); +XMLPUBFUN void XMLCALL + xmlExpDump (xmlBufferPtr buf, + xmlExpNodePtr expr); +#endif /* LIBXML_EXPR_ENABLED */ +#ifdef __cplusplus +} +#endif + +#endif /* LIBXML_REGEXP_ENABLED */ + +#endif /*__XML_REGEXP_H__ */ diff --git a/lib/libxml2/include/libxml/xmlsave.h b/lib/libxml2/include/libxml/xmlsave.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/xmlsave.h @@ -0,0 +1,87 @@ +/* + * Summary: the XML document serializer + * Description: API to save document or subtree of document + * + * Copy: See Copyright for the status of this software. + * + * Author: Daniel Veillard + */ + +#ifndef __XML_XMLSAVE_H__ +#define __XML_XMLSAVE_H__ + +#include +#include +#include +#include + +#ifdef LIBXML_OUTPUT_ENABLED +#ifdef __cplusplus +extern "C" { +#endif + +/** + * xmlSaveOption: + * + * This is the set of XML save options that can be passed down + * to the xmlSaveToFd() and similar calls. + */ +typedef enum { + XML_SAVE_FORMAT = 1<<0, /* format save output */ + XML_SAVE_NO_DECL = 1<<1, /* drop the xml declaration */ + XML_SAVE_NO_EMPTY = 1<<2, /* no empty tags */ + XML_SAVE_NO_XHTML = 1<<3, /* disable XHTML1 specific rules */ + XML_SAVE_XHTML = 1<<4, /* force XHTML1 specific rules */ + XML_SAVE_AS_XML = 1<<5, /* force XML serialization on HTML doc */ + XML_SAVE_AS_HTML = 1<<6 /* force HTML serialization on XML doc */ +} xmlSaveOption; + + +typedef struct _xmlSaveCtxt xmlSaveCtxt; +typedef xmlSaveCtxt *xmlSaveCtxtPtr; + +XMLPUBFUN xmlSaveCtxtPtr XMLCALL + xmlSaveToFd (int fd, + const char *encoding, + int options); +XMLPUBFUN xmlSaveCtxtPtr XMLCALL + xmlSaveToFilename (const char *filename, + const char *encoding, + int options); + +XMLPUBFUN xmlSaveCtxtPtr XMLCALL + xmlSaveToBuffer (xmlBufferPtr buffer, + const char *encoding, + int options); + +XMLPUBFUN xmlSaveCtxtPtr XMLCALL + xmlSaveToIO (xmlOutputWriteCallback iowrite, + xmlOutputCloseCallback ioclose, + void *ioctx, + const char *encoding, + int options); + +XMLPUBFUN long XMLCALL + xmlSaveDoc (xmlSaveCtxtPtr ctxt, + xmlDocPtr doc); +XMLPUBFUN long XMLCALL + xmlSaveTree (xmlSaveCtxtPtr ctxt, + xmlNodePtr node); + +XMLPUBFUN int XMLCALL + xmlSaveFlush (xmlSaveCtxtPtr ctxt); +XMLPUBFUN int XMLCALL + xmlSaveClose (xmlSaveCtxtPtr ctxt); +XMLPUBFUN int XMLCALL + xmlSaveSetEscape (xmlSaveCtxtPtr ctxt, + xmlCharEncodingOutputFunc escape); +XMLPUBFUN int XMLCALL + xmlSaveSetAttrEscape (xmlSaveCtxtPtr ctxt, + xmlCharEncodingOutputFunc escape); +#ifdef __cplusplus +} +#endif +#endif /* LIBXML_OUTPUT_ENABLED */ +#endif /* __XML_XMLSAVE_H__ */ + + diff --git a/lib/libxml2/include/libxml/xmlschemas.h b/lib/libxml2/include/libxml/xmlschemas.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/xmlschemas.h @@ -0,0 +1,218 @@ +/* + * Summary: incomplete XML Schemas structure implementation + * Description: interface to the XML Schemas handling and schema validity + * checking, it is incomplete right now. + * + * Copy: See Copyright for the status of this software. + * + * Author: Daniel Veillard + */ + + +#ifndef __XML_SCHEMA_H__ +#define __XML_SCHEMA_H__ + +#include + +#ifdef LIBXML_SCHEMAS_ENABLED + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * This error codes are obsolete; not used any more. + */ +typedef enum { + XML_SCHEMAS_ERR_OK = 0, + XML_SCHEMAS_ERR_NOROOT = 1, + XML_SCHEMAS_ERR_UNDECLAREDELEM, + XML_SCHEMAS_ERR_NOTTOPLEVEL, + XML_SCHEMAS_ERR_MISSING, + XML_SCHEMAS_ERR_WRONGELEM, + XML_SCHEMAS_ERR_NOTYPE, + XML_SCHEMAS_ERR_NOROLLBACK, + XML_SCHEMAS_ERR_ISABSTRACT, + XML_SCHEMAS_ERR_NOTEMPTY, + XML_SCHEMAS_ERR_ELEMCONT, + XML_SCHEMAS_ERR_HAVEDEFAULT, + XML_SCHEMAS_ERR_NOTNILLABLE, + XML_SCHEMAS_ERR_EXTRACONTENT, + XML_SCHEMAS_ERR_INVALIDATTR, + XML_SCHEMAS_ERR_INVALIDELEM, + XML_SCHEMAS_ERR_NOTDETERMINIST, + XML_SCHEMAS_ERR_CONSTRUCT, + XML_SCHEMAS_ERR_INTERNAL, + XML_SCHEMAS_ERR_NOTSIMPLE, + XML_SCHEMAS_ERR_ATTRUNKNOWN, + XML_SCHEMAS_ERR_ATTRINVALID, + XML_SCHEMAS_ERR_VALUE, + XML_SCHEMAS_ERR_FACET, + XML_SCHEMAS_ERR_, + XML_SCHEMAS_ERR_XXX +} xmlSchemaValidError; + +/* +* ATTENTION: Change xmlSchemaSetValidOptions's check +* for invalid values, if adding to the validation +* options below. +*/ +/** + * xmlSchemaValidOption: + * + * This is the set of XML Schema validation options. + */ +typedef enum { + XML_SCHEMA_VAL_VC_I_CREATE = 1<<0 + /* Default/fixed: create an attribute node + * or an element's text node on the instance. + */ +} xmlSchemaValidOption; + +/* + XML_SCHEMA_VAL_XSI_ASSEMBLE = 1<<1, + * assemble schemata using + * xsi:schemaLocation and + * xsi:noNamespaceSchemaLocation +*/ + +/** + * The schemas related types are kept internal + */ +typedef struct _xmlSchema xmlSchema; +typedef xmlSchema *xmlSchemaPtr; + +/** + * xmlSchemaValidityErrorFunc: + * @ctx: the validation context + * @msg: the message + * @...: extra arguments + * + * Signature of an error callback from an XSD validation + */ +typedef void (XMLCDECL *xmlSchemaValidityErrorFunc) (void *ctx, const char *msg, ...) LIBXML_ATTR_FORMAT(2,3); + +/** + * xmlSchemaValidityWarningFunc: + * @ctx: the validation context + * @msg: the message + * @...: extra arguments + * + * Signature of a warning callback from an XSD validation + */ +typedef void (XMLCDECL *xmlSchemaValidityWarningFunc) (void *ctx, const char *msg, ...) LIBXML_ATTR_FORMAT(2,3); + +/** + * A schemas validation context + */ +typedef struct _xmlSchemaParserCtxt xmlSchemaParserCtxt; +typedef xmlSchemaParserCtxt *xmlSchemaParserCtxtPtr; + +typedef struct _xmlSchemaValidCtxt xmlSchemaValidCtxt; +typedef xmlSchemaValidCtxt *xmlSchemaValidCtxtPtr; + +/* + * Interfaces for parsing. + */ +XMLPUBFUN xmlSchemaParserCtxtPtr XMLCALL + xmlSchemaNewParserCtxt (const char *URL); +XMLPUBFUN xmlSchemaParserCtxtPtr XMLCALL + xmlSchemaNewMemParserCtxt (const char *buffer, + int size); +XMLPUBFUN xmlSchemaParserCtxtPtr XMLCALL + xmlSchemaNewDocParserCtxt (xmlDocPtr doc); +XMLPUBFUN void XMLCALL + xmlSchemaFreeParserCtxt (xmlSchemaParserCtxtPtr ctxt); +XMLPUBFUN void XMLCALL + xmlSchemaSetParserErrors (xmlSchemaParserCtxtPtr ctxt, + xmlSchemaValidityErrorFunc err, + xmlSchemaValidityWarningFunc warn, + void *ctx); +XMLPUBFUN void XMLCALL + xmlSchemaSetParserStructuredErrors(xmlSchemaParserCtxtPtr ctxt, + xmlStructuredErrorFunc serror, + void *ctx); +XMLPUBFUN int XMLCALL + xmlSchemaGetParserErrors(xmlSchemaParserCtxtPtr ctxt, + xmlSchemaValidityErrorFunc * err, + xmlSchemaValidityWarningFunc * warn, + void **ctx); +XMLPUBFUN int XMLCALL + xmlSchemaIsValid (xmlSchemaValidCtxtPtr ctxt); + +XMLPUBFUN xmlSchemaPtr XMLCALL + xmlSchemaParse (xmlSchemaParserCtxtPtr ctxt); +XMLPUBFUN void XMLCALL + xmlSchemaFree (xmlSchemaPtr schema); +#ifdef LIBXML_OUTPUT_ENABLED +XMLPUBFUN void XMLCALL + xmlSchemaDump (FILE *output, + xmlSchemaPtr schema); +#endif /* LIBXML_OUTPUT_ENABLED */ +/* + * Interfaces for validating + */ +XMLPUBFUN void XMLCALL + xmlSchemaSetValidErrors (xmlSchemaValidCtxtPtr ctxt, + xmlSchemaValidityErrorFunc err, + xmlSchemaValidityWarningFunc warn, + void *ctx); +XMLPUBFUN void XMLCALL + xmlSchemaSetValidStructuredErrors(xmlSchemaValidCtxtPtr ctxt, + xmlStructuredErrorFunc serror, + void *ctx); +XMLPUBFUN int XMLCALL + xmlSchemaGetValidErrors (xmlSchemaValidCtxtPtr ctxt, + xmlSchemaValidityErrorFunc *err, + xmlSchemaValidityWarningFunc *warn, + void **ctx); +XMLPUBFUN int XMLCALL + xmlSchemaSetValidOptions (xmlSchemaValidCtxtPtr ctxt, + int options); +XMLPUBFUN int XMLCALL + xmlSchemaValidCtxtGetOptions(xmlSchemaValidCtxtPtr ctxt); + +XMLPUBFUN xmlSchemaValidCtxtPtr XMLCALL + xmlSchemaNewValidCtxt (xmlSchemaPtr schema); +XMLPUBFUN void XMLCALL + xmlSchemaFreeValidCtxt (xmlSchemaValidCtxtPtr ctxt); +XMLPUBFUN int XMLCALL + xmlSchemaValidateDoc (xmlSchemaValidCtxtPtr ctxt, + xmlDocPtr instance); +XMLPUBFUN int XMLCALL + xmlSchemaValidateOneElement (xmlSchemaValidCtxtPtr ctxt, + xmlNodePtr elem); +XMLPUBFUN int XMLCALL + xmlSchemaValidateStream (xmlSchemaValidCtxtPtr ctxt, + xmlParserInputBufferPtr input, + xmlCharEncoding enc, + xmlSAXHandlerPtr sax, + void *user_data); +XMLPUBFUN int XMLCALL + xmlSchemaValidateFile (xmlSchemaValidCtxtPtr ctxt, + const char * filename, + int options); + +XMLPUBFUN xmlParserCtxtPtr XMLCALL + xmlSchemaValidCtxtGetParserCtxt(xmlSchemaValidCtxtPtr ctxt); + +/* + * Interface to insert Schemas SAX validation in a SAX stream + */ +typedef struct _xmlSchemaSAXPlug xmlSchemaSAXPlugStruct; +typedef xmlSchemaSAXPlugStruct *xmlSchemaSAXPlugPtr; + +XMLPUBFUN xmlSchemaSAXPlugPtr XMLCALL + xmlSchemaSAXPlug (xmlSchemaValidCtxtPtr ctxt, + xmlSAXHandlerPtr *sax, + void **user_data); +XMLPUBFUN int XMLCALL + xmlSchemaSAXUnplug (xmlSchemaSAXPlugPtr plug); +#ifdef __cplusplus +} +#endif + +#endif /* LIBXML_SCHEMAS_ENABLED */ +#endif /* __XML_SCHEMA_H__ */ diff --git a/lib/libxml2/include/libxml/xmlschemastypes.h b/lib/libxml2/include/libxml/xmlschemastypes.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/xmlschemastypes.h @@ -0,0 +1,151 @@ +/* + * Summary: implementation of XML Schema Datatypes + * Description: module providing the XML Schema Datatypes implementation + * both definition and validity checking + * + * Copy: See Copyright for the status of this software. + * + * Author: Daniel Veillard + */ + + +#ifndef __XML_SCHEMA_TYPES_H__ +#define __XML_SCHEMA_TYPES_H__ + +#include + +#ifdef LIBXML_SCHEMAS_ENABLED + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef enum { + XML_SCHEMA_WHITESPACE_UNKNOWN = 0, + XML_SCHEMA_WHITESPACE_PRESERVE = 1, + XML_SCHEMA_WHITESPACE_REPLACE = 2, + XML_SCHEMA_WHITESPACE_COLLAPSE = 3 +} xmlSchemaWhitespaceValueType; + +XMLPUBFUN void XMLCALL + xmlSchemaInitTypes (void); +XMLPUBFUN void XMLCALL + xmlSchemaCleanupTypes (void); +XMLPUBFUN xmlSchemaTypePtr XMLCALL + xmlSchemaGetPredefinedType (const xmlChar *name, + const xmlChar *ns); +XMLPUBFUN int XMLCALL + xmlSchemaValidatePredefinedType (xmlSchemaTypePtr type, + const xmlChar *value, + xmlSchemaValPtr *val); +XMLPUBFUN int XMLCALL + xmlSchemaValPredefTypeNode (xmlSchemaTypePtr type, + const xmlChar *value, + xmlSchemaValPtr *val, + xmlNodePtr node); +XMLPUBFUN int XMLCALL + xmlSchemaValidateFacet (xmlSchemaTypePtr base, + xmlSchemaFacetPtr facet, + const xmlChar *value, + xmlSchemaValPtr val); +XMLPUBFUN int XMLCALL + xmlSchemaValidateFacetWhtsp (xmlSchemaFacetPtr facet, + xmlSchemaWhitespaceValueType fws, + xmlSchemaValType valType, + const xmlChar *value, + xmlSchemaValPtr val, + xmlSchemaWhitespaceValueType ws); +XMLPUBFUN void XMLCALL + xmlSchemaFreeValue (xmlSchemaValPtr val); +XMLPUBFUN xmlSchemaFacetPtr XMLCALL + xmlSchemaNewFacet (void); +XMLPUBFUN int XMLCALL + xmlSchemaCheckFacet (xmlSchemaFacetPtr facet, + xmlSchemaTypePtr typeDecl, + xmlSchemaParserCtxtPtr ctxt, + const xmlChar *name); +XMLPUBFUN void XMLCALL + xmlSchemaFreeFacet (xmlSchemaFacetPtr facet); +XMLPUBFUN int XMLCALL + xmlSchemaCompareValues (xmlSchemaValPtr x, + xmlSchemaValPtr y); +XMLPUBFUN xmlSchemaTypePtr XMLCALL + xmlSchemaGetBuiltInListSimpleTypeItemType (xmlSchemaTypePtr type); +XMLPUBFUN int XMLCALL + xmlSchemaValidateListSimpleTypeFacet (xmlSchemaFacetPtr facet, + const xmlChar *value, + unsigned long actualLen, + unsigned long *expectedLen); +XMLPUBFUN xmlSchemaTypePtr XMLCALL + xmlSchemaGetBuiltInType (xmlSchemaValType type); +XMLPUBFUN int XMLCALL + xmlSchemaIsBuiltInTypeFacet (xmlSchemaTypePtr type, + int facetType); +XMLPUBFUN xmlChar * XMLCALL + xmlSchemaCollapseString (const xmlChar *value); +XMLPUBFUN xmlChar * XMLCALL + xmlSchemaWhiteSpaceReplace (const xmlChar *value); +XMLPUBFUN unsigned long XMLCALL + xmlSchemaGetFacetValueAsULong (xmlSchemaFacetPtr facet); +XMLPUBFUN int XMLCALL + xmlSchemaValidateLengthFacet (xmlSchemaTypePtr type, + xmlSchemaFacetPtr facet, + const xmlChar *value, + xmlSchemaValPtr val, + unsigned long *length); +XMLPUBFUN int XMLCALL + xmlSchemaValidateLengthFacetWhtsp(xmlSchemaFacetPtr facet, + xmlSchemaValType valType, + const xmlChar *value, + xmlSchemaValPtr val, + unsigned long *length, + xmlSchemaWhitespaceValueType ws); +XMLPUBFUN int XMLCALL + xmlSchemaValPredefTypeNodeNoNorm(xmlSchemaTypePtr type, + const xmlChar *value, + xmlSchemaValPtr *val, + xmlNodePtr node); +XMLPUBFUN int XMLCALL + xmlSchemaGetCanonValue (xmlSchemaValPtr val, + const xmlChar **retValue); +XMLPUBFUN int XMLCALL + xmlSchemaGetCanonValueWhtsp (xmlSchemaValPtr val, + const xmlChar **retValue, + xmlSchemaWhitespaceValueType ws); +XMLPUBFUN int XMLCALL + xmlSchemaValueAppend (xmlSchemaValPtr prev, + xmlSchemaValPtr cur); +XMLPUBFUN xmlSchemaValPtr XMLCALL + xmlSchemaValueGetNext (xmlSchemaValPtr cur); +XMLPUBFUN const xmlChar * XMLCALL + xmlSchemaValueGetAsString (xmlSchemaValPtr val); +XMLPUBFUN int XMLCALL + xmlSchemaValueGetAsBoolean (xmlSchemaValPtr val); +XMLPUBFUN xmlSchemaValPtr XMLCALL + xmlSchemaNewStringValue (xmlSchemaValType type, + const xmlChar *value); +XMLPUBFUN xmlSchemaValPtr XMLCALL + xmlSchemaNewNOTATIONValue (const xmlChar *name, + const xmlChar *ns); +XMLPUBFUN xmlSchemaValPtr XMLCALL + xmlSchemaNewQNameValue (const xmlChar *namespaceName, + const xmlChar *localName); +XMLPUBFUN int XMLCALL + xmlSchemaCompareValuesWhtsp (xmlSchemaValPtr x, + xmlSchemaWhitespaceValueType xws, + xmlSchemaValPtr y, + xmlSchemaWhitespaceValueType yws); +XMLPUBFUN xmlSchemaValPtr XMLCALL + xmlSchemaCopyValue (xmlSchemaValPtr val); +XMLPUBFUN xmlSchemaValType XMLCALL + xmlSchemaGetValType (xmlSchemaValPtr val); + +#ifdef __cplusplus +} +#endif + +#endif /* LIBXML_SCHEMAS_ENABLED */ +#endif /* __XML_SCHEMA_TYPES_H__ */ diff --git a/lib/libxml2/include/libxml/xmlstring.h b/lib/libxml2/include/libxml/xmlstring.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/xmlstring.h @@ -0,0 +1,140 @@ +/* + * Summary: set of routines to process strings + * Description: type and interfaces needed for the internal string handling + * of the library, especially UTF8 processing. + * + * Copy: See Copyright for the status of this software. + * + * Author: Daniel Veillard + */ + +#ifndef __XML_STRING_H__ +#define __XML_STRING_H__ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * xmlChar: + * + * This is a basic byte in an UTF-8 encoded string. + * It's unsigned allowing to pinpoint case where char * are assigned + * to xmlChar * (possibly making serialization back impossible). + */ +typedef unsigned char xmlChar; + +/** + * BAD_CAST: + * + * Macro to cast a string to an xmlChar * when one know its safe. + */ +#define BAD_CAST (xmlChar *) + +/* + * xmlChar handling + */ +XMLPUBFUN xmlChar * XMLCALL + xmlStrdup (const xmlChar *cur); +XMLPUBFUN xmlChar * XMLCALL + xmlStrndup (const xmlChar *cur, + int len); +XMLPUBFUN xmlChar * XMLCALL + xmlCharStrndup (const char *cur, + int len); +XMLPUBFUN xmlChar * XMLCALL + xmlCharStrdup (const char *cur); +XMLPUBFUN xmlChar * XMLCALL + xmlStrsub (const xmlChar *str, + int start, + int len); +XMLPUBFUN const xmlChar * XMLCALL + xmlStrchr (const xmlChar *str, + xmlChar val); +XMLPUBFUN const xmlChar * XMLCALL + xmlStrstr (const xmlChar *str, + const xmlChar *val); +XMLPUBFUN const xmlChar * XMLCALL + xmlStrcasestr (const xmlChar *str, + const xmlChar *val); +XMLPUBFUN int XMLCALL + xmlStrcmp (const xmlChar *str1, + const xmlChar *str2); +XMLPUBFUN int XMLCALL + xmlStrncmp (const xmlChar *str1, + const xmlChar *str2, + int len); +XMLPUBFUN int XMLCALL + xmlStrcasecmp (const xmlChar *str1, + const xmlChar *str2); +XMLPUBFUN int XMLCALL + xmlStrncasecmp (const xmlChar *str1, + const xmlChar *str2, + int len); +XMLPUBFUN int XMLCALL + xmlStrEqual (const xmlChar *str1, + const xmlChar *str2); +XMLPUBFUN int XMLCALL + xmlStrQEqual (const xmlChar *pref, + const xmlChar *name, + const xmlChar *str); +XMLPUBFUN int XMLCALL + xmlStrlen (const xmlChar *str); +XMLPUBFUN xmlChar * XMLCALL + xmlStrcat (xmlChar *cur, + const xmlChar *add); +XMLPUBFUN xmlChar * XMLCALL + xmlStrncat (xmlChar *cur, + const xmlChar *add, + int len); +XMLPUBFUN xmlChar * XMLCALL + xmlStrncatNew (const xmlChar *str1, + const xmlChar *str2, + int len); +XMLPUBFUN int XMLCALL + xmlStrPrintf (xmlChar *buf, + int len, + const xmlChar *msg, + ...); +XMLPUBFUN int XMLCALL + xmlStrVPrintf (xmlChar *buf, + int len, + const xmlChar *msg, + va_list ap); + +XMLPUBFUN int XMLCALL + xmlGetUTF8Char (const unsigned char *utf, + int *len); +XMLPUBFUN int XMLCALL + xmlCheckUTF8 (const unsigned char *utf); +XMLPUBFUN int XMLCALL + xmlUTF8Strsize (const xmlChar *utf, + int len); +XMLPUBFUN xmlChar * XMLCALL + xmlUTF8Strndup (const xmlChar *utf, + int len); +XMLPUBFUN const xmlChar * XMLCALL + xmlUTF8Strpos (const xmlChar *utf, + int pos); +XMLPUBFUN int XMLCALL + xmlUTF8Strloc (const xmlChar *utf, + const xmlChar *utfchar); +XMLPUBFUN xmlChar * XMLCALL + xmlUTF8Strsub (const xmlChar *utf, + int start, + int len); +XMLPUBFUN int XMLCALL + xmlUTF8Strlen (const xmlChar *utf); +XMLPUBFUN int XMLCALL + xmlUTF8Size (const xmlChar *utf); +XMLPUBFUN int XMLCALL + xmlUTF8Charcmp (const xmlChar *utf1, + const xmlChar *utf2); + +#ifdef __cplusplus +} +#endif +#endif /* __XML_STRING_H__ */ diff --git a/lib/libxml2/include/libxml/xmlunicode.h b/lib/libxml2/include/libxml/xmlunicode.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/xmlunicode.h @@ -0,0 +1,202 @@ +/* + * Summary: Unicode character APIs + * Description: API for the Unicode character APIs + * + * This file is automatically generated from the + * UCS description files of the Unicode Character Database + * http://www.unicode.org/Public/4.0-Update1/UCD-4.0.1.html + * using the genUnicode.py Python script. + * + * Generation date: Mon Mar 27 11:09:52 2006 + * Sources: Blocks-4.0.1.txt UnicodeData-4.0.1.txt + * Author: Daniel Veillard + */ + +#ifndef __XML_UNICODE_H__ +#define __XML_UNICODE_H__ + +#include + +#ifdef LIBXML_UNICODE_ENABLED + +#ifdef __cplusplus +extern "C" { +#endif + +XMLPUBFUN int XMLCALL xmlUCSIsAegeanNumbers (int code); +XMLPUBFUN int XMLCALL xmlUCSIsAlphabeticPresentationForms (int code); +XMLPUBFUN int XMLCALL xmlUCSIsArabic (int code); +XMLPUBFUN int XMLCALL xmlUCSIsArabicPresentationFormsA (int code); +XMLPUBFUN int XMLCALL xmlUCSIsArabicPresentationFormsB (int code); +XMLPUBFUN int XMLCALL xmlUCSIsArmenian (int code); +XMLPUBFUN int XMLCALL xmlUCSIsArrows (int code); +XMLPUBFUN int XMLCALL xmlUCSIsBasicLatin (int code); +XMLPUBFUN int XMLCALL xmlUCSIsBengali (int code); +XMLPUBFUN int XMLCALL xmlUCSIsBlockElements (int code); +XMLPUBFUN int XMLCALL xmlUCSIsBopomofo (int code); +XMLPUBFUN int XMLCALL xmlUCSIsBopomofoExtended (int code); +XMLPUBFUN int XMLCALL xmlUCSIsBoxDrawing (int code); +XMLPUBFUN int XMLCALL xmlUCSIsBraillePatterns (int code); +XMLPUBFUN int XMLCALL xmlUCSIsBuhid (int code); +XMLPUBFUN int XMLCALL xmlUCSIsByzantineMusicalSymbols (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCJKCompatibility (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCJKCompatibilityForms (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCJKCompatibilityIdeographs (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCJKCompatibilityIdeographsSupplement (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCJKRadicalsSupplement (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCJKSymbolsandPunctuation (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCJKUnifiedIdeographs (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCJKUnifiedIdeographsExtensionA (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCJKUnifiedIdeographsExtensionB (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCherokee (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCombiningDiacriticalMarks (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCombiningDiacriticalMarksforSymbols (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCombiningHalfMarks (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCombiningMarksforSymbols (int code); +XMLPUBFUN int XMLCALL xmlUCSIsControlPictures (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCurrencySymbols (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCypriotSyllabary (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCyrillic (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCyrillicSupplement (int code); +XMLPUBFUN int XMLCALL xmlUCSIsDeseret (int code); +XMLPUBFUN int XMLCALL xmlUCSIsDevanagari (int code); +XMLPUBFUN int XMLCALL xmlUCSIsDingbats (int code); +XMLPUBFUN int XMLCALL xmlUCSIsEnclosedAlphanumerics (int code); +XMLPUBFUN int XMLCALL xmlUCSIsEnclosedCJKLettersandMonths (int code); +XMLPUBFUN int XMLCALL xmlUCSIsEthiopic (int code); +XMLPUBFUN int XMLCALL xmlUCSIsGeneralPunctuation (int code); +XMLPUBFUN int XMLCALL xmlUCSIsGeometricShapes (int code); +XMLPUBFUN int XMLCALL xmlUCSIsGeorgian (int code); +XMLPUBFUN int XMLCALL xmlUCSIsGothic (int code); +XMLPUBFUN int XMLCALL xmlUCSIsGreek (int code); +XMLPUBFUN int XMLCALL xmlUCSIsGreekExtended (int code); +XMLPUBFUN int XMLCALL xmlUCSIsGreekandCoptic (int code); +XMLPUBFUN int XMLCALL xmlUCSIsGujarati (int code); +XMLPUBFUN int XMLCALL xmlUCSIsGurmukhi (int code); +XMLPUBFUN int XMLCALL xmlUCSIsHalfwidthandFullwidthForms (int code); +XMLPUBFUN int XMLCALL xmlUCSIsHangulCompatibilityJamo (int code); +XMLPUBFUN int XMLCALL xmlUCSIsHangulJamo (int code); +XMLPUBFUN int XMLCALL xmlUCSIsHangulSyllables (int code); +XMLPUBFUN int XMLCALL xmlUCSIsHanunoo (int code); +XMLPUBFUN int XMLCALL xmlUCSIsHebrew (int code); +XMLPUBFUN int XMLCALL xmlUCSIsHighPrivateUseSurrogates (int code); +XMLPUBFUN int XMLCALL xmlUCSIsHighSurrogates (int code); +XMLPUBFUN int XMLCALL xmlUCSIsHiragana (int code); +XMLPUBFUN int XMLCALL xmlUCSIsIPAExtensions (int code); +XMLPUBFUN int XMLCALL xmlUCSIsIdeographicDescriptionCharacters (int code); +XMLPUBFUN int XMLCALL xmlUCSIsKanbun (int code); +XMLPUBFUN int XMLCALL xmlUCSIsKangxiRadicals (int code); +XMLPUBFUN int XMLCALL xmlUCSIsKannada (int code); +XMLPUBFUN int XMLCALL xmlUCSIsKatakana (int code); +XMLPUBFUN int XMLCALL xmlUCSIsKatakanaPhoneticExtensions (int code); +XMLPUBFUN int XMLCALL xmlUCSIsKhmer (int code); +XMLPUBFUN int XMLCALL xmlUCSIsKhmerSymbols (int code); +XMLPUBFUN int XMLCALL xmlUCSIsLao (int code); +XMLPUBFUN int XMLCALL xmlUCSIsLatin1Supplement (int code); +XMLPUBFUN int XMLCALL xmlUCSIsLatinExtendedA (int code); +XMLPUBFUN int XMLCALL xmlUCSIsLatinExtendedB (int code); +XMLPUBFUN int XMLCALL xmlUCSIsLatinExtendedAdditional (int code); +XMLPUBFUN int XMLCALL xmlUCSIsLetterlikeSymbols (int code); +XMLPUBFUN int XMLCALL xmlUCSIsLimbu (int code); +XMLPUBFUN int XMLCALL xmlUCSIsLinearBIdeograms (int code); +XMLPUBFUN int XMLCALL xmlUCSIsLinearBSyllabary (int code); +XMLPUBFUN int XMLCALL xmlUCSIsLowSurrogates (int code); +XMLPUBFUN int XMLCALL xmlUCSIsMalayalam (int code); +XMLPUBFUN int XMLCALL xmlUCSIsMathematicalAlphanumericSymbols (int code); +XMLPUBFUN int XMLCALL xmlUCSIsMathematicalOperators (int code); +XMLPUBFUN int XMLCALL xmlUCSIsMiscellaneousMathematicalSymbolsA (int code); +XMLPUBFUN int XMLCALL xmlUCSIsMiscellaneousMathematicalSymbolsB (int code); +XMLPUBFUN int XMLCALL xmlUCSIsMiscellaneousSymbols (int code); +XMLPUBFUN int XMLCALL xmlUCSIsMiscellaneousSymbolsandArrows (int code); +XMLPUBFUN int XMLCALL xmlUCSIsMiscellaneousTechnical (int code); +XMLPUBFUN int XMLCALL xmlUCSIsMongolian (int code); +XMLPUBFUN int XMLCALL xmlUCSIsMusicalSymbols (int code); +XMLPUBFUN int XMLCALL xmlUCSIsMyanmar (int code); +XMLPUBFUN int XMLCALL xmlUCSIsNumberForms (int code); +XMLPUBFUN int XMLCALL xmlUCSIsOgham (int code); +XMLPUBFUN int XMLCALL xmlUCSIsOldItalic (int code); +XMLPUBFUN int XMLCALL xmlUCSIsOpticalCharacterRecognition (int code); +XMLPUBFUN int XMLCALL xmlUCSIsOriya (int code); +XMLPUBFUN int XMLCALL xmlUCSIsOsmanya (int code); +XMLPUBFUN int XMLCALL xmlUCSIsPhoneticExtensions (int code); +XMLPUBFUN int XMLCALL xmlUCSIsPrivateUse (int code); +XMLPUBFUN int XMLCALL xmlUCSIsPrivateUseArea (int code); +XMLPUBFUN int XMLCALL xmlUCSIsRunic (int code); +XMLPUBFUN int XMLCALL xmlUCSIsShavian (int code); +XMLPUBFUN int XMLCALL xmlUCSIsSinhala (int code); +XMLPUBFUN int XMLCALL xmlUCSIsSmallFormVariants (int code); +XMLPUBFUN int XMLCALL xmlUCSIsSpacingModifierLetters (int code); +XMLPUBFUN int XMLCALL xmlUCSIsSpecials (int code); +XMLPUBFUN int XMLCALL xmlUCSIsSuperscriptsandSubscripts (int code); +XMLPUBFUN int XMLCALL xmlUCSIsSupplementalArrowsA (int code); +XMLPUBFUN int XMLCALL xmlUCSIsSupplementalArrowsB (int code); +XMLPUBFUN int XMLCALL xmlUCSIsSupplementalMathematicalOperators (int code); +XMLPUBFUN int XMLCALL xmlUCSIsSupplementaryPrivateUseAreaA (int code); +XMLPUBFUN int XMLCALL xmlUCSIsSupplementaryPrivateUseAreaB (int code); +XMLPUBFUN int XMLCALL xmlUCSIsSyriac (int code); +XMLPUBFUN int XMLCALL xmlUCSIsTagalog (int code); +XMLPUBFUN int XMLCALL xmlUCSIsTagbanwa (int code); +XMLPUBFUN int XMLCALL xmlUCSIsTags (int code); +XMLPUBFUN int XMLCALL xmlUCSIsTaiLe (int code); +XMLPUBFUN int XMLCALL xmlUCSIsTaiXuanJingSymbols (int code); +XMLPUBFUN int XMLCALL xmlUCSIsTamil (int code); +XMLPUBFUN int XMLCALL xmlUCSIsTelugu (int code); +XMLPUBFUN int XMLCALL xmlUCSIsThaana (int code); +XMLPUBFUN int XMLCALL xmlUCSIsThai (int code); +XMLPUBFUN int XMLCALL xmlUCSIsTibetan (int code); +XMLPUBFUN int XMLCALL xmlUCSIsUgaritic (int code); +XMLPUBFUN int XMLCALL xmlUCSIsUnifiedCanadianAboriginalSyllabics (int code); +XMLPUBFUN int XMLCALL xmlUCSIsVariationSelectors (int code); +XMLPUBFUN int XMLCALL xmlUCSIsVariationSelectorsSupplement (int code); +XMLPUBFUN int XMLCALL xmlUCSIsYiRadicals (int code); +XMLPUBFUN int XMLCALL xmlUCSIsYiSyllables (int code); +XMLPUBFUN int XMLCALL xmlUCSIsYijingHexagramSymbols (int code); + +XMLPUBFUN int XMLCALL xmlUCSIsBlock (int code, const char *block); + +XMLPUBFUN int XMLCALL xmlUCSIsCatC (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCatCc (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCatCf (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCatCo (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCatCs (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCatL (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCatLl (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCatLm (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCatLo (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCatLt (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCatLu (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCatM (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCatMc (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCatMe (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCatMn (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCatN (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCatNd (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCatNl (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCatNo (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCatP (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCatPc (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCatPd (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCatPe (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCatPf (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCatPi (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCatPo (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCatPs (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCatS (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCatSc (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCatSk (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCatSm (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCatSo (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCatZ (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCatZl (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCatZp (int code); +XMLPUBFUN int XMLCALL xmlUCSIsCatZs (int code); + +XMLPUBFUN int XMLCALL xmlUCSIsCat (int code, const char *cat); + +#ifdef __cplusplus +} +#endif + +#endif /* LIBXML_UNICODE_ENABLED */ + +#endif /* __XML_UNICODE_H__ */ diff --git a/lib/libxml2/include/libxml/xmlversion.h b/lib/libxml2/include/libxml/xmlversion.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/xmlversion.h @@ -0,0 +1,458 @@ +/* + * Summary: compile-time version informations + * Description: compile-time version informations for the XML library + * + * Copy: See Copyright for the status of this software. + * + * Author: Daniel Veillard + */ + +#ifndef __XML_VERSION_H__ +#define __XML_VERSION_H__ + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * use those to be sure nothing nasty will happen if + * your library and includes mismatch + */ +#ifndef LIBXML2_COMPILING_MSCCDEF +XMLPUBFUN void XMLCALL xmlCheckVersion(int version); +#endif /* LIBXML2_COMPILING_MSCCDEF */ + +/** + * LIBXML_DOTTED_VERSION: + * + * the version string like "1.2.3" + */ +#define LIBXML_DOTTED_VERSION "2.7.7" + +/** + * LIBXML_VERSION: + * + * the version number: 1.2.3 value is 10203 + */ +#define LIBXML_VERSION 20707 + +/** + * LIBXML_VERSION_STRING: + * + * the version number string, 1.2.3 value is "10203" + */ +#define LIBXML_VERSION_STRING "20707" + +/** + * LIBXML_VERSION_EXTRA: + * + * extra version information, used to show a CVS compilation + */ +#define LIBXML_VERSION_EXTRA "" + +/** + * LIBXML_TEST_VERSION: + * + * Macro to check that the libxml version in use is compatible with + * the version the software has been compiled against + */ +#define LIBXML_TEST_VERSION xmlCheckVersion(20707); + +#ifndef VMS +#if 0 +/** + * WITH_TRIO: + * + * defined if the trio support need to be configured in + */ +#define WITH_TRIO +#else +/** + * WITHOUT_TRIO: + * + * defined if the trio support should not be configured in + */ +#define WITHOUT_TRIO +#endif +#else /* VMS */ +/** + * WITH_TRIO: + * + * defined if the trio support need to be configured in + */ +#define WITH_TRIO 1 +#endif /* VMS */ + +/** + * LIBXML_THREAD_ENABLED: + * + * Whether the thread support is configured in + */ +#if 1 +#if defined(_REENTRANT) || defined(__MT__) || \ + (defined(_POSIX_C_SOURCE) && (_POSIX_C_SOURCE - 0 >= 199506L)) +#define LIBXML_THREAD_ENABLED +#endif +#endif + +/** + * LIBXML_TREE_ENABLED: + * + * Whether the DOM like tree manipulation API support is configured in + */ +#if 1 +#define LIBXML_TREE_ENABLED +#endif + +/** + * LIBXML_OUTPUT_ENABLED: + * + * Whether the serialization/saving support is configured in + */ +#if 1 +#define LIBXML_OUTPUT_ENABLED +#endif + +/** + * LIBXML_PUSH_ENABLED: + * + * Whether the push parsing interfaces are configured in + */ +#if 1 +#define LIBXML_PUSH_ENABLED +#endif + +/** + * LIBXML_READER_ENABLED: + * + * Whether the xmlReader parsing interface is configured in + */ +#if 1 +#define LIBXML_READER_ENABLED +#endif + +/** + * LIBXML_PATTERN_ENABLED: + * + * Whether the xmlPattern node selection interface is configured in + */ +#if 1 +#define LIBXML_PATTERN_ENABLED +#endif + +/** + * LIBXML_WRITER_ENABLED: + * + * Whether the xmlWriter saving interface is configured in + */ +#if 1 +#define LIBXML_WRITER_ENABLED +#endif + +/** + * LIBXML_SAX1_ENABLED: + * + * Whether the older SAX1 interface is configured in + */ +#if 1 +#define LIBXML_SAX1_ENABLED +#endif + +/** + * LIBXML_FTP_ENABLED: + * + * Whether the FTP support is configured in + */ +#if 1 +#define LIBXML_FTP_ENABLED +#endif + +/** + * LIBXML_HTTP_ENABLED: + * + * Whether the HTTP support is configured in + */ +#if 1 +#define LIBXML_HTTP_ENABLED +#endif + +/** + * LIBXML_VALID_ENABLED: + * + * Whether the DTD validation support is configured in + */ +#if 1 +#define LIBXML_VALID_ENABLED +#endif + +/** + * LIBXML_HTML_ENABLED: + * + * Whether the HTML support is configured in + */ +#if 1 +#define LIBXML_HTML_ENABLED +#endif + +/** + * LIBXML_LEGACY_ENABLED: + * + * Whether the deprecated APIs are compiled in for compatibility + */ +#if 1 +#define LIBXML_LEGACY_ENABLED +#endif + +/** + * LIBXML_C14N_ENABLED: + * + * Whether the Canonicalization support is configured in + */ +#if 1 +#define LIBXML_C14N_ENABLED +#endif + +/** + * LIBXML_CATALOG_ENABLED: + * + * Whether the Catalog support is configured in + */ +#if 1 +#define LIBXML_CATALOG_ENABLED +#endif + +/** + * LIBXML_DOCB_ENABLED: + * + * Whether the SGML Docbook support is configured in + */ +#if 1 +#define LIBXML_DOCB_ENABLED +#endif + +/** + * LIBXML_XPATH_ENABLED: + * + * Whether XPath is configured in + */ +#if 1 +#define LIBXML_XPATH_ENABLED +#endif + +/** + * LIBXML_XPTR_ENABLED: + * + * Whether XPointer is configured in + */ +#if 1 +#define LIBXML_XPTR_ENABLED +#endif + +/** + * LIBXML_XINCLUDE_ENABLED: + * + * Whether XInclude is configured in + */ +#if 1 +#define LIBXML_XINCLUDE_ENABLED +#endif + +/** + * LIBXML_ICONV_ENABLED: + * + * Whether iconv support is available + */ +#if 1 +#define LIBXML_ICONV_ENABLED +#endif + +/** + * LIBXML_ISO8859X_ENABLED: + * + * Whether ISO-8859-* support is made available in case iconv is not + */ +#if 0 +#define LIBXML_ISO8859X_ENABLED +#endif + +/** + * LIBXML_DEBUG_ENABLED: + * + * Whether Debugging module is configured in + */ +#if 1 +#define LIBXML_DEBUG_ENABLED +#endif + +/** + * DEBUG_MEMORY_LOCATION: + * + * Whether the memory debugging is configured in + */ +#if 0 +#define DEBUG_MEMORY_LOCATION +#endif + +/** + * LIBXML_DEBUG_RUNTIME: + * + * Whether the runtime debugging is configured in + */ +#if 0 +#define LIBXML_DEBUG_RUNTIME +#endif + +/** + * LIBXML_UNICODE_ENABLED: + * + * Whether the Unicode related interfaces are compiled in + */ +#if 1 +#define LIBXML_UNICODE_ENABLED +#endif + +/** + * LIBXML_REGEXP_ENABLED: + * + * Whether the regular expressions interfaces are compiled in + */ +#if 1 +#define LIBXML_REGEXP_ENABLED +#endif + +/** + * LIBXML_AUTOMATA_ENABLED: + * + * Whether the automata interfaces are compiled in + */ +#if 1 +#define LIBXML_AUTOMATA_ENABLED +#endif + +/** + * LIBXML_EXPR_ENABLED: + * + * Whether the formal expressions interfaces are compiled in + */ +#if 1 +#define LIBXML_EXPR_ENABLED +#endif + +/** + * LIBXML_SCHEMAS_ENABLED: + * + * Whether the Schemas validation interfaces are compiled in + */ +#if 1 +#define LIBXML_SCHEMAS_ENABLED +#endif + +/** + * LIBXML_SCHEMATRON_ENABLED: + * + * Whether the Schematron validation interfaces are compiled in + */ +#if 1 +#define LIBXML_SCHEMATRON_ENABLED +#endif + +/** + * LIBXML_MODULES_ENABLED: + * + * Whether the module interfaces are compiled in + */ +#if 1 +#define LIBXML_MODULES_ENABLED +/** + * LIBXML_MODULE_EXTENSION: + * + * the string suffix used by dynamic modules (usually shared libraries) + */ +#define LIBXML_MODULE_EXTENSION ".dll" +#endif + +/** + * LIBXML_ZLIB_ENABLED: + * + * Whether the Zlib support is compiled in + */ +#if 0 +#define LIBXML_ZLIB_ENABLED +#endif + +#ifdef __GNUC__ +#ifdef HAVE_ANSIDECL_H +#include +#endif + +/** + * ATTRIBUTE_UNUSED: + * + * Macro used to signal to GCC unused function parameters + */ + +#ifndef ATTRIBUTE_UNUSED +#define ATTRIBUTE_UNUSED __attribute__((unused)) +#endif + +/** + * LIBXML_ATTR_ALLOC_SIZE: + * + * Macro used to indicate to GCC this is an allocator function + */ + +#ifndef LIBXML_ATTR_ALLOC_SIZE +# if ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 3))) +# define LIBXML_ATTR_ALLOC_SIZE(x) __attribute__((alloc_size(x))) +# else +# define LIBXML_ATTR_ALLOC_SIZE(x) +# endif +#else +# define LIBXML_ATTR_ALLOC_SIZE(x) +#endif + +/** + * LIBXML_ATTR_FORMAT: + * + * Macro used to indicate to GCC the parameter are printf like + */ + +#ifndef LIBXML_ATTR_FORMAT +# if ((__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3))) +# define LIBXML_ATTR_FORMAT(fmt,args) __attribute__((__format__(__printf__,fmt,args))) +# else +# define LIBXML_ATTR_FORMAT(fmt,args) +# endif +#else +# define LIBXML_ATTR_FORMAT(fmt,args) +#endif + +#else /* ! __GNUC__ */ +/** + * ATTRIBUTE_UNUSED: + * + * Macro used to signal to GCC unused function parameters + */ +#define ATTRIBUTE_UNUSED +/** + * LIBXML_ATTR_ALLOC_SIZE: + * + * Macro used to indicate to GCC this is an allocator function + */ +#define LIBXML_ATTR_ALLOC_SIZE(x) +/** + * LIBXML_ATTR_FORMAT: + * + * Macro used to indicate to GCC the parameter are printf like + */ +#define LIBXML_ATTR_FORMAT(fmt,args) +#endif /* __GNUC__ */ + +#ifdef __cplusplus +} +#endif /* __cplusplus */ +#endif + + diff --git a/lib/libxml2/include/libxml/xmlwin32version.h b/lib/libxml2/include/libxml/xmlwin32version.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/xmlwin32version.h @@ -0,0 +1,242 @@ +/* + * Summary: compile-time version informations on Windows + * Description: compile-time version informations for the XML library + * when compiled on the Windows platform + * + * Copy: See Copyright for the status of this software. + * + * Author: Daniel Veillard + */ + +#ifndef __XML_VERSION_H__ +#define __XML_VERSION_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * use those to be sure nothing nasty will happen if + * your library and includes mismatch + */ +#ifndef LIBXML2_COMPILING_MSCCDEF +extern void xmlCheckVersion(int version); +#endif /* LIBXML2_COMPILING_MSCCDEF */ + +/** + * LIBXML_DOTTED_VERSION: + * + * the version string like "1.2.3" + */ +#define LIBXML_DOTTED_VERSION "2.4.26" + +/** + * LIBXML_VERSION: + * + * the version number: 1.2.3 value is 1002003 + */ +#define LIBXML_VERSION 20426 + +/** + * LIBXML_VERSION_STRING: + * + * the version number string, 1.2.3 value is "1002003" + */ +#define LIBXML_VERSION_STRING "20426" + +/** + * LIBXML_TEST_VERSION: + * + * Macro to check that the libxml version in use is compatible with + * the version the software has been compiled against + */ +#define LIBXML_TEST_VERSION xmlCheckVersion(20426); + +#if 0 +/** + * WITH_TRIO: + * + * defined if the trio support need to be configured in + */ +#define WITH_TRIO +#else +/** + * WITHOUT_TRIO: + * + * defined if the trio support should not be configured in + */ +#define WITHOUT_TRIO +#endif + +/** + * LIBXML_THREAD_ENABLED: + * + * Whether the thread support is configured in + */ +#if 0 +#define LIBXML_THREAD_ENABLED +#endif + +/** + * LIBXML_FTP_ENABLED: + * + * Whether the FTP support is configured in + */ +#if 1 +#define LIBXML_FTP_ENABLED +#endif + +/** + * LIBXML_HTTP_ENABLED: + * + * Whether the HTTP support is configured in + */ +#if 1 +#define LIBXML_HTTP_ENABLED +#endif + +/** + * LIBXML_HTML_ENABLED: + * + * Whether the HTML support is configured in + */ +#if 1 +#define LIBXML_HTML_ENABLED +#endif + +/** + * LIBXML_CATALOG_ENABLED: + * + * Whether the Catalog support is configured in + */ +#if 1 +#define LIBXML_CATALOG_ENABLED +#endif + +/** + * LIBXML_DOCB_ENABLED: + * + * Whether the SGML Docbook support is configured in + */ +#if 1 +#define LIBXML_DOCB_ENABLED +#endif + +/** + * LIBXML_XPATH_ENABLED: + * + * Whether XPath is configured in + */ +#if 1 +#define LIBXML_XPATH_ENABLED +#endif + +/** + * LIBXML_XPTR_ENABLED: + * + * Whether XPointer is configured in + */ +#if 1 +#define LIBXML_XPTR_ENABLED +#endif + +/** + * LIBXML_C14N_ENABLED: + * + * Whether the Canonicalization support is configured in + */ +#if 0 +#define LIBXML_C14N_ENABLED +#endif + +/** + * LIBXML_XINCLUDE_ENABLED: + * + * Whether XInclude is configured in + */ +#if 1 +#define LIBXML_XINCLUDE_ENABLED +#endif + +/** + * LIBXML_ICONV_ENABLED: + * + * Whether iconv support is available + */ +#if 0 +#define LIBXML_ICONV_ENABLED +#endif + +/** + * LIBXML_DEBUG_ENABLED: + * + * Whether Debugging module is configured in + */ +#if 1 +#define LIBXML_DEBUG_ENABLED +#endif + +/** + * DEBUG_MEMORY_LOCATION: + * + * Whether the memory debugging is configured in + */ +#if 0 +#define DEBUG_MEMORY_LOCATION +#endif + +/** + * LIBXML_DLL_IMPORT: + * + * Used on Windows (MS C compiler only) to declare a variable as + * imported from the library. This macro should be empty when compiling + * libxml itself. It should expand to __declspec(dllimport) + * when the client code includes this header, and that only if the client + * links dynamically against libxml. + * For this to work, we need three macros. One tells us which compiler is + * being used and luckily the compiler defines such a thing: _MSC_VER. The + * second macro tells us if we are compiling libxml or the client code and + * we define the macro IN_LIBXML on the compiler's command line for this + * purpose. The third macro, LIBXML_STATIC, must be defined by any client + * code which links against libxml statically. + */ +#ifndef LIBXML_DLL_IMPORT +#if defined(_MSC_VER) && !defined(IN_LIBXML) && !defined(LIBXML_STATIC) +#define LIBXML_DLL_IMPORT __declspec(dllimport) +#else +#define LIBXML_DLL_IMPORT +#endif +#endif + +/** + * ATTRIBUTE_UNUSED: + * + * Macro used to signal to GCC unused function parameters + */ +#ifdef __GNUC__ +#ifdef HAVE_ANSIDECL_H +#include +#endif +#ifndef ATTRIBUTE_UNUSED +#define ATTRIBUTE_UNUSED +#endif +#else +#define ATTRIBUTE_UNUSED +#endif + +/* + * #pragma comment(lib, "iconv.lib") + * + * pragma understood my MS compiler which enables a conditional link with + * iconv. + */ +#ifdef _MSC_VER +#if defined LIBXML_ICONV_ENABLED && !defined LIBXML2_COMPILING_MSCCDEF +#pragma comment(lib, "iconv.lib") +#endif +#endif + +#ifdef __cplusplus +} +#endif /* __cplusplus */ +#endif diff --git a/lib/libxml2/include/libxml/xmlwriter.h b/lib/libxml2/include/libxml/xmlwriter.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/xmlwriter.h @@ -0,0 +1,485 @@ + +/* + * Summary: text writing API for XML + * Description: text writing API for XML + * + * Copy: See Copyright for the status of this software. + * + * Author: Alfred Mickautsch + */ + +#ifndef __XML_XMLWRITER_H__ +#define __XML_XMLWRITER_H__ + +#include + +#ifdef LIBXML_WRITER_ENABLED + +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + + typedef struct _xmlTextWriter xmlTextWriter; + typedef xmlTextWriter *xmlTextWriterPtr; + +/* + * Constructors & Destructor + */ + XMLPUBFUN xmlTextWriterPtr XMLCALL + xmlNewTextWriter(xmlOutputBufferPtr out); + XMLPUBFUN xmlTextWriterPtr XMLCALL + xmlNewTextWriterFilename(const char *uri, int compression); + XMLPUBFUN xmlTextWriterPtr XMLCALL + xmlNewTextWriterMemory(xmlBufferPtr buf, int compression); + XMLPUBFUN xmlTextWriterPtr XMLCALL + xmlNewTextWriterPushParser(xmlParserCtxtPtr ctxt, int compression); + XMLPUBFUN xmlTextWriterPtr XMLCALL + xmlNewTextWriterDoc(xmlDocPtr * doc, int compression); + XMLPUBFUN xmlTextWriterPtr XMLCALL + xmlNewTextWriterTree(xmlDocPtr doc, xmlNodePtr node, + int compression); + XMLPUBFUN void XMLCALL xmlFreeTextWriter(xmlTextWriterPtr writer); + +/* + * Functions + */ + + +/* + * Document + */ + XMLPUBFUN int XMLCALL + xmlTextWriterStartDocument(xmlTextWriterPtr writer, + const char *version, + const char *encoding, + const char *standalone); + XMLPUBFUN int XMLCALL xmlTextWriterEndDocument(xmlTextWriterPtr + writer); + +/* + * Comments + */ + XMLPUBFUN int XMLCALL xmlTextWriterStartComment(xmlTextWriterPtr + writer); + XMLPUBFUN int XMLCALL xmlTextWriterEndComment(xmlTextWriterPtr writer); + XMLPUBFUN int XMLCALL + xmlTextWriterWriteFormatComment(xmlTextWriterPtr writer, + const char *format, ...) + LIBXML_ATTR_FORMAT(2,3); + XMLPUBFUN int XMLCALL + xmlTextWriterWriteVFormatComment(xmlTextWriterPtr writer, + const char *format, + va_list argptr) + LIBXML_ATTR_FORMAT(2,0); + XMLPUBFUN int XMLCALL xmlTextWriterWriteComment(xmlTextWriterPtr + writer, + const xmlChar * + content); + +/* + * Elements + */ + XMLPUBFUN int XMLCALL + xmlTextWriterStartElement(xmlTextWriterPtr writer, + const xmlChar * name); + XMLPUBFUN int XMLCALL xmlTextWriterStartElementNS(xmlTextWriterPtr + writer, + const xmlChar * + prefix, + const xmlChar * name, + const xmlChar * + namespaceURI); + XMLPUBFUN int XMLCALL xmlTextWriterEndElement(xmlTextWriterPtr writer); + XMLPUBFUN int XMLCALL xmlTextWriterFullEndElement(xmlTextWriterPtr + writer); + +/* + * Elements conveniency functions + */ + XMLPUBFUN int XMLCALL + xmlTextWriterWriteFormatElement(xmlTextWriterPtr writer, + const xmlChar * name, + const char *format, ...) + LIBXML_ATTR_FORMAT(3,4); + XMLPUBFUN int XMLCALL + xmlTextWriterWriteVFormatElement(xmlTextWriterPtr writer, + const xmlChar * name, + const char *format, + va_list argptr) + LIBXML_ATTR_FORMAT(3,0); + XMLPUBFUN int XMLCALL xmlTextWriterWriteElement(xmlTextWriterPtr + writer, + const xmlChar * name, + const xmlChar * + content); + XMLPUBFUN int XMLCALL + xmlTextWriterWriteFormatElementNS(xmlTextWriterPtr writer, + const xmlChar * prefix, + const xmlChar * name, + const xmlChar * namespaceURI, + const char *format, ...) + LIBXML_ATTR_FORMAT(5,6); + XMLPUBFUN int XMLCALL + xmlTextWriterWriteVFormatElementNS(xmlTextWriterPtr writer, + const xmlChar * prefix, + const xmlChar * name, + const xmlChar * namespaceURI, + const char *format, + va_list argptr) + LIBXML_ATTR_FORMAT(5,0); + XMLPUBFUN int XMLCALL xmlTextWriterWriteElementNS(xmlTextWriterPtr + writer, + const xmlChar * + prefix, + const xmlChar * name, + const xmlChar * + namespaceURI, + const xmlChar * + content); + +/* + * Text + */ + XMLPUBFUN int XMLCALL + xmlTextWriterWriteFormatRaw(xmlTextWriterPtr writer, + const char *format, ...) + LIBXML_ATTR_FORMAT(2,3); + XMLPUBFUN int XMLCALL + xmlTextWriterWriteVFormatRaw(xmlTextWriterPtr writer, + const char *format, va_list argptr) + LIBXML_ATTR_FORMAT(2,0); + XMLPUBFUN int XMLCALL + xmlTextWriterWriteRawLen(xmlTextWriterPtr writer, + const xmlChar * content, int len); + XMLPUBFUN int XMLCALL + xmlTextWriterWriteRaw(xmlTextWriterPtr writer, + const xmlChar * content); + XMLPUBFUN int XMLCALL xmlTextWriterWriteFormatString(xmlTextWriterPtr + writer, + const char + *format, ...) + LIBXML_ATTR_FORMAT(2,3); + XMLPUBFUN int XMLCALL xmlTextWriterWriteVFormatString(xmlTextWriterPtr + writer, + const char + *format, + va_list argptr) + LIBXML_ATTR_FORMAT(2,0); + XMLPUBFUN int XMLCALL xmlTextWriterWriteString(xmlTextWriterPtr writer, + const xmlChar * + content); + XMLPUBFUN int XMLCALL xmlTextWriterWriteBase64(xmlTextWriterPtr writer, + const char *data, + int start, int len); + XMLPUBFUN int XMLCALL xmlTextWriterWriteBinHex(xmlTextWriterPtr writer, + const char *data, + int start, int len); + +/* + * Attributes + */ + XMLPUBFUN int XMLCALL + xmlTextWriterStartAttribute(xmlTextWriterPtr writer, + const xmlChar * name); + XMLPUBFUN int XMLCALL xmlTextWriterStartAttributeNS(xmlTextWriterPtr + writer, + const xmlChar * + prefix, + const xmlChar * + name, + const xmlChar * + namespaceURI); + XMLPUBFUN int XMLCALL xmlTextWriterEndAttribute(xmlTextWriterPtr + writer); + +/* + * Attributes conveniency functions + */ + XMLPUBFUN int XMLCALL + xmlTextWriterWriteFormatAttribute(xmlTextWriterPtr writer, + const xmlChar * name, + const char *format, ...) + LIBXML_ATTR_FORMAT(3,4); + XMLPUBFUN int XMLCALL + xmlTextWriterWriteVFormatAttribute(xmlTextWriterPtr writer, + const xmlChar * name, + const char *format, + va_list argptr) + LIBXML_ATTR_FORMAT(3,0); + XMLPUBFUN int XMLCALL xmlTextWriterWriteAttribute(xmlTextWriterPtr + writer, + const xmlChar * name, + const xmlChar * + content); + XMLPUBFUN int XMLCALL + xmlTextWriterWriteFormatAttributeNS(xmlTextWriterPtr writer, + const xmlChar * prefix, + const xmlChar * name, + const xmlChar * namespaceURI, + const char *format, ...) + LIBXML_ATTR_FORMAT(5,6); + XMLPUBFUN int XMLCALL + xmlTextWriterWriteVFormatAttributeNS(xmlTextWriterPtr writer, + const xmlChar * prefix, + const xmlChar * name, + const xmlChar * namespaceURI, + const char *format, + va_list argptr) + LIBXML_ATTR_FORMAT(5,0); + XMLPUBFUN int XMLCALL xmlTextWriterWriteAttributeNS(xmlTextWriterPtr + writer, + const xmlChar * + prefix, + const xmlChar * + name, + const xmlChar * + namespaceURI, + const xmlChar * + content); + +/* + * PI's + */ + XMLPUBFUN int XMLCALL + xmlTextWriterStartPI(xmlTextWriterPtr writer, + const xmlChar * target); + XMLPUBFUN int XMLCALL xmlTextWriterEndPI(xmlTextWriterPtr writer); + +/* + * PI conveniency functions + */ + XMLPUBFUN int XMLCALL + xmlTextWriterWriteFormatPI(xmlTextWriterPtr writer, + const xmlChar * target, + const char *format, ...) + LIBXML_ATTR_FORMAT(3,4); + XMLPUBFUN int XMLCALL + xmlTextWriterWriteVFormatPI(xmlTextWriterPtr writer, + const xmlChar * target, + const char *format, va_list argptr) + LIBXML_ATTR_FORMAT(3,0); + XMLPUBFUN int XMLCALL + xmlTextWriterWritePI(xmlTextWriterPtr writer, + const xmlChar * target, + const xmlChar * content); + +/** + * xmlTextWriterWriteProcessingInstruction: + * + * This macro maps to xmlTextWriterWritePI + */ +#define xmlTextWriterWriteProcessingInstruction xmlTextWriterWritePI + +/* + * CDATA + */ + XMLPUBFUN int XMLCALL xmlTextWriterStartCDATA(xmlTextWriterPtr writer); + XMLPUBFUN int XMLCALL xmlTextWriterEndCDATA(xmlTextWriterPtr writer); + +/* + * CDATA conveniency functions + */ + XMLPUBFUN int XMLCALL + xmlTextWriterWriteFormatCDATA(xmlTextWriterPtr writer, + const char *format, ...) + LIBXML_ATTR_FORMAT(2,3); + XMLPUBFUN int XMLCALL + xmlTextWriterWriteVFormatCDATA(xmlTextWriterPtr writer, + const char *format, va_list argptr) + LIBXML_ATTR_FORMAT(2,0); + XMLPUBFUN int XMLCALL + xmlTextWriterWriteCDATA(xmlTextWriterPtr writer, + const xmlChar * content); + +/* + * DTD + */ + XMLPUBFUN int XMLCALL + xmlTextWriterStartDTD(xmlTextWriterPtr writer, + const xmlChar * name, + const xmlChar * pubid, + const xmlChar * sysid); + XMLPUBFUN int XMLCALL xmlTextWriterEndDTD(xmlTextWriterPtr writer); + +/* + * DTD conveniency functions + */ + XMLPUBFUN int XMLCALL + xmlTextWriterWriteFormatDTD(xmlTextWriterPtr writer, + const xmlChar * name, + const xmlChar * pubid, + const xmlChar * sysid, + const char *format, ...) + LIBXML_ATTR_FORMAT(5,6); + XMLPUBFUN int XMLCALL + xmlTextWriterWriteVFormatDTD(xmlTextWriterPtr writer, + const xmlChar * name, + const xmlChar * pubid, + const xmlChar * sysid, + const char *format, va_list argptr) + LIBXML_ATTR_FORMAT(5,0); + XMLPUBFUN int XMLCALL + xmlTextWriterWriteDTD(xmlTextWriterPtr writer, + const xmlChar * name, + const xmlChar * pubid, + const xmlChar * sysid, + const xmlChar * subset); + +/** + * xmlTextWriterWriteDocType: + * + * this macro maps to xmlTextWriterWriteDTD + */ +#define xmlTextWriterWriteDocType xmlTextWriterWriteDTD + +/* + * DTD element definition + */ + XMLPUBFUN int XMLCALL + xmlTextWriterStartDTDElement(xmlTextWriterPtr writer, + const xmlChar * name); + XMLPUBFUN int XMLCALL xmlTextWriterEndDTDElement(xmlTextWriterPtr + writer); + +/* + * DTD element definition conveniency functions + */ + XMLPUBFUN int XMLCALL + xmlTextWriterWriteFormatDTDElement(xmlTextWriterPtr writer, + const xmlChar * name, + const char *format, ...) + LIBXML_ATTR_FORMAT(3,4); + XMLPUBFUN int XMLCALL + xmlTextWriterWriteVFormatDTDElement(xmlTextWriterPtr writer, + const xmlChar * name, + const char *format, + va_list argptr) + LIBXML_ATTR_FORMAT(3,0); + XMLPUBFUN int XMLCALL xmlTextWriterWriteDTDElement(xmlTextWriterPtr + writer, + const xmlChar * + name, + const xmlChar * + content); + +/* + * DTD attribute list definition + */ + XMLPUBFUN int XMLCALL + xmlTextWriterStartDTDAttlist(xmlTextWriterPtr writer, + const xmlChar * name); + XMLPUBFUN int XMLCALL xmlTextWriterEndDTDAttlist(xmlTextWriterPtr + writer); + +/* + * DTD attribute list definition conveniency functions + */ + XMLPUBFUN int XMLCALL + xmlTextWriterWriteFormatDTDAttlist(xmlTextWriterPtr writer, + const xmlChar * name, + const char *format, ...) + LIBXML_ATTR_FORMAT(3,4); + XMLPUBFUN int XMLCALL + xmlTextWriterWriteVFormatDTDAttlist(xmlTextWriterPtr writer, + const xmlChar * name, + const char *format, + va_list argptr) + LIBXML_ATTR_FORMAT(3,0); + XMLPUBFUN int XMLCALL xmlTextWriterWriteDTDAttlist(xmlTextWriterPtr + writer, + const xmlChar * + name, + const xmlChar * + content); + +/* + * DTD entity definition + */ + XMLPUBFUN int XMLCALL + xmlTextWriterStartDTDEntity(xmlTextWriterPtr writer, + int pe, const xmlChar * name); + XMLPUBFUN int XMLCALL xmlTextWriterEndDTDEntity(xmlTextWriterPtr + writer); + +/* + * DTD entity definition conveniency functions + */ + XMLPUBFUN int XMLCALL + xmlTextWriterWriteFormatDTDInternalEntity(xmlTextWriterPtr writer, + int pe, + const xmlChar * name, + const char *format, ...) + LIBXML_ATTR_FORMAT(4,5); + XMLPUBFUN int XMLCALL + xmlTextWriterWriteVFormatDTDInternalEntity(xmlTextWriterPtr writer, + int pe, + const xmlChar * name, + const char *format, + va_list argptr) + LIBXML_ATTR_FORMAT(4,0); + XMLPUBFUN int XMLCALL + xmlTextWriterWriteDTDInternalEntity(xmlTextWriterPtr writer, + int pe, + const xmlChar * name, + const xmlChar * content); + XMLPUBFUN int XMLCALL + xmlTextWriterWriteDTDExternalEntity(xmlTextWriterPtr writer, + int pe, + const xmlChar * name, + const xmlChar * pubid, + const xmlChar * sysid, + const xmlChar * ndataid); + XMLPUBFUN int XMLCALL + xmlTextWriterWriteDTDExternalEntityContents(xmlTextWriterPtr + writer, + const xmlChar * pubid, + const xmlChar * sysid, + const xmlChar * + ndataid); + XMLPUBFUN int XMLCALL xmlTextWriterWriteDTDEntity(xmlTextWriterPtr + writer, int pe, + const xmlChar * name, + const xmlChar * + pubid, + const xmlChar * + sysid, + const xmlChar * + ndataid, + const xmlChar * + content); + +/* + * DTD notation definition + */ + XMLPUBFUN int XMLCALL + xmlTextWriterWriteDTDNotation(xmlTextWriterPtr writer, + const xmlChar * name, + const xmlChar * pubid, + const xmlChar * sysid); + +/* + * Indentation + */ + XMLPUBFUN int XMLCALL + xmlTextWriterSetIndent(xmlTextWriterPtr writer, int indent); + XMLPUBFUN int XMLCALL + xmlTextWriterSetIndentString(xmlTextWriterPtr writer, + const xmlChar * str); + +/* + * misc + */ + XMLPUBFUN int XMLCALL xmlTextWriterFlush(xmlTextWriterPtr writer); + +#ifdef __cplusplus +} +#endif + +#endif /* LIBXML_WRITER_ENABLED */ + +#endif /* __XML_XMLWRITER_H__ */ diff --git a/lib/libxml2/include/libxml/xpath.h b/lib/libxml2/include/libxml/xpath.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/xpath.h @@ -0,0 +1,546 @@ +/* + * Summary: XML Path Language implementation + * Description: API for the XML Path Language implementation + * + * XML Path Language implementation + * XPath is a language for addressing parts of an XML document, + * designed to be used by both XSLT and XPointer + * http://www.w3.org/TR/xpath + * + * Implements + * W3C Recommendation 16 November 1999 + * http://www.w3.org/TR/1999/REC-xpath-19991116 + * + * Copy: See Copyright for the status of this software. + * + * Author: Daniel Veillard + */ + +#ifndef __XML_XPATH_H__ +#define __XML_XPATH_H__ + +#include + +#ifdef LIBXML_XPATH_ENABLED + +#include +#include +#include +#endif /* LIBXML_XPATH_ENABLED */ + +#if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) +#ifdef __cplusplus +extern "C" { +#endif +#endif /* LIBXML_XPATH_ENABLED or LIBXML_SCHEMAS_ENABLED */ + +#ifdef LIBXML_XPATH_ENABLED + +typedef struct _xmlXPathContext xmlXPathContext; +typedef xmlXPathContext *xmlXPathContextPtr; +typedef struct _xmlXPathParserContext xmlXPathParserContext; +typedef xmlXPathParserContext *xmlXPathParserContextPtr; + +/** + * The set of XPath error codes. + */ + +typedef enum { + XPATH_EXPRESSION_OK = 0, + XPATH_NUMBER_ERROR, + XPATH_UNFINISHED_LITERAL_ERROR, + XPATH_START_LITERAL_ERROR, + XPATH_VARIABLE_REF_ERROR, + XPATH_UNDEF_VARIABLE_ERROR, + XPATH_INVALID_PREDICATE_ERROR, + XPATH_EXPR_ERROR, + XPATH_UNCLOSED_ERROR, + XPATH_UNKNOWN_FUNC_ERROR, + XPATH_INVALID_OPERAND, + XPATH_INVALID_TYPE, + XPATH_INVALID_ARITY, + XPATH_INVALID_CTXT_SIZE, + XPATH_INVALID_CTXT_POSITION, + XPATH_MEMORY_ERROR, + XPTR_SYNTAX_ERROR, + XPTR_RESOURCE_ERROR, + XPTR_SUB_RESOURCE_ERROR, + XPATH_UNDEF_PREFIX_ERROR, + XPATH_ENCODING_ERROR, + XPATH_INVALID_CHAR_ERROR, + XPATH_INVALID_CTXT +} xmlXPathError; + +/* + * A node-set (an unordered collection of nodes without duplicates). + */ +typedef struct _xmlNodeSet xmlNodeSet; +typedef xmlNodeSet *xmlNodeSetPtr; +struct _xmlNodeSet { + int nodeNr; /* number of nodes in the set */ + int nodeMax; /* size of the array as allocated */ + xmlNodePtr *nodeTab; /* array of nodes in no particular order */ + /* @@ with_ns to check wether namespace nodes should be looked at @@ */ +}; + +/* + * An expression is evaluated to yield an object, which + * has one of the following four basic types: + * - node-set + * - boolean + * - number + * - string + * + * @@ XPointer will add more types ! + */ + +typedef enum { + XPATH_UNDEFINED = 0, + XPATH_NODESET = 1, + XPATH_BOOLEAN = 2, + XPATH_NUMBER = 3, + XPATH_STRING = 4, + XPATH_POINT = 5, + XPATH_RANGE = 6, + XPATH_LOCATIONSET = 7, + XPATH_USERS = 8, + XPATH_XSLT_TREE = 9 /* An XSLT value tree, non modifiable */ +} xmlXPathObjectType; + +typedef struct _xmlXPathObject xmlXPathObject; +typedef xmlXPathObject *xmlXPathObjectPtr; +struct _xmlXPathObject { + xmlXPathObjectType type; + xmlNodeSetPtr nodesetval; + int boolval; + double floatval; + xmlChar *stringval; + void *user; + int index; + void *user2; + int index2; +}; + +/** + * xmlXPathConvertFunc: + * @obj: an XPath object + * @type: the number of the target type + * + * A conversion function is associated to a type and used to cast + * the new type to primitive values. + * + * Returns -1 in case of error, 0 otherwise + */ +typedef int (*xmlXPathConvertFunc) (xmlXPathObjectPtr obj, int type); + +/* + * Extra type: a name and a conversion function. + */ + +typedef struct _xmlXPathType xmlXPathType; +typedef xmlXPathType *xmlXPathTypePtr; +struct _xmlXPathType { + const xmlChar *name; /* the type name */ + xmlXPathConvertFunc func; /* the conversion function */ +}; + +/* + * Extra variable: a name and a value. + */ + +typedef struct _xmlXPathVariable xmlXPathVariable; +typedef xmlXPathVariable *xmlXPathVariablePtr; +struct _xmlXPathVariable { + const xmlChar *name; /* the variable name */ + xmlXPathObjectPtr value; /* the value */ +}; + +/** + * xmlXPathEvalFunc: + * @ctxt: an XPath parser context + * @nargs: the number of arguments passed to the function + * + * An XPath evaluation function, the parameters are on the XPath context stack. + */ + +typedef void (*xmlXPathEvalFunc)(xmlXPathParserContextPtr ctxt, + int nargs); + +/* + * Extra function: a name and a evaluation function. + */ + +typedef struct _xmlXPathFunct xmlXPathFunct; +typedef xmlXPathFunct *xmlXPathFuncPtr; +struct _xmlXPathFunct { + const xmlChar *name; /* the function name */ + xmlXPathEvalFunc func; /* the evaluation function */ +}; + +/** + * xmlXPathAxisFunc: + * @ctxt: the XPath interpreter context + * @cur: the previous node being explored on that axis + * + * An axis traversal function. To traverse an axis, the engine calls + * the first time with cur == NULL and repeat until the function returns + * NULL indicating the end of the axis traversal. + * + * Returns the next node in that axis or NULL if at the end of the axis. + */ + +typedef xmlXPathObjectPtr (*xmlXPathAxisFunc) (xmlXPathParserContextPtr ctxt, + xmlXPathObjectPtr cur); + +/* + * Extra axis: a name and an axis function. + */ + +typedef struct _xmlXPathAxis xmlXPathAxis; +typedef xmlXPathAxis *xmlXPathAxisPtr; +struct _xmlXPathAxis { + const xmlChar *name; /* the axis name */ + xmlXPathAxisFunc func; /* the search function */ +}; + +/** + * xmlXPathFunction: + * @ctxt: the XPath interprestation context + * @nargs: the number of arguments + * + * An XPath function. + * The arguments (if any) are popped out from the context stack + * and the result is pushed on the stack. + */ + +typedef void (*xmlXPathFunction) (xmlXPathParserContextPtr ctxt, int nargs); + +/* + * Function and Variable Lookup. + */ + +/** + * xmlXPathVariableLookupFunc: + * @ctxt: an XPath context + * @name: name of the variable + * @ns_uri: the namespace name hosting this variable + * + * Prototype for callbacks used to plug variable lookup in the XPath + * engine. + * + * Returns the XPath object value or NULL if not found. + */ +typedef xmlXPathObjectPtr (*xmlXPathVariableLookupFunc) (void *ctxt, + const xmlChar *name, + const xmlChar *ns_uri); + +/** + * xmlXPathFuncLookupFunc: + * @ctxt: an XPath context + * @name: name of the function + * @ns_uri: the namespace name hosting this function + * + * Prototype for callbacks used to plug function lookup in the XPath + * engine. + * + * Returns the XPath function or NULL if not found. + */ +typedef xmlXPathFunction (*xmlXPathFuncLookupFunc) (void *ctxt, + const xmlChar *name, + const xmlChar *ns_uri); + +/** + * xmlXPathFlags: + * Flags for XPath engine compilation and runtime + */ +/** + * XML_XPATH_CHECKNS: + * + * check namespaces at compilation + */ +#define XML_XPATH_CHECKNS (1<<0) +/** + * XML_XPATH_NOVAR: + * + * forbid variables in expression + */ +#define XML_XPATH_NOVAR (1<<1) + +/** + * xmlXPathContext: + * + * Expression evaluation occurs with respect to a context. + * he context consists of: + * - a node (the context node) + * - a node list (the context node list) + * - a set of variable bindings + * - a function library + * - the set of namespace declarations in scope for the expression + * Following the switch to hash tables, this need to be trimmed up at + * the next binary incompatible release. + * The node may be modified when the context is passed to libxml2 + * for an XPath evaluation so you may need to initialize it again + * before the next call. + */ + +struct _xmlXPathContext { + xmlDocPtr doc; /* The current document */ + xmlNodePtr node; /* The current node */ + + int nb_variables_unused; /* unused (hash table) */ + int max_variables_unused; /* unused (hash table) */ + xmlHashTablePtr varHash; /* Hash table of defined variables */ + + int nb_types; /* number of defined types */ + int max_types; /* max number of types */ + xmlXPathTypePtr types; /* Array of defined types */ + + int nb_funcs_unused; /* unused (hash table) */ + int max_funcs_unused; /* unused (hash table) */ + xmlHashTablePtr funcHash; /* Hash table of defined funcs */ + + int nb_axis; /* number of defined axis */ + int max_axis; /* max number of axis */ + xmlXPathAxisPtr axis; /* Array of defined axis */ + + /* the namespace nodes of the context node */ + xmlNsPtr *namespaces; /* Array of namespaces */ + int nsNr; /* number of namespace in scope */ + void *user; /* function to free */ + + /* extra variables */ + int contextSize; /* the context size */ + int proximityPosition; /* the proximity position */ + + /* extra stuff for XPointer */ + int xptr; /* is this an XPointer context? */ + xmlNodePtr here; /* for here() */ + xmlNodePtr origin; /* for origin() */ + + /* the set of namespace declarations in scope for the expression */ + xmlHashTablePtr nsHash; /* The namespaces hash table */ + xmlXPathVariableLookupFunc varLookupFunc;/* variable lookup func */ + void *varLookupData; /* variable lookup data */ + + /* Possibility to link in an extra item */ + void *extra; /* needed for XSLT */ + + /* The function name and URI when calling a function */ + const xmlChar *function; + const xmlChar *functionURI; + + /* function lookup function and data */ + xmlXPathFuncLookupFunc funcLookupFunc;/* function lookup func */ + void *funcLookupData; /* function lookup data */ + + /* temporary namespace lists kept for walking the namespace axis */ + xmlNsPtr *tmpNsList; /* Array of namespaces */ + int tmpNsNr; /* number of namespaces in scope */ + + /* error reporting mechanism */ + void *userData; /* user specific data block */ + xmlStructuredErrorFunc error; /* the callback in case of errors */ + xmlError lastError; /* the last error */ + xmlNodePtr debugNode; /* the source node XSLT */ + + /* dictionary */ + xmlDictPtr dict; /* dictionary if any */ + + int flags; /* flags to control compilation */ + + /* Cache for reusal of XPath objects */ + void *cache; +}; + +/* + * The structure of a compiled expression form is not public. + */ + +typedef struct _xmlXPathCompExpr xmlXPathCompExpr; +typedef xmlXPathCompExpr *xmlXPathCompExprPtr; + +/** + * xmlXPathParserContext: + * + * An XPath parser context. It contains pure parsing informations, + * an xmlXPathContext, and the stack of objects. + */ +struct _xmlXPathParserContext { + const xmlChar *cur; /* the current char being parsed */ + const xmlChar *base; /* the full expression */ + + int error; /* error code */ + + xmlXPathContextPtr context; /* the evaluation context */ + xmlXPathObjectPtr value; /* the current value */ + int valueNr; /* number of values stacked */ + int valueMax; /* max number of values stacked */ + xmlXPathObjectPtr *valueTab; /* stack of values */ + + xmlXPathCompExprPtr comp; /* the precompiled expression */ + int xptr; /* it this an XPointer expression */ + xmlNodePtr ancestor; /* used for walking preceding axis */ +}; + +/************************************************************************ + * * + * Public API * + * * + ************************************************************************/ + +/** + * Objects and Nodesets handling + */ + +XMLPUBVAR double xmlXPathNAN; +XMLPUBVAR double xmlXPathPINF; +XMLPUBVAR double xmlXPathNINF; + +/* These macros may later turn into functions */ +/** + * xmlXPathNodeSetGetLength: + * @ns: a node-set + * + * Implement a functionality similar to the DOM NodeList.length. + * + * Returns the number of nodes in the node-set. + */ +#define xmlXPathNodeSetGetLength(ns) ((ns) ? (ns)->nodeNr : 0) +/** + * xmlXPathNodeSetItem: + * @ns: a node-set + * @index: index of a node in the set + * + * Implements a functionality similar to the DOM NodeList.item(). + * + * Returns the xmlNodePtr at the given @index in @ns or NULL if + * @index is out of range (0 to length-1) + */ +#define xmlXPathNodeSetItem(ns, index) \ + ((((ns) != NULL) && \ + ((index) >= 0) && ((index) < (ns)->nodeNr)) ? \ + (ns)->nodeTab[(index)] \ + : NULL) +/** + * xmlXPathNodeSetIsEmpty: + * @ns: a node-set + * + * Checks whether @ns is empty or not. + * + * Returns %TRUE if @ns is an empty node-set. + */ +#define xmlXPathNodeSetIsEmpty(ns) \ + (((ns) == NULL) || ((ns)->nodeNr == 0) || ((ns)->nodeTab == NULL)) + + +XMLPUBFUN void XMLCALL + xmlXPathFreeObject (xmlXPathObjectPtr obj); +XMLPUBFUN xmlNodeSetPtr XMLCALL + xmlXPathNodeSetCreate (xmlNodePtr val); +XMLPUBFUN void XMLCALL + xmlXPathFreeNodeSetList (xmlXPathObjectPtr obj); +XMLPUBFUN void XMLCALL + xmlXPathFreeNodeSet (xmlNodeSetPtr obj); +XMLPUBFUN xmlXPathObjectPtr XMLCALL + xmlXPathObjectCopy (xmlXPathObjectPtr val); +XMLPUBFUN int XMLCALL + xmlXPathCmpNodes (xmlNodePtr node1, + xmlNodePtr node2); +/** + * Conversion functions to basic types. + */ +XMLPUBFUN int XMLCALL + xmlXPathCastNumberToBoolean (double val); +XMLPUBFUN int XMLCALL + xmlXPathCastStringToBoolean (const xmlChar * val); +XMLPUBFUN int XMLCALL + xmlXPathCastNodeSetToBoolean(xmlNodeSetPtr ns); +XMLPUBFUN int XMLCALL + xmlXPathCastToBoolean (xmlXPathObjectPtr val); + +XMLPUBFUN double XMLCALL + xmlXPathCastBooleanToNumber (int val); +XMLPUBFUN double XMLCALL + xmlXPathCastStringToNumber (const xmlChar * val); +XMLPUBFUN double XMLCALL + xmlXPathCastNodeToNumber (xmlNodePtr node); +XMLPUBFUN double XMLCALL + xmlXPathCastNodeSetToNumber (xmlNodeSetPtr ns); +XMLPUBFUN double XMLCALL + xmlXPathCastToNumber (xmlXPathObjectPtr val); + +XMLPUBFUN xmlChar * XMLCALL + xmlXPathCastBooleanToString (int val); +XMLPUBFUN xmlChar * XMLCALL + xmlXPathCastNumberToString (double val); +XMLPUBFUN xmlChar * XMLCALL + xmlXPathCastNodeToString (xmlNodePtr node); +XMLPUBFUN xmlChar * XMLCALL + xmlXPathCastNodeSetToString (xmlNodeSetPtr ns); +XMLPUBFUN xmlChar * XMLCALL + xmlXPathCastToString (xmlXPathObjectPtr val); + +XMLPUBFUN xmlXPathObjectPtr XMLCALL + xmlXPathConvertBoolean (xmlXPathObjectPtr val); +XMLPUBFUN xmlXPathObjectPtr XMLCALL + xmlXPathConvertNumber (xmlXPathObjectPtr val); +XMLPUBFUN xmlXPathObjectPtr XMLCALL + xmlXPathConvertString (xmlXPathObjectPtr val); + +/** + * Context handling. + */ +XMLPUBFUN xmlXPathContextPtr XMLCALL + xmlXPathNewContext (xmlDocPtr doc); +XMLPUBFUN void XMLCALL + xmlXPathFreeContext (xmlXPathContextPtr ctxt); +XMLPUBFUN int XMLCALL + xmlXPathContextSetCache(xmlXPathContextPtr ctxt, + int active, + int value, + int options); +/** + * Evaluation functions. + */ +XMLPUBFUN long XMLCALL + xmlXPathOrderDocElems (xmlDocPtr doc); +XMLPUBFUN xmlXPathObjectPtr XMLCALL + xmlXPathEval (const xmlChar *str, + xmlXPathContextPtr ctx); +XMLPUBFUN xmlXPathObjectPtr XMLCALL + xmlXPathEvalExpression (const xmlChar *str, + xmlXPathContextPtr ctxt); +XMLPUBFUN int XMLCALL + xmlXPathEvalPredicate (xmlXPathContextPtr ctxt, + xmlXPathObjectPtr res); +/** + * Separate compilation/evaluation entry points. + */ +XMLPUBFUN xmlXPathCompExprPtr XMLCALL + xmlXPathCompile (const xmlChar *str); +XMLPUBFUN xmlXPathCompExprPtr XMLCALL + xmlXPathCtxtCompile (xmlXPathContextPtr ctxt, + const xmlChar *str); +XMLPUBFUN xmlXPathObjectPtr XMLCALL + xmlXPathCompiledEval (xmlXPathCompExprPtr comp, + xmlXPathContextPtr ctx); +XMLPUBFUN int XMLCALL + xmlXPathCompiledEvalToBoolean(xmlXPathCompExprPtr comp, + xmlXPathContextPtr ctxt); +XMLPUBFUN void XMLCALL + xmlXPathFreeCompExpr (xmlXPathCompExprPtr comp); +#endif /* LIBXML_XPATH_ENABLED */ +#if defined(LIBXML_XPATH_ENABLED) || defined(LIBXML_SCHEMAS_ENABLED) +XMLPUBFUN void XMLCALL + xmlXPathInit (void); +XMLPUBFUN int XMLCALL + xmlXPathIsNaN (double val); +XMLPUBFUN int XMLCALL + xmlXPathIsInf (double val); + +#ifdef __cplusplus +} +#endif + +#endif /* LIBXML_XPATH_ENABLED or LIBXML_SCHEMAS_ENABLED*/ +#endif /* ! __XML_XPATH_H__ */ diff --git a/lib/libxml2/include/libxml/xpathInternals.h b/lib/libxml2/include/libxml/xpathInternals.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/xpathInternals.h @@ -0,0 +1,630 @@ +/* + * Summary: internal interfaces for XML Path Language implementation + * Description: internal interfaces for XML Path Language implementation + * used to build new modules on top of XPath like XPointer and + * XSLT + * + * Copy: See Copyright for the status of this software. + * + * Author: Daniel Veillard + */ + +#ifndef __XML_XPATH_INTERNALS_H__ +#define __XML_XPATH_INTERNALS_H__ + +#include +#include + +#ifdef LIBXML_XPATH_ENABLED + +#ifdef __cplusplus +extern "C" { +#endif + +/************************************************************************ + * * + * Helpers * + * * + ************************************************************************/ + +/* + * Many of these macros may later turn into functions. They + * shouldn't be used in #ifdef's preprocessor instructions. + */ +/** + * xmlXPathSetError: + * @ctxt: an XPath parser context + * @err: an xmlXPathError code + * + * Raises an error. + */ +#define xmlXPathSetError(ctxt, err) \ + { xmlXPatherror((ctxt), __FILE__, __LINE__, (err)); \ + if ((ctxt) != NULL) (ctxt)->error = (err); } + +/** + * xmlXPathSetArityError: + * @ctxt: an XPath parser context + * + * Raises an XPATH_INVALID_ARITY error. + */ +#define xmlXPathSetArityError(ctxt) \ + xmlXPathSetError((ctxt), XPATH_INVALID_ARITY) + +/** + * xmlXPathSetTypeError: + * @ctxt: an XPath parser context + * + * Raises an XPATH_INVALID_TYPE error. + */ +#define xmlXPathSetTypeError(ctxt) \ + xmlXPathSetError((ctxt), XPATH_INVALID_TYPE) + +/** + * xmlXPathGetError: + * @ctxt: an XPath parser context + * + * Get the error code of an XPath context. + * + * Returns the context error. + */ +#define xmlXPathGetError(ctxt) ((ctxt)->error) + +/** + * xmlXPathCheckError: + * @ctxt: an XPath parser context + * + * Check if an XPath error was raised. + * + * Returns true if an error has been raised, false otherwise. + */ +#define xmlXPathCheckError(ctxt) ((ctxt)->error != XPATH_EXPRESSION_OK) + +/** + * xmlXPathGetDocument: + * @ctxt: an XPath parser context + * + * Get the document of an XPath context. + * + * Returns the context document. + */ +#define xmlXPathGetDocument(ctxt) ((ctxt)->context->doc) + +/** + * xmlXPathGetContextNode: + * @ctxt: an XPath parser context + * + * Get the context node of an XPath context. + * + * Returns the context node. + */ +#define xmlXPathGetContextNode(ctxt) ((ctxt)->context->node) + +XMLPUBFUN int XMLCALL + xmlXPathPopBoolean (xmlXPathParserContextPtr ctxt); +XMLPUBFUN double XMLCALL + xmlXPathPopNumber (xmlXPathParserContextPtr ctxt); +XMLPUBFUN xmlChar * XMLCALL + xmlXPathPopString (xmlXPathParserContextPtr ctxt); +XMLPUBFUN xmlNodeSetPtr XMLCALL + xmlXPathPopNodeSet (xmlXPathParserContextPtr ctxt); +XMLPUBFUN void * XMLCALL + xmlXPathPopExternal (xmlXPathParserContextPtr ctxt); + +/** + * xmlXPathReturnBoolean: + * @ctxt: an XPath parser context + * @val: a boolean + * + * Pushes the boolean @val on the context stack. + */ +#define xmlXPathReturnBoolean(ctxt, val) \ + valuePush((ctxt), xmlXPathNewBoolean(val)) + +/** + * xmlXPathReturnTrue: + * @ctxt: an XPath parser context + * + * Pushes true on the context stack. + */ +#define xmlXPathReturnTrue(ctxt) xmlXPathReturnBoolean((ctxt), 1) + +/** + * xmlXPathReturnFalse: + * @ctxt: an XPath parser context + * + * Pushes false on the context stack. + */ +#define xmlXPathReturnFalse(ctxt) xmlXPathReturnBoolean((ctxt), 0) + +/** + * xmlXPathReturnNumber: + * @ctxt: an XPath parser context + * @val: a double + * + * Pushes the double @val on the context stack. + */ +#define xmlXPathReturnNumber(ctxt, val) \ + valuePush((ctxt), xmlXPathNewFloat(val)) + +/** + * xmlXPathReturnString: + * @ctxt: an XPath parser context + * @str: a string + * + * Pushes the string @str on the context stack. + */ +#define xmlXPathReturnString(ctxt, str) \ + valuePush((ctxt), xmlXPathWrapString(str)) + +/** + * xmlXPathReturnEmptyString: + * @ctxt: an XPath parser context + * + * Pushes an empty string on the stack. + */ +#define xmlXPathReturnEmptyString(ctxt) \ + valuePush((ctxt), xmlXPathNewCString("")) + +/** + * xmlXPathReturnNodeSet: + * @ctxt: an XPath parser context + * @ns: a node-set + * + * Pushes the node-set @ns on the context stack. + */ +#define xmlXPathReturnNodeSet(ctxt, ns) \ + valuePush((ctxt), xmlXPathWrapNodeSet(ns)) + +/** + * xmlXPathReturnEmptyNodeSet: + * @ctxt: an XPath parser context + * + * Pushes an empty node-set on the context stack. + */ +#define xmlXPathReturnEmptyNodeSet(ctxt) \ + valuePush((ctxt), xmlXPathNewNodeSet(NULL)) + +/** + * xmlXPathReturnExternal: + * @ctxt: an XPath parser context + * @val: user data + * + * Pushes user data on the context stack. + */ +#define xmlXPathReturnExternal(ctxt, val) \ + valuePush((ctxt), xmlXPathWrapExternal(val)) + +/** + * xmlXPathStackIsNodeSet: + * @ctxt: an XPath parser context + * + * Check if the current value on the XPath stack is a node set or + * an XSLT value tree. + * + * Returns true if the current object on the stack is a node-set. + */ +#define xmlXPathStackIsNodeSet(ctxt) \ + (((ctxt)->value != NULL) \ + && (((ctxt)->value->type == XPATH_NODESET) \ + || ((ctxt)->value->type == XPATH_XSLT_TREE))) + +/** + * xmlXPathStackIsExternal: + * @ctxt: an XPath parser context + * + * Checks if the current value on the XPath stack is an external + * object. + * + * Returns true if the current object on the stack is an external + * object. + */ +#define xmlXPathStackIsExternal(ctxt) \ + ((ctxt->value != NULL) && (ctxt->value->type == XPATH_USERS)) + +/** + * xmlXPathEmptyNodeSet: + * @ns: a node-set + * + * Empties a node-set. + */ +#define xmlXPathEmptyNodeSet(ns) \ + { while ((ns)->nodeNr > 0) (ns)->nodeTab[(ns)->nodeNr--] = NULL; } + +/** + * CHECK_ERROR: + * + * Macro to return from the function if an XPath error was detected. + */ +#define CHECK_ERROR \ + if (ctxt->error != XPATH_EXPRESSION_OK) return + +/** + * CHECK_ERROR0: + * + * Macro to return 0 from the function if an XPath error was detected. + */ +#define CHECK_ERROR0 \ + if (ctxt->error != XPATH_EXPRESSION_OK) return(0) + +/** + * XP_ERROR: + * @X: the error code + * + * Macro to raise an XPath error and return. + */ +#define XP_ERROR(X) \ + { xmlXPathErr(ctxt, X); return; } + +/** + * XP_ERROR0: + * @X: the error code + * + * Macro to raise an XPath error and return 0. + */ +#define XP_ERROR0(X) \ + { xmlXPathErr(ctxt, X); return(0); } + +/** + * CHECK_TYPE: + * @typeval: the XPath type + * + * Macro to check that the value on top of the XPath stack is of a given + * type. + */ +#define CHECK_TYPE(typeval) \ + if ((ctxt->value == NULL) || (ctxt->value->type != typeval)) \ + XP_ERROR(XPATH_INVALID_TYPE) + +/** + * CHECK_TYPE0: + * @typeval: the XPath type + * + * Macro to check that the value on top of the XPath stack is of a given + * type. Return(0) in case of failure + */ +#define CHECK_TYPE0(typeval) \ + if ((ctxt->value == NULL) || (ctxt->value->type != typeval)) \ + XP_ERROR0(XPATH_INVALID_TYPE) + +/** + * CHECK_ARITY: + * @x: the number of expected args + * + * Macro to check that the number of args passed to an XPath function matches. + */ +#define CHECK_ARITY(x) \ + if (ctxt == NULL) return; \ + if (nargs != (x)) \ + XP_ERROR(XPATH_INVALID_ARITY); + +/** + * CAST_TO_STRING: + * + * Macro to try to cast the value on the top of the XPath stack to a string. + */ +#define CAST_TO_STRING \ + if ((ctxt->value != NULL) && (ctxt->value->type != XPATH_STRING)) \ + xmlXPathStringFunction(ctxt, 1); + +/** + * CAST_TO_NUMBER: + * + * Macro to try to cast the value on the top of the XPath stack to a number. + */ +#define CAST_TO_NUMBER \ + if ((ctxt->value != NULL) && (ctxt->value->type != XPATH_NUMBER)) \ + xmlXPathNumberFunction(ctxt, 1); + +/** + * CAST_TO_BOOLEAN: + * + * Macro to try to cast the value on the top of the XPath stack to a boolean. + */ +#define CAST_TO_BOOLEAN \ + if ((ctxt->value != NULL) && (ctxt->value->type != XPATH_BOOLEAN)) \ + xmlXPathBooleanFunction(ctxt, 1); + +/* + * Variable Lookup forwarding. + */ + +XMLPUBFUN void XMLCALL + xmlXPathRegisterVariableLookup (xmlXPathContextPtr ctxt, + xmlXPathVariableLookupFunc f, + void *data); + +/* + * Function Lookup forwarding. + */ + +XMLPUBFUN void XMLCALL + xmlXPathRegisterFuncLookup (xmlXPathContextPtr ctxt, + xmlXPathFuncLookupFunc f, + void *funcCtxt); + +/* + * Error reporting. + */ +XMLPUBFUN void XMLCALL + xmlXPatherror (xmlXPathParserContextPtr ctxt, + const char *file, + int line, + int no); + +XMLPUBFUN void XMLCALL + xmlXPathErr (xmlXPathParserContextPtr ctxt, + int error); + +#ifdef LIBXML_DEBUG_ENABLED +XMLPUBFUN void XMLCALL + xmlXPathDebugDumpObject (FILE *output, + xmlXPathObjectPtr cur, + int depth); +XMLPUBFUN void XMLCALL + xmlXPathDebugDumpCompExpr(FILE *output, + xmlXPathCompExprPtr comp, + int depth); +#endif +/** + * NodeSet handling. + */ +XMLPUBFUN int XMLCALL + xmlXPathNodeSetContains (xmlNodeSetPtr cur, + xmlNodePtr val); +XMLPUBFUN xmlNodeSetPtr XMLCALL + xmlXPathDifference (xmlNodeSetPtr nodes1, + xmlNodeSetPtr nodes2); +XMLPUBFUN xmlNodeSetPtr XMLCALL + xmlXPathIntersection (xmlNodeSetPtr nodes1, + xmlNodeSetPtr nodes2); + +XMLPUBFUN xmlNodeSetPtr XMLCALL + xmlXPathDistinctSorted (xmlNodeSetPtr nodes); +XMLPUBFUN xmlNodeSetPtr XMLCALL + xmlXPathDistinct (xmlNodeSetPtr nodes); + +XMLPUBFUN int XMLCALL + xmlXPathHasSameNodes (xmlNodeSetPtr nodes1, + xmlNodeSetPtr nodes2); + +XMLPUBFUN xmlNodeSetPtr XMLCALL + xmlXPathNodeLeadingSorted (xmlNodeSetPtr nodes, + xmlNodePtr node); +XMLPUBFUN xmlNodeSetPtr XMLCALL + xmlXPathLeadingSorted (xmlNodeSetPtr nodes1, + xmlNodeSetPtr nodes2); +XMLPUBFUN xmlNodeSetPtr XMLCALL + xmlXPathNodeLeading (xmlNodeSetPtr nodes, + xmlNodePtr node); +XMLPUBFUN xmlNodeSetPtr XMLCALL + xmlXPathLeading (xmlNodeSetPtr nodes1, + xmlNodeSetPtr nodes2); + +XMLPUBFUN xmlNodeSetPtr XMLCALL + xmlXPathNodeTrailingSorted (xmlNodeSetPtr nodes, + xmlNodePtr node); +XMLPUBFUN xmlNodeSetPtr XMLCALL + xmlXPathTrailingSorted (xmlNodeSetPtr nodes1, + xmlNodeSetPtr nodes2); +XMLPUBFUN xmlNodeSetPtr XMLCALL + xmlXPathNodeTrailing (xmlNodeSetPtr nodes, + xmlNodePtr node); +XMLPUBFUN xmlNodeSetPtr XMLCALL + xmlXPathTrailing (xmlNodeSetPtr nodes1, + xmlNodeSetPtr nodes2); + + +/** + * Extending a context. + */ + +XMLPUBFUN int XMLCALL + xmlXPathRegisterNs (xmlXPathContextPtr ctxt, + const xmlChar *prefix, + const xmlChar *ns_uri); +XMLPUBFUN const xmlChar * XMLCALL + xmlXPathNsLookup (xmlXPathContextPtr ctxt, + const xmlChar *prefix); +XMLPUBFUN void XMLCALL + xmlXPathRegisteredNsCleanup (xmlXPathContextPtr ctxt); + +XMLPUBFUN int XMLCALL + xmlXPathRegisterFunc (xmlXPathContextPtr ctxt, + const xmlChar *name, + xmlXPathFunction f); +XMLPUBFUN int XMLCALL + xmlXPathRegisterFuncNS (xmlXPathContextPtr ctxt, + const xmlChar *name, + const xmlChar *ns_uri, + xmlXPathFunction f); +XMLPUBFUN int XMLCALL + xmlXPathRegisterVariable (xmlXPathContextPtr ctxt, + const xmlChar *name, + xmlXPathObjectPtr value); +XMLPUBFUN int XMLCALL + xmlXPathRegisterVariableNS (xmlXPathContextPtr ctxt, + const xmlChar *name, + const xmlChar *ns_uri, + xmlXPathObjectPtr value); +XMLPUBFUN xmlXPathFunction XMLCALL + xmlXPathFunctionLookup (xmlXPathContextPtr ctxt, + const xmlChar *name); +XMLPUBFUN xmlXPathFunction XMLCALL + xmlXPathFunctionLookupNS (xmlXPathContextPtr ctxt, + const xmlChar *name, + const xmlChar *ns_uri); +XMLPUBFUN void XMLCALL + xmlXPathRegisteredFuncsCleanup (xmlXPathContextPtr ctxt); +XMLPUBFUN xmlXPathObjectPtr XMLCALL + xmlXPathVariableLookup (xmlXPathContextPtr ctxt, + const xmlChar *name); +XMLPUBFUN xmlXPathObjectPtr XMLCALL + xmlXPathVariableLookupNS (xmlXPathContextPtr ctxt, + const xmlChar *name, + const xmlChar *ns_uri); +XMLPUBFUN void XMLCALL + xmlXPathRegisteredVariablesCleanup(xmlXPathContextPtr ctxt); + +/** + * Utilities to extend XPath. + */ +XMLPUBFUN xmlXPathParserContextPtr XMLCALL + xmlXPathNewParserContext (const xmlChar *str, + xmlXPathContextPtr ctxt); +XMLPUBFUN void XMLCALL + xmlXPathFreeParserContext (xmlXPathParserContextPtr ctxt); + +/* TODO: remap to xmlXPathValuePop and Push. */ +XMLPUBFUN xmlXPathObjectPtr XMLCALL + valuePop (xmlXPathParserContextPtr ctxt); +XMLPUBFUN int XMLCALL + valuePush (xmlXPathParserContextPtr ctxt, + xmlXPathObjectPtr value); + +XMLPUBFUN xmlXPathObjectPtr XMLCALL + xmlXPathNewString (const xmlChar *val); +XMLPUBFUN xmlXPathObjectPtr XMLCALL + xmlXPathNewCString (const char *val); +XMLPUBFUN xmlXPathObjectPtr XMLCALL + xmlXPathWrapString (xmlChar *val); +XMLPUBFUN xmlXPathObjectPtr XMLCALL + xmlXPathWrapCString (char * val); +XMLPUBFUN xmlXPathObjectPtr XMLCALL + xmlXPathNewFloat (double val); +XMLPUBFUN xmlXPathObjectPtr XMLCALL + xmlXPathNewBoolean (int val); +XMLPUBFUN xmlXPathObjectPtr XMLCALL + xmlXPathNewNodeSet (xmlNodePtr val); +XMLPUBFUN xmlXPathObjectPtr XMLCALL + xmlXPathNewValueTree (xmlNodePtr val); +XMLPUBFUN void XMLCALL + xmlXPathNodeSetAdd (xmlNodeSetPtr cur, + xmlNodePtr val); +XMLPUBFUN void XMLCALL + xmlXPathNodeSetAddUnique (xmlNodeSetPtr cur, + xmlNodePtr val); +XMLPUBFUN void XMLCALL + xmlXPathNodeSetAddNs (xmlNodeSetPtr cur, + xmlNodePtr node, + xmlNsPtr ns); +XMLPUBFUN void XMLCALL + xmlXPathNodeSetSort (xmlNodeSetPtr set); + +XMLPUBFUN void XMLCALL + xmlXPathRoot (xmlXPathParserContextPtr ctxt); +XMLPUBFUN void XMLCALL + xmlXPathEvalExpr (xmlXPathParserContextPtr ctxt); +XMLPUBFUN xmlChar * XMLCALL + xmlXPathParseName (xmlXPathParserContextPtr ctxt); +XMLPUBFUN xmlChar * XMLCALL + xmlXPathParseNCName (xmlXPathParserContextPtr ctxt); + +/* + * Existing functions. + */ +XMLPUBFUN double XMLCALL + xmlXPathStringEvalNumber (const xmlChar *str); +XMLPUBFUN int XMLCALL + xmlXPathEvaluatePredicateResult (xmlXPathParserContextPtr ctxt, + xmlXPathObjectPtr res); +XMLPUBFUN void XMLCALL + xmlXPathRegisterAllFunctions (xmlXPathContextPtr ctxt); +XMLPUBFUN xmlNodeSetPtr XMLCALL + xmlXPathNodeSetMerge (xmlNodeSetPtr val1, + xmlNodeSetPtr val2); +XMLPUBFUN void XMLCALL + xmlXPathNodeSetDel (xmlNodeSetPtr cur, + xmlNodePtr val); +XMLPUBFUN void XMLCALL + xmlXPathNodeSetRemove (xmlNodeSetPtr cur, + int val); +XMLPUBFUN xmlXPathObjectPtr XMLCALL + xmlXPathNewNodeSetList (xmlNodeSetPtr val); +XMLPUBFUN xmlXPathObjectPtr XMLCALL + xmlXPathWrapNodeSet (xmlNodeSetPtr val); +XMLPUBFUN xmlXPathObjectPtr XMLCALL + xmlXPathWrapExternal (void *val); + +XMLPUBFUN int XMLCALL xmlXPathEqualValues(xmlXPathParserContextPtr ctxt); +XMLPUBFUN int XMLCALL xmlXPathNotEqualValues(xmlXPathParserContextPtr ctxt); +XMLPUBFUN int XMLCALL xmlXPathCompareValues(xmlXPathParserContextPtr ctxt, int inf, int strict); +XMLPUBFUN void XMLCALL xmlXPathValueFlipSign(xmlXPathParserContextPtr ctxt); +XMLPUBFUN void XMLCALL xmlXPathAddValues(xmlXPathParserContextPtr ctxt); +XMLPUBFUN void XMLCALL xmlXPathSubValues(xmlXPathParserContextPtr ctxt); +XMLPUBFUN void XMLCALL xmlXPathMultValues(xmlXPathParserContextPtr ctxt); +XMLPUBFUN void XMLCALL xmlXPathDivValues(xmlXPathParserContextPtr ctxt); +XMLPUBFUN void XMLCALL xmlXPathModValues(xmlXPathParserContextPtr ctxt); + +XMLPUBFUN int XMLCALL xmlXPathIsNodeType(const xmlChar *name); + +/* + * Some of the axis navigation routines. + */ +XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextSelf(xmlXPathParserContextPtr ctxt, + xmlNodePtr cur); +XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextChild(xmlXPathParserContextPtr ctxt, + xmlNodePtr cur); +XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextDescendant(xmlXPathParserContextPtr ctxt, + xmlNodePtr cur); +XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextDescendantOrSelf(xmlXPathParserContextPtr ctxt, + xmlNodePtr cur); +XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextParent(xmlXPathParserContextPtr ctxt, + xmlNodePtr cur); +XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextAncestorOrSelf(xmlXPathParserContextPtr ctxt, + xmlNodePtr cur); +XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextFollowingSibling(xmlXPathParserContextPtr ctxt, + xmlNodePtr cur); +XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextFollowing(xmlXPathParserContextPtr ctxt, + xmlNodePtr cur); +XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextNamespace(xmlXPathParserContextPtr ctxt, + xmlNodePtr cur); +XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextAttribute(xmlXPathParserContextPtr ctxt, + xmlNodePtr cur); +XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextPreceding(xmlXPathParserContextPtr ctxt, + xmlNodePtr cur); +XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextAncestor(xmlXPathParserContextPtr ctxt, + xmlNodePtr cur); +XMLPUBFUN xmlNodePtr XMLCALL xmlXPathNextPrecedingSibling(xmlXPathParserContextPtr ctxt, + xmlNodePtr cur); +/* + * The official core of XPath functions. + */ +XMLPUBFUN void XMLCALL xmlXPathLastFunction(xmlXPathParserContextPtr ctxt, int nargs); +XMLPUBFUN void XMLCALL xmlXPathPositionFunction(xmlXPathParserContextPtr ctxt, int nargs); +XMLPUBFUN void XMLCALL xmlXPathCountFunction(xmlXPathParserContextPtr ctxt, int nargs); +XMLPUBFUN void XMLCALL xmlXPathIdFunction(xmlXPathParserContextPtr ctxt, int nargs); +XMLPUBFUN void XMLCALL xmlXPathLocalNameFunction(xmlXPathParserContextPtr ctxt, int nargs); +XMLPUBFUN void XMLCALL xmlXPathNamespaceURIFunction(xmlXPathParserContextPtr ctxt, int nargs); +XMLPUBFUN void XMLCALL xmlXPathStringFunction(xmlXPathParserContextPtr ctxt, int nargs); +XMLPUBFUN void XMLCALL xmlXPathStringLengthFunction(xmlXPathParserContextPtr ctxt, int nargs); +XMLPUBFUN void XMLCALL xmlXPathConcatFunction(xmlXPathParserContextPtr ctxt, int nargs); +XMLPUBFUN void XMLCALL xmlXPathContainsFunction(xmlXPathParserContextPtr ctxt, int nargs); +XMLPUBFUN void XMLCALL xmlXPathStartsWithFunction(xmlXPathParserContextPtr ctxt, int nargs); +XMLPUBFUN void XMLCALL xmlXPathSubstringFunction(xmlXPathParserContextPtr ctxt, int nargs); +XMLPUBFUN void XMLCALL xmlXPathSubstringBeforeFunction(xmlXPathParserContextPtr ctxt, int nargs); +XMLPUBFUN void XMLCALL xmlXPathSubstringAfterFunction(xmlXPathParserContextPtr ctxt, int nargs); +XMLPUBFUN void XMLCALL xmlXPathNormalizeFunction(xmlXPathParserContextPtr ctxt, int nargs); +XMLPUBFUN void XMLCALL xmlXPathTranslateFunction(xmlXPathParserContextPtr ctxt, int nargs); +XMLPUBFUN void XMLCALL xmlXPathNotFunction(xmlXPathParserContextPtr ctxt, int nargs); +XMLPUBFUN void XMLCALL xmlXPathTrueFunction(xmlXPathParserContextPtr ctxt, int nargs); +XMLPUBFUN void XMLCALL xmlXPathFalseFunction(xmlXPathParserContextPtr ctxt, int nargs); +XMLPUBFUN void XMLCALL xmlXPathLangFunction(xmlXPathParserContextPtr ctxt, int nargs); +XMLPUBFUN void XMLCALL xmlXPathNumberFunction(xmlXPathParserContextPtr ctxt, int nargs); +XMLPUBFUN void XMLCALL xmlXPathSumFunction(xmlXPathParserContextPtr ctxt, int nargs); +XMLPUBFUN void XMLCALL xmlXPathFloorFunction(xmlXPathParserContextPtr ctxt, int nargs); +XMLPUBFUN void XMLCALL xmlXPathCeilingFunction(xmlXPathParserContextPtr ctxt, int nargs); +XMLPUBFUN void XMLCALL xmlXPathRoundFunction(xmlXPathParserContextPtr ctxt, int nargs); +XMLPUBFUN void XMLCALL xmlXPathBooleanFunction(xmlXPathParserContextPtr ctxt, int nargs); + +/** + * Really internal functions + */ +XMLPUBFUN void XMLCALL xmlXPathNodeSetFreeNs(xmlNsPtr ns); + +#ifdef __cplusplus +} +#endif + +#endif /* LIBXML_XPATH_ENABLED */ +#endif /* ! __XML_XPATH_INTERNALS_H__ */ diff --git a/lib/libxml2/include/libxml/xpointer.h b/lib/libxml2/include/libxml/xpointer.h new file mode 100755 --- /dev/null +++ b/lib/libxml2/include/libxml/xpointer.h @@ -0,0 +1,114 @@ +/* + * Summary: API to handle XML Pointers + * Description: API to handle XML Pointers + * Base implementation was made accordingly to + * W3C Candidate Recommendation 7 June 2000 + * http://www.w3.org/TR/2000/CR-xptr-20000607 + * + * Added support for the element() scheme described in: + * W3C Proposed Recommendation 13 November 2002 + * http://www.w3.org/TR/2002/PR-xptr-element-20021113/ + * + * Copy: See Copyright for the status of this software. + * + * Author: Daniel Veillard + */ + +#ifndef __XML_XPTR_H__ +#define __XML_XPTR_H__ + +#include + +#ifdef LIBXML_XPTR_ENABLED + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * A Location Set + */ +typedef struct _xmlLocationSet xmlLocationSet; +typedef xmlLocationSet *xmlLocationSetPtr; +struct _xmlLocationSet { + int locNr; /* number of locations in the set */ + int locMax; /* size of the array as allocated */ + xmlXPathObjectPtr *locTab;/* array of locations */ +}; + +/* + * Handling of location sets. + */ + +XMLPUBFUN xmlLocationSetPtr XMLCALL + xmlXPtrLocationSetCreate (xmlXPathObjectPtr val); +XMLPUBFUN void XMLCALL + xmlXPtrFreeLocationSet (xmlLocationSetPtr obj); +XMLPUBFUN xmlLocationSetPtr XMLCALL + xmlXPtrLocationSetMerge (xmlLocationSetPtr val1, + xmlLocationSetPtr val2); +XMLPUBFUN xmlXPathObjectPtr XMLCALL + xmlXPtrNewRange (xmlNodePtr start, + int startindex, + xmlNodePtr end, + int endindex); +XMLPUBFUN xmlXPathObjectPtr XMLCALL + xmlXPtrNewRangePoints (xmlXPathObjectPtr start, + xmlXPathObjectPtr end); +XMLPUBFUN xmlXPathObjectPtr XMLCALL + xmlXPtrNewRangeNodePoint (xmlNodePtr start, + xmlXPathObjectPtr end); +XMLPUBFUN xmlXPathObjectPtr XMLCALL + xmlXPtrNewRangePointNode (xmlXPathObjectPtr start, + xmlNodePtr end); +XMLPUBFUN xmlXPathObjectPtr XMLCALL + xmlXPtrNewRangeNodes (xmlNodePtr start, + xmlNodePtr end); +XMLPUBFUN xmlXPathObjectPtr XMLCALL + xmlXPtrNewLocationSetNodes (xmlNodePtr start, + xmlNodePtr end); +XMLPUBFUN xmlXPathObjectPtr XMLCALL + xmlXPtrNewLocationSetNodeSet(xmlNodeSetPtr set); +XMLPUBFUN xmlXPathObjectPtr XMLCALL + xmlXPtrNewRangeNodeObject (xmlNodePtr start, + xmlXPathObjectPtr end); +XMLPUBFUN xmlXPathObjectPtr XMLCALL + xmlXPtrNewCollapsedRange (xmlNodePtr start); +XMLPUBFUN void XMLCALL + xmlXPtrLocationSetAdd (xmlLocationSetPtr cur, + xmlXPathObjectPtr val); +XMLPUBFUN xmlXPathObjectPtr XMLCALL + xmlXPtrWrapLocationSet (xmlLocationSetPtr val); +XMLPUBFUN void XMLCALL + xmlXPtrLocationSetDel (xmlLocationSetPtr cur, + xmlXPathObjectPtr val); +XMLPUBFUN void XMLCALL + xmlXPtrLocationSetRemove (xmlLocationSetPtr cur, + int val); + +/* + * Functions. + */ +XMLPUBFUN xmlXPathContextPtr XMLCALL + xmlXPtrNewContext (xmlDocPtr doc, + xmlNodePtr here, + xmlNodePtr origin); +XMLPUBFUN xmlXPathObjectPtr XMLCALL + xmlXPtrEval (const xmlChar *str, + xmlXPathContextPtr ctx); +XMLPUBFUN void XMLCALL + xmlXPtrRangeToFunction (xmlXPathParserContextPtr ctxt, + int nargs); +XMLPUBFUN xmlNodePtr XMLCALL + xmlXPtrBuildNodeList (xmlXPathObjectPtr obj); +XMLPUBFUN void XMLCALL + xmlXPtrEvalRangePredicate (xmlXPathParserContextPtr ctxt); +#ifdef __cplusplus +} +#endif + +#endif /* LIBXML_XPTR_ENABLED */ +#endif /* __XML_XPTR_H__ */ diff --git a/lib/libxml2/lib/libxml2.dll b/lib/libxml2/lib/libxml2.dll new file mode 100755 index 0000000000000000000000000000000000000000..c2134b84c38f5e49889af1f9c8e3de35534ee2bb GIT binary patch literal 1230959 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

4Lj0B#aKo5#n8L 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

(!gr&IOJ--lmyWhkWEwFOz^0aQysc8~`tu0P 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ͮ(BlVbXEQO$vqR)gY@=RAa`$MJNHUHL2AjKyH((Mr}kSBe7N zdQkDLiujgr6IDxud~I)lIVX1$`kGy>a70ABa}~+X4*_dcOU0w}^{SP`Csx6wlN6A$PSs|Se381Fm$zZb$f*6s*ra*<;Fa*5ZKVhYm6g=;aF$Rgq& zC_^@ct63ykiPNT)BzCkw{w2^?s4vY2KcgO}gB~u`iGVZJrz@X82gM!hsW~N%z|VT@ zZK}(mxuRo;FqA3NMZxvLUaJ($6266tHiQ1nm=84UDQRfhXukv2-VMpf^=0@~4v$jDJrhpH7a4$tH8+6H3%9<*MNu51c^nGrlh8copv zjIp-En@;^S^p{_aO~V0{%vzzDCZFY0;qiP|ovl|CMBG2cRR)~`6 zGG~<-?Fe?o{QYysPIoO+4@;_?>retKwZ44DHd5LSjhtnRui`{()MC=#s?+zH->{A9 zN?MWPRm>*I_)hUprqTu3N);9o>F&R#f4L(G(9cF zxtjI#l_C$03}MwFryLU3>nH|JGtR?oi$_Ev1Zxk4S*%*L|Vq_p)w zAA-HEA`&`X`;zfnu}VyH=mBz@S$J9%yxWr+_=cDz!TdQ#oAd7!qumG%dV4xy9vxmc zOH9iqzC+Y-o*11$?{dcyb~0GBTORG7gQrva=?5Zvsb<6%k{q^L=$t~(xRwh0I>om{ zlr0CXeuYwEDl`oXNS~;_Ijb?^dxZChgFxd%2k{%>d0gBIdHaLNw*K65L{}CwRBrR(-A6 zuNWk%sK*9k)dEbRIvZB&hzCb~-emSU24qXUq0gt#=P12T8kiX4kv->5w9kK$3g??% zGV<7|conR)VXNMvuD%9QL_}bT7*A+esSMAkK{&1z>goTK_qVh{>z7|kg2O(P{^c{> zWhCLcSa>Lk9^ zAN$TbL?pBl0(<4sbcN1l^<+iv`01{iQ$T0W9%g<2x316%dhFPo6u2YeYa76%S}O`U zo9$Em4TZ&BQ?V8~tZJmUSxx*R#`$T_QNgXiJM)I~9sQedvt0;LWofMgJ9UXeXIE*W zC|h3~!7keGpYPU16B@JltK5+UHa5gk6n!yYkIdoC#ua*?OV76#Dov8uDqfmX{D|v; zj4pY05dxtmCz<%H;y4>qOn069_BLwQP72?|g%KRojex@4Td5jb55pZpp0}NKp)Xeo?RK~j3hG{c@j^0NOGFA1rDWZrPkId+psAt z1!!Fdafq;7+N?-}7$Ug?-uVK{AfABCZ zSmHdhvO1yzXi48(kP}!{eNBy>qsfb@cHv1DlkB9@3wshKaqDf8fIieV!86iqX%w|& z%yvHhQ{5G}=@b4~2gjsw$a(OeO3)B6JQJauvL&vi6#(-yMS}abC|;6N9P+1Pfe;-9 zR_0dIRM|mcF8Eys{|R*3{GYp)z1Puq;N;Vh-xT$q4Nq6QS<;7K*?^B$VUaAS{t;`{{-B zor9Y<%X|1n?mB15ueAIQmSBVRtZd8kSls0~Sh{gU3gqFz6t^(J+)hZ z02=GYX;4j9sJ|zCX|L^0<-XrlP+gww)gcF*4$cotnsf< zGnTPd!;iGxPMNOVy_e9krcgIicZEIJyt?*r?BtN#a11`A-HAPoq_MkZ>8R@C3jJVu zJ$}XKFtwyMg9uJ1{LP8eL?6OkU_@w9DI)n+;48=i4S^U@?-O@=?@tEv?p-f^^a zZ-*;Aq2n61!ng@fc|%3XI99sT)Q(w3B8B@?8Iq*NkA0 z9g6}RR~?Qeio28cNNR>e!IXIja4z~uQs$cd{1%Ddq_Q9X@JdB*n-2#e@5ssqZ?8h;C*c2WW=L*jeIvO*EqGc zUB`A;OHEikUVZg^b3cQuKSF8D{SgT5waL9cQ{UuX{z*zTAMwm$gVXRcGSUs{G$AJu zRIUOhhd=RIF)1HT?ec>NbE$3bGB`}bbUErif5su;bPFE#KT3GW`^lI%#0%0E!A=Ga zer`RJL;~@#l%6v_{z~nQt6EHPW$J7ReF~yH^ z0S)@W%Bx`0b=TpTRz)B-47rxQd2A08%nJyi4F_bwPY)sRCl#pu^FiP=W6YwCAmGfD zA7#;)Z0#gaB`y2+uaN7xl06fML20)U!?OCS(l&}Xw2jha3VQiOCooT2#uTUWz8LMK z%~{;#P$K(RX>0cIk*Xzc6r(KOMhmyGoTif{DAd={(+MwMz&U=>capl$6`uPD|9 z0x^LW=Sl*rrmO|%TJvID+bV~)#oXn>53nkZsa6RYLj1{n3D(Lo2CK3UN2nDR;`j)d zJ(nh+;V>1ek3EQXm#c-tp}CvI3#nL(eGlKXYvKQe$35T2{iqDT1dre&OoUSyL`)&4 zdHxNNprOjicmuQGHV7NLOE{wU`SoXCN8n^%$LL*(o>wf6iz6@h0CipT8HT?}lnJ2v4KUTUNoFlxIxKm{N zFvIO&teZXg+G7a5X*wUAp_F+n{s(Le&6!hbd&dDChrY_BZ$seZgn<0Wz4;??CnRp# zBL>ziN`>y)Iq0Ys*4TD2-z7YFvAj$0j6UvN!pz!mM<6w; zF&y(hh)AQpW_7`Aw(f{7LOx&(yLc^p6<|Zwtj^twSR)y1;vd+I4sl5}v#zyobi>Tr zMP1UC^G3dmLhdG73Fp{2e}ww>>?B*w*mT_U%Ts>dGxt7>z?;o{mVZ0zYlngCvPCF?=dT=$GkU*`tElixWuUK%tzVQR!4~55;12_^th2 z+MU2uFZ3SznB-N;TA(kN7(E00QqS>Zj+*>*=`JU4?%=v`_Gj`EGjs=E?7o+Th60tc z!eG~QSLq+7*}NvL>(S+R;LLXqZ_@nWn4VMOg2ze34h zz=X?MwA`2_CT5E$a)^>S@JN|m#7OIfs3F&Lx(WkJxgo;^qrhYkau9QL^SVh1kVP&s zAS)%vV9}87!9qm|2Km434Uv~Bl41|zUTi@ z_U!>tRonl71B{9e8Wk0Ft*ET41!VzNJ# zzYt1Px_hwc~OqD))OoXJ*iJ{ie+Hs8J5 z(6~#!=ykMPo}MqvSPopXexANn`{!H^F}Kw@-;DhLfPGZ?(Yf(NRiXO5j-<$Jh+;5kwuSqlW>bC8cbz=uZGLpEgP8fPObBl$*^m z*k5`7Eau9n1^p4X()wm>UWOd||btzLHDj9qMrT_rP$M%S2tVCfnuXIz%_5Krg)q zrkWmXJ=iNe$jXEV*B&U>e6DxFHt;j>_*zF>ZhEw5 zH#YXZT#=y?<1N0GIP`}&=x)e1;^^Q?vgjAWZV;YVjKID*5sG?6>4h%eI0vrivfZca zqv%&9Aw&;h$Zg9@&vyAUFe3QEd48@@ZYS0@?iLYQ|BzyYjbp=B0^vFy?IeOt(FYQi zhqKeNc|`MNttwfyD$n7~h<5+bmVI%yX9tR|pLaSx4Q!rL32yj}c7|<8?py4Ys6S$b zu|+#*L=_4jJ?mKeh{?;Whb4Uf+M+N>r^|mkbdUmEH=aatO~zifCTzh&T$p-xS6aoi z3|t<`v2a;7#g0q8#AT|5%Wj7q7Xaw@@cwSgyO?J4GCSR;83=Ts z@0^S5j=~puJFclA(p2NEK2FAA5x!U^AIF^Lrh%5)VC^3B35a-A;Ujac^F^hDa`(LxHS zA8z$i88!#avY#gwn*F>GM$G`wpCwUd3QdQ;TF5jt18p*2gJ^~}7 z0)4T@3)$V|znHOj!zXskDJV+s`N;_66)t7!HL1#egsb{yz~X^&Z9BC&GdOfLUMXqP z>IT^kL-y87ux03_5xqd@)O?Kbj8EnDS@0);tvkCs7H(~#;FrMKKMEU(bBFnNcG4ix zwEh_1d8@qe%dxM=b3yHQJHxBuYzUj=&*davT0za=54~8#0P!By^SDi{Q_2ybjB;Qho%icWHeXYjvyxevgFqv7u}{ zn!s5J_71i1o@C)YFzm2uk$4}T_a}Hq+zT@L5WyrC-e^u=*$%wF=&h^#y{Yb?6 z5&J2MIUP6DB8jFjgc>D67nl=ykJUV0>X*U^viVjU4WGK$py5-v$F05fME=p-TaV`- zO}+KtVYY)&7n@`kzs{u3@Q426VF0!C*0=MI#@>4KVUG1JIb!6#S^PUH;BYuci<+IJ zmq0F(lpgFb1xk!MG%*H317spGwI=?>ViGU&*?32d== z66p>eCN~q7R5}5^P2W_z z{dVEY*)~Y7v2C(pv+6SUCC%F2{wy}q%;^X{s#MDwMe1>S*Fx{~M}mekNGo5CwWy=h z+BVd=FKgT2@T8A)55#o6b-6WNY2BxbTZDMx*}C|LI+|klcsfxX?gjXE_T>>79=`n$ z-&O|04}-lH%oJ)J!~OdlIF@&TdpPp4g-8q3Ckh!7f6qD~?-t-f&DFP&hcHP;n0(ED zAgx!+N&TT*7SuY%Cz(1o39~WFsZKyW2Ql;3VlvrsgDNHn@}2YZJXk2rncM0$+yH7*GFAI74v{r_Rb&JP#Ufn-w=j z32)X0QDHNkwq$ynym^*>jt%*h;=ela-x}Tvq!0zTUk?7$IQXx(>j5tEow};!PIDf$ zJ@c3{6v&9~2|P@ZL+e_RL+e^IF~c+Ggp7=i7<_Ir+XZtc;oZ@5#02I{(zkL5(@LbR z?5X6}>9R~t*LrwsXf11CLc(okv-bROu@Y}~^5rvq9jJrLF#TVR9I*8NI#gw<3%sl} z;J@b(|6LdOmy*8*|33=HmytKgM5hh;RpP&O;=lFczbD0i&xrqC5dYPS|JEAw#u1=h z=IyK)o;Sx`$Pn9t=raVJVNDhzC$dAiHcidRrX8nzu_17p_orx=pA&p-MJ!{Bdd&#` zCimaf^u9E67D?vF$nQHz5d%@`|=b+{dPzC@h`qOQfGkdqB*#d=Yt*90s}|HbBBQ^l;#cEiQZk&8-7di z{ur%aAL1CKt3ir++4`k?2aV;4KE^5{+HriEvQ58)1Ayq5%U1FqREm}_=*9Z><<#RUX zg7}BeVjJYuT!F9vCDo&~{R3FC@1d0Vv|k3;C3~MeQhx!O%;Wa9o9$gNlg+q={*XIQ zjn`fhO~s+9fBi*M;^usx+0^&gbdk4wZ4{l&C2Q4OaU)Q)MpiUC`?6>{YJ)Cc z&jg|HJqN{`X25-$xBST{_hdM*IPf`rwC7U!5kw~D)~EO8OQdwTugp!3au2jm zT{BPJ%5GEFV}7QI%<;Nf-L0$D##F@7(3PUK zm=K}5@mS;3{FOu;JmRa^eOpe`S~*Qehe$Mj>;)s?IrcuI1ydApuTNr ztCjp`c!XE6BU_iIpEa6(fSMi|v1z{jqsb9X-!w}kWbpIdjXMXf<0H)6?AIC1WiX~^ z9|u!qA50+4+6j#3x+wScYRNhSH_?*QXlYMRIrXhhp85;bqIEp==X9I;uGBmL&X?uY zQSN-Tq&mF$moJgcKhzUtlv2Bfv6$no7MR{KQw04{Q$_0yIuT9XXf!nfO?kqa3R|7^ zqNy{usVc^*Djcg5jHWthU?U@9C7P-dO?|iYb+vdz{ZKly$sZ*{BoWyxU0+x0fwL`z?# z$(Gi~NxpbRtlTkWRo?j#cZ~41>M$2(&osF(`L+!yn!nFz9%lBD5y@Pxioo>pdm`)@ z(bOQLss3?)wPU!c-|v<*IYKR~4xhdsE|N_(#G2C=VILdQ_uSp$x^!u@tlFC|7ZxoR zaElKaEqY>2&JbZi%uv)Zcgt~JZyTp*YJ}0$1+j8P?(bo&$ok`~NY`U@(p?c&L^S{N zg|hii9e=eVjOmNhO~zxyL8`m(_JU4*K1Rt}3~!7r3hz%&sbBR}ULq z-Dh-#^aP@-7mn9eWw);WbB7#Noa(7lJoVfy9mbU;?D06qFbZ@e*PA@{1<7Ok8Ymo$ z`ST;W9yb9r}}TJPFB|AeRF2y@Nt(bomz( z4e2i&fNoMvx`|%MKiA>sumj=E$t}%V0ZEmlqfm2McR&qV3xUAp8+0&Sjc-1VE;Dlq zJmjePnt#*$)vlA1c;7TJiJu2Vwm8C}nqAh{;^%ApvkE_-5RWpQC{Mzg9V!yeM?lQ_SeHvC5{43>CwcMHciEzrG-rT*~a$&|q z78!3A{=~JW4<>-aoYBTJOC1l_jX2oIJX12ia8Ce|aj?R<`@t1$J8EYCQ)u2PUKHLJ8ZS5s=w}Sd4b?AWt;79 z&S9$|^+mSJj|9?Upv|}&o?m*QXK`CW8Zi^3ze=wQybAC}?VkX5e@Q3=me8#2)%@an z1i}X1x8?k)Q%cq=#MwMt{SJX5NQ+(yPxKWpfq+D|B*bndAbzSzbvy_wPZ5eG`VNCv zl_#oW5Q4EnkLKG$)YC~oJ)N1(^g5-eCD1E7E5F6H{1d!Rc>pDhW;#(bvRS<ZJYS#mx?6V2E!b3Md81fFWmBa?4S*`L5Y3F4HA2oZ}+k8S&sE>@b|;?1Xhvc7wz)DV3kZ^q*}Fi z&ct-`9E$uhr*raxdab@^1ia*w0X-3L#nNDLZD1^sC6cQIN#?r!L z*%{_hq?XsIg^32KhIc*C?0P)9E?*Bd3_cOH_x?%ON6~e;Qxt)Umt9{UscQ(RX4mgx zIC{t`2-@Y|Q4rqef8%;MCF`->Yw0=DgqlYrn}#j*ra)OzaT>_t>A#62)AdS8l~xna zPL0V(A_&CQk}4y&i*{Fc>O3Z?;E4%;eo5)_Wgm;MxBiaO19K4afNOePhe?=+iG;qq zZS)*)JNQxge?fJEH2}eoI5|`Jay)*zU>8oUAr7-(Qo1MhU1JNr7RSj@kS`~UW87+| zhgc+kLfr&0=i50iO0t^Er7J5yyV;IFFX7#VNa0LGIP13^v-<@iN4`?ls-EiYbhwL0 zyYEsxt=?Z^)bdvEuhGO$i0~bmpSwpA2c@$&Eyi;lu^0Suct)z%Wz(y{_%_?%q(6mWJUau+*|Kgtw)wM8Qa(b;ZW!;gaU<%8 zayyMAeSPpJoI7WwsPl_K&?hnbZdTg0^|Tgkd1)~s*PA>lGdo?rBXHmugPbS67eVny z;KSStH{h7DM=UC}r^BaXSo`HP$W$%t;##kKqJ4Fm-3Z)bHv+$Kx9y6pzE+o4Y}@{f zt4AbA!ka(NE6$pc;?AIxS7|;cY7s3Sa(~qwZuahqLAtN#D0dHUW3)OZMTTrOYk!mH zGIHms^RHIQTQEVmyitdHL&T)U;r2L0XI>8fh;{i<{!A?pQHZ;G$SB0Gxx^up(?<5( zLs((0%rtz-43V+*yK9ePU!qoN3!0C0`SN1e3vjT@hZy7Kc{g#VsGT;(I(8gCc6BwIP!4stLCLqKW+5`T>jzUw6y#XY*Lhx zrp&KgzRzfk=R_s4&U(t$!&@;y&ZxurE%YyGo{)SU$P0(o&t^%WDScBQZc1h5M)%*< zIcbME@Z8<^@CJP6iCer0A9#OtxcR43=8pRuWzq}rt5@JMaewW;(3=tKjsu(UoXssU z!OAWd|B8>rU(Tq^jh;{Gm^m94^B`*U=7{pl5ZJnVFaCjhzlqQDX4-JM$VN6Jh3n0@ zeC3#|u|v94==pEYcA2Z{TD&iStxof}FqxP#%t2I4l&3ez{eAEYn`dG%Qp&6e$^-`@ zKd-5wlv<=rO6D(;lDA&ZnJ)3C{?bv7Pv)h5p97*wy&d%XEpX8z%HF_PYBoDx{}(Sw zp&;UT6+cG`xPQ~{QJx*%j+0%!#b5&ZU~fnCeV^z{kh{U4$9KVgL62|oj~*^xOicK_ z(1;l@8Knx7(E*9*`Pai)ztgOHsP7Z1tRquWZt57OT;3q+a6RW(xPrFw9{cb$+3FXi z)avX`5f5$mg*Rlv2`MHQ;B*L_0u_j3a=5&Byx@7k6LTg*=em2vNf7(^dr{*zvlSCwlL?Ew;w7ncf{jFhrI&(t}@qoD^WTrHr1Wj=f1uTB?klYD5MsH#0|T{YD>^h5e9^ zxj~ln<57FfdVWpX#)l7wP*Sj@$;?73^zEl+@j)zhM3N_-R?$tOew5s0;-7Bu9%(Mr%4il5Q^P29_ z7R1aO;+UH~!f|4dr>wXbCk=(LcZi^BLiqfU$p0>;d4X-3wVNw>j`in*vX%v}?$wuC zY5fp21mwbV`VnGzgc#45-X~~jZ$-_l^0sPe{UP8QEgl(SYf_0)OPZayR#!1E(-^lUX(oIQPwj1187yu)MN)4)~SQ;b1h<5b76_HTv^BKo2qYZk^1Y6$;`u{JygP%K)0$|KpZS9xq9?9*%>ln^HY(lq^k$G) z_XbjOjZGo3B#|?I$;V&x6;3@HkqoLJK`BmP15vh8v=)!Y(1uaV*4k`#6B2}T-)y(y zX;jPCstespc{Q9VsOz@uG@8?5WGLC--7pS=y?>G9@0^>p8531Hk$u5F>M3p`6^1CP zQ}1>7+dT2oQA;hW#zH?79VK&y)A(Z`(Un(AyO%qfD{g#;a@J+lffFl{(!5<;N~&W) z)+~o>Ip_53p(d>Jhde(iMQgP9Sk_AOo0U0kKb_HQJWVuOb{ks6bs>@LM2%y@z%e$` zJ!^*(9hyGAXr;4hc6;o+m*79j&hA$>sSSp`$03#OcgE4egZe>2AV6q$iJKTLC zmyhBcFuOSGLo-w|_av2?oIOtQv=B**;Zl|^-(ZfONg-h&t1yMshd7)#p7e$S4s%rt zkhCp9+t(fpH53fs8RBw^wrx}(CJuS^v#Im`G9qeZET>qxJeK#2Bt<&YjsUpOfs3sb zd!Xng`HzA@mNa^`7}^{N=g+T~K5dn_oQS4TsY%JIr=>vgRLL5%B;1tOsq+%l`tSOrX$thMyvnONIExs25GJb=6EbHxJ-Rv}BWrAi=LeJ;HT6rap>Oxo;NE$gWvyr8 zkS@tSHjg|$`zWbW^Q*Oky?EbT1)k}h-slJwwRor3JJhl|+9?X^T448=W}C}>8&bez z#fl&@K@PVG_L4bys>^pYK3vLfnr|(BN9|#`_#YDM*0Wd^EFq-`)hkD+PHzV_I|}n& zTI%f_>^WV(IF{|zkTvNL27r6GcLPB1h zmk@YP)K-E|9L$Up%G%u9CV)Fh)U4;RqVup)Ril4vQRE=x3+AB}8E|!*k)Yn_#CGUKO?g_>@+#P_8!ApylNOt{YkEFA zBWq@c`%QYa@MqQ2NE@U-Ob9W|wi~t2V@RHRRJ%C}B2Xh&Aa>I>*{PRu7Pw|&sK!kc z5i6&OVRqVcJl`?YBXVQgTsZH}g#@`?OT7+L!Q51T4Yzm9)BXRBHAtH_0LPiX!K$6X zwXW@Dajlh}&3Eeg5U!iG-3Nm}qanx5Eh0FXP7G)iPTU>ExrrggyZl#nfOjQEx%`*n z*PI0U^>^ehfl!?WX1A~h`&3bX3ErV`?rTLVZh2WJDpC;k*Em8_-z{a_*Q?j2avL~w zYvLr-N>UCK6m)g@(vKk1WD0dc6Vs4uouAyK{%*S^%9vxlt*15C)w68mub+b)S9x4` zX8~t{0UvhA%qsUyiKcXkE1vx9K6S3A3v+W7`8_8BX^x(9X$ z^U#vR#;Y5)$X9*DD&S7cug~MsQ^c|iiRZKt)XD&~ zk`?Rj#ZCF0JvaoEX6gc`n1<1*5nEdzQVn#*iMF=nvDI8HNMuBBmAU*l8(jH1dXrg^ zcT`xIDOPWnD(2JDrXXzD|O!L9AjW6p~dRWqjj48DodL z5HjtQHD!$@G%ut-eRPVUA_R7|%l8wXXH}KHP41IPrpTJ$a9^Ud2Vyge9qtR*_J4>l zevkx;w_i7XlqEaw`LonXe3qkvNL)e9Uh?OHxKThw7Jw)fc9|b%}=<6X$f$^iI@rGybMoqf_st_ z()7NlCobH_b$>UWvks@lxoxoPr4ubZA1%L|3W+l-k4~KngVGaz2>YENK8)p>6q@;y zW7+b>1(J{|H?!I0L%j<-;mnwC7o^N%>a;@Yc;!LS_O;!(2@=Z)ZqkcqeZ4v%)fC~G zn;@<}6eRgjvXdVV@p-DuNKvmzB>p5^me5uezzP$<{IVJJe*hhug8R#2uBuq<)ZaNM zj^mLLssHGFR*+2U|2!M#8dL-Qn02)R4)s7>clluv-1tB~ z_4LF+gUeijo0A(388Ie(X9Z#YCV|Lf5UPd}3GoZlx;td45`#_)l#P-qF1%eR|qi6232yR2|333lCy#li8 zKJlsNIG?VWv-!@zN6JQhRJ*9lM97sjdFR7YPeb!x&9^Hs_0yBfMB%3ULGdL`-gyop zG0y=p2h-s$R9>ZY((;{-@5L3odRkx)i-+~TO`h**egfZPX|Ck2++uCVh=KEr=h*=q*s$PdvPQM4~_QogJ@#6m-sR!vS zsELUeO$127((~A7sa`(_E9a~B^I{R$_I+qOZye|1z!5Y~HS9apCDinHpVzkuLycW#ryVvW2Ldlc*nR zW4VFHaHP$kh}pC4t)xV5#buo)Zy2pO+_%uYxNk(TP@%nz>ID(o`1DF~Oco~UcX1mj zT2(*@1Jl}2uT8i*YX6oGC(y&dOX}#UEX_|fy@=LpKWrD0$)#;JpMhQYk5+L3GVqO^ z3ZH?eaICUP?Aobd+RO2`{cd~#oKTyQ-*c0R=IYG<^Zf}6nfgBu*>WoxvAZp7eoTS3 zSeytKtqp26C(Jz^)XeT#zW(vTtnP$irMzC9oI=}w4BSOVC#reL>ewU{-8xD8rxp~s zrno*DtV)S4-_NMo`+ygg8jZ~pOM1}DnrRiZB`PaKu=4Z~;*>)i{TPn3YRDcZ&W(CC zH%WCWMNO>rHv8);Jn6`J-lV3y50i+?<-3S$Fy6t`?{q!jkoHaQzxdMEF>|<@$I-aM zfWEMz>=(&*f8g8T6h7uNPNDURg>9syW%0a35WA=?SD0Deyl@4FA}8T)F&NKe1AE-0 zz9dMtkw6>Bn^Gx;ci%;@944xxvr$`+a~C0wQJtK)xKp%wkaZl+$OuCXSD#*SF59eV zQ0sspP1`FpNwe2_+xvOGQ}bZFyjv|!AX(vN9jpyUWSOz(vcXr={qmtFBW2-V-0)2$__W1SqXn5w-Xe=9Rhj<~wOkzu`hBEsHB83eVx_`_7(ZwO-5t+%`F8B{(L?Mgu(nS+A5ThhSROB+ zQ1KR_@B`n4Pvo+XUmjzzDiE(ubfSJJPlbEGmp4S9kbuSr0z`0^IDFjcKc#Kqe< zmteBz!_t@0&*ek88JZey$5UOYmN)81X(~>s6OZzZh_BA|;Alb-nSM^dqgl9%@H_ES z5372si+(Lu=QuzghZ@Fm{8x7&!Z!#-v0CK!Q@#h%wJd#l~7fR9cT}XfSJQKkL~u3jcLaDArXndk z?l--SPKEYq9;f?7FugLzVQl2n^bZaT`*$H%^&`c19(~dWKb68Xr6QX^o;+;fDq6V> zXj{*}bM~O`L zP;EzcV-TFaQaJV!h9`kLd)N)L6oSzu22j&$G*<$w}|ClujR-l)z= zgj|xF%0ZsmsqxICmkUnipO4WI=x~1s_mJau!d83)nrA0gU*I-C5XRBnR?m5J1AyN5RQ<9KjGfjV)?U*gS08 zQ?E}H@|eCB&tXY%`Pghprv(lT!8nL(JpLmIQ$;KB{#N6-$Q~jSiZ8%R<|6w4aP6^I zU&&54Fn4*HNZxX+AcFcWj?~Hf?joifh{c^3c10PpRQG=G(0-oX>UH>imr|S%_yJmy z{>}ewns0jr8L9a|Ws^%~PUd!x7bpH?h}|L|+T=tbKP^4mf1EPu~VHvZKxT^8?uMTG=qpr|vCq&)NYM z-_sO`tIW&%zT#3f>1prKM9%^2+YR0y`guDNJ-?`he(o%}cu63_jUg zwA+W$JX{_U29z5Up*0pJ=?)Pv=D2$J<~#MWW7dK{xSvN@(n1G4jqqP=ENcq%%F8Sx z<>+Z^aC_8IlW3lPT{JH(YED0*j>QX&u|0W!2dh=5!%0jnkf)~R`&Jy86<2{pA+U$T zDfqp%@OzBReL9_;oWvZvf`>eXU%32l75NZy5*gG8F1^iWoLvuimL zECMK{#+&7G_b3eLLR#nYRO+lj3T{?iz9;Zkx;Ge0NL*X0Gds<@n!13OS0S}g9x_lp$tgBDDSc+a)i z*mUu7)BQYkR@4P`# z?u547D`MPnZFz~&?hNnz0a3DK*r+t65mOJ>dNmPt@FTJAv2s>Nd&?W6-9vcBJwF77 z*+(^QvHiXvPL6B>sg)cAn*Ql{&jXkZP8v>#H-=Sp|Pr?MgY0~2p7m5 z7A?Z?5XJq8c6|?_$F{LEI!V`q3^C~-VW$6s02f^K=gZkoB7M?%g!Jpdho|*k|Q@G?RzA~h?oHC=X=WC;LA6HVJXi&>Ne^^XO za)mo~945saI$CiCsbt_A(=m}V9mo^30&}%I;T`s`DO%&*6SF*p3tuT^Yh?;4#4fqi z{55J)v~nO%DSJkEQK`8J@bjDFRLZM*6s;w})#D2!qK=(cckm@J^ZrbAVS-v#l{MK( z=R(;!bz(-=;a&YxV9J%b>kk zuW?-CoxT>*ppqF1<5&J^IOsB9yPQX&=Q>XBk)|A=RvU%u%La8$sW&v(b4uWUl?Kn@ z7s=vkSa{lsq5LiM%5M}2P#xj}yrFN+6qjpb_xvN%GE%jwKA zWWa$)w?z%-f6NzhAHzNax3z|BCU3p!SlC77cRDRWS))3-+Y;cq5?B4k611NES4+_A zmms=?y+}t0t(qYWp6NR<1HDzpzr7iK-6!P*_7ckz=cM~QQbhDSey6>jeX+ySiu}-z zej0Y-H|tA&7oz@QqJBC|%KO5BXh=2uK2I+U>^6_wapDvcYR#nI;m|TI%JVIp0oe+F z-`0k_Y~ZU+$_h%!m-!X;OTQj?bhSD@h2-nB(O@uFi{v-icpXEp<e#L3CRE*k7D91|`4K`bk3*u(xkTr?eSz+D;t%P7Q}Za*@CF{Yg4sgh>nVo=~44gPwCh{(t_A9X9PEml8S5+B^Xpd93zyVagtUDiQSi=5!^?72JNfg0Iz z%tO53w2VYENpea9^@(`Az!q^=(IDYUOPDukuYSpBQG3W-w~W;u$5;i?o^jzH{=Y?I!;m5wq z=zG-_qPbNqas*EGx>EmEkDL9^g_rv-?e9bvLJ;D4p4ws#?iM+?665<_I5NJ3zM0e| zTKGM)7RnV8uK^}r51a3%mWX$b7HgTzu&6)2;D-VKluDk)>+proB7iO8y=9wmjo!HBq^?}~1v zC$!ikE0$Gclk@}KN_#gpnnQE37c?)2>vp9ArK9%S-duuUw(t$XU;Z7mB~r}zh*mQg zgY^D|17qCZBkSfbyE&;#KirvfjkP_cukH9G? z1{sdJkr;iv94}Y+6VETk^ATK)36i;xFvb( z2cX!8E#?|IP`*|g)v^TDlZcS;8-C+Ga1siCl{u9SNUPH-BccP#M8Ho2ob${uX^XE= zTeRA{xXOyw@3)}z8od~%s}GUcWIKv*ZNzAQ@CgQX<;O5zxF;+w$K+?bhj$}BH`3lG z*tR}tVc)VxL#x)WUB-GDJ06NjwvE3i`=(Sb?YHR20GF=@beDUWl&dAL)6Ydm`Ut6= zj!fV4{H}RePuBxzA-zudeoEzX$0FB%w=N%%+nlqs-|`!p7j^cW9Z))zhJd3ohZ}Xb zbAz+@QDg4km3H4&PjXiIt_3G}%bg)nO((P5=~{kcC_J9Fq7w6>?`~d3IG?)@?WoOuFqpC2-UXo05oM=Q|@$sCKB! z*EE8SoGjPc3xc=Pc{t{8#(5Z!RQmXbOr@v4&mL{|<4oCWug&Dx>tp>vn<_qVq_+i{ z@w`nwFXrc-|KVA?d^SuxLp?NH18d`gQGdmP>6m>hj(LQO2A1B&_u*k{PKT5h`ZXwu zN?mFn%V!%HwLV=ZQ{X-%Ra+|n672DO<{0SxGJfy*z#IcTn_*}I zB^Z%%P2*$9F4!_R@Q|=rSqC{_@TRaaeT10FI#2)inaA$6?QxRjfAep3|Kh!pq~XWW zU}33OOZ2w)nVnpd?caQ7?OA?~kNn`wP>4Sdd=N_YSJA^tBU1_pm7%61xw|1w^y zoTbrvs^HX)yJeS?M3)PpfECYBX$5l-Mb;ZW`s)lI{Z>*{wZ2~jS=eZiwRw!Re>At= zd9Y-Hy1nJwqTI1+(KaPo$={~mC42iouF0PFxVJ&nPeV>J$7F`|W3mR~B8k!_0aTj4 zRiAd8a|Pf>{dUu*!AqZn3#3U~AK)<;f>m+{0HJS$taCcpfYKq@)jlFJd^%V=J)+3Mt&mID^bJrerR}&auY9 z_uvwlO`p@Uji-Y>Yy_45kSAVbczaVc5!hE5meYIxCfC_cZ3B z514P0-xWLru^b2m#jIsM5LN&W+jYAn(IP@3@BoeXS&T?nv{L0DKC9(HJf_YXgj{T> zYsh2$5=`twh975+_!$A*OC;vIu#&K!o$PP(d}>hmOKoBLZ%xM%ao^ag!3ar1=QzO1 z2zcbz3g*fFX~4xZP{(Z`^Ul5)dI7_oF5vvzu~z8ZeW}FwUr`Y--c!RE*9wdmJY-@l z`sf+BQ8Y3^y(X1*!u~G3y&*o|fyYVw*uZy{c(Z{<-VY;x?U0#f61xVyRU8#V?r+*6 zFdeexk{U6N4D5Xd{~jewZwwi*;oY4p!F!tE>i~X{WlP#)5l=_8n9Ey^N%C^}{s9{> zQfPI><1-0+evsoM@N*!Hw^3}f3QLy3=}VHp>!J)ng?P}Xe3`MUcH0uRvuFbwf+79C zUF)BIL?T!bDf*s-^fpUKr2V%S{D%rBB?-6W6j9XK9F4uX|%38vJuOW7QV7i;Aa zLB{8HTkL2ai+ejOc$LeE=r@bG++&UR+yC*#dIyjDTaP!2$4}!i#0g{l#p4G8Yb#aH zF1fLh?qcg6=FH5^l_T`vw!`9H>U8!FZB^&7Z4nW$>I7u2I~gsH!#a;+O09;$@S1ANFTI9eQddue-~K8ZTn) zv%0N)?0376Fyi+!`(0b*Suf~L=lRfp12D$&|eh0lY@vJrTlYyJenVrVRyqMC~TCfv(pZIBz zU4C;D@ZAW`J_E&|L-+xozm&eY4@d8nVoEFm6X+bQ;sK;}Bd{URmn3~%@_R_sxpQaJ zvgtn`vs0SMd|u|J-0uiV!vz1UUHBvCI>eTIH?W$cQfl>Qj)m*nyV&HlQ@wr=r+tAuAyD+h>N-jqL_LMJjg_%nv*v6(&H;OOtTNGK(HYUnCNm(vT0AlBr9}&1Gs%0%SeFXw`paq{oZhDYevC6ct>dqEX{XlFY1ka(XXidBp2g8KbM?F48W4excu-2bl3;Ic zp*9AG-&r8wrAaAjHmv--y@tx|6)*PI--T#7)3&d^U&s6Ed*K5%eTlKJzO3aLK^>7V z4V&0w0-KX?E^qmrct6n{3=`tpXAc-r@G1{H%m&eg9`0Bt7X3EKG|lR_#dkl$xjYncyWS|8@ttVjt}WW={le9ik?^<6;&?_M7b&=R_Q zo28w@wv6Ac72mymEaLKfAYUVz)hN6p>0}_MDR4i5BnidNP{9B?1Qn$qMQI2uvCH{i z`L}vpQbivm&jUV4J!X;n7!?FKwLP-j_OaKQ1BFF003 zi3<)$XUg~8?P-NeGFYomG<+u$z|2vdpjmdSi#E#(%Pf1@_riY4Tjtm;5sq> zy`G$&dvTdY+}G9R>K2;^ta9nez+e|FWu3s4Q`9e?AH8&Jw9*+sJ@UW?baT5PdTo&C z=4_shlSDuHPS3X9#FeP0z)Ix5=Sb|O_-vN^?9eOx*||J*-^xN)l>o_0(OQ|DIS6>mc^;El*3viwL=t&Jl>JuiO=`9YgiGZ7j)3zDW5b?;VF^O z44#md7;{3n_PLmok7Epdb+&CjCcY$f8=en+0nNu2e8aK0oLf&8_tdWvheym(ad>Qg zCy4svqME^1I2brFRxh=rt|3<_3i<1aUj(7)Rv(qNp52y8_``n$NtempJH}F8H_BJJ z@|8^!epS9YFJvX@m9Hx0s|5M#66=*mzS<|b%ZW?PS2xI4U&&XeS+A~?uee-hITBEP z;uNy6P0>D80{v5dZ&S}hFN#<5<*T0*^Hr;SbrY;xi!7fan<-#}1UdhhO->cB{v%)Y zJ=Sf0RQc+_(QYPz8S>S(qunqqk+0r6$|vnIFw%XsyX1EJelFuj-0AFyx>%DbCEU9c z8?%}Y-QFrEQu6IMW|*d6mg_5}nGLn<`{sL(%PG{cSz$f&cZ;&?1Z98pUr=_PKKqCv zdQ_@K2x|1NA_QuAA&KE;Zwku1Jg@W+m**{-^Yfs{4qNa25QYcPg?Yol0~jDgokZG~ zNb{U}Y#M6%Tj!cWLWm2VHKWUT(!YsV0%Mb=9`ZY{mtT1QW z`>hPo9%kgPG@0H%I!Hof5*8ilo3Ojo$hq zGXlP*D?IWK=o3T|Mm0CtS2wp0O$c(^B2jE^@|tWn0)9}J8Nu)jgxGrD6dW`HasZmZ zxl+q~m9|RO#|9HnV+gG;w0v#-_O)g@umQmME%)&3w`-0-Ei6g#`K8?EQcHl4D~ zkr@z(9_`ZRQED^r3dUy2YH6la7Qc@4>oILiS=&8)_i(N#Oy@|o z#GT@&q~S-Dz;j$+y}DGsdQ-jvA?xXfEgzssN&}nLn+%<4Qn=2fB*4v98@!J7BEC{% zLDzo|WN5K_p^R z%3738|EW|M^|sNSCi}X`8r|Zk zZlgQ&gn(LXK#5b^HnJ}y#6zZ*az&R>y(uALjj@Y`vW@5=32`1*iD^NOa;RxDMBW^w z(5W;?UFb}6mi^bj_VGRT^wrD5?xlkC1Uw2YZ6IyfxZe))>gAPA+d7@@qP4&ORFn2mS%t17EF(dECLLD#9*CDQw>;v|QJ zO`b@7jg*blgf{|pMCOW4U=+ zZeK&E<=UenmVOQ<4o)yG-#?&u)ETUnCb%JxQmIUKD&NaV9tmdv6%{ZowQ zU3wJ(^NI5HlTp^Kmufk<@1EUIf!6vLo;O zq%PpQx`98>;7KAYr^}xrqFw)V@V3rKg<%;E>D{?^a=HxDZb*;5ScB7^ z4Mh53fkklwTRI2fYQTeQ`%9(WPTUsU+-|s_+0Xp{tu*f6snLQvQ9iZHnZJr5JT<1p zLp-h!kDoKG9a8@jkJZ5Im29kV`7c1O(EP(Z&3gYM-K;8?u9SCv-AyN_%2&O*8(cz< zidTP#l0|k8pVmjM4TD!UFP}~FRSoviPjI3M5>~=_18m~wPsAtT&MJ80+RTN1<*Ir& zh4|_6EwUQ%TCr&BVAb45Yqm|BIh8#&YhtAIy-i#D5|)fDH&-3ymuvu~H~k?g6(kVr zXvkl~#@;&j)!sSAHOP-$QU(4(tSqseCE$P4rV@#onfg|3Hc1)Y@nM;q8DLiv zQ?ovp1CW`$=&O%fzk9XYw;87dGW_2j5j*V+eJ<4ZW44N_ zMO8SzhP>MS{2CVN{0jXNGzz6&-O;^JYPT~?zr4fl7dwfRM5UxoDXN#2dNg!aj7U9s zYK$n_(jN>odmIu4j7)Qg+xu*3K<+uEGTb+2e{`5V{j`TI-@@zSf8DBGqee1=gR5cWt?-GFT^v^eBTg z+5$T7uM|}HuRc*-ORwcO8u6z)wO3yb$_k>RGSusaVQp5wY{f*_6Nf&yoCidNOMF`- zzG~La`|bGhMdS)=oDMRB@yQt`HbXtlpzhwc>kiexD@CE>ngs&|Fzi0vHN#HRS z@Jaw9i=Y5rZ2_MofeS3)+X2iYX5gR&tS=Y9S6RSA!*TAFWdg64z}XgXpKzQjt(G5> zz?WOVyW+xd{@Mb*Spr{Z0lys=hI5kze5nLJ#{x#~JsZwHS-?&SoMHiA9~Xx6Zx-;5 zWdisF3wV%$GwEq@(*4Q$;1%(KFD_2`85OdS^Jz<#8ZsyWO zNi|Qc5We8en&&MXd0grRiQ145q3*yWk3nf(0f?6%1rpB2)8uP}KB%o$Ws5`A5JLQI| zwA#8_LQS)J{8B=FZ9$zYq3*VNd_zJtSx`|Ds>bS3kx)NbP~R*SP}NqCw@9epET}38 zH7VZg@rqa*Z3w6p0?Kz*Y}ac8w|wKoM{x&wNF$J-fJZm5YnF12Q;i$EhZ7t}&rYx5 z%C!t|-MXNNXCGmO>Yc?cx_dPga9|bm`Mdz8$jEK= zBUCO%Y%HHDNW>0Ud+;3q^HFrJX@(KN7f9f=coXIp54ll5UrcudBVPMROzOOyZUTtsW zHrdF!c2j_BMKjkn2}jLFZS+r^3_v#ZV7p--wzu*(Il4z6sh4+{c4<3I=L2%90A@*K zn6D+wD8M`v8Rl&X!(~cWcL;lWqcU@ZzWZ1t+`JOL4VulW$ZbxRFk1ohbYz$;3G+H& zUWyEJvV>U*n01k14lEHcQvg#F8D@)w$py@ZkzrnyFlPYfQ!x)D&y|hHWRxUcIk;hYSo z1MYDfTv3ynV}SnZ7odkbP3mjnn!%gkcbEtb8Dz&tQV{FCxwHG7$8)lg_pyoMenWrf zN5X5Kgj>&W0l-Cf8vX`dc~Gt3L7&CJ_fW8)p%9P}Pr4R)nOb!<0xl=XJ}S5m@HhRb zBN1@f;}dWT7;ZP4MS^=;!p&j0KLB^mk&uyyc2BevI$XY=r1{$> zc-}0&^*VN^Ne|q4!Urm!={T?O0dgQ?IW-eDi`U34?R!}EvaK=O)Yn2meJ9g&5dw6^8 zGC4#4sTBKWZ2R$g+O}Bq^m=%fXfF1rP zs>==L^38V|4m$OOzm>tz##o*gjAbn$q(9eb zURYY=yGUsD3Mzbg{QAOu5ny^7Fxg@G2c{_>A(z+|j^{JoHK$Y>@q9*9f{1K++9rJ= zC4idUy{;Zxa~40sSL`Iuy&}r$HDnLrw}=IE`Aed?PG#N<34z*|B0Q8Y$QD@;l@j6w6M`jBzXfr( zgyk{x=;Tm&zW{&a6HQX6VfI^Uv1mY&WK7L zahGO&ni+3uv#0)C!4}w_Y}#{=lX0*v-)lzPr+ag^yOKBg8yQoVJx;{bMKFUa6=EyA z6SU0W+qC;W#7=F70}gk^{(6j8gyDZ9hX4FK*2Tr4;PLKUPLciHF8ua63~Qetq1nIl z$fymr>(c;{;8TC_xNUt_F50?+D@Ke{*kdBw$XNY#jl9**mRC-fLyGYGex0~;ihxUw#N~@)1}=+7r7aSCh0z(=6`dmv10Cc3>u2l!>)(z@ z_g@R__g@kh_NrDIwQ0{9O8e1h%QbgvwJrDupS}2juo*_J~z&kR{DdIzW1{VB9Oz`gc zJYEqKyx`i1F~OS{M#Kc$d_Lb2kDu=1wDB+T7%{=@Fr>6=L!L3_?S61HehS944D*RZ zdd<>j2+mf#lciUy;WI>|;wvHTt8SaONsJ)RLg_hs|BBejl=V{{p;jMjBCnj(eJS@f}wzo zS@0O;;QNU|`Tiaf^EoFYiWpgsaA~9I;Vvz{`UMV)Miw+0`JyCp>u=8yt-lyFb*4u8 z{F(JaVXxPour~xqI5Codq|Xh8Pf52y4Wuu1Z?GFhWzUh84tYm+l0{MH$X6#qJG-*8 z3q|F<5en6wB&PMHC(R4BA?&?J@9%kmo^8PW_{fZ<(ZgKNQ!M_-hsy% zGVdT-2U%@?0qm!N{!=QCmw#uw$Tn}!zq5QHa!uADq+wjDb9w$wF~4KB~%$N#f>S z4nx$zEIw*nlS_T+%A*ztHMHmv&IL8YM-8POwF$wEf(^wVlGphu`o~9)w^^2WVvL9u zHXR~*%(EVgb+6wW#x0N+=oQkeD|xK zq2DX=ywKr|`9LHd6w8V9zev=vO?&e(qi7-0QA&Oz1FAZtTg~>hBG1GKk=bp#e0)tK zpF^wF`Gfo+Pp`lgm7GDueW_Z=a^&ntseo3^l)AwYG;#JwY8fASJ~gfUE!t}@)6@A0 z)YJ%W%4VMzNl=Psid9eV5h3RQFf<+dm%c1KoJO%rTqTzjn*-$h_z8!&M3;Xqe$Po% zi*{yiarwVypSWF_@OHb6%gMB;*$eQ^u^4kvl#b>3+q7i0yKlgvRrYLOM%ASsH)30G zN(q!qvE4LtbF@^rg|(SNYy@)iy<)Vt;hy$nwjme2pbc6CYlTzkf#}y4T>fKRcq*hX zKW0l+BBtw1*+7~7u@^6SPu!%%TPC@DJ5zXaFb64bQ5PmD*b7*Yex3Ml9jCPrKEVz7_2Lv> zqkN~9wFE8-^NkZzcF_!`vYsr7zMn6N%;h@>k_1V4nuKep?+$5iw9U!>d*p4Hd}W)- zulbedO+3EuQS)(~_`-Lvhs>yRxsW9QHvdtXV_L#2i!%qLPhoGaT}aWElv>N>(Xg-l z#xxIwV^3)kicjZpxO#_hz$;x$5FKhcJI!*9?DE8hc#g_N*#?=vhWFB&IrR1neX6)$ zD%llS6(J>1l*DZvS3VM3bMIT`ti20qd?g=;Ee+WVSPR3FGsfD#eFnNPI0IcM2y>J< zPQ5f_`RJS&v<1hBX;bbN6Fs>*UEa;FJe=`>W4OfQ3E~T1z9SO-(ZpZ4hER0{Wx}B1 z7wE5O{B=O}tWnF?dCS*F8@XEu$)wEuwJ!f_sIUjA$G?@g3HmP$QgvW|>{N+?jb}BF^Z&UK& zcvx1)^_p@szjm$Y0|3Xvi!)Gl)bqPqR-akw^t7sFO_`+$o}DN^Za87pt0hhF^;zqW zkpI-EbQi{R`%0d>afRuS^+|hohphBXdNp*bP>jpB=UBMfy#CSfyzHwVwRiBloTTkf z6M6kV(!K>Qsycgo21Xop^o~YFMoEQ*k6bV-Q7T{@APvP7(-gB`MrLhU-ci#~=*}c} zu48Oz*=nY%m9@3CJq+mu>H-!Sni(n>KGM04DW>sM=6}xle(%g3zR6XKPwP8?S$pY?#lR&m^~jON3Z`EP?4xDisvn{ojJML=Uwtb zK;xl1bDg9aT~;wnFg}k-@D@cepEKxgN8orQqJUBA-#0Ox(Nqf#MvPGMcFK#R;V6VT zxOvb8IeW*Nqx;@QRTF((7Q1=u}qxQ(k;<*nfhtGaKnKUmcF)gB=fb z(L|HJJ)GHKS8YR+YV@sARbklE-Czi{;^B*t@;t_bsgfTuA=i>_#wAI&P^9|T0!ydi z&`2ok%O@2FIWYL9$Jx$Bw{i^f)T;z_nn{{$-|YR7$|%{J1?T$+#@DsY|A1*X2#rU^=Dllvqg)>Vfz>Wrb;aOON7d}Aj-a(#Y@5A3JaWS;{~ z(oGWG!axVj54+r!>sV9d|4@@zsIxiZb>dZ){VAfgKjsix%g}7ecQkkDL~i#S{^oK? z6W!9K@x}Wb)J$-7sG1*bi?3c+t;UD_sE684gHqy$R>= z<4}8vKr^wtneKjOKa`9tsRI0Egf{~h;1r64)82(>4Hk_X!s$^& zOUaoCI@X{66^+K5f@WVDnRMy|e~yaxt?g>mPd&y)J*72xBhUPMU_cM!oBAjXNO!%W z!2+$PwTT}7rXtq^)qZfaBY0Jv*BMb_(7Vmv9*>1-W>*ZLT|YH;VNN-@vpHppCOh2! zI>9^jyQYiE`X%1Csw*rVBLn6eeE#28eIBa%cCh2}SY7}pp2r8gMNwKwiWvZx61hU; z3;o>l3<*|}L)BW>ULXpyq7)z+vZ8}XQE;}REE5ppqM?Ww1=lHz<(rXYfYYTOZlw*R z3;NPVLx@}Pj8$Dm@Ib5h1`bFcuc7mezKV4IOOn`ISY|blIYI|NSTM@pfWK2Y>&GuF zP1@crYf@vgPTD?uV+U#bomY$9UX=UD*7b0jQ#!GU3rh`S0ybC?FdUNJ`;v?)_G)Dj<0GHreB?8X`5V=Vx}P|k%jOaI>l2x5Ui0k*NnhOor{nLP z>CJ1Xo?~MNS~H9#yL}%9TtL-$2d%}+sai<^bWwkKb>H$w7+NLI{+acRCZ*$o>*q$Ja9C(yEz)(C?@F$K8V_xl`5nQba z#MU6n`A3MGCVPF5nY@w>*f}An5MK|q!ro!tys&5#%$PjHcHP2{|HoRGOOMs{Y<6Sc z!}@W-`q+NJ#dJa=gWufoWT^dv%3bBQM{Y!My|pq4rN^(;J(*70nI+mZ1RycOj4B;^s%MWAwM#UE8w(u z(jhPBSueD62Z!XhU@Gb_xQ@05)Jkx1Z@CTiqv$OchV~aOqZ`YaY@L$hv%JkawRyn) z`$O~=bxMwQUU){ZF#1c-={xI`9HV&Qr-OwfurL!ZE@W$3lyK3}bu7hiM2k*3Zttf-z{i%$9G~vsRUF?pGPNz?CLN| zr{{rqIlDB#D4;J#L(rCI8ndzM{63wT!|y13=^h;^7U@nBx3`PD$3WxUSk!GrlgSU@N6KE_I#5?%{b7|$v=6FMjk1mR*RFM%e` z73m}BJdvFNY29dc#9SwvaH%=@wXQGK2CwZE1THhcN2D@kHh@ZRuIs%joOFwTlAkhJ z{ZR9hzVp?<9=tW3&CE`A=Vq*PubwhtrIzth-P?5z9az?EmgW2uRW@+5Us=O0AN1FR z8)dK>)E`KkTE*aVAM?{fyJ#>oCoO{W>ULh-WKetYZzOJSyevLC^&so{&UPI>YViKN z9`I3mR1iJ%Zx6L+*SGODZ{rp`o$2vgjADe;V3gD2v90VXJY3gC1h*r*3Py`u@R6O=CM$6}VhQcE{Y<;X?Y97yLa?a2%rwZtQRwDZJpt zK*1Yz)(E;w=>K@Z0b!je1;j|6bdeL84c^a>6OkF)7EnulCV1{@c_kgm(49AJVw8!d zo8Y_X_iNlnQJ&`5SJrVGjjMug_h@-{tz}ZmcbSxuRCTzs8jdQNr*a*p{C2J;I3|~2 zfSVrRcoKHRtp3o-eLEjlFQ8y~>16c_{ENN4w3?lPpHXx>A>OF&ZVf7cC3JZEt$b~F z&@mw?S2TDJe+&eu{o>_7|Lg+{Z2Mj2ro`d@y#&vJ?wXu+*^{(^H+T9{r)$#pVb@ju z%&Q!|)ahnapVPTAhJoxJguYzWgv+X&-oV@X<`Tamarn_2It+i~WpDW-Q&|0j`ubA| z4Fm}rZS_CY?F9E=#I&He{r40mU!rZaN@R9k@o&5$p@x%zfuv4m$0Kuwi7ucpxBq7?uX z*c|=3;}ud7v6AW$pj}6VRB4n`<2B1CCc7jpjVC(X-{&W@agazK5i$}WX;_GKTrq{p zeaFjvVAPc()+Z;V+$LV`*5I{^yI_7zuhdb6nB;(V-R@KTq=}t_GVip>DBI#1z2tw$ zH-uyT`CYv*-^TlU1~Wq}oU5SeiHbkq!c}mt3FB_79||l2+l(`lSR*6C40_jej|Dv< zSMd_tLtWG51WUZfOSr=>J8_-+IT%}=o6t6FkotS5MSE3H17k94mHC}9#r7nWRK?EZ zM-5!Yi8d+pFyq1qSg@2_u~qHWbh&mf-p?tjF4~=1rfb*tb_bZ=em|FiwDU8U83zzt z(0;j|UgkZ$8RT5x44LAzgXTH|tXsfT{)f=BKkTfH~s|Dw=hnL*aYKL|_F znmiRMIS$xVoSMkSc|BW^9tP&N3l}84l*9*`x-bxx#C;J>qu$Zfb$fs1?Y$q6nd4#= zuGXeac00_IxqSHvBfRj*d{Fq`lv-XGfU4DvU3%{}@_{{YsnbMfp7FC-L?OJ?eVt{O z_jQzAYV<>vLz7lU=;(*7D>_IktJ2l?@vjVcpC;pAB z^6bMMWtDXg|8KI&w|4*WR-a@`q`Ms*YQ&b zi4&0G%9fZC~vgz=a41Pj_;)|TDpa| z)F%)&0Jq`Fms!*Rs_gn5MOTSkkK|+~s~;aa5~9MM@poC}Q(omzdq@?e_0+pN2t{|0 zzD3E;RzYL)FZ#H`jTHu&DBN_>~M_z%OW3BLk9^QjMj>jpp(p!2TJ&9&k3a(2qPk%}b)WljLaABYi z(hht~>qBtP^D`D|XP3{KRb9OLVLxxNetyY=e%!%+(gXcq6EXbsTMZ%B3V43WSi@^t zAKd?THjM19h7p|Zx-}ug;8gZh9LBZWCpQZv2v>)9+Ka)PzYJwF4c@_?K#vP~k8AO^ zOM8+6Z=PkcRGQ0@1^T&k@dZ!kf;-Qlqrgg_Ig6r^O-SMd{DOZN!5Of+KC56sb&! zlPAShq(#$OkBEh{?!CuJYByTI4mcw|jA<1T+5>)XOMHFz+>%y?`kr_<5S~+u{SgfL z0r%yxHN31hMJwrBzs;((;2jc3E!5K}KhtxP!}>L51*sIYH#`mJ+#4FZPI(4RgL?WN zVR7Tc>C84Lw$q)yC!OEvNVv?p4)659HO=GyQ3)2HI^*>~@*0-B!S}Dgqf?Fd8#uEi zRLH*1d*hSZ&Y2<%8ccf&r4H26bT@;v^XR%{z7?(H(0eS4<$!P-$;cTLyjXS7u{cDA zQi{hhT6m4O`&QnyYcGk?>k;aXVu_SUlC{t$1wY%4(zZ$S5CC_ZNJD@eIc-a0SKnip zjrGM*38l)!7}s7$f-(`{RUC}jqcA%iZkjN`H4MJt%D~lbvn*1c zIh={*urpMQQWoPo>i-P%O+OXW)qE(S1mWmhvgsDrDFB|YFVk9c&R@JOSKzxit((} zr7>*pju{MHg?l~Bvv(4bA<@6)Vpcb~Vphuahau3FWr2jp ziEDSyRX^`K>`|qS^>GSG$YGa>pS6h>LTd;0#AOOC<%Kq2OFi4W?Cn8T##zbuQ6p#5 zPz1PkJ5;->>(E&@@uuzA^iP-Jb=y-}+bcV_{RP^ymvlX(3SJE@x3uyu_cOdzyROxL)k1|4nqu#vW~6ga%B`We<8-Z|`a!@8+{M2#6iZ&ZYoPz!#mpQA-3T@7?o{CWkF~_9gV!Cc7wXb(x>&1W~)tN0^Z8b(o&d{|sjRvMtB^se)Z;N9ltaKZHM;54co86UQMo2?bW*X-BWNQolug2?yr=; z)8b={;TUu0x&Z1pcMk*7pMn^35HD4{Hc;w2Uh3NLK&fzEsw&vlTfEf9pewSv&WLjv zE9IOXhzAtv-s2&jPd>+&kdu*u&aEW!zU*Nkh*dY{t9c0}RII6+`yY4nHcTOiRX3v_ zc?mKTXAg1n0uOPne{vf5yrI)|^;cf;>)^B9_nmJCk(b(M3QRS`nK{S*ywoWy#k`DZ z3!*dDisPlwmzXXDiSCw&;3fXn?Q%EG@w-@wEfIV?Y(ahsF35IX;$`w97l{YU^hSt` zH=y#|Ci=CYqU4jD#`L(7x6gOA_wOm1_|F*=$jj`o#Z#y+@s2KV@o1KHttMJ*_TE|m zy^W7_?Q;B0PK)&Y4dcqo9oAjis6m+<|En8LMQW7uf?SQZDtr ziDFKBEwd($LJn?nY$Qz9ir!K$!w|@2CG7EbpZCJMnm+~C_uV;7FE~@twdr$_2C=8~ zT#P|*p2DoWebTZg4UWfwXHQIz1jYewKHv1qz);aB4nu8hZx=;E-(f^^$iI6>u`u5l zU?mx7etH|;CoP87dnGQ0rk8VDrhOHulWG6+Dk)vSk|-&wR!#ivxC^+7;`5 z*VWa0#_+n0tsxJ^23;GwRGd4#asFmgP;BoP*$E&w)BU!VmPVWD;_+P0{%Pj%zY4HhI_pjP7yPsotFL$FhJfHBIy==m( zTDvANt-Q|o)(}ICD`zrYabtvmStZVs^LBEx6xsfz&N4;G{!(z3ck9A9r5~2fqL_(U zR(;rCe34=L&-e0JvxK9|p5nHyg0tolx81n91KN1_P7)i;{`V;3&8N^x?^38PPGHK{ z-N~k$*b-c(TTifM`ZK1bMXJNPHpDo32VE=$Iy;Xa7jrugGnc@ldasJnl9jt=Xa;`kVob=F$pEO{*^>uhgM-%iQS4(~EQ-OlFnxIPvl%PQen z^fiNbsfz*NBb;m3D0_vXA$4SvS#tDdr+%` zHuzKzXg|Jdcpc74Go|6|Drs?)L0q6mGM#OG9(h7Dt#J*;-9sOSU9?6~i; zvcUz-WcuZ5ZVFX#?716@cMy3h_H2!`h(3fJ}}tSYyVSI z6Cd>l=cV4%^}Ag3aJF~O#=urT2cPPzjr0b0VI32|ZbZ6ud~=Xp*DvW|wjo~xoNmJ2 z!)~b8>&k1x?AiqQ;EPbaxs^Tn@AC>XwF9osz8DgtODWn6HKkSq^0G{^6L1LUWtW~- z3O8Ug%D5D4-wLB`0oQ_PdghPzpayVjuXq^edKWa{R7LiFAkY2D#2L z+^bm8(L==mRYj@pu%sBV#goyL-(p;FE~&Tp8#=Q=8KeB8uP^gu!!kpB+5E_Scgi(` zNa>H6vqdV&aa-xV`c3V!VYn{yIQbaS zeA7fLSys&ig$b{_D=9I64wt#Z<%6&!uJU$<;)A~TFSB;&T;V^h9V(f0y>?1DN@aFp zuj>C%mz5RCB;T({W>ZdyWTu1^%BRx%^$|RqRrDk^+{mmznxh3=9AGnYAz0{6s#eRRtL=jp9*Pkh#lBwe<)i3rri^{wpg|X<^jUSnBK> zycEy9ZEhDDENTeW3+9Cu=1FIk26#8afZp>XTaL8bmHfvS<3S- zTvXCyw!}DY-ePhL#RyA_rrs(zS78&2Mnnk9(H)bLF~T3~sd;<%+#-Cjhw>(IA2g(l zdEugLo72^zzaN}2ptX_RNrv{w3;2#V1N)79L7p_{Yf6`hpt8*=$cRD0qF_RdfyC)E zSdQFKuoGuSo36~Cql~vIQ!I)t(i=4cj!xQ8N*n6h9mo8b@d$d z5fxnoO^&7}1?ObyVGfUf{RIqLx*KSh@hHbx8ZGCoYD|l_3a;NMxY#N@fcK&>M56Ya z4dVEv_bCeDzC?fqsQECOi0}3FR+9e060#s6HL-fx8KtkZINm5Y_XF-t@cRVdy&|`< zq#clyp4bd!(q6vaGC<^hv`3*i#< z5BNDgok6XN)X4lWq7dv zEp*O$Q(r%U)&JMB4$z6|Y7RCwZiX`1eG$^6k+6VonecGn0#dOuxYh zG%Ci$U6_O|d3sV8^fHlUC95HNouH?6@0Lscf+g|&yW^>7?MrA{{t@HF(Y+Sw$$lSd zSeZqsg}v+s>7Nm?a<vUbN11?v5`jS0>1~|dnLyK6JI@1AG@?wWY>Ac2D1KEtU`*Uh z+yXalXR|?A;q7BEIPQc456ia3-1Xp$oAiUblMQYadcDw4g5bOpR!vxmYX1y1P}n_b zX%rmv7Z9&tEJ6bFSr4@Hmy#FEY-_TH0>Ddm_Ys^+ky%L|N;gGDw4Aw0^`nG{dXep$ zWqTnaigFTzty1n4<;)^P7fx~tSA^TW2_qZj6)DS1a^4DbgYq(k#KAL3HbO;8n3B0p zF%`=8H8`Nm&CtL~d^3Q#Jl!7PAKUXC3}N1*6g;9 z>g)JfzK^}Qr{6+cZ-tV%K}lgj&C@ZAk#`u&_y<&~NFPd3!|ZG1^f>u}SS2-HPLKB6 z*C~1H67yCFFa4iiH&4Z}nO=y93|gg(os5%QgorDz&>*aQ3VBTXX4($Fd>F=@o|soC ztV}_K_9Bfrx>#B=)aW>=OtRuirA+p|F^(LC{e%ssPL>v7eBIZ&y8)Ep+bNS2Vd2JS_eMy_0g;C`eK+W~+VoKXla$wQez#u_;zPR@!|#>UGT z(Xd8xhDEu5q?~1?Cs9`Stzg~S?o`*LuS@s5vKW;*Us3DZ|Lu9n+N=l3$qXcoOW?fV zxBBH}n1_rI)HIw``*tx<6SLa7t}!*_VBW!MtXWLwT51QtpVbR5iE+roO-0&0p%LW- zQ0O~YalC|Fzv8>u^KS={m=PI}J@ooHM_N1*F6?f-0#GWK%Q+jQyQ2i>RwAP|C=WjA zI^^i5qB}^Gzg>&36X-%@^n8=!oMPXgBrgJ>!IKfkqxPs%@{ft6f6daTLON1Y8z zJvze#j0U0u6!)Bi3ftDfbs#1rn`HYs3~eJVLP30AydLv5!!bQ%V&@YU)@RKvlA6t8|MbM41<#yr zx^t@7hQe8M98o4kBb757S-hEZl(c!+!9AKwLAk-Z?jOi1ZH9GEM<+l_hMEQET*MG* zW1x2d5sn%K+n+XuHqjQ_n2Z9cdW2*923mSVc8*>EQrMFP%`V2pSe0?n%A^n$!l=JT zm>wD+Ze;fxyd~8n@JfbZILw4Sm@V06+yI1MW#&BBA@NGZM$h8&t6TiZz_d*_0SNn) zS8-*zR^|r6nd72xjn^SYx5d$$B_gpbS__OG!WQ*&Ja&^tC|NOzEy~+(5}`6TbWYY= z1-z=80`pnRygj6Pqio-x_9EA3gecYT$e3|PD%#!>__|QsA)nti58~}JGCGUxz%o-$!YP`o|$?6H8jhYF+kS1*uM&_{1kuqY)Bb0rW8i6Tr8Qm|+*+uGI zc#?_Wmh(1;Y=M2V`geRnNRJ|WkSiH4{Q{hIAX?xIq{1ReOYZ|H8QHDtyCNopd`V;| z{3j8{pVUM&O1R*B1c&+w?RL9C9JKTn&fxS-C`E1s(C={s%*X=9yZj74k`v2;cbPv& zW3(QdPK*}JQXPt7K>G#)yca1(CZTo~pL7NzA*(Yh$tPi?bcwSF^KrY=lhjOfT071P zo2sNmdOt#WJbS56WcM{u63Owh4Is~Ph3ao&?=nmS^&A?$Sfy5=)KB1N##E^VX!V2e zJ=SqZYPni)`f&HfK^Q`1Ze7=7|LW-;8@jo`z{NRig1+b$cfqpC3OxQC^=)K`U2Lo#Y&6D zARUQNoi&tB`xrd!u@jg+I{NBXdt9WVR3K7G9)oJ#E0IT7zCMWd|F)E&{iji+dR`{n zv=YO5Bs6;R_Gzr#M@kA{-oAnpl{S&wA#HD|xwqi#MIS(qh9Qa=Hzz}C?jbD4m z*M+x9vfl~HV&B$7*%Y>XPd^J#_9Y&`lo7;&q(o{g#PPTE%%Vz>X)WSo(q%wQbGnYa~XM2mi zbdVV|1)=r!9uj6?tdkkh5zxs>3Zbs#d)oZOulpu=#u^cGb=?ATHc5WB^Rq(p=|EM;Q zC&3NCXsYPr#9I?ZRb^iF4yfwefmr>j^L~HHSO#=EN?;tT&?R5#rXbyS015N(Mj9O> z^VGAy(b_q6YxfD3N&}?g{WI(8dft^Cx>B?K3@LpH)7Z8Sx9jBJsPX5q+S{1AVR~>u zaxv8nJGiY{w@g`>Dq`wpUFs-Ioq3kpFA*53Yg`CvS=j2LO~JmbSaQ@KT_5Y3uEaTa zJQd_H-a`oRs6N1d3cm2o(^0}(pM#cPWQ&raTa@+BX#j`%DpBza|0)tfJ95QZx%fHMBowQycrm0q?(ga2-d@QGu=7j0J?9)D0bI~ z*0GM0aLw z5brY9Qao>Iz~x&~Ya1A?L5y#hu&PwpTIw;mPMtc3Tp|d`$dci$~>66#0DaYNwO$+-+ciT->zL z7hJo<31q}@)h=>Y@gdzDk($GHl#Q)RA+t+-9q?`*2A78|nvFPyAhof=#t=<|v@?GC z%w0Qxk-;Iqs~eVf&qTiye1oWCP8p{>(T;jJHhg{f%=Z$k8#7_0riv8%1=KZ51O9V_ zoHj-1oUV(=J;S;@1=+4XW}t@oXU z%!vncHZ3^E8A(e8Zk~$dp(MnfXOS0KU4C&Wj-v#}jWWtek|HGqeIMIMx>QZ+jv0#G z3XBJEa$(B2c-YtOa6ZudR&TqbDM?^^Ygl{n9ox%i=^s_t;^~Hd2iM1jR)7ZIS{~Dy zwC$jc$*gQ#$2O88+57GsT9kOy=puy_tot>ePt;}V8hG8ItS)jJY79OjJ44IWT*1nj zSUF@r)#i4M;@tEOIcD~*7r8N#+Snd^)4flzo6&sJVNtRp*XD9{QW0E;>yWqKwnRt4qh$Q}4&VDLW=P1c>II_2QwE|R_<@pvR z^SC_D3VRYG<<%I(rX3%xj+yCtCrSjPPUu*(9|>W&Hio0`U#0p+E-mNmH)hb9{emTiRC|U#-AStV&?%; zSL_xF3uT34t=J>9-pt>nch*|ADy969YLylf`lL&>6S-w9tSKnuqJVHhnx z9~&i$v60L>zg1xm3@pBbnd#zlcxN{L{_LIT2s0bFmsNzx#SwBQ0BfwA7b82!7&beK ze0@ivFUf2xxk0ed#3{g^+JZLCTC_i%|5I<#7UHi8x6pW_py@{um{SI|aoxiQ=+>G+ zb_%vExm>fXaB|d|X9P8Q0 zG%CEM6?l~z#0X)B)A4)i{)suTH~FD^7Tf+b(f!ey;J66aA{{EwM6nM>;sqf z>%}cl4dd~3Ne*t&-#`3u^Oo5#X+q1Zw#B>)YtrXkT9eP8=8Hl8i2Sx0JPi(HE_>uf zTN0SX=V>DmBvR>^r&^d*Wdy3_q~fwk_r}Cj5Qk1%n?_eT(h9PpUe4PmAC`CcvS59( z%$h(*V{J&zCui4s*F4&W+C$0&hE14?Hq)3VQ|{x@4aoO zCkH2W^eJspo7+i02_pxfgVetDgl>|EmzjjjX*oN~m$p#FccG#>kCX*;YxGK>IkayM zfGu#rhQ7YxZ)=Dj)uD(d92VCh zN8bRbYIm`#QS^Bq*wn%t6xIWY3fKhjNO#2^C8wJzmScc)CTX{lB8tdV&6~Hhkl1gH zA*g;Ho!sn~m&D2Qqdn68F_vbk{^%90$#IWAh>>r&1zT~6Y3R$Uyv4?fGd|4MH)n}GB!reh?28L%2`>vh`}zxx`B$_c|~cY(Q!dq zGw-cEsiQ^ z#kket@Pby9prdA5L8}@pAIZ!2W37li3tBN2w4*e)s2KNr*N%c#42L0}D`-V&yr>qm zVlZRz2p_-!RzYyh$Bq4t@jRX80rUR@$Xl8N%SYk1l5Eobc0^!yZjm%{*up;)t3P)2 zE9?8zhRs6JXG{S@I&HpUJAVeYOS8%MG~8T3cP z0VbuVur<-Muv$K!-_~PcFZVQKVGex$X<=_#<_9@G$Ztzrc&6Z_A1S>N-w0a|d7|fg zK0$0$;OmQTG;P-}yh%DSpzMT6nQAIHhJjUjoX?e~nxwKYxo1KtYpAH0DD`&(ILIQG zDPh9ak%1BPb5Dg4oW&7b?dw)ogZ=2J`dZ)8OyXCQmcvFX}c*a8dNUrABv}(KEFgS{9b4 zLyG$$BQ!0%I2yj8d13i*_#mb}AIIyoVF$9k;gG$dZlc+W=(U zUw5E!XE(>N1KmC<-aYrA`b&M|PP^kqCB+IPYi?PyDfg~z7oYE!dslk+GK)Map;WDb zMX#%2YaCdwr6zZp$uo~FFH8l>9Pl3K_CB=f3oknGZEXvTNb<%XD9bu%iIsMm4(~Yd zEet2!-Ce7-;6NSxr_S~Vc@$E3oP?KmPxm#2IVbbmZWYHZxH3QQo(}uf zfcv!;_v_Vy6Kwyt3R~MeUoK=D2K$eS5&6%B!_J`d63;Ux*>T#Fw9J$AP1(ta+%msO zZilJ@RE@qvnP)9HVT4P&$KhOgp4EM?$uo`Z;Ruq-oep#=ym+Iwlh@Er?($e9GF|+hpkIfGEc)9!G$1o z0>E#9TLG4+=@+e~Hh?;8>6m=3;0U#KAXmc^^C2~Z-GVo7MH#?-f?A7vfBzDVzYEA9y%A6Z^z4Nd%~`i zRCj;L7mt8-L28K-Uc!(kQj1ksiBC74=Nc0BCNv@p;I>9vJ>vZ8)WlXtgRxr9JiX0I zh0VfBWL+fH422Kn7I~7^QrQ_xpzOC;mi&FWcELroH^C1CB9;L(F~aJ3ekm&h6MA{?2oK>ykb8s?Tn=5udt)Khd(rhiDwcH0oz)tz#3Q~jmU@cghRd+Fvx^P z7Ed$ipC!^gHL7ukQM^H!M-j_U~X&6p}; zfoCz`xC{L=D`Tx#ZKe@*g(~b`JZ$caYYH<@2wTrp``{$V=LWUNKe)$2+DT#S0e5CY zwF=Hl{K{Z*i$bb9JIab zno0R(C(WMd>v;wF$1-1dcwPhhc@pZ&*$w{8(}HUeZmOeRNwX$aK6_na8H=mjl;Z_Z z2=26(QMiE=xMLTY4NRZ=UdJBgLAcZ%-$FTr2;Y8u-yCbk&G`@tOmO^5Sp*yC_}W)j z6x`KpsK;x+$+&g$1}~}SQhTcDM42ka;5z9>rH;NFIJL1tN$F>io<2?VII>Vk7)<2xUqcO z0GDr~T+^gN7bvW)is4?1Y9Ha2U^2=go

d$`P0)A@-bfqq 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

CxHKfg0t5Z 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 z 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π3r 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Ά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 diff --git a/lib/libxml2/lib/libxml2.lib b/lib/libxml2/lib/libxml2.lib new file mode 100755 index 0000000000000000000000000000000000000000..4ce6ab2abb9837d528a1d4966d160843f7b1340c GIT binary patch literal 1055968 zc%1CLf1DL{y+3|jQHjWil!(lTh{%j!T@cMnF1su&F3Y;R{K!b0J!jZGaCYW6=Nwqb zh`45E=H+tDl#I*ua=Bz)uMv?Eak*w@WJYFYW@biQFOm5xGUC#A-t(Lv?;o%CoHPCN zJ)b>$9zJp3&*$qsXWnz3^PcznJ@0wXJ1;Ywblr#U-;;&EV2GqCn%;A77K>n8#mRs$Ok z0-ve_KD`Y1%wFKL$AMes0h_h}n~wsYuLr(xJ#fb(z@6iOtroCt3vk!7z`uFZo(Aq658USfyAA+f9}aw@9r)&5z_(rm_Fn)Tuz&|10KR(x@V!mI_a6Zsxd3={ z0626I_{l`zr#awfTY#rV0#Ek=&pZnJdNS~vTY%p_3p_soIGP8J9R&U`3V6u^UO52# z@g(rtOyI;i;N*VbuPG08r(Fh|z5zI68*tY1z=#WgkpsZlyMR&0fj2h;=iUyyjH4P0;`aN&Aj%7ehPGl7e)0;X>TE`AcYbOvzQdSKQ8 zpm8|Rv;vrOFEDQ;F#jr`?KYtO8Q{v9K-YR;(SyL!6mV51uxuM}^>cu69+18oFt-7{ z&jBkh2XfZ{)_Nd+0B}wMr4C@t?ZDbYz;$DQ^~-<_TY-&_0@t4cKHUs_#sNON8~EG_ zU{f2gc?)ps3&0nq0(WcxzW5-pbvUrC9k}Z@VEZ$`zqbHiz6Eg4JrDPe0q$!CcIAQH zyMa9~0^ghkd}{#s_Fmw?2;hOMfd}sb9y$tqzaIF(I^c&71Bb=}kF5kAzaRM7Sm5VZ z1HZTp_~kRevtxnh`hdgt0!Lm2{`WHAceeq*e;IhO4S0Dc@ahTRPi?@TcLFDe0jGLA zoSxbboIVaXVK`vYUZfj{%J%fTlKJ&W*s_CxH25 zfwpBp`(~iyFwiv_Sacn*!Y^w+Ex*6EM57==O`0_;HE6afY*bLk^9N4uU_<9}ijjMrg?gjQu0`^}6 z9C!%$&N$$^oxt~Q0=~Z&cw{*6=zQSNcHpt6fuD{9ezpPl`99zm$AD+10?+mV&+P#Y zzYP4(Qs93N0mr5QFYE$dngP6W8*qFK@LDHuVheEc81UCw9)_J}0jECzoH+^@J^+k( z2zbL-;Em0|n{EQ$ycZaAAux6YFm5Yw-Z9`E6M%Pa2i|oIm^2BPTm&w726+EDzz5oZ zX?Fq_Jp;^W0cPG0T>3KbcNYR5S_d>f05rV}v`hx(^#JpC0SiU~3tNCI_X6GHfW_Uw z(%XQm9tA!+8Cc!}7`uVYFknSD(6=90H5TaK4&+Ax&U~P_4p@CRFz^)cvEjhSX9Az- z13q~>@b?b`pE?fQI0?9EF>vz@z%6@#O-F!#8UuX31^7Y{xMMr;#m9lI!vOc(^Ke%W zuzfSI;{jmji@;aL1OL$h{O1PXtM>t4dluMpHgNweV6O%2+Y0P|6gY4a_|9bDyE}k~ zCjtjI0*@R6e$)p1_$lD=HsFbSfG1A@zgPkM@;2aCM}X%h1BcfEM|K0xp9Fq)A@KVQ z@P{41OHTu@jscEu0A4!^{AE1wf42gEecHnrbyI<1_W@^(1zxurc>Tk`*^_`#TYxv$ z1Ltl6#*PEVZ3NtN&%-;qfp_i%CXNOsZ3ZU42E4Bmc>g`X)N_D(2WWT{xcGA5lDmP+ z8h}|lfyVQIrggxa!@#`x!2AQif_h-#^}v-+0Nv*Ui!;E|gTO~70UzA}EI$VHbOV_u zf!_H*b{~)%3s@U~{Ifuz8z>zB2F?T4<$>!C0iS3FK6wbZz8Sb-8*t+(;Iqqs&us_( z;Wc3MJmA(Xz-`BXJKBIR?gYN{07?VxOXXV-#x&tlfc)P z0pGYE*gFQ;mjU)40RFoU_)atM-CKe09RUtr3OsTv@aPM`kL!V-Yy^IK5P0%@;HeDo z^bX*e9Y<92o{Ye>HG)AMpE$z#ldMFFgaiItw^{3-H?0z+a{U|93s`*JB>e zteXrBTMeA~IPkjjfY)CGykRdesty?44V<$H7;_kS>v-U8Hvw-y4vg;rChP&;eID?h zb-;U{1TLHfOxXfVeIB@I3NZa<;Ns^2w{Pdc?b~^n^(4@EA<%RKFy}?Uy|#I9&oK`R z&I1+>09QT&bdLfScLGbd16REYe6$l-z5_6h1DSciiY-7k1*~cZ`tJtv!vJR~P}~Bn zegRn90DNo{@bUe?Ctd(H)&tjX0B+a^d}bW**;&BndVqhp8TiLNz&{-UZW{&M-U4h{ z3Ea6A*m?l?mr=mKt_1$=K451GxVr_o#{ur$3*2`c_*y;i^&a3Gn}Bcb2EO$q@a>bp zf$_it9l(PdfQRk_9)1S+!ARhTGl3uV0YBag{NzR8iAlhdi-D)^2A)0w{AvvF>ki;I z>w(|i4gAkZ;Ak6g>_*^)J-~~HfmhB3{&*?yrxn1TZw3Cc2RL=6hqF>MfV!K2VY`7d zp95Yu40wG5@P>`R8+QStM*`w$ON2TZ5~Cawb}?E~IB3V7d2 z;Qa@IsTTnC*8>gD0vDeLT(TPY;C^7%XyEc3Fnbp;rw*9A5@>x0XuAw(-w9lKCeYOm zEV>(5@)~f}EMVCVVEHh>uz>W#z={T-?*?Gy6F~nwz}^B}`!rA-1FUWX25tq`9R@yL z4}4++@X5!4>n8&@WPls*2X1;9_*^^i51W90d=|KMB5>P!;Pykn7pDSWx*7QAr+~XI z0Jh%?>^Kg5c_#3c8-V|K0Jv{7u&W!`eLb*eH*o)P;9H%*x3>ZR^&;@VOyI%mfQNPh z4?hMRJO%vl0^mn0fFExLesU0aVi@q`eBh~DfTte^el-gC^(^2w7Vz8c!2cWq{`UlM zY%=h|QsBjHz{`h$Kh6aHR0RI~An=!yz^R!YhNmo`ZaXmSC~(#+;B_|uuRjQ!Jqj3= z0Y={qoO2j>%WUASHvn%t2%J9}7=Ilw;Rx{VX5c+rf%m=$TsRw;ay>BhA>g8M!1QZ? zi?;xmJP%wp6_}L+F24_$eGHg01(=%$T6X|fJO{L&4|HUJ&TT;VAz;awz=s=vk7R(4 zZUUA+3G~baGPeRNUIwzAz^W~PH4?~Q4LFYhrAfe=tAVxm03SOEtX~XlxDVL)D)6Zm z;L}@x&m0AAz6`j<0XFRhHXj8(KNI-EX5fxzfjb+3t($>ur+|O$1ODw%VCOL4?oQyI zjljM8fcstp+-snRuNQ%D>;v}J0sH0w`>zKM><1or75MH%;Ct5q-`@oM;2z+Ihk-+r zfXDiP$F~AcJPG{#Y~U9yz%OqEezhO?^=rW4DZr5x!1K2ONB089jsSlc0ld@zypjX{ zcqj0ugTSAU11IMLr#5+bU1}e2`q{u4^MSKA0k3-u7uxvYU^&!9*0i-(t^Jbv; z0U&z{$Tb7jO+fxZz}_0XE(OT>l{O=`(@Pv;&{L4*1+b zVADuo^HspD+ko3%1n!sxd~qZ2rTxIR6mZuJV0#YOu?yIF6!=Of@E^AU|M?=Ys|VP< z1=#aA@XfKnx0-=(-w6EIZs38lfd^ZFht>lR-wPZ(0{rkoz`YiF`0?GqPo4#y=meg; z7kKJ8@XPtYuWkT-eE>K-4meT-p5F`nE(QF)1Ng&3z{`_>SJwf@4+4Ll1pFlj{NFwg zBT^}#t^*i$190X(;B|Gt>t_LPC<1TX3ydBCoO3BK<|bh50btxo;O+ImJ1pRxTYz^x z3rv~>Ozr_LH~_qVIPif6U|J5iXcsVJBrx+T;L>}5%U%RNbOF$K9niD~m~#Y}cRnzG z9?*6>(0&N$I0bY~1{U=IORfh#{4ns575Kz8z$b48{{AuGhC1NJS-?%V05?Aj+;R-~$Mb-Hng@J- z0QkZqz#S)nJ7)k}bHKJ;z+Fdyf2#-nJqLVwJMfjGz`YZI`&IzEb_2U#1impD_+}6A ztsTI(Ujq)*0}m8|2loNrO99_+27a&(_~CuPkDdn}J0E!bD&UDtz>^OFzZe1hvJ?2# zUBIs&0}h`99GMS1zYaLMA2@ab_(MDJ(ha~X4*R`=h`+UIr$d2TWWFOu7-6 zya%}8F!26Kzy~^jX)Az>ZUv?v1ZJjyOFMweZU<%^0vgW*nq~oWRswTx16m&du6P+} zZvZ;h0iE{&-N%3>Q-BZm0Ux;w_~=u>HKT!^c|c}0uwn<$_c*Zf6wrSmU@r!)y#Xlf z0ZPvS1EYX-mjl1`yA0U3 z8QA|QaNrd1oy&pm=7I0+01nmxkJJN?_5g=&2OfJEc>EObvj*VjJ-{zE0lz!|{OU#E zxd!0y0B~e4@ca?rcjJNIF9rT^1Mt!=;FaUR@k@c%t^-c&22LIW{yM?K$kUbrr{4mc zu^%|=C@^9YFmf?)_C{dTK4A25;M^&|Tb2TD-_gU{_5g2x0T@3Km~a&^@p@p=y};y? z!26nk_dCD`wgJ4oO1D8Dqd}tWZcsbCt5ty?Jm^Tub-vPMSOb_i( z0as1{x~>8iZ3C7(4P12&uxuG{^;Y1TV?g?Hz}yP-J_=+{0J#Rhx*EuD0h}j*(r94K zd|>T5;A6Xhk3R!!7!Pb*3|zkxxZyDHnR9^8&ICTU9{7hnz&}0*+&T)ltrNKYMqtZ9 z;7g-`f9?kU%{+;TUt=@jr!ZNTTZ0AF|vxZ@OXXEU(% zI$+yQ;I0>df13>a`(ohBw*y~!25{T39`0KS?79`$eFXT%DBzomfp2XDzI_llFdBHE z8+h<`;GxHX@7DuA$N@h*0Q~3#@K_u0_>I65PXj-n4gBIpz`aI#_|*%*b5nuCIpD|+ z;Q6P4-;D%*KO6YNdf=t|fmcof$1ew7yAe3?9Pob=fxoWwaQ10?fng(nGh2Y+8-Njy z18EP54^Jnc-Lm&-46rrIR#uW6S&X^sfNy`vGS-P+SbG-U zPrLwZyd1dx7T|_wfzM0@KI;IVdj!}t9@xABxb-&Rw!OgZ$AK@-1in-R{`ofGU!DTo zHmipn?ZD0(fV=kt_Z$WOa|-a))xg&t2KI~t?q3G%y&c$h2>7ovf&cCXzH=w=-G_mP z#{dVf1|Hc6Jh~k?bOiXxIlxbwfuA|R&vygAI1D^99C)?^cy2v#cpGqJ58$?0J^XGs z@cZ)tw@>NerR#uKb^(8U0{GKwz=`?5$*sVtmp#1kw07Y1&A=HC0K?A&M$7|7ZUD}{ z7Z~+C@aFNrxr>3fYyjSRFYvY}f%As};~RhptAUC40h5ja?;QucuLF4hO~3~Z0QGf1 zLpLzvF2KDudidZ7;O|<153L6pcLGf>0xcH;^Hu=!?*iJ60t=@ASLT7P`+-F-14|o# ztF8l<9R!w-1B}H$dLv*y4)k3Lth@!t9RlnWaP4fMFaVTx0c)NI){O_QbAa`a0G~V` z`1_^6r#1oZwb8>(!-1PG2X4s$n{Ed-KLvb#IPis;z#YqgFWw4#X*clCM}fP}0k+Qq zcB}+;t_SYE8@T5%@So=aUu^@vb|dihJ-|1P0ehza`|`m42Z8?{1AM0s`0je(d%J<} zKLb269C&mlaA+Cu*mmHjV}YL)fuHXMe(@^s%%#AyTY%>t1Acoc@ITi9M^nJDPT+-y zftMx%uWSVVct7ykIlzf!z{$P9Uq^Zvb=o}O^o_t7$ARHj10(JMMxFrPI1hN!ZGd}i z^e|=yF!lyu+#ZJIxoposf3ALcCYM{DwTylX=HdIwcPz{X-Cmn;u!fhJ8cxR zw$)`8-Oy}*ez{il`A);?HM{MWl9gtXluJ>4zTI5oNga09Di)+nvPjYGcE*g$23=AZ zsrxctBUo>HF}Zx5P!{&AG}Cceg8)g=4p zIU`>%Gn&H5y036M&}sJDtL2=8t||*mNBK%sR)uCWr_beyD&6FmMlt5g0$o)aGZ}q0 zPxR>)$29flsG|D(oYh7Sr-ox@vT1cEsQ^wQqCpg;O-1ZPM>hle|ZZ4JT{#>Gg1_%d%tjj z$QTGABN{o?XU}3M(Iuf zRgV z=OvDub8X4U(N`>4jd-Wu$Ys}QFSSHKBxTI_#s?KaX>s|)9IlJmhNujoB#}fPM-?Sn z?cFGv#Ii1eT1QHvM9Y04Ns&0B7o>_Z?RFZCtXjJ%vLv`&qeWKs+LG?;I9*k=hr!oW zRv#}$x0yyJ)@)J$A;sk4;@ysRmzi6k1cyA&xP7~{>3washjcR;L#nY^r96gXTIz|w zDLlt2(L&xxt3RkH@^p)x%h_w<%caJUYHU_9PqSG_n^wlKiVGdxZ=lA|YJ6TXS5u$c zr=~La0#7v--79rZi8vcYQJ}4~St#0$zEpAqrN!mrbFA?y`fj)0QFHJb$I{IbPT(l- z((F)URiw@-{;91DY7nZ*>vIUvEjinuVtt-t^d+G7T{BL>D;%e3F!4&r1t;L5&Q|S( zxRMyPS>#hV`w>65M2R?fKZC7`!)5xrp{OD z`!=JXZET5J#Ok~1q86~N1+P`JHm{tKyuxutI}vEK^D(WKQjz#%m~>t2o{Hptidw{G zmGc2yn9}z9TZvBpJfqO%{-Ek$x}pVaunpZ1pQ_VJd_FFhTNB1sXhZ-n5qBdbh38@_ zKt(2mm^@;9Oj*cMG}--b$1ks3VMHxtbGEJR{77O*8@Yn^%$LM~W&>9xw`CiSpLd!C zw-Sd(_Bn<6WM&fY{oAT<@;#-Gb()$uYx z3Q4E)(SWG|#+tB5Y&r0Qzrz26S z%2!a{*s_)>r?!mxEJ8Fr@IZ(ht!dIzs>{3f$!1tHSiIvZ(j0N6bdyEmIi{mj=wtUy z#IZ+GmG~y<2O%_`wevAw!-*Wd&@!oUPFfZP{de)ANK>PLw9E;`Ozi6*At%6sbP#HyCRmx-}^06bV&Bcil9hZg9p$Qh_7Id@Sq(TFQ=j3~h zvcOTkCp15ZpsKt+hY;Od%(P_1TePYql60sTWv5H*tF)UIbwY{BB*cejfbPeY11L#z zge5&t!rPVc->nS`0_K`U@BjYKQjj;G>YUPH7hNuEDc@@8pj2x_5u|XuwFW6r&qOQdmO`AE5r#rn5?x* zy5#dDOLn)+bQ^GmQV$=)kzCR}CPa|OM(Mm=P=h=&N?I9VG*Muqv|AiC$RoL=U%fa@X2i&YRYy=H#S^>@?W;9rZ<#5^&x$CrswendzeK6uL_J zyizw;5UYz(vo4#XE%Xp z!%-2O)@BkJ+DtyCm)K^nu$A5(!&;-3I^;RV$l1L_An1VTTI+g7`P~9GOox7SE7A@p zyV|`xx(&!i$24Xud1GTMh-yr*#YS?Axdm<)*X(!C1^1*}m^U4RI$bKrK!r9sj=iQ3 zSL`T6FUA!z3gJZ4DWsijzF07<44YMq1hExeU>K4&(^;Yxi};8!(yo`?>ouzhoHnz_ z?&hia=%`S4n+~}aw*}!f{rz!IY}6338&iYh z!YbL6W($1X=|?KHV+9#14OME+3NnPDm0TCfTnl))F_-T%EVoSuQ*Z%o%H4 zC}#vG1XP>7rmN)ss=aQ-qI{zyhIH044QDo5Z&E*r)+MDiW7@1Gt$v}RM@oN>()jYp zFzH<|a@kd;<_Ho2q2wM{%c~+YW=1ictde|VCgW9M>Zz#>qXXizOSz`$djqN-DYhDH zNBR|guCp`;QPc#M4CP{sqOrksXct11X6CJumCH&3E^et zwGyA7jte8q9>-jxJ8JQ^(1)7ZIV(elcu@^oYrcK-FB^q84&oTXGkzHZ?jJ)a=MUDi^ zz1HVC*iF=uK{bG>h(Md;?yj9z%MtM*W2JL;!OS$xzryb;xd+>AKNkCxeT@y3gZRdU zc1u!FAUC@mxE@38nnirbn5*5Ih7Ic|v78cd1=BH=OI%0?MAKR)n{)dH`l})pA#1uk zd}Q9q+C^;}NYz8dt>sKBy;gI1Rpd}`e=Wz(b!1)3II0^JITHGNvKH%C8_uf23R`zw z*T*Rlth(`{wAGF2!Xj8(i^Lxo!2Cj=joMdf*WsGDh(#^&3F) z$vhR47h{xmqfhclDny9rQm!*T$tRVbflu;DrMC4+KB=B4Ao(N}B1Cjh$FD;?ejQY) zI>b_SC>4oM^2rrc%nC6^{n7YV{h<2*v?PAH>Dd)6{&S|Ii zxLw@ib}B@OSfE_We3DO6$8Ujn{1#BhW`THY7EmEVM4Qqh^hrLcUI0MyN$ME4iO0B& zI%nF%bEb{@9ood-p^XX=BATf4p-DU+ny5W)68E@?@_Li#^(N|fXcB*iCMraTAObjj z{uTZWps-I<2>T>TPrF=nMR7_Gx?FTzTqWBQwh#@M#k2tRaa=^u*^Ft-&_SFm^e>`4 zj@@JhdCEsuzFqy+$j*)?NGF%e9_5_9cAa4rvz8e@q^k`J14?~arMC6SFv*@6&zT(t zYmBS?c0~>ad!X4dq{mbhCF1gSzrDiNb+%MpR&+VINH#Nqn0i8q0!_wpF{agPs{tDhumlDb;0Y?va%j4ROj=RG|A2H%1hTXvKa9iB$ew(+92D775uj%8;L@0Hc zK2D6F^KntE1J}bw*OYB3S>r;(AhXvrEZj;_w;+lx-QDLjn=9B<+E&+jmiknQE+CY= z6_K*VQqi2_o{q(=>GlR!7{ODY%9hH7M}a2$u9DY}%FJOal1Zzz#E0<#UOzvZj@^hF z6RE~(v)!K4pD(VJ?&xduPzl$&u`{M$OeHrN6RI61d+gl(#l2?mTb;sYf|cVveIl)2JcC!;CI$+REi1Jg{5M`ova{77~5tW8MnG^E@onn zsV*!Ea4$gq`4qn)U0fJ(g=ywz=L~CA{DyR4VE|53cEaL#C|ghiLTRp9Tw*w^Qy#w) z+PE;H+4iOhx)*l0vz}hXy7_S%EEgUHnob4hlqQPPJqA{hrq5|3LJeeN&b?4}rTff& zH8&B#G;^T1#L2pQ<^8*u)!YVAa z>9%6F)ZE?dJ-2QdIj^2sTXvg7j=0!Lca;x~3u-JDbK(j6d%yIpgEc_1LpqbAFdSvt!QbGH0{)Jf5Ak z=9vTfjDb!lM!}rX5R=o_Ri&a@qfC8KK~15nBfQm`HP_QnQ`z`hMGn!5Wph(`i3bX` z5rh_dKFJ}pSZ?RF=To4@oli;(sm5ld^2D7_VgMm&&nI41g>v3jgJR?gwjk#>i@G6A zeGIL}=aq7?iC=T9Oq@;R5K+vP3Vn1oC<5nhMsxo9ip<6Bmv*0AA@;lzbVZ3h=fnU? zir-=F*#<4{T$3UQEhd{9A9s%NvLa~DuSk^X`13*x@TE@E$e7O3{v2CtP|7B00;>$z z$%??ar=*oJa<)Zh;bl=Ui^B7=iXwB;p#MB~yE$R%b4Afg92>1Ov|I62na4o3^h~oh zLe?tT|G2&Ob}D$roju)6Z-fYo38-KjQvOaeXAHE@jop9}L#gpUgBm2sMux2LRhba< z`yHwZztBC&*r}t<7zHR&t7XOKjRF)&`;>otm=d7PDaBq{vR&Ww8MH?^Rp7llmCowm z7CM<%i6Pb4tZJSWS-B}MN&*?Ihd^~!$p}eP7HOqKk#_%5*T~lBilWUT$A$|43)6db z0g9x}BgHPTSF>fpOnRB?GI2yiOV%k=v?)1|2%*~#WCWo_?NfP(KpPdS+ZAoaj^9cp z+mN>4FMLZZbrcgLscH7$Ty!H-vkfJR(pisqQK#H+r9%`kr?n=h3Orj%A(y4Ax=@qY z@Hj}T$;8A+sy8Db&VF);BocQwDOKR-8OlmZlql1oZD^NE5rQ_?dn1OCb^AiJCBy(( zD${nF8`E|QwKAS0!yT|p5zJeMKAa#W*JO0%%y4lRp zWY?N(G2Q33&eR`8l|s^+qNdFvsUfe;AjayZF7ny*F-(&pcV}A;3X$1uSl-3jD z*AioYi|c!ZOz^i+Y!@Ei<;f_i25@S@B)%hHkrr1fqX@QwvdPw;Grd`u{`*8!LCr!% zr=nz=Y0bsUk)^jJ&@wN$Z8w)EW+`eTLM`qq>F+D^W!i7@FHchcy8lInMhr_kaK_vb0D5Mx3T$t%4VHHaYrhZMCDaT~-Y_$}CZ zv~q=rh-AsUw>`h_;@=bJ!)e`9a@nG{O7KNOJjV*@dNQhBiXwv$W0l)gO#qWtWii{9 zom|4{DhZ70Gjlm_0G^NI$RJ4!kxG2Pu$kp@6u2POu_hx2cvP5RCG%DYSKfl6(N$%R z^p0>^76iFgkc5C@)2rn$aA8WSS|ctT&g(s1We=s8Ek%%s3dDbp&an>$kY1S@bVOB3CtAWCP z7iG^w63LiHF?0`Mu$AgfgB3;$4oM{E2$N};i{wL2NBEk@b(;QLWYk?F10cD@V~?`2 z*ZM4wd{2m=^%q6;7-^`#`*2vKXy=S^YsjL>-2JHycWr7{V!BCr>jnJcoEnUQW^#fK>Y zKpOZJNHwP1Hq@MrOBY%BTuH5XIfdss zG_f6GB;7uc+Xk`i0!^DBeBH4;Oi#P->Qje(Wp0gC7xs0t1F7Fmi|&hg+!v2Eizv9G^d2z-1xIm zmL-9_D)SOgmbsV{5rP(XwkkTWcn1jWlft4ln`kl7LA=~#ST6N17&Of9LK$QlXfZM6UPgho=7}4zMd-`YKC66>LdE7OmSi)E>-E0gQ|8ME-ei0QU?AC>{?onYPSl&U2 ziiC*Ds8JbCSI6iC+9%jRko-CuiH{g|S3?)gYd(v|`Pi;^+foKmQph>tV3n#VtTsG~ zl^#RjxFALDskD#u-pTt#>=C~&Qm-Un{J-TJ=p4sVjZ4*;8$5~RA~wZ{)k|(m#unBQ zr9_FA_g|4fa+_F^E%r(8Hq-?uk~WVJ%f2|~TSQqBH1R^5@<@j)aFq1>@hqPfp0^NK zq=O|vsGn2Tz}CAR2DXt5c1oJbrwi~U;W@T~lus53Iwpr0Pdr*fXaQ@6oIg=g&PD|I zQm0w4bF0apPS!$Jec`&q`;7n6Quh+nY8AYWq4FE)VtiHe!b(;0$<_k-u!$-Kr2lj< zo1$UL2U`|HI$NAq?9ci3aw&CEUzs>A!u?%(D%p}Ij*qBhEBY<;TDHU1R`&)^!*N>+-jh?r zsX+xq5;^&l&>~j%CF-^{(@{y)=VK4B=ICl`N1|4Yo)J{)L{U;mZ8RUNsSD)?3_Xr~ zovNbvoceU0zy@jRO%SpWQ0&?%FQF(4KBap#DWSQnTNk_DF$zWb&burG6dA|Icy~sm z5lw;h(*5>ovs1W1$Z=sxx26Xh;82vu!xFA}V z-!82WAw=q3(=jos>OBNpZWBU~DvJ#(N{r|VhNsI$sxjrZLFOzw&|E&02r9c3HLpA< zEYcC785Sm0fhR{oXju?+1FqT#LDLPRY9k_z8s1c;h|~^nYIH$~|J|rjM_W<$8?tDlw-fg45{56?IFM z2D~@DI_@jw08X0M-QCe)7hakJK&4Ii( zb56_^v0<7$66S8IKWm9|=14W<=M0!>B^YFwWFwQ}uzO*jU`7J>XG<} zX_0>!j*ZfCOCcitq?OL*vWE1ynJjpe!KRqCN!!ztsc`CfNZ{{`=`1mFtEBURr$fRu zkS3HQZpUk2ktKEGL^>qesHnCehSd|^ zm4FN3IF@2nw)ot0M0p8wb=EEw{3gG;K!7fQNp@a)xgs=w9XW);R&_#y|&lS^Ts7FV{TyLtiyK~ajiIyXw#j*Q4 zZJWpvDd76LZOJeZ=cU-O_ZQ<9q69u^zmOe59)K-m@6e zk*z3z`?>wAkIaXZXZWr@cZ;i(%?O&vvRZ_Whaz%w9eWKO4MpT|*HQlsyiO_715_HF zQuO=D>y&~O_t`2r!b>m8#OWj4OGEk1ctLtuxSqts=vDnY2NJvzp-gDy8!flB%C;1{ zl~~6`F`n3DTG0vo0cXH_Xrm6lfmuGM1of~Nf=i2+Sr zBg89$_VyvE%DiyfM^R)>xerRJ9Pj;~P1PXsa9YTE??u*{PLX9nnMq5k5zqElo=m7p zA}QW(lLe8YoFUzzoiZUE66nG%$PSnp|B-9*OLSpU zKulgTzWi6leOpssHkWZLxC*vHMM^Q6tWg|sS6t#bhS`$ZAwl9uB97D1j3u|nOCi~< zQ~|*ZE-%44!tv)n6%lI6v-=_)5%SG`kq(KzlG^F>$tY+)H%ED=;ob{=l%DGcGbFrh?5x`NL@tRHZA4 z3hg~*PI#0EP$X?0A(pJzBi?2B*Uxz?J}B)tZ3Lw$Gl#Viloppy$sy16B{Yd8y4SQ! z3i?iUWv}qlM^&_`m~E8JugjZ>&zaHWQ)Zp(Lu65!^-O3k8!TIEE^+&(_L>44JmfOb zGB3CtFI}Ec^2iLE)$ToqO)S_;%aI^87z8#-OY7$eY?Ssd2IA|q2u)$N;e4#L9*DsD zX;#%>;5V!6ucV2r+X;@##L2$UTId$r{yga?=f?jksvHT#@t!Lk@4338H&;D+bIGGO zS2}uZ`h)V~N?G72A}Z9~vq8IqlIF9GnT*yylBTfQa6h)a>>4F8F-&!TR_%=;O7v-I zU9gDq66C}tWk!=rFjwLA0@4f@LX%lG-t1j49bG;?Le`YV1gXkAaY@kVvLd#LRY@jw z!F;5DOH{j0vMwvS9DJl?S&od7UUx)|^67|BLjo0b5N?df>rT)z1ZuQMqsVW8e z98%H*)R6K2_FSYIn&*9{Rf=d06s&kO$51Xzio}ytU=$&%p~4pYBfp6kB1#PkRN}x1 z$4&d25x3 zIffYSQYDUzn$NvO>Ki1TSESyq#0!i!A)1W!6^?UF-#1TbU=gBEw{&+b%Cm!zLHJdqN zx4}l~rZt2~n$`#&@%LDGMqiZ_QX4JAvJ)@vh$#V*q{$)1QKxc?dL}c9txlo;)g{>z z{5!q4xh}VTC{^LxyPCy|KBcOBQ|y-ovMbPYQ{}0t)XY?IV(J1rQ_7iLYx{d_euP}4 zLqe(ycrr{%kHhd}n3R8Jfn{m0Ee3?mAOXl6VY!OxC&lM9HD1ww>a^#la|lz*Rq!QaiA0C9-0$9Oiv@TVbIkKN`z%Udns7 zg%ZQDEbW%JE!*Q5!cdjKdTArmHFrTHMbFcC2kqka2r2Ise?Gz;)RFKH7GiBYQf`qpsu^i!(ezMbCZMxMdu`7Zia^!|3 zO=Rglhm0!vH;4+THSq)*u@iRk7zTC;*AB8YR#B-uVdu!-J$mVQswy12AXCp$*C@@WSe@~V@!=h|XRz#BCh{(D> zzPi8NN~;kfV_?3JvOAI>aO4&c<95BX-rfCZvCui{%ZlQ|ga8cb z%db|}=z^lQH3-dTaq`H!7_xqvyfq{X0!7A!F~P+AF7sL`P*8kMxsAz_eiBDRE=S1v zX=0>U&O(PUaUn5Jk0-q(F^0;MVUl$VmncC#E2POFE=GRhPGG~d+@};+FRhNCaa@p6 zcBntF1PXD~*2FCl0illOEO`V)NhReYC`u}+4-ccS#5>MS>0s zqv$V{zmxt-`5VbEl)g_IJ%}hjffj3XRv0Uk1%V>tq8PEs8&Q6uF_R$;!0{3z9|ew= z7)@XhC*58R8T_r>_vbjI)HfILq?crsv(lv(X_s)D=8L*pW=fZDfkhe@Jz?cLfkoPF z7Z=0`F!)<4)m-i!QNlXn%5IaY&uiD%)2y#Imv|f1T;Xk0UP`*tz;S-cy%bAR7zH*+ zliy{F-{y6DY%wO_{1mZj+gy3gHlL8YNFoiQ)ha5F;)t|QG)n=^fkHRHWC4_KOyZb| ziolV9K}?w$Z`uf7^II^DxvU}CRgyq97c*Ce4}Ay^Wl>^8vnk(nhDZsy=+QGGgD8eH z<#~>dh?t$H_g%Z|%AVV4axWq}Bs4E4qeRg93}iIdHkEFLkgCe7^CxrxkjlP4EhdJk zX<|^HCxfIoBp*?3Lbqg@x>gxu#7AI5#{Zj~dMFDVrA#4|1)n09vXBLzaxWL%(rO(d z9T4)YG@kU6tcsPY9FgV-A|}$Yga)-KUJ*Gul8bW0XW*51MHdv}XiB|JMk$vuo(z+U z9%;b?w8T#$X(6k;w^*b(f`|!q>gN@IU3&VSq6AzsRfdrD)7-P0Qly}S9EK*SElXO! zqOK(~2$D#u^VcZRr^N|{Art%^Gbv7^M~WI7s_LkU!1`%oikL_TMEG15ain6!Xsjyi zT6p(2G{eV)=CM{L{<@%z@HDnCg&}@TK=}!2q#&aFggj2baehi3CEz$WHD@5t8geD! zYQ&R%(tkU+lU*$b3JN%J&^sXTr&sxis!t)orf>_xSsWLpIt{DWRAPKKOfPhlkcAGX zOI0IJhDmlOSBU|MKUi4HmZGAF936?MY+9b( z5mA1EdQwQ@eMTKV6<9yLaE(xjMUg;1D6=C4mZi<2nHIXmd@vz;v=h4ov_|)ooNl;Al?I4crAU*3HM*y0>UUZ2sGd?U zbF}hgt)lRpIwee%c#=9tR83}e(PAW7P(|a}U|EoPV&hh$Q%YPeDTi<)QKWf-RqMJV z6lpT6i;g0_nZ3H*mPAG`T(HD3^0>Dn{|2hYvsel_S|X}IWhH_lS#9&mLPQa*Mn#FZ zCibQyx;UH^k&PKUFHdMxC6{a}IgZ!m5^g&PEK9q)v#4OIZ!4AspYq;MA}vxW@jOEf zs#79QQ=wc0u^zE3aFnpn1y6EG=|M@6=7|gyl@VgZF1*0{Y0a$$Rbr%f;aJq!Mvh34 zD#y1Hv8`N0^yD_VVOb6Z9OjsuYCtGacSRH>;ugkyiztRP``Kc0$#N*r15<>?v8;(7 z^Id9yC=q=DQVn_C>p@7B@ooc-7@`$vjv!(}UDuZ)w2)OUtxDUIXm|>(PA?Hu$<)R~ zO=fk`VWe^zMqH4heIY9$r}31Nm4KsXlc|zVvbVk{ zv)*JOqGIRs#l&!`JR?rxBS!xU7F|Fjsh4Guj~MN0_ZmG?)LC}25K%(Mg*s?TKqQr! zrxzQ=bT-Z%o--x!j8Zj^b=$k@`%y(YAlSqaIS5>k3Pv)8$pwlMaCn$lT)0OT0*Y7& zMdCfiU~m4i#OK2VHcFF0d`zn)k6H_?pLTx;*PJaSVcbO)BC6G*Ljyiyyc-y7u811U zNfGJYBA_?UNsL6T!(RJ}9e#q~4WtX;-rTtyeZR2PZ|OG=eFxQQE&wtAU}wQOeMoEJRdeCZpNeND(+P(2ucf zi@i=on5-tSEIqBEoxL^70xy5-9( z(u^p%S2FR;h^QdJ-gZ~a%4d)&1*H5uH&1%Wa4}5HlIz+CQIndQiXw6I8ap-7o)U7( z+ekz@BFtjUq^6jdP<87MaWr0}Lqb`zL!?7OdVh%Y(hz@1QE@DtC&Q#%g$Zn!mQH=1 z43nDol4xE=BGA;4;U$UG#PV@U&q(4U#vq~$A%YAMW89iW8UvPio}r=;VcWTGTUxe? zC*5Q)GladiH*2Z$O*J~Fuw~{P!zyH%PwR=Sa)3@MmsQTG+to-C$%R(h^tPtiNnY0| zWirb7+RfgWY>_JRbMl33PIov$QKY@D1Y5;X`)y(bsl{fb^JL0?V@CgtaX*F-pp(jF zm2}fLNo}7-x!==Bb~yxgz%}KnsEaSpp46xkkBJ1DOo8apt%Wwe zRm)ReVs7l75URuzd!mY~*?Rr_tw)Z)pV1ABC|$Dh!TV*TiCUCWU{eL9nMWe$rR2NT z5?R0s=)xTckt>*CIO}N^qk9mP;=pj?xh;{7JoSbn@{XN03k7d=-$KzT2@8K|M2o0H zMb2UmVsSr5l=l9LevB|_1qVRbs7SJ;u+=c_{l#rHNM_yRU=*iy+x)PoL}m-_W!B0V z?2dXA!gE=RdVP}2X4$2X-#w1NpV1CRX}4)m93bY!M3Fk3DSgEYcs59@Z&9EWo`Zw+c|=`M$TNddWnLFAMp99J1hv{bA^4QHM0InqS&EG4 zh)_eIwide5PBvduULK?oL9?+E)3EpnZG-@db<(^WJQ*>R=RL-)I73bd6$M72LSERP zEf%pL5g$*8jGn8nBNd5}^b>EC!nirn8}ZcInh+ye7cNFp6GSP+-$GnoNS~U0(S?a`luUWkt~D5Mqg_P!C>3N7fOvt}43vA})$-V(`;`V*;2& zPcx*HfD@(yN@SFzu8Fe3bK4WWXQOT7$sFp0__no)A96rr06E(#YIFK zJz-9-GbOC1xEE2XyvMjTq<=aIfjr%36k5sVHzBwb{iahw=*3GZ3P*~=DEkiLrhh9)~#>bI0FQ1lAh>B(j? zrZs0EScgocO!9cktf_RcdB(Klh4y&H{abFjQ53s}6zyb`G}W;*fnuE;szt8yJj0!} z3e5;|bJDiRRw*Iy6cxrr2(40?Woi0)PAQC|ueg*#b`|++KuiFW;%Yg)9w~G^rPtHq z>p{X~noUyUlkaUF7C{@k}}+zp{g83~F3dA`Q76$`fq7uiJafKI1iE_*>jM zki7^sjLR70a0A?)wi+$)9%Haa zJ-qwM?!~4cMk^X)JJsi()Z-EpOKd|%3WCos1Wm!phI&ENlaR!=;=+~-vFo6g5=(#KsKFe6>uO2h?! z<+45QPg*}Elgp*}eL2m==_&qO>v+c7{^>q~(jZlrdW-w-a(~0i-3>3#dNaI7xW|rt zDn51>T{KlWb`PCUcEWG5oroJIF>;z6sk6KzKg|1U zlz%+WO7VMK<_I^?NBA^9F6ABN=o>F^|8-9n)5!2gp86T!;29PF3e)Q^;eG`i`v!M6 zhGV}@o8ndE(TDL*yBK*|w8!I9Q=gTc$x3wC#TYJ5_iH`Rwn4`Uzt%Aq7tnDtg1GZs zyqJOd<4IF^cR18gx~z) zU@M{vPEW}$7{)VRInGGweQ}=8oE|clawV!uEpY!`t|^vZ;b~RHUnAhA=|gT3KD3)w z2X6A7KheywE{N{uh31SD|FL&6}o9s88?kh zRqm!z;HF?9t`0kE6$@4Cq__D@dKVHOVTsrI$h_e`UEx8w3@A%3bLcH&Ro^HX`IhQZVHR- zF|8@pP4b$0l%{jhw4r)Q_|PtLC>MDrY4tkkZ>g7}V(Hx!=sHJL-lv{^(e#>i)U}kO z7WS-U(}b(lQSb1X$WfPbC8|qxrD#X_#nM|U4A6M0;gZTdHT7b}Qx{g?sbLj*>g)0FL*?@y+;D<-V~w-*96reoLu(uW;jiCi2j1u2glYMJd5UO3@TM5fM6P zRX*xIy+OUo)rzw$y|cWL%W8Gj1fPkV)xwpkF7@G5oU_!?OI?i4T?t0Sr>XT;tz7T= zId=s&ajVr)!5xywQB%2+)TNqIf}^B+)|8<0PJ;388t&2M1n=Z>M!sNX(444R4<+o; zNyQ?pBMF!|RRr!c`!zHSxCRgC8RE3@zQK6^KsnApBm+=&vQ(dX2GQ6i!PSyJ8 zO+FL(Xd+jNx)l3b-X?@|V!V=M#&_+`T}lUD@fHvc-#JpXo=GxyNi33R9$C}5sPd8S zhD+2oQLWTCJ#djx>@&Sb*Q(V$Z}yqUJ(Iao)TKU{3fvPGg|`hy>im*m9DABNi=!7##Oyr>O@OaGJl;j}lCch%-JTx?KTl~--S}u4fSQV#wJydzyM=la!B2Lq}D8Wc| z4cA0h3odH%>-SRCx+rl?)TF2 zWqYgFNtNF_Q;MV*NfdQHN-$TuhFjcMg+A(bN@lbkK(+cPQHxtBl4K)E)43?Ym~{=` zGy5>-BEu@=*y?A&v8`4oResNmES6#?H9+U7p|wiH5ACU?yr;74T}EBDQ#3P!roAK; zOEr|J>fDrIe0!?urdoMwWQpRY>b=H|@tMd)Q@E1Ur5aO&i*){pan8`Vw)ml)vp954 zSE)a&-P2X;oTPvt|*#LG*(c(KAY$>kH?n*L3Uc2K^9g@2S*P6L%u}Du<;HD%a<+VGnV4>tDHf7#_ zt5wyyDbc(FrC6k&1YPH-1mom2ypC5p=P1J|7M5iBYhU#~=RMwM%CF-^7ftaM5utO| z(E8ruhj!M2&{>^!$;wpyh*hFF24ayUGs&XPN0pDDyOQFgT6q?wjq{OR#ZNMg_L;~( zlekjUr7lSc{;`#*;6A5wOMTdrIw^fr?r>2SbGKD8X7$pKeV@632(86MO2ejZwo!q z=((nNT8l|h8kbE?FnV6YeZYB&%YuspdtRY>Yq0S?Q&As~D4NDyLWIs)3C7lIxc-`} zbyo27!XT@^;-6yBM(JFZV2r(nM@3t-F00<&Vxmz|rC4Qr72~KRtAy9?dIob8N3|DH zsrIUMQ=;_@xFTtM)E;wJdFs&obMZqvs9A9kYqC~%dn(a=KdD$6CxxocO$o-*Yq*8p zM7k+xLsjopZoJPVYN2yQi*Z%iwo`)n={5WW-)z!Z)$6E4Pw)vvit$p6ixP~w*YF&w zM#V*qxm<7utcu^9nP?6bSu~BSq!^vMhSm-jKeW3p58c&a7qaY_R{!k0MEyIZSdyy< zUFWC-tf}B?-p5YxsHM%XkNcYyMTQgAzSY z%ojWq+iAGhyy-UyIv3RaBe%dLKeQVarr4865d{LppG#i36YIvLYxw$pQRW`Fh8F^Qf% z5sM@lN)~nXOp>+0YqzC5Bl1ztN;6$-vh!g}~B>UHr&k_{wCIu8x4Wg>oP57qM?nsaT*$oWeU4Vr72 zSS-~_qN;P#(5m0!hj!C6&P`6gk;|?dWUGFw#ZnBV2IxFBw3>LehpJy{Ht6HWaVx9F=5kk=pIKO(GoCUd2yY|1CW?6iMr(*cNw^ zdDykv;(j;bqCqpajVqGYLop6YFq&P%cW@^P4r+6cWpux(T3wXz4z64*!c202&Ql3S zw`=$g$-5{|rKbhhwHquWrxwRQKKf2|iQNI!0vC2uBey8h6b|FveZOBb4K5cU7&c zl8sObMT)aijE{y^5fMMMkKQ5r$Z$-nIC$=rL`9-Z6ev0eC7H=xyEW1If`iy2$%VX; zu3iTvu8E=|5hmhAosSZXZP##n>Ft7#TI^iTUNb1$OG?oQTM;ojcO@C;uH9PdJlb7V z>#D@HR8*umJH_}Y$?Dm)TT8u7@KLi_NSjv1u!;+v>K+?NTuUiMBWy*)=-icL1?}2> zDsG&{UDf<bJ#Pp##-QtJ#&YOAfcniBaY`(l# z;A-_yvN_#yu~aL`y3SEU?~4>aw4+Azj`HWIwq*-$af?;!sDz_PLa|goiK@;`Lvy>u z5ACKm5pH6m$JOejgfj%fB57R|=ncGs z!Z#cZ9tUaOa3m-i2Q?%ZsjlHUBO@aR1+xVgb+%UjduNl)8KH_Mdy0{@(( z&Fdpq4UYHMw5#v0X^(qLHDLVtg~S7Pk1IeKRcbjZr98|0qwQ8D&C|WCMws&P7Sq!meExozA()>K$}0;)#6m67}x6B1s++6rF<-j4ofI&fSLqzq9}d=sq;&M@#h+D=lu1I@OWB9(0DI#7_=+Z zY^`&Ob5XX6XBUq4naDkpxKh-mE=dXQ$tp9$d`{<VMQ+JNJ*(<Tj4{{lRqJHvpm|22%jh>*e`Bz$nlBVd@{pwIT$EshxrU$o`b+4d;KXdR z?Nz0Gdsp>3DbbT(O0gt25xUM%NyeUQ_sOpl8b=M9C%>d(#ri46O$o-JYxwT`pCdOp zrYSz7S*>nLba!4YmTV{@K;x1@&Xy{Fh;)nLotCENM^K%CBgJnH4p-7~OLQUtQ z1Y_GZJp1*P$VEBZcB+0hb)wm?Vv%GUNuth2L$j#G5ACCuBOe*LLiNwePv#?`NV1P4 zQRkxsW8Bl#F{H~X@Xx#zzxVmHX(W&_{Dt8@ZBEG&>wKlTEvS zbee@yu2{t@o4?yI6Niy%cc4xHxUT{wJx+c+#Hm@jzV`AKrWY)FX%B~f+9E;rIIH~G& z%bR>Aa?3=n6m==~wafXU$YyckYL=m~YVkvR<#&-+t}Pike7u`2!C>iONySo( zB&j+#4XrILerPv6uehmtTR(|TOvVC7N%o7E9--^7BEaCYf(tyS@Fxp{JUP14VXNvpF+Wz4!4G_4fH9Nlp?aorjXV zBe8bxt^OwRkX^EhgKI8`SR~m+lBn}hf|=Ge?4##6A6ctSr2N=)b@zDSCXL{aCX zBx{D$u8)2#`>4It-(yy98|iQHkzXX*N1>?m(a?Jm#SiVHXJsFSZ+EHQF{DHzky5c} zGnIYI%hV)mS=a7pz^`~Wv2u2q#U>-&XQryxO^HSWZo`5OysC}T&e0(A4v(0qKc*%iw@HHYiI>*@k9IT z7o@+c_u7}}c}Ss1F?Q0rsNs?%Gq7v-Ee=n~E=n0y>!3t$anOx>ml^YJxMXO|Tl~eXg@s>`N=30yKVnwRMmPZS$mo< zl58YV)43?g?Csih(N858`M075lZ!OB-b793qM_AA#1HMF$0Zk4`DB z_nC@oEvaaPwUh{rvt}k3?XKZk>k#RzL0D_aMT@ak*;;F6l6ALhcRtFGL~pSdY*zgk zLbCZNal~F}%)ExLe?L?l)n#%+omK0q zgkk){3`&Kzl1}xL2#U zCiqO`tro6Sb*T@hbl!?YWdjxaN|JMwm+t(RnM$ z2z>2&>-)5~{OiJC^p^grsD|jgHMG8p_@TY^aOf@n$cA%4s@GSEX28hBl02o#IzJ^C zcdy}93%?iosWFqO^7)*JRxON*BRPl{G~T&*XdM;tLwn~T&pWMFI#=>qr!6_7cTlXF zDi?`!kSggslwbtChTnzqUEV_-j-56Og>J_*y`$UgZgw!d3ni|2s<$*@I-eyNSFhnV z`Gavjt74B;+$Pr*t-QZtyp?3_mD+uV_&XYJrK-41Uhy-;M6qHm72~F%6)wwCj_;&5CZ}3goO-3()A70BGEnyG@Xl*jBD3!-|T+DMRq^XjYD zPnE7yKo^TJl%(q%m1HfI+O46!N;t|lRMk2vaSg>6OKYfdej0kSrud=#bf4fS)?LPN ztyV83?bmTdBAmpFIv)* z(m4Q{Te-uDO& zYVyv?YIRSgPk2kkA%_QbXr*uQL%ZhxWA8q| z?6|7Kf#19UA%uW!3>afTwgnh4W_Pucc8vi`TcovDtM%^6GA&~Ey{p|p@69ap=2=>& z_uhN&z4xAw-h2J0l1_S0NJ5hTn|kY+caO;Tas2Mg_x=CCow4Mz`R&Y|bI+Xn)ry+9 zJIe0o#V;gTJ=paQH7tuG?K~t3k)QVXS@u;nQS4!|n$XX(DkK#`qeR(ZvBTfe6|9njUou%7{#I?s;V|W@c_%g^DrXPvFcdjq1ot@!n{-0&u zh4B93s5_StmIljm9ukG=b(>OZ#EJm+&drg8&ZAlx4dH(uK%} zpD^>`_dDpi#ZecKIWlzJ?WpU-1YLJAcU@mn>sm^$rO;D>uCkYuBSP7Z6kUhyF-cid zh#I!$OCfWZI&gpA7{9nScX~AbHO^anMCrM>$LY?&P;ZQ8Seh=|1%Rnz?iuy*DZ|uV z4yKr+si!!ay4leb@V-!+x`DZy`l8I#g=jc_MkMh8-TT!|<%n?fA}NXvTV#bJ5sIKA zk3m{6T}}L5fBC{%%f_(qLRXCI`imTnW~Ls6)F86u9{0lef_#1jM`2zfzdw>_TEe6H+e{KCpuLe`A)d`1e#L{p4H zYTR?xKHp_NM^bYT)7^6md6&sTF~AgqkQYQI+T**-XG>n9-soV8?lO5e2AXmdQsbUs z_W3UJS(2LZI|W%W$h%AyiUFn=guJ+Chkf?)nX(riO^p|2K}#6~yv$)TzvffP7cZYt zd&wuhWWC&2jtDPDr6@Wq`)e=Bp=eqfXS{Q5-d8>BRzAJ5va}y0-NDq%V5)FbGGY`` zgX!YoZ}){y%hhbHU5NOw8yxU*i+ZwhT)QurAxVBL=O9IhI%$u)FMMjLXr=n0vTI}o zxprSr!cp+Z!;l+HF4*6d?N3qM(7o$8uWZ+$Sim%B!R)nYYVoC7@RM^bOWSM1*M@H% z-?q>4Yr$R;47LvkyK$dxj_=NLMCdsyMb%-iXQduEG>KEwMUXE{Cl7zW82cp2*Y;t* zAMEz|knq>5u3wB9AsL$FQ;?x{k45#c8~Q}a&{oh3yTSMuldvJz9t?U&1|jJTBnVTr zY~F?LcMvoURm-1H3wk(6!n~vIHt+Lp8Yjc;(ZNC0*Mq94>P=pVdRU6C!$KyBY79{` zHsM-G9inb|-pm8|GPnBp26c?>k=1sj91+@1OHp;$1=gr-vN2fJETSLCf_XnX>mcih zqb#6;-HbykE!MCgu6TqBEmhfob#J0#~f3hqbATE_DL%Do$%S8%0pOf$tOq^7NpRu8+Hj}&Tnf3!E69yLWcx|(VfQq$H) ztA}09M+h~+Af)?kvU4Sx2t@}|4nkfqojUx@4}G}gC46KQL=S|~UbXPVE|B$eq#SX| z4_QJpFj=mEWVJQa>S34lVX~}sx+^8fJ5d&jiD$i`3SbsfL+$T7)rU%6_6T>L!o5>v zp%`5D8tyJLm~Pbm=KMZH*0LK!R|C3YP&vOk98*m-4#~k}i~Y^{eXuMi=*N4E?)MtF zoL?D^38x%}++cFW{=ScYQ0->>FbRV$BkTtCK3;~Sv8hKPHHZpokE=dDP^hVk8iM3- zGYKCJQhs5`PbEA!P50S_s`_XQQTNq+Eu;>SarRi<2e_y^HT~*NA=I5}P>0A^FPMFV zmmSpI=BN&+X*AT$II6pMg1T(J;i~TaZR+~xf^?q`f;6ilJb%EGAg{imD(@BLh>-Ut zDZ&oRN?B~0fG}Zx;6DHvMAUlEn+AQ!XFg^%cq&QatHaZTznr|i91-r8rKmdWA_Lr2 zp*2Vomq4~KxpIGP9X8lHHNCc)9-`7EkS#=Y_;GW_=F46W*JN8f8FrKKARPu#Z+o;` z{tvRgUR;g{Uz<{79X5VdR(t{BnaaQmA!~@5aF27RSB13$-VO6FS*Y4ViHpxX747q7Lps0u4%}}`64;~%=E>4Y`G92AaJq)>NyJ4$`-Az)v*&0RR z6m*ajp=e^NLC6atcRpu&@nz2QmfDNDDnWUb`L=RI*tu7VsKd@N$&MD5hR8SzX~J|o z@wZ#WfkhK#NvLiWQb?ep20?9IxO&(H#X``29Pu>lu3SrbGz{Ztdin-fLeoXru7G4A zGTk1}sH0le`Qadl4g1 z;AH`ktM+)8*uL;`kQZ5Gt%ZYb%9AbLjrXE3YX?L4ZQga4*oh(Px*9Kq%po$@v*xVH zmuK4*VXog>OM^b)H~(jsBf?kJ38(n`mYD3T4oBA{oq+7PXQ+LCzP(x4+1n2WWZmGN zZ+R%XnQ{>Fg2+sJ+|@L!y=;sIyFAI3i-wHu7vHF^rgBJ{9`zJt2-BIw-*>V7+R(Yf zAQ}V-J0$A|^)6P0quCL|kefDJtsZtad&13Vn9U~ZjsbMv%j4k*D^!B8>|>;jqj5{UGA;Xt=|>`%(5gN_n@W zqveQGMH&#E4hy;pQijM`pEU1KzT}d6c4g%QAc%TJ89Z5OFDplcv`3`qI_wIAq!}SL zfwNo;xx;ktHY*{0S%vF1x}#gQeMdPWysb)6b=Yg!1aB_PU|lCM9lZVhUUS#3Oa3si z{867KD-HF%=HxJ&*a80lWDt=t_t;?IZ19vH292-nT>b&bAfh(hTzE!`o z91-r$N>OS1k2!sxj{7G4*hxgD{-l{L^W`3Q$?EG=|6o6eMgyLN-FiYt*4oR<5n=5O zQiL5AGr*cH%m#J#%OQV=EWgM3wfB?!^@GFl|D(IQh|90l;TWRC3CIp6({Iktd|73D zV{Kt9EA}N zlGDZZM?rE(_nG(nazt2qwG>f@J;Y>7dRRIq^E@O9k@@#n)a!LoYds!k+vXC^i(QW> z5tdz)d>#_jb}Uy9yQtSmq6WJovWid@SVbrXonjF3g2>K$+^68R!b{%yp&wr1)b}h$ z^(ipJ(j8eY08E`g-aAdXvkI!RMhi;^rJsc~A+qbo%{!DY z)e#r%nojk4dA)zoC;Uz53(FCqYF&z~!!9vMl@wkRFXb}G86t!3@m=d-z!_t7=i=9Y z*D{u9jI)p?M84ePH@gd}rdeq_c(R&sZ+3cEHc#q#NED_Ui}@V%<;`wK5)~7!2)wZz z5sHpVQFK`L*ItrCG2p}vRxlZFbG5{mjQ4hJ<-z>{PsrC=-CB+aGj-Vc$QqN(C?RQh zv~!T6b{|gluq)b96_M40$|V({*w{39L1eQ}m`|wt9lT6Kh4Dke%lOZ@5=4Qm?@CJ6 zQKd#W+LEH{FwSI0aELmtrYj+Fm_982c7fhB#L<1mp}IiV;Q*EzO_+T= z{oRl8oUCbg6jA>6_~vp%C~DY`u?)x5Q;b4t5Si))^X=Z3THN(oO<6Z_upf4pd9k&~ zcwSkzMI!vhU(J1lruUN~?69{mNz=qIHD?ajLjn=mZI3G|9~1&NPf71HRJEZhD%Fs5 zTG~m-5vF&Gzwd7k)Q--ENw7CP?{9TD8XsvKlGAo?Q4hPEHA&9izEtE)cx41N57)vn z9BF4EO^C|w<7PI%ml~6^iYC#5TXscN)r-mzp=v{lti#5)R8^HVJc}>jI!GEKNAB?( z-x(o|?=dr zkR$gTx6j`Vyh?RM)(`5tfg%)}n+7kK?6$vaBKHX|ak`&9z39$=P-`M(I69hY6jFn! z;P!Xc{7RvQ$H`u{5d~Q_xLI=*j_yW`19FZbve+K4irg#98Spe~)43lU@FC$@Gip^t z56gt4orXLia@rp6GrlN!ig*(AH%C!79R>Mzq=dgKIZ}=YQ>UeMYya z=3E@5`$NL(AE=$9n?lrqHC_stL*%hN-h<$TVNULZPWS78JIfJa?W`1)wg-VdG(eet z5#$Sz?e_R-c)a$t97cP)K}xtP7xgr(!_gQ?TrNbob_rtE- z32>LJp(EvpQ*OW#n#Rd`1thD@f2)UG)~q3GN@hcKIDjEo&KxHH?Qd_=8A;AT62|GY z?PFquWk@p4L!uBFaF171ULiz{l7vUy!>R`(-LG*`D=KG#G(ecug+X8;4Q zgQQ_{;Qqev-EB(CzPZSM%#58QtL#WQ;`Y90h6eePuYhDBvfqoQtg{ZXjyTE!o?(Wp zc}H2Vo**mR7t~eO%S>6zVbD#&e9u|qc1Bj(Y&jyN^`s~}>?*TKYX}vh*Z7Y>7BT%& z%-n-7&(oJqwn*0Bi^~z=Z&Qk_!?Nyh!mvx0(R$#n^MO8ic&KXUWH>y!G-z#S7h8%uVHp@KWWViob7>X93bN6faZq zm39$|#Y@9i+OzKYXP>>?u6XHAj~BDhs2qg6V0Mr6ceZ;(@iINL-EA9}1}$yR5cRNY zd4a5Db9!=ho3>otW<#!Sw$1IThuzEb6))5CcC=}GJKAh|J8E;g>S6ctJjDy$j>Tv% z#z#NZAmC-D&F!j(-OFu?m&?=R<+9DoLJ?vg? zRlLyc5rg((^j53}AunxqS3T@ro}+k~p6tt}E&HbliT&z%d-?O(^L7fVXJ)EXsCRdX|ucPVfXS( z#mn@}b~kLZ-HoQ%E+)I{@9gDf#mn@}UN&r88nm>zUG=bQd4{azTtrq2_U>}dXt7!i z+P%yzwz*yPuzR^l@iINRx^uQ%-8nc{H@Dd4cGbh~W%E;M~jHA||)% z@9gCU#mn@}Ue4LLG-zovyXs-r@^o3t`iQI+?A>J?ipeD(guJwMyXs;0@-)RuIz3*@ zrh(-k%+NahyX z+^%}qy}Xa&WqQ^E)@^G6>+o8@++v&CRS&zDrzl>g=j~|S#-%|^o7+_nyO#HswJc4~ zcL7Vb?*f+K?*ir)+T5;s*u6Yi@iINL-6h*>cd22vyU^x#)x+-Py%aCgQ|G;8tMguh z>%8X{+PYo!uzPuu;$?c)0+wuR0ZR>Q0SlPyuD`S0Cn{d1XSTa! z6J#xfcaFWW91&WMN>OxJ_SecXELa+>Ao>BHH190S4pwe+v;yowW>}eVv~uqRE7?9x zu2$YtSb5;V3sHDEF47v`IhSmhUp_#<27XiLbB6j*)GaE)SSa`cEMcHA8O!YQ7RFj{}KLcq*>=JmwoVDHWpz#(*jlj+ehQ_-c zHJ+HDG0Q5tYW!~pjg)ugt}>`X;g%F#hjHel(A{2xIK)1J9zS2-35r{dlL6h;WbE_R z650f0)kTmm#J++a@1*-*pf9@5Qru3udRP-!HHbp&A9&n+M*8yZ`Jc6@(}#}*Q5r`4 z+-R81i|Oy|_QG;R$Xb^o>#$2qk_CmQ0fR4toV8Wq>S1^GAHvyaKcu_Tgj&ZgLeT}4 zgOC?QzTe{=ncpG2Bth8k^UWYlc@j~+AE9<+*2B^j8K)snhz$O$IWwPe@bqLyPd7Pw zy3NrOupU)=x`nxW`gh?ezP6kMSHozJF}mOG-%^eUOI1#y`1@9vY)OQqGm_6hf)H7H zkLTY1CJ8!-2l3@NUtsI;9^E?Wmq!KL!uDbc#n4){Z~U2T}h~&M(c0@L9midyvU`l#p~n+DXV!TaB(Bc1QoL zIwI=__g0pNVsq2r1(DyLF=x@fJhA>sc;V4r&<`2ioeiE@jtDbV{Z;Yzy@ttV%5Zcw z^)TcHk+=5v?du1_4ksR@r*GH2v^df-mvO$3^(;S zBnOdy_P8eV?<6_FZrI&S_;CEnk(VLnYuTsiNXqAuaNm}|vu zV|a!)=rYI|BIEAyH}8M0I6K25o`hZT<0WhCj&fwuH}7z07GRcZAYF*eyvNmaeOWFWFzkJa_&J_74Cjz z3r&}0zXsBU$kKb91^W}BYm@h~PlURgK{DitGPk8$Pwtupn;4>wt?^RGoO{0h#Ekij zTz4>c)X^Mp2QthpIGQ^>!CdwaxSIQ8$z1-^U5gGz>FLqs%RE_1c#!hdu+O7lQ2&JX40488JMehj{r7~kV(mFwg)Sy6 zWPRb*-HotxS(XbRQ-~Di?>BS(4!f0HeSOk0-XZtPQg6 zj+P_B-2+l&9ri}1xU+_5a09M_lp($bm^V9Y`I5!`ZCP3VBQ0`C+u>uJ@|OWe$`K*# zv=mi`U0|v(Jv397c?Bd3vp(Rjtltu{il6GKen0MRclY^Vie#Cg>9TBB0J4rD)&@Mz zU;Jh+YaHLjBpg2u^8f$g?30V2s&1zHWOUA7G=(P-YrYI}hRFPTyu$e#u(Pe;D&6-? z=M_#cv`N5i8Z+m0~ zI#+{F3ekby`Ny@}^fV4Txx`Dqd>ObEgZTZyBDayTwombQw z!kg%Bc-KlNpX_H(eZ@q{D^cSkADvTszSRUP((w1=hWIxJ*O(&P{)c~h^2 z)FDWwS?3}slgE<(?4g{ zGWz1^CoPUP*XZ7rZY@WIqdM$-Wc;sgbJSFv(NvW&*H-kahh5Q6SQIG*du*GmsO!u> zxRousRV~h8vi1JfmHjxVEPE1gvchgJN04=84n>O&HH&j?O}~2BZT%Q%D|;H!wRNN% znOM^ggf@Xz)3b3FlbbiQroKEIe-xA@YV@e;dT}`-bZttJby$}*=yE7lbgosLZ9Dp? zhuzwbOtMBePkNo-k2sbpI#w#qB69Kz=1k0&FUa2tIx}nWsCs)vIU>BhNs6$;vMo44 zNQfdubdBO{`z3&S*bV-0lfk+~F(&KpI@g8VOBCHJ6lW1xe2>NbP?Na2KyiA-O)OA! zuTPvsWcfYLc>G|KIKpqG?^4F2u{_bCI&l`W1F*mE3O@kas;ctn`g)h%6($xZI@Tu6 zBGv}x%_>-5?qS~#JIkx`s2aPo91+ION>O##>sgbr=CVYms>E5us({DejeH;IORmDB zJ1e`+??wrjs9T#Yz`SU>Ri9pHN`)H#6$-27E z`Mw+)XiL2a@`cI!`#azNPP;E{b!F=2`-l}M#9Gq~BJ;m!RtNdgndLj|=2ouBKjo!( z{6mk@A>qy}v*n1e*OQ{`u&WHR2ZY*W5d23Vi-j@=b7D9bG1ct zoyF`TBCqdp4~uWGcsdMxhNui3@69$!7|zP`4}7o&UEy3RbPL$%lB zI>S34l6*gH@S+k&p2Gg2YvoO2R?w_k3c3WQ#*qXkY1wFJzT$7%O3z!Oe ze|3GCUDp)WEa;&%>6%otFuQ=rx_ex+@TGQLWL4p77V40iI5jxJ^tAW)ZSYGhj;60> zK?w`=G_hu30g+$#xMtytZKm?o`w>}F_?iVNELc=?&B6kvZr$JYz%R0Rn$Gn=BQ#K! z(|X`Sn{8JQyRR>7^2O-R)UPwg(7YaKTmso@E7#S-ZtDv)TRdHhdgDn3^_{4$<1J7N z&5Fyo2GWJ8TsJ$|_%hS_d_WiFUiY_^BSO}_QbZkgj)Ah8O~IN@wz+oouxt7}RnzLI z-(QJ(RX#8wD+>P{)IzhdGA@B^A#&}r<{aLaeAVY_w)&&tKIOaAE#-(XH77;WVJplq zm4{@dRGxtZA@b=S3;G;Y(D-+g_MR?yK}AS5LDd;Z5T;Vy-@Mdk8-nVkKC+7Nd8rA{ zHK%7F^?(b^MXPTnwY7eTS@T)OOSP-en zRW2tn*>itu^FG6Bs(SFzeXBcCj=0z6si8H%n)v*~h^l`)`N$b&7u7(i!4M)h?(y5+ry7Rn?}&0;Z+lI3 zEy`)Y(+Na&+~bP7Pcc1_-uVPyaaV@~NouZUInj1&R}Z_RPc|IU-)-W$-tn62473X% zQ;6KS$6pRRz~F+NDw0XebN-<%O3Y1X9(I(lTkMvCA_ziBynce%S9 z5vpD%Mc82jW>E!%2}lF4hV&saG+}DV{atVQ z7(>%$kPLaUnZyT-(S6%HQjWN+x7b1hR4G?LvM~Ky{QXMdqYYW=vyrMS%vTEb&;VO* zPr>7e%(=&V)PIzwD}Ne{U%0bBk}sv#DA(V;upAM>;63WW@T|yemqE@j{apP0e&HjV zoH4q_ZZAh%zF)A0HrZE$t+tzsdf07!glcPx_k(L2X9O;)w(w6#Jv19G^BPDOBJ=L? z7w#W!)g|7XsOrLe;SPk>z{}yy@pzk;R}Z_d57T`Gz48m(K3QA%yu1{aU6phi@`T9C zdz{z$P@AXxIY`$NKCdOhf;lxm{SY~Nk1Jw6#ME?tl;-RDWHn(bVk}`npri{RQ;5vF z$EH5mG_@8*(`c#=3o<2L0GUGM-#yM_eUNFYE@3N+WyspX=dmo|LBfp7AZLhd{H!@! zzuUpt6C9mA&C%H{j?RF+=4)p+Gk0enXgVY7>e=Opa5W=E(qT)?<_eSq+nL8ysrx%K z{{Yp_L!&t5OZx%o`Ud>WT!dwVB%g&ewH?yc!>;N5RZW`-AM)f;z8R$BX=+6GX@}2x z>Y>?Onb$zNFjedReo^z7T^CtZm@jIykeWC(IKtGe`}?)%q2cIqc#S_~gxPb{-`c8cs-cZI83g_Cu^4QAnWW%IpUs`QbU7*P3+xy43RTGZe|mFxr@a%Sz=SMA!Br(mq*JHq3Z!D zvJQJAv+I(>gN3PALCO$Wb&r)r&B|iNrde6+q%3YwhRCpcT%|B*R7O`AzDhw4&B0fL zE=>P)e|7a$UF>Wpq&IeWpp59-2*;c@3lsk%Ra633)}=)eX`(Sq~$=F&gYT z!#^R-@a)FSs~}~V&N2Re8UJRhveUtkU)Wk>bcNksj<|mruZ7mYOI!lkYWE;j54)|< zwAIg3+T;IQQFVo{I2K_+r25Ty{5eehy1$)__f<`6!@S1;-8&S%lW`T2&5<|B3~?{hdu+)^)864${LaGd&=y3qPCELbK!2 zE`e+z^705N(k_5ZwfmB)huu_Qn3DTsPt)D%%)~y~`W28YOa~Z$t4!Yn$dcD< zsOrL3ncBi@H0H8mGl$5kpD>?`_d7_t#ZekiyKYFk+fmwy3DWLj?$Ry+(w5@>Xb@G_ z?jft~u5v_Z+mfQ|u&h@SphyX^(VKQ9AZ`|sdG|PH`hJGEY25=r4-GKpwg!Q*29ZPe_zAdUF-3i6i0gO)im*UY z6Y8#J5Lt7N=jhuOPvsV7WIbKS99;?v1T|^rwi!gO++$H&7Exsj>1h+y&@@{;4~c3! z$*6~2)I%0gN?Sxmx03H@IpY2Wvl$-f%dI!$45pIZ-|r$e0cDKQ-5nSIU4#g$QB{K` zOg+25E5_$7nxqex$%?wY9C2SU)&L08!F=x$d-E^eSFHW zb(e!J=4k6Fj<#-gv;|~QYg;!kcUxyGTjzMPN4R3@rgB7Bs=fm({=P*fEES=sc&af- zi+hfIe$mWc`l97brDZ%r=mvCm*?LAfBD7TB@fCmHE1A$zhN5z*2O%$Qg}8dyy{u+l zwy%b1cYi0Y^CuBmH?9@pMo2=BEI{+Uu$>DaG8R>q(BfZgA8EXsvZUmAUIWo$E@I;fU@o?N2X9 zgrp-<1RZvam6D1uBsSFmWW+s3?X!_nm64QgEfU5^nrKE+xI@Lvf_u(+e$mVp`tpu` ze`zG@jSd*QO4i8@<%n=nJ*SGlFZ)X_NuelE$`MG4dtTXRDX*!dbO%!-B@0EBQj9=S zFj-=M^M0?cr3C2)rz^!Z?Bzju~bNnRM+C+h`uXHk;GVg!7C7VL@jNd3djN3!pC6cS1}mo7yE;DmvuFyo%#onJU% zn0eO!p_z9`KjkJf9Y-@yonR(=#!oV{sG7;g=vb*%C54rjOaJbjyynkl#l{2{f~Yh0 z_{;bOA!VIMXL#OmXFVLIg!i>^{W9JfmJZ7}4Lzk0RmUEGWph&Tw9LEXA8fUN!XeCckXHr``I0_?{-` ziJIQifIN}$o(ANJl&s;T_q1b@o_LUN)R`aeZZASdRrx30)s9L3{++z?#*k5lqP?z( zVf!1~$#(BZ^|0S@=1Ma>7+egZba*N{%)6vgz2ms<9cc+kfn}bA?m3uF)&5qF&I(7H zqv1YjL(Y|>YB;(d=>%k_tvXf@yPX-;PWBDk6xqqcvDqn4Kz0y0X^(3!UZL6{>jqJK zQH5eN)8GYBN9^$zo%cvyvVB6SdU5@tQ-or0Y1j#L=44w@tR8kPFE6!Z^^{blAXd_i zLea)L(G!S@Vvmj7T^h+MSEj&-QI^wKk#ho3OYE_cmsLjg>CS91M)tKCZ7~2DK~xcY zY~-bt5yG7VFh=x((8hYu6K#hH^{^XxNo{1vDSzdJc-yH$(X3R1kQevtuFqcXlDtr! zpCG-MbCgMy!zU1x!ybEiap~pZ%_NM{%hTYc3PtfE1|cu*nOmQ;DK9F$JhbwbQP7`? zY)To5!lfRAv|w_z{%Uz)sipkon+7emo6E#|3no)*e*5H$mZPPX;&+ekT=&LuL})oG zMbXK>T(~5MqF|YHXF=p?J)XDRSy+h=HiKly=~{80x74A?TBJe1%W=#Oe*W%{bw}>y zAiq(s^m$fDv=m2aUNJ@0j_dwd_OK*IzG)L?|{e4PFp6z8>%0 z@%-FNWPR>awd1;X2N0Iz2)Y0=)zy5BSq3-r4o71njYD$UYG3uR%el3dvmHE2SdH_FLmi4HrW}K`V6w>mt~flW z*0OoE$LMNtUU8^G(XbRlfR*_+gRCBQE4K(M+3Uq4n?bt2#fPLj-8*NHtzqei%=3__ zwwHu@*hM|tB5EZ`;)Hd{igNBHVG9ccRh@=BA#%$ezo9=%^)ww{}sOpO>L%R`L-@3MNnN@B8>oLQ0r0x>8W@<5?&=m9S~Hi>WR4*UF8xm8EP` zh3T-e6c~@7rKYdw=G&~Wdf2VpP+K`245uY4oQI-eDaRl!m>v-3oyC{$a-Uvnp)2KS z<%p0{<@$=hZ3H=A0a|f~B`*36-q;hq}ct^MprTJ}p@tTUaV8>jjW0M2)e> zyZyXpX=*(0T#5$=2_Fv6QLYPh-tET>NwH*}gdAaNi_M&mFOE8;Bjtz6VzQ2IDMy5( zIXN1(!fHn_B1b{)`Q_vD=F`oWdDDB8f{G=>Q~iG24bm`URI6>U5`l7 zb=VcA>jFcxQERvua_64+_W6zOovORMq>r&4S!d2~bXrI@RMiPR^8J+sJCLj!Q>7eT%d8FG((y~FS|emk00 zUutN8Fa09O7bbu1@00Q0RbQ(K=VIEy4$1mDQjWMk8P(8ixb!O^S%}>EyqVMTMb^KW zvZUWzy0UIBM}(|pDXI>;$ZWDE+_#KNAX{zMX!Wq$`d8BySx?UEGHN)Gq6RyNT)W3l zynhjPF7AgZ-#!Sse2X9S$Nw=sPdqa;9hB_~NEW7o+~2CGe-^UF(})p2!_y5;c#iH| z6=jB`W71ASju1I?k29eEWI8%E+)k4)+9PWTmjN}xf;>qVK&IOIa`mvA`bV3o({bGA zK{P#2Ju@^Imbe0tHG{~l&zZ7(dFuUxChOF}0grlg>lSV;M}(+4?0jU68KTONtd{C? zkfOG0wR+eU{k@_nF9R9h`FSuPypx@C?;BfK7EJ1C$P*%Oe%zcx-RI!xW=BszwVdJU zE=Nyu6FePd?w$G#sw5okwg|UaF=sGN9He(EcrWg! z!vnJ7UR;g{ahpMEV;-bS}OQ33Al%?ci7uA{Xy*?)1+z zMOn$(8J^0YOpq0I9l298JS#5SWsoyWZM(m3e}8IscK#siU_rRA>vg>SX`wX%6W2hx z5SjVo=9d$`+{OMx(N!#aWLd&&W6zCvBTfc%g;gD;g|H1NvJMNFCd?Y1MHz4%Bn?yP z?r&|)A2EFr7xNIBwMTcd?G(N}}4HW#lRc3FQUWIgUWIN);e&fOcZog2p1+8#9O zVYl`+(;E4i7_JA69u`Dv@(c`-fA_ei>kmy)qG&d-?dguZ+_=Y;Q@^EndT1jU@Ztwc*b}aDN)5}xNjVE?LS(-^*7Tc-Cb`sQ ziZnHpxHxqM9c#j5zWwds@f(V!jq^LFcGk{s6u+rdHQ_pV7-3mJ=@&qz+O9C_VK?>b zimAs(mszx_<_@#2-DSt75czG7`{@0eVydXYrfLb-N3RaYVrW9G`N?))QT4Ff`BlZv z$bfsiX8TK$ttd>hAM9`{cB$1uGAK!BAVF>J zTRrT8eo+WIqt=Ac?WKXseV=KrgfmV|W;=;oH5Q;rBr^^YeX zIm1j#)-GnsDacUU2VFhvhJIc#q_u@3JYzaij<|ibVuofR<<=8#EDMwU_P1*C=Tuo! zST(7KWi#beHF*-#fyLiluzpq%mA};#&3A_v)?>n5(eErrgsQVrRQfJh*3c}pY!^Yk zFx}Dp%^v)W;%h00^3AA6yy$U5cV30d9#}%N=rS(>Y@NXLWbwDM;HLpwjD=)f;VKK% zuo_7f$O-uw+uGmf6_ zo#5$i=I-eyZJyM&x@##P z+~_U`LCjImQyc}|>?jE6ZC4Arfw>F%VO0=WInO9Zgq*7HPVx7>lIe1+XkahL-Sgf) zd-);ZWqCB9TjzxHl82&uDF-1hh|IRfPpBUhUY6p6L-OD9;+{|WJQL>IwsxPliSM?w^dwAXeKGkC6Fylj@sYM(Dwtj7~y?nahV}CtVU7| zn%a7B^{{LDK3P-09~=yM(HexXCfwV-7M96LI}LflsF=$xtMpf(*H5uICrc@4|g~@Bi+? zP!MI!i5OiwHvrkAJ3SpTfW?9zExN`J-U3ECycI_XO<(v%iU5W9rhX~dnv=w z&D6t?8$_nqB_JhWZ&jfb>rL-O9@AXBacIJFgam=_k#asNzSP>O{nW} z-V5Fc$q=NRgA}zHVfC;p`ld?JYMcy$G@Co_#Eh;Y=Zvr(l8Q(>1sOurGJAX{`bN{x zO4Oxm2y-V=LxK<$=O9Ix3TA)b)W5-0L{<>yOB{u zd*`{S91(6_Bt_9-i%fEphoX@w#{ezI+RA11uxt6cT1)Z#r>e!da#@6;ahWi`Ifm(4 z?eD&NUn_gbXEt=7OgEP!!VIvlo)nIWrg1)Vtj!*)hh5Fr$Z8nfXA&lRY@5Y2&R>qX zXODfZllbb&%5vOgjII?-okSLjN~IWqq`2pceV*xlRV8Jq9}fv<`!F-zA{5n1H3n&M z&k_4P)BVa^%c(~m=E*ROBeGhYXSyO3iHkf4dBNPt;iWGy+bF{t4{hG08$nEep_{igFvWINd% zzW%N3lQrc0O{Xm^Q<8QX@`TAM`&%*i#kwa(_g>^&F(`*)_tW48(FMcfXV@3XZdRf+ zOzFD8KEujzOgZ%l$PT7T+256{FO==%xn{cGkUOtrN#U4q8gtHbm>Ok&)qH`XW@mY- z)QrQisL4kmHEn&edf3%`eyL`eUk*n7v`W#EmE&9$XoRHrG0s7X5E*HYvp}C$Dw?|x z9b~_my<#S?%)4~ox)50)TUZJw`vs6GOue$ds~n$Onc7Z+BwgwA0guuRy3aJkDu*7D zYRNbWIl@#d`@72VIW|X(?h_8N%Atk?D{3%=$VhuUOZsfZ(D-d-R3M^i2r*02Lb4!| z&H;*MF}Z1fXGxz`E8_JJbv^C|X`GOigqbB-!qPa|E`UrS^3xvQnLe{JwZ(^V|IsQ1 zN7fVO&ZLHsiV)dqkH2sK458>UPk7WNT(ju>eY+Blu1AbRauB)ddGnd(OSkV& zujFhdahDH=VYIgv4bx=QO-bjGs)}f#XjO`;!(PjTB7116DCinU7iKR(f8X6ct_g=!hyD1^5n6y)nAw-7TV?&=>8Cn~TUuU9T(2pZNC5DucR72V+$WU8x ztsZtmpHdr&Ql3OXe|xk$lISxjXt~;V4Ycrh|UD4mBP+JN{+uXAQ}ynyS7G5~en!$T}=wvMDG$ofmu^Bn^@E z_E_2{$K1wpR9!7j) zG}xt_E5KB(s394Ylyi_GL^j>ys+EtF6j85x!c?t@a11>Y?>~s_xX1g5e}p7wDejL3 zQFRBR+cVU8A8|`qh9m7PqzO|U?(gdGhgX`kw_mD~Fss9jFZ_;g`wNSRT(`$P13s*F zME~nKM9+XZ@T)n8ujLjNF*_*wTjlhj!cI?oJ4SatgsE~;Led5GCVwfnu-Nu2Q4hPJ z4>1jq^@F?r^z7frDJLL1ZKhg1>~=m_vLn8aqkI3sOX42D7)K zzq6hXsMYKTNzfg?(b83ene|BFXmI2ckR411ZGY{&e{E-Z{AZl*$K5N_VMm0c*^y5` zb}%_;f7iestL$X^@2i9EUJgy&b8VOZ8xs_&PbtXW+r)QcUV*pyO*nlmxF%Lt#YH@!i)uHHI%0b8rW~W7e_is&wm$hZqCF{j?|JFJbUCSEW>v~}U)9c#bI-Ox* zr5{|&+lMFHJYDSvdt}YH*6CP6lJ!_lLXHp_<9TyN!H`;++QXt+;( z&HT=CM0h$YMb%-iXObs-XqqeNBFGmat2}Ssr+o4C7Qk1Yd}VZJ(6^T(!q>7CRfk<< zpsymdMqSkk+2d{v2R2*rLERRcs;xW9kxAVe;Lu=P@->hyOfL|BpNz3Z*XpR> zpVB9z92&?=y$JAi5>X-T@eDq)_{#QwQv%V$v$B|1@Cuobc>@S zAoFZEy4%swi3yIf{EMrjf#hiXR+Rr}xAU&8qlEYJ)q-L6g%(v;Rjx_6+LEH{FwPWL zV2B2?hASa)ZEq0uu#4+k#8u9yDs$}(Vh;I!a$O?WvlIJAD3=rK{Xqn zez=V8JKvFVWK!Q+C^Q=@{R&7HCdcltEUwC0j=R$;OAXB?OTPk;bpq3W#NQqgJxNy9 z&3xzZfDaknx^UMX5=KY{CHWL&sO_q)9(F@r$(nL}2OzQrvoe0P3r$G&-mx;eUl-^HLvpgCc>=2jZ+CxbX z$S0&&21(6Qp9j(Cph%}My8UpF zYjH|gh9d1Oq^ZqttA}0F>kCbL;V|XN`B8c>N|%Cue>dn}88Sw9Mt!6lnVjLahbF6n zt^i~m$JCGed!KrpEGz5oP;S^sxl^F~eaZ~W6s4YpG+}bx{$?g$D{ESdl;2dUn%py! z*04-a#s!cmM7G=G@ADp!O`YA@+1!kW^3#v1EBEj7pwLWOwre0=h`jf4^ZDn?uJ9LS zUFBmypJPxJ_Tq9x2-}n*>##0Ug#qE2%)kpFYlxiqaWfa?i?xR>*0hHOS!-42Ct+!jzUKnhvZ;(p!BzXX+x4z|2nccvU=R> zm(-99KMwaEM26er4q@j?LD>&9>l(S8j$dQ<=n8W05N3p=ATm!vju6>vk9TKUw>qNx z9CO{B$qcE1QG+5($8moZJt!&K7>D_A&>wNa>mEo&Qb>j(s@ChIjec*kZx^=`+AoM$8fXSoHumOIQzUpaYj-@xiho-3Pl}?0j9AN^RYJ1tR8kR ztCg3i8}`E>y+eu~^76JUY6mZwzo$BQdAsp%IP+Hde=SQ+Sl%1`-LFGfsAj!S ztVgO!*W&NXYA*~9uUMTHZZ`PU@`uWH$=Y#Wu~I|Q`N(G=L5Li&$AV5Nf~p+N6bZ8AY4kIYptdqu zJ?w(+R|Kt{XN+!+&plHk!m-H7M`J!YF?wLS)G#FKsg+Xo8}zfu{JZT9(Fme zR^{{<;U2N*`^`8Uo10#P8cZ#+zi(KtQq*L*Q@Uz!Z&+nG7B-C;;yFx)*x&i_eZtLZ zoJ`yNScIhWk2%4t(aS@J1PSgB&4pEEj@%;E+Ma?wLkE?JjZkp%E zbC_JRzxSI(RnB;R9FdiSzTa5p$JHpL29Zhjcz(Q~sL5uIbk*SI$7MJcHqG;6_x!QX ztKcUqH|1=Rsu{#8c+WZ|o;VwJ&lb-wnD?2Z4qo0VMb+fxNseA_aP$InEUUddmAQL4 zQF$595vf{vdO0Gj9FZdEuwzVEF($x`b6@w|@cg1VgYo5_a=bE<&j;!D@V&7d5l)Uu zQFK`L*ItrCQKd|n?ILFpej0tYz+!j+6Y<`vL%l+h7Wh9&M5x$?? zP>u*EcSuomSoW7(l0s3TG|pyc5!qgk--70HDd$Gx5HCdixO-(9-h$+CBr@tSa|q`*~6|{V{hw4xyEMf?GJ`P((Q1!pY>Cq>c(|f03a+`5pV%ys_i489(GeN&rQV#kC*=0u6-oTkR(c$ zbC4oL=GWt=*xj-sMpuvXQ>+TbMAKjeQ622@j*0pwEC3j)hJ!47own6dyBZK)$?>y-;#< zhNs1>plFXx*3a|G5#i@PDWVR`KE${Lg=IL>PeY#Cz7^_W_jFY9w3@_&tvF68*Qq0) zWOYaeBk2qz2vc|L?+WUjrJ((tIA0W_D#v*RwGKrwQ;$JfFg+^#{hI2ILQ9rVyBH)9 z>0autUsI{!$ZFJaNKTuHRu8+J+l8EmgMQcx(?jxtoHNnZuyjf0c}Nr@6YcSyj7LmS zD@hV3l;7lC_hht%1$nB@LYgqSX@51nKxoQqXtIwA^49fJqe%@**QB4dYdX1z$WeP- zJ@kBwrlmN_Bc`g!xq8SR76?jQ0GYznMlTqqZf!7SJ0Mf~mpqWEw=wWb9>r8<6!?-y znR`#_d;2_LNhGV;yI+oQQe}ul@7wwZmXDle%-|uVqRSSz#<;Z;?#V?&hT7w`*4u=d zyp(2pfBgG+h3;J2eXUgwNtdObgYG$qe6`2<#ph~@vhSl9+ajyTJ-?`iWHnTtfdsV~ zYW1)Sx>XZ&CW)_3nV>u*tDy1>BnVM8?Q!PlIhvr;qsy0hQrwBCD#B%s^sua!l=F}% zL>Aj)QMXt{W#3s%p{P8p22tgCNK~8MRu8+VXIn)T&$_7-1wZeU^N=V+cKf(FZ@SMx z)Xk2ffOS+u)Lo9E<|c?b%G^ag%PMLq;X%r`(;yAIbY)d5vqIK}6j_G_43MRS*C0&0 z4w8n*e9xQG796DA;3y5~)M7|G>L~4=3DS-*cWKXTkams_$SS+D91+USN>O##>sh0+ zEVPNlii-eW3y56!yqOF4#n;UZzOpX9RDIo1jtF0?QdAxGTGr@GX=v7T4WtWE%e`RE zyp|nw-R7tZ$Ojm@W*l|hJ3&`gpX#dX84bF!)rTk;@ao$ys?uIjjtFUQk|OM|A#0ST zhdGg*`42z_5xMpg<{j>S2ZOgb8U(7C41;$&8ay$lC`2!C5r zbe(*!MF&pq@EXJ+^76;cyPhv^2RBX-#~9sxRF9S;LfZpUWF7WKHc^|Kv<78}+`Y#$ zw;P(25zfB8i!-;?#tf`<4Wz5h>#K)d*VBcrvq9AB^DRF9@$#rk_={j%&P)$WS7n}u zL?QC}^JdM1FZZjb>7q7QBvW+1&^uC&2vw)0s5)nJh{PNyns}gd8EV`X1k*o+=!zhEZ=L?&bBi zYf+D1o1QzA8JdpDb_FC0Q@`%-9qN7TvdD_U-Jz6_nlQnRPGUND`@8GaQ-q`PYnnB( zhHfrLgdzK`S8_Nyp60J-PM$<$;XST4es7`XR8Rael9hw2HkL!u{ix?4MQv9V^{^{? za;@l*bL-2z+h-%Pg50~RNa1LB#4zNhtx{JHyPNl_-8{^bVHignqXA=d?>?v+V<{w! zk8%bQgsDtpy!k$LQwtV$w$sGQ;_ZPrJjNewcWkd!*1w_wV?}J zYmb9mHfj!}grp(T&OwSW9aj8(|9XO=D7eZPT|ub#uQD8qouHvw_+-1&qk7oYyr-;& z(G}y|6TS+?HjYD$U9J6}Z<-A8NXZvuN z^1*tT@+9b!)q~10t08HG^pk+26PO&czjq)e9Hl{$?gWH;fT8X{bvQa7F%HQ=L?*;gtT*zB1C@KV@2<*6>W}o!(KI!oDM}wNSY$; z9Ha=5VfJ|5{9i)R+D?${@szG0)V#S4N7p09Avu^mBh5E=U-ELO2~1~he`h=Is10qzS&xo5 z+BrO!mX%N?Bn^>v4pP+a7O5U~MgMLnqP~BrszX?TyG`_+k z!WlzUO<@&|j;9`m++g;I^fzbtufk0*;KPGpT5^UW99@od0lHBAe{- z{pfEDK`T)jriW8^KPtllB-LjjO>Nf<^{{LDYgtqNpS|%|G8oCHAVZk!wZCief1w%L z;+M(#L9NA$aIAWY6ObK5-rD1L{y*336e}Ne??1SAei4!tQ1i;iJfb4n;}zFG(*!ZL zOjZwS#T9tRpY(2z>9XOknm?7)^ztvS0&($FiclMlU2Q2vzf3g=6Aru0%YB$VVSHpIN@_D)vXhO`i{V zl%5N(@m^l}5EUJi=+>IOupAMN)}_cg>=Kh50paPcz{?*5$)UAXyr8IGM&gBwh*Xn*^` z{9f&5Iqr@MI8@!B`oYxUXmF%)NKV`3Lp|(repi;0t#jx1@fEUqP&05jBomNy3NqxL z;r6-b`0vPu*cGyNP(8=9P)suoRxp*<{@!o?pRmF&2cv#ERrebyB;Ag33NSS1p4ImG ze)HSH(9ZJI+;4V_a{XcmvVzEDdz>Bmt=h^`dM$nY)aoB8N1U=lme4dx)+-=c?H+~d zVVCurLROIhVLh^%Q19whI69$v7;=NiS9|Q{HzYTM!Bn{!*k0AeFyzKP8$G{h&YXRj z_58YUvp9IF#SFJtvvfx#Z6U?MK_;}sytIdvH+6KL5eW7(*CYU{EDJzdHmhCL1hT#kaR%GDaa5a%j|K@{Vxea%iFv=4s(gD zA5_hK8IDe;8U@tMBC4f5uJ`%HTFvR8A4FZ=%ilzb&VyUL8$Zeu#^^rBQ1w0yA!@oB zuY|;5veRZSJzuiZztAL(aCZ9kazsd5mZIvgi>z6i1F;5Mi2St2eHwqhwsk5^lW=#G z^1P1$Ra2-wjcQ1mCjBJj2$8QoWqa|rla+6Sgd4Iwe*5=L|D3Cim1c3naxri z7UW5~05XN?1>$cXho3b~k+p>C;~>I;3^mwk_dZk)yPcnr?UYSqsMGd)#04$8|+Z2@g`fcAoGP&b7a+H7q+O=``dCk^Mel zzRCHr-tuF1PuU7+6b!0QCg|R!s&zVH>tQLn4htD%OAoOLnt3gx4v`n1H|yejnXCV3 zvpTZc?kq=ywzE=H9rk)QNt+Y1248KyTs`c*egyVK)|P9&90+TYs|Hhue7VOnueSoG zdW>%W{5kO~_huttvM{vN#f_AVY{Oy2tmV?=KAX_%=_s4}vb= zO!$x|kMgOwCt1RhEm=?7J)Ky@bm#W>D~0cqJmqbx3GYDa`jvtlj=`s~H}{D}MAqD6 zHQy_#Sr4+xm8nsahhwNIMg%cG~A& zT;E=KS{v?UQBpPJ+KWpHMU_(zLS7KrXOHhc-&T1!Go6`3BP>;s3qE=**-X&;lag?D5Fxat^!9$n;q85)%{r@x-Oe{lc8a%mx^|Fv z9LwALnMrT&3z+>K{k`LSQ>A8kG&m@VWXP()+;OCER5;2B$c}ri+2>szzEQSAcppdC zT^{OCOfd~s5V>WKvxMJJSvftrEIsten!#iV)sR#?`Z-8Zn`>4NyP~hJ6rJkzrfrQ> z4M|m`pMw-3a?KvkdA`n6L{<=H&Lf2b@oBJw=_6v!d3^aU<7*2$8(iD0XFU#j*@qca z9oryW8PzKU)o=s>-z^q$MPY zlkFtr$UXb)^PAaMSB|ot_tWrZR)wOfDTe?nCowh7{_aBaRfUzS4+s6Qm+eBwcF1~h z-GxR8M>eAjLv9fHW{=;+zOrxAqkE6KtsD`m?v*0y zuyf3!%4pbcKMQHX^!G5|%zV-GWrn7@9S>Pe&o4)WrdLZ5b=X79qRG;V2s#gmLgcbN z{@(dZ4N=Q+m+-rq^Y_krNC2eb6l4gI$@aL@`j;4n=-!Q7JFTnX0C*bYV7hns`#k$% zNzN9}lDAX$Jk!E5BpK%+QHb2N$M>QyGDOjpguEA(;Q)dfUcNx`va}!edxR@p5gBU{j-jR+hTOPktmhZaIgc;*na`Kp zFh=+3bVE5J%v7uQ#ow3xB@zykOM?_dR@&pQ!9K5)QhbcL79EVT?|gYMApAwV^VeXu zuoObJ(~u`bF52TK*5{U{L#tk0?3oEwd! zq-*A;azvPUkrYLTEiz%I2t@@`jX_%6Gs-^CZ$7)!vYEsOjM3GCnBU}~C|1f5NJ^VG zRu8+B&#I*4OU-#X3|TFRT#XctYDON1TSW`}|h@DUuz==-y!vZ`FAy2ABpZ zZ9fe4uuJ*mQc9VuBP+%ItE;P)WZi^Z-El-cvByuOPb#g*t1MK#Af8Cznv&CM(($%( zSUv1^K2f%_n#6;A2T!^)8pIp68j>kUIt3ZR^uX}f&?i)e&da}<(_!d5d>1DFQ0T#iiaI4Fgq(2+(VHEpM5^{}h?xKd5gIArQ-Ys|0| zMz+(Cr#4rt9(GS3t9YXO)`iFwm!VkTz*^=JwZk5FE%=y9OVMyf(|>zYB^aL3YTI4GJ>cf_PEC8qbehDxBBpd ztQAC!jTDYbMjnUcVDiZReh>ALsvNRv5Z^;pq1ebYc){%3=kJ~7BZQZ&pj@Y-Y6f?w zslw6Oh;c{`refINJI#j+Ie8@tRW-Ofjag_T1|cu*S!179I6qACvPL*tj9B3;LNT;7 z)Pc?;vcn#~X@97&BA26(HG_E5)PVCNVjH|+7s)CUPWTE28DR;J9bbV;sR;$xT{`TTt^ z|3KksDIN?+uQTA@%d2p7Kw=z{gQz+7czxjmgdDPBFzX9?7s$rmkH^|9v3l5zynkt= z`kkZd1TizV-c}~xQ!u?G{LS4wR(Z*LNnIxE1(Cb4bjzC1DeG997gi6umBZRfkZf_f zRxtOLG89cqH3)e@R1+UF?=8N(IbD;ytVG?o7e;$$gQ(Z%bl;p_P>u*Y_e&9V*fvw_ z=wTU-%nKk>h)xq8--E7JrpA9lKc>3}8s;8UhN9Z32O%$Q|6%p8dwI0-vONAHPWR*P zm8p2!mcmil$m5V4M9$db?-)jQ3tM{y&K0&3>kN@De}t4VV; zK@^|e+1cFg2GM2`Un5+9?!3Nfge3W~oP!i$a>V|21|2Gjf=4;w9blY0gUaDp@D#(4 z8$@-n$2$clvYRcQj*@7J^7^>*PQhkKrXb}cf+cOmD!$E{(RnDq0I zsI~)!de}u>Rz&sVA>r?gvCp$29E+fG9Fl|SrEJcieR-a7RSplL(E;W9pIgcip=VBt zro&d4uBQme=BGLX2|{F|Jzk0L$%0Oe(*3jJA1C3uXY5M66q1QZISDyxGt=r}chs#M zt?q1II2ivq{KD2c;Wbsv%vuRaRivGQ47GdjsfXRru4G8m=uM3ws3dXKsUmTH%V$98fA&-sZo=MW2h-dAvJCFvwGOoT$0oj zcW=6CFzXj}I0l;u&!`zpZ)Jb)Ht#37$;)C0yFuPe zO9}T@#;mkU;TUkl3CIp6!|d-J=M9pb^>8>2^9orz$U9CRjsd3}h14Lj%O0zFy`-in z&zKrDmhz0%N!1xM?cRLqVOR4yNzECaZpYm#Je{5_jtI%%BcFl{VY)B-yDITo)zB6n z9>md*t|82-gcg!bk#rJr)b7@&9(G5MsE(H6DB|5Tj3dG|Kh8Z-ZDH9oDW@S%nBDsP z?do$;^+eW?b5|b`icJpa<@h2Zuk3Ms#>0}A)r9l>WtP$Hii)YvkV7)?NM|5Hm>jde z?_d`sLCd_)rzlsLhhxYoMC%W5|578kQ+ZI}Le4R5N?rtL0qb zX)ykI23@`xBt!mCu@5O-Pwu^1%&=rmwzGhy1x(Lpe>JU}nl`qV`Q_=;RD=a-s?I{1 z5SeL@pLGvfG%e-7r*t*BKkF=Eft;2m+@0F0X!WprdLZ+3ZZwYYLR9R3K{tQoy3!$s zBlxJJkQ&TBg63PkFDo5uwVHL(d#2n}jtDU?lA`FaMJ9<^w|H4^*3x!;Ru8+Dv$>YI zH|q24!@+LcCwz}_%?T;tNNChy$W6PWpnBNdoDpvFZ&|3Caa~W9Lea%EeyekQ!9Dlv zvzJxjC98y)5-)iux|ebg@`A`Ydp!4D5njsvPjsJ4&U0TW939Psm5K$-o`L?(W|ng` zd=Mvx+iB7p9S~OIJe!fjk=UrikejxOSv~A-mV}$-(SYvimh;m|grbWn2LUf9-Sfut zi{{rjzIZuZdbu#EaeC!rR|8J9(F0GN-4#SdOhw= z#}i3}qmYq@AvcJ6<%M~}&9fTZ*bc}|=Ib5OPXKcBwk&c7H<`nyI^1F2Zu}e0yjA{R z_bXnCv3Iu+;i38(;)(Uh%cOtzPToV;0%ANC4U8cJNZ|vM<@NUo^qR`aetdOGoD{5Z*aab9bzLs7V#o211(r#ru3 zYB}nl<(*PYOJ%o<&~ut%HN4Uy&Mrzjz|%7*fCa1QNIzd2OuNv z8C;*|wfB}r@0+YY>cb>bT+9B%(G0&|+v6*S`;-1Czd7gW+^m00@P#jLhJhu!*;Zl!5S}?sP z{MB+I*OI?8tWU*TQ5}k;MH+*&U^-3s+Y#xw&~hq`2Vr5RPgad0H+`*+h?5%B(PtQ7(8-^xsQ(pu5HE{AR8H zw#*pdLRvCXNA0UdClLAFlctoL{tu=6i}dqtlJYkKJRo**U5z)X^IOi0Q9Hyt6> znzIn{Lh0YTlXnf(h3Gb56>Sz*J?u}QxlG6U@O;EK;vRqe&sRh!LXJEJJ#E^`T=lSP znJu&|#iJ-KyeyFw<64<3ha;PjM zUXQ=1enp`s=xv`lx4u0(;K|bX&+5mNcc^#$qS_jk%*c8g@N^v0@4??L`u9|xR<5Ny ziGu!0l!htY{I6>leM?BHB;zFHsIBT%54)q6SB}bG%pu`?jcZk}5{{}z8iw4o9Uaue z?&faI4dpza`z%O=V`bBz29Y85_-^yEO3kV2CrVch=5BM!&gRr)H*Mvwdf45(G3fm`Z#U^Un_UjR>H^l zv{=bP(X13hkQGGDug8^EFRrcdAnDSz;#z4Xg`#Px1|ctqJh8{s5HG5{Z1G2VGUWNg zozY#Ba;=8YLsIdmXCOhC4#8&5*cU-B)C85km}CXrT8;=ob=djH8Z!i0Z$SDvK+!xR zQ|xi3=BTD<8u|~(;aKf7s6pg~J^m))PN8NHKgy@#n*=Q!9gcJYvV+JCdpz^GL$$LS zCgUF};kyoQ<|9I~0jkbGf-rev^IglAyU*>api|?YA6Y%mDo2E#d!$G@>=e`WWZ~HC z6yuN_Oc!8(tNet4SQC(;-KMqso!TAvuVB>O5YXdVwtGbkM!RE|Znxyf!6= zW5OwiAvf(_bn0Pu^ZeRPd{F!*PKlc;9LqH?JR z0WZfe-6Z_IyWCoNA^zrsxx3gVF%xDm$1uGl{Oxe`oJz||)MJdU7S|3(RVb>JVg!=X z_K{EzyOdjMDT9ObkggQWeWeIRvr>*hTH21l>S5RN>`KdW);F5&4m+6p%CgetRg6GV zFm=KH&TpSpOW}Q<(v^al-tq)cY zyO*15FY&=4qdRZG)CcFGXj+OP$O@)D*xxzsGiob+9wcoY>4AO$hfnHn-!Q3a!90n|P*g7UAmjy63+(Y~(T#}qZ()$oncV3#MuWqvsr_35qyICqIKLs9^lCm~0eYGCte<%^@I=Z=D5y3*$Z z9;HkBVZX=d&T*bojtEEfk0&2F!%9bbNRlG+6l4fd73}fXEKkb}J;?dN>3$Ghsed)e z8gl)b#SBRxvYmqzwYg#Suq%4sOwro#k+VDJ))}L_zpZO-xC%v>5hIWkL~eM&oH6^d zN6%9WDO>z9-FwW_$`PUD`BDU(yvOjRIt$P zZY*q`uy+`q!&LkF`yT!j%?{=7nq1$*<#4Q`8tycRT3?U9rhM;0&AIRz@0BkVWYxHS zO{s+=!_iJab};>h{r$e+$)%kjjCS^u@sE$WfqYqo}KY-Cj6wr$Xbubdr5GxA9l|q@rc??`1W!{%!FSh z#n54!Oq~fE;YgEV%Q^decox$?*x&DMpJ)i8`*d>s-c}6gScdN>n9dLWacC*x{qq)=>_8lF6uDq#P18GMhz$#S?C zro}H_n2*1^g$NJ0T?Um_thj3j@4Ady#|xno%3$~^53PF{ebHGQB^Y~?lZ5D{{1`bG}G=gbtv*J zMjEu=U1kv792U%#BVRHs?-X9h-c_DnjtE0XqzF3f7_09p`to%1%Jd8-f9vlP=)Vdh zd68nV2ktaHfkZem7CRQb;i5gy$>R ze6AXfG-uII0P~hMpQ|4ByURONJ7n)J?)lt06dR_7dkmtE_qaKSxzEAN&5mAx|N9zV z?sD`pH^EC*1LErC-*Ycfn1(?=e2i}}`A%O39kraC**k9ULqcA7QXAnU7o!U1ILZmTo$*^&`-Y|*c02#1+9B)4`3+5k zVl&g=1=Bym-yOmJvGS5-U)Q3`@iu=8V*yz=t~-M1A*p!OGms!m#@XLH&OcOw&hbH< z9FmoTx#N_fsA%dz$O|U#?C+fT?<+6G>*{z;9FjGInG;vxsA$9}qz18j+`O6LS#VHu zgQFT?h1*bb)KSen6Vx1G?rQ$7Qj_InSE6p*3!}ZWLDcK>WXR~gm)~BF2tmtIR2_Da z2|?D-R8GJpkgc}&uzJ{S{cUdRd_JRG-dQGV$@vK;LXq^ygOC?Y?XkaJ{-*G9c4udE zEBhY$@$aP$MfM^MLSEYaUzl{j*w2@r0+U#eLqpYMa8WPM*QEHOcB>_wuK;m*Uwz6<*BA%j)F0 z3!*03;~f+JB=d4M817#<82=%BB}$XSV}$FnTz5<`LK1o`ryxU!dSj0b{jtT+-1Hfm zgAL6!7{YWO_P6rpk1U2L*N3`R-smBLgc<~4GQ|G&k$qbwXghq2GrI3pu6<i3V)_2SwMR1HT%BaH)cPGT~|{&qS416>Z`46$pMb0r)* zoCY^-j#xeHZhl{OL-=mvn)MT*m|&XjGMF5(zjK-2leJ7iPy9L*6H9{?L9`5T9! zMakgkA)$n32%_v+7w)swU)O>j*-6tIlM~KYG0L-56Aq-K4P$O76~*DY`76T>=PTE{ z;l{jbX~USCt{(+F+;0BTaKrg(tf4x&92QVJpVBnoA4C1!jhqE^iDEx0gSyy=-Mt z3cl5Ul)P~n3e=*8Fe{Y2akzc8{-n0Dp2;Ye8^b=|E0S+tEh8ML225afx+-IMxb6Hg zw8Pd7<+`LoahaLnh0;?Z-0RXGHD1z_+k)@gZ_0J448_n=4PjO&S>SMMv;MHQvNjl~ z*L!TeP-?T#3al$NdO)8`~xi0A7%6u_k&#Ju?DeM7!~`R&R}(E+pEMQ1VYU$k&^ zHDDNX({&$)huh6>6>cuc{My0Rg>s88#%_GyO6uXXY~U!ShEOdWu$tdgYN{Phwg(HM zrU?hA(MB;flpJul&q}|c)a=XaVj;)>AJ7-1QLtXWJGAq%{0pLar8 z!SbuMrYMU>GMAb9Ub#woo*HQ-UC^Rg60aAnBqJmU$(qC*QL@6}=K6j`Ia-ulUmFTw zGcVV-+GU2};nwojM$67{oG*x$G899L8pE^@cBl*Z+54AkE$KjBjq+p8cRGY;?g5VOl6z z;c(wU{X(rJ8t0o?mS&94F~0AhKsXSMHjKF;^o)o#VTobw7N z-<5GjIDibC!0ZsZLj>Ff>!+0+RoSL;dOK|W_;$fELjr(|8AQ+uB_AAa?dMNHL2Tvt z)_!WCxX{e-LdXcO+E=Sk_JaROtO zew?8JOvooNS%j={z+FLqqL!8P)4?z~T8oF#SoGP7^6d(0g#;-XQk?&6+f;F zZRCSTHe)%GNxmV+d<_w5D$J08B6|{ZMCni*?tS%-X^z(NJS)Fc#^)l!eKiQlLZr=L zf(Uu$fX_rf+6vlDr_Z{>G+CfC5eUgdWK3d?y1X+y+>U;vb)@R$HrN^>;4)@CSgSDNsug>XXwst62t|lBPM;k`mEE9Sc2Yl!J1Ff6&baax* z@%TzQ;G3DI+&LQ|nSzW-%n>0|9q=>!_bW%>OBExwjtI~2I3iC$gp72+>;1m37IYkC zb)I%N8ch}P-G!5|-p>jPO0s7$O@!R^id_j5il*;%XsX(a@YVD}HPUK&trpRe=n1E$ zIxG}a`vJ@pAy2((n+oM^?Dr^B7bn-R%WN%<(|(zH>-CRiah~Gp>H#&-tLl6el-&bQWfdU+cu>~y`A z;o-LPEw!C}dHoreU%*ms?mlqH{ITP@Nm2NM%@kLU8Q|uk;VR$!PR8Fau5CWw+H4!4us*BgR_n6TAzuNs-xNlp*PDQAWn zLe=t$ogogT(&Fn{HQ88Z+sVm9y&~rOj-l?j(&~AQ7SWP;MCf|VuuMnxJSM8kB*Vik z>T98>g~{k>;kXFR&gh)(I&8qhZRcxhJE|u!S2vU=bF1Yt7{t5~cH_HX-!+HQG3={b zFKn&ctwvfar?d!`#EQ_ZSWadbp;RV^ySneI8Y610ZIwi2>&16a`79E52Rb+fX2uId7#-cNt@NxV3y)t))y}RAmK1@Kr;}80#THJ8%XQ)Mbp} z;TH6zji3#6Pn@#VL&+G|;TUo@=G_TX`doy2-uaSR&1Nzg$*g?F5MnXTJ9d7af4)Q&dtfe?JJWR!JQ zMJNzWHG)Z@bhZe$-s1BcDQVyMA!MtDQg300Wf*eIW1=V-=5WtFpQniug0CXdxhL)0 zZe~cK?B^G5zUOmmDeKceB2JHlIAE)VlJBX*fnwTGOikBS86IvmpHr(@o8;+e`o}O< zLwWPrgag@V!K78R@^WNK_)a{4qS-XO_<_Wel@%UO!5d+xD_Ovv}u^t&lWD zjydGKa)FRP4tRIA&!`k716Q*}#w$EesgYLGMJ=j!cQ!0E-4yl-OctRkIpCVFPp@Rf zvgi>a_@0-%Yrg7GbUMutW`&YD4%f=3)mHXSWFi*BN*M~YqJ}Ull)e?=)(3uSZRJXo z_mBBn@vaYSLV;N7F-!|3FC4CxPpP%6$LW}Hbp=IB6$;c+k6~K6{>AWcYx(3t%jT_< z-sEsR8S%~1_^!OuLTR~xLCi~6eGCt`mrts_buZ->0J{6d5$5H05k+24R`A)acr>_^Fw6oRi9-&zPg9Meoa zimB-`yYO(Ux!tPS%NW<16Rt;9C?=P^8E*m3Q!=~ZK2hIlt+4KaM0ldELov0??0vLy zzUxX154V>mTQ6&Q%6IQgnwK&Z(~BC!yimFlhkFNeQ+c@(-8x8bNY-mG33o6}H~@_{ zim9R00EfGm)I_P-9`6q0nD@F%-@T+@IKT}U$K+7zfWtlCSNbFsX90F&Ui*u@GmNG8Di?jbKs;y@vz7`%RRT;=;arSTxDx zdxjz0{p#TWG;jj5L+LmiZl-1g?5wBBnD3c}kg3taanMoYn4GTi7andoaVaOuuEdOTc9BMD~YKT&xM>d!6!Kr|k$y`-j8kx7A5(~{l<@y9BtIHw7!!2uQ%VMj^`z{)WgCUw> zr>h`_huh9^X(yJW@_F`ztsC!(tvVDH12*!)@iLuu^=J3${~`9a4+OHHRoV z+w~=ehg;EgQ_+U($AYgS-@e3FNNz-G3Nu9LOC0bWkE{)q_W`%d@06<_-#Z>79H<9O zV0OCw?%?6JGXQoLr@Ou#l7rCv?)qm5+2??-V*N&u-fy07?GEKChIH3=Oksuy70Lmx z5kE8xRX0L>4f(DSH$!p~nsY7da?|i|3yNw%3)Vx_5fVh?+e7p$AvYcHJ<*#jN7cEA zt0T%i5ex}oH0NwY>1Z6Tq9;m4X}>4){WPt+aV~%&D*a(Z?!9mljXa zr5TE>IZP2DR~>M5(3_N^tuz}&c~yzXRgiCW5DW+C0pp0A)h<5`54W6;QF4kevnrw4 zO!^{YtH=Av-V6xrcP%Jewq!6;x0l(jPOi5W!Pi_}$UUr7#X{bkR z#dyEpFhT-yj2TQ&*HZ%?Zb6S4f`s6E#qwR@u7~54GeZrbb8^5nt=CF5!+zcyJ|!7n zp?qsvn@}_^?GR>#(nBNMC-sBc%D%iVGnw=mR|0uIse^DJ8hsp-L&-3Qdu{5~avs@9 z(;E}kE8V@XOeARB!glhf^-2M@QLD^Lzw zHIy@r3dKcchLINX&GuP@ceTu#4I zZOeAHa=ceU*db|vT$7k1LOyuKb`(mj#Oo?YnLL`_Hp;AcAG0B^N0XRw1@a5jNNede zT0~3Y5m8%mg{5O-HOT>= zl`dC?${)zy+T)j_WDv`2I~gv-S;-Zaj>$cbiRwCNz{4%-QYC7kdWIR{=!E=whAmUN zHiui+wN=?UoE#Npa@D5aLhwBkdDnFrA?bk38B9>uJp&$YL7PC(ULsX-7gs_4_e4fW z4npk|W{8lH4tSmD1~AmtmvS}ay-w5$$$@Boh3Rs)-yb~Oiq)!g*w8u6(Apq9$rsB|84R^v7=rU|y1pxh^l(}_a1>E64fvO8*Y~={=NH^=E)1zGt6jsgc&tOSLGL#Dl`{ z<6<*I3uULlaPM_aw_2is>VwTy4CP)&3&&)mO<;Dq{vGge+j+HaXM2yW8{hsNS}3-e zauD-E>E97<<=CrqFI&Tyb2i7fatwrHt5L(48%o#aaL+Rz4%`gbnxUR&wgxUSGwPgA zQ#vc5Q#>YLty-R=qvvTYcfXpOPyqjgoT~(?sd=9BwA(<+`Tr z1<2$yq1bM=XK1194`^p{LOJ)mtkqKFjc zQ0E-*ev=>CdaCke+IP#DO>HN6Z*o|^q2TMux3bU- z$%LfOV1fvB%>ln9eTgP$?+!R4dA}vKL$VOg6M9WFSu$-W@Swz!?F2fBEx299Arj4|(XSf$d z6Aa7LWX@umDAm&8R)oB;)RdmwzM7>cWq*{2ts?J=5Ir1?4;;qabo&{?!|mn;x*Ngw z%;USCVH1k&WrmfmUk5zgR-Rv5*-i8EDMj7=a5dxoWM+i~@tAX%BFZj@;a;ikYZa;f z%6ER(I}nbEXHFOC2R-9&(qxqzGofEmC9JPtPNpSy1voya9eq9W2Nqcvltx` z?T`#S#vG=Ikckd>1?q=biuelhUV#e2LG;X!jg@^bhxz~AKYls-*@p<<6X;Pgk;$9dE0fq>j(`Gx1eXYg1~zTu7W7{JLo$J#~h}J zvR`4i>oz{9Q54If!EN=e@_k?Gy>7z{$v_0BFhgDM4S2W>-D?)%fo2G64YZ&VvZ=a%;7qE|H@HvQ)YSZ(v_X{>7Nv*M+@M{3Q2e5m_!_% zqjY!<_ua)^rK4CznO?!X$<~qgy9*;E4Usj23F@-W@Nf%yzeZ3|`m&u|PkZt$j0JgT zoz0L8LU0N*M94Y^+*dPR_A(JM_XD{OX3XzIC6w$k#c?p(?zLv4!4Hv8M?0Wrh%_0?;0`? zj;*L3$K(+Da|FDC`Motcdz1WRlCMW`d>Hj_@V&NquV8kEWl^#}fSIE7jSly0^mNUX zYTeG(67g(gx2QM9F*$@<=z!m{K24Leoq!)owt~FhvO2@EBw6#AD9Wyc;XbpymnP~` zoE}Co-|HIjnXL}TBGgV`b_m()fbWgoQ?s*~^wYsGIa-T{(U|dm-^6<(Gc3!J{Q<<( zSwbfJtbK)h*u&Jlo~Dqurk1Ifd74_DW2$&R>1%39GgZ8*tiRvOQ8I{SHZJZzxZ0}U z!?w0wr$;8wmFfCn=X?VD`ysOc&6D3EJ=typFaNhUZ``x|~l3@qTV1fua?0}!~|4$?6^1;E? zGJ(QYkM}b^49CEuPhfVsTs1u0cHY_8DH<#%(TH(fwRf%>gk#Xr#xXgRz8&H2TKB&z zIZ@Wjvt%$i5u(pl&b?}+m4obBr-h@t(MK^gl%5^o?v44sG&RNd$yJQ^-k5DD7MR&y z2s!A0&ockB_OhMqPwyDzqMT*wa3Gp?6j8HEsh1A-j`(kDHJeF)Z<23K625Bu?}$M- z5Du8Y>`;0ukSsv@6lRD}Cmpb%|E3vQkJGU%e=--wP#cnENT0$C5i-gFuR453X(%d}-t}a@ zA+JZ1IOl7~d)1*GlBUQti8&(Vl~?V%=up;d{8y)=tC_rB)YtR9D>|h{T2B|XsFuVv zfp}7(%|O+B0+U6^ItTpD>%W+?4kt%K@D=6#&dUhNEvcHp1aagh<$$ z^4^En5!OslGc-|Zro+82`Zt=U?eXU5B)`p85%IpL4#xu2PGEK@)zaa#6@Yid-}Z?a4@99{Q)6owdQBzTsi(hgdz-gk%BIW-vjN4jtjHLi{IC5L-Fks}S2z zTxe!^q4bvy_x|{8m6s$wG&NupQ`2?ifQMVnKdRMir2SrWQy!#z)p*x!fN-E2eH@e1b>x7DTh2c; z4YXcdYlWq_;w{{D3)35ha5hZm-P0UnnZ} zsa;Q#@nj?i;u>2)zP&O*I4vGy7;$sPKZhLhuDpM*bTb*ogQCigZ*{ZpuDnesnwNG6 zv(oKh2oJZFziF)O%Q(u1Rb^(6tr_1pomNPO9XN#<^3NTIoca6f#?T|XMHfJ>c6>8` zS}2B^dJywM*|#vLBnYRWW3r)v_eFBr! z^?iniTh?D1vWhk+LZoa(`M$+6Lvl(|GngPsC3Cof{=yV=d2N5u1Qj8<1ywVcAWE(| z+^6~ z2h>Pw$i1609-0Np`58oYvuUVgvzvYyE(m%V)YP|7!-Ko{%_fhkPt;PpTtjhd1ZLG4gIcZNbt=G(w@XsIBq*L+)yf*!>xV)9nDRe?;`Vp4-2z$%z=N@!fN~4aE`@&C=qZDGvGB>bEp4#rMfo3+>rz z-N|K^mopC%I$Z>OUHZ+|%i3UYdHP-QJ;TthOLaIVn|2(NL&+6~dtLesAcwCS+I0yo zG}p&4EnRgoJltA-z0{JX@j-e}M9Ec)_jRcaMdP9mVqOT<$t!lwFO;szzgBozo8;+e z`bYF+zBNpuxX6PsuEBYM8fopkMvG`kJR&MP?yy=$*gPhRkVOu-_xrEvqITtz2U(Pi zhedJIGFwr;z2A|rY*N+-FjIt#a=>S)UqMYR&RGhEHHXv;QCkd4e%Uazm-J=%Bf7j$XC*BxCnhkDiRyL}goj(yFJYn>?{VV0 z`uDCv6tdbb*k=4!Az(7Yt3CC*xt9 z@|EOUALIzh38|gL91*&31iT{t=M6{e=_JWzrp`3Ayor zGX_6a3d-}WC$nJ`51*0;xAJBM(gI`*kkB+y=qE5)glu`h8G|1!WfdL5u148dX4}ch zB(Dml*{br+7`VgIP+=dyOi}XW;qKV+BaNxON#1^~Y(4qz*kOlcP%`E)MO}Xpc(@h) zaH(i8=nW6!qMtKYJ-%xVv`{oQ`XJ`TKliJ{2nWc~hcP#l?$hDA`L5bc z+FvL)O*qhvHjKF;R8a@)<~x;}_2XeY*eU8>7Q#&%4sfFnV{Qm};(&K_{tn%Z;QKV? zyQ6axitS~Fm9Ez`Jls~kU0Err4~B=6T$Xo=3-L?^LjrcpDa;V1+Bw`+W8YR9TA%*@ zI6c~z<20^z%I0dwd)1g7lBUQti8<=(oZ;bi^sNp@z1!nlj`&`~yz88uVWFIwc}x_g z&N*CB-{KH;b#fRF`wJ&Zg@uZ0<}p!Sr87L-qQ2Q7N-%yd^L|HagoHZ61)c3O(C}~z z`X(r7l-}g4$2$WJ!*StJ6PTSY0}T(iop03blzVpZ?YQTi5z@o4<;>if?9AD2|3i4V z-F$=YrtE^w*Ui0Zq;=!o|4QG>P-eQ8I{& zI(NQz&wi_z-C@;=uvtt~w>u&{+?u}5)Ko0!?ep!h@0TTVhUA9SOk$4wGu9!$-T2zd z(e`*}`hNxAGm+oh4J{O1O*4d9>H2WM!)@hjDl3;3^9p8%r4w?^Vwwo~>42|bUu|ky zm@AkSk{i<8D;TBHIox$zUnOov@kCyojE~vc@mj~#hM~OZ1DFxQ{)hor!+)hRlAiFr zQh8OwH(>xG>5QDtDkYB`?wg3O5R>GjSlO@2G^^EGeEau!y@_yyq}(`XFhSkUi12U= z`f@SOqbye?;(X6DUOOX#P?Q;C4Aau>j0g|6mM^QcY^423`F(QL;?=DHhN5%P1~D&` z?iS&mUA|O|WxgAYwo<%uzfBm8lEIv}11tWy-_`T0 z!3z1jN=SObqVoKS`X3{7A+?!SNPXv9{e8umMR(zTB~YoL?}gb%!d2)`=sbHe-%r zYWy>`A!qYHeX8bUlHd6?m2DUely(3!(sdYyhug@fDI<4$O=S}XATq0_a)r>{A>e)? zpE?yX%%|U-DtPa$J>IMs;VQ{Cin$GPjf=8?Sm^_k%~=xolsWA5sO;o)|33%KEH#_NqK2*m+r zh89BB`m}wo6UtfU$x6%G<5!Cn^1Q`7TaC10UZq8{B-TVNMh{0<1IH0LX9(HpfUi$C zft-!B&!V2Vo~!?4>h(zr#{s7r#@tZ)5Qkf%F)7{bPrt(}a+GGbId?$!s?jjQ(b#}d zObw-jgq>p!<*p`g)NJnw!S@<3T=N!!2dpNa1}q z<9+|zgko5ka~DI&4TpPP$yzM~&Q~JRd1Y&0S((w%{7lz77#?mZZ)v3PzSs5Y9ju39 zP?>#?OXv>~@EfO-(n|ZR$<>PY8z<-Ew9m6NA=ex5+k&+9QgvwAm)95KZGjPziASHo z1QB+t3pkILXo9%+Wc1GCfp9E4^LjI$q3lW*?w(?!Ru23Aj9z<++2NRU=J#nlP3R>N z@UwOd?C?F~ct2~qlE3pazo)y*FFf2@ZnRp~k0<2@ENsPiXMVMCOf&T;riQZrT)1~O zAE&E{vhvQDs~Xy!O&yNyrXI)S5Nd}5KHm&WIlJjV_VOs7j0NLbbno+x7LMiyjAClK zZo=?zt2u7e6x)aHP4bh;VpQ%KAsKqW3?_(BKOFE%&?6wIDu=8caaH8C5)=)~Vab@s zM0I=7!NV=;IuxZ<6!R73wHF-{mdlezW$|fBWpTK7)Y8(#SCRJ}H3$dsGeb^STMQ4k zoB@!-SB-bRrwPR&W`>q7vkVWnmVTv0K3P81X6yMazIV~ynPnJ`&c>K<+d2JUS6vJb zx1Gb<&PLkbO*it5>C-${JKojBdN@#yHjKHU^f3;%o-5MaaDHm{uIEyrSX^dEA>@?< z-k;;mrIhV)ub&N1^0hqAhKG}!Z>^5k{v7U*G(4_J%n_wSMYwl4Pbfzh(=?V*Qhc#& z4SCv1}k1HR8x-cRBn96$$*V{#}xD#AVMys46t z4D;qoWh=-3tOLT)=@=839ZEJi+&iC-DeY9<&-O;cJePx_n2xOiqmB+Za(5_3eU zS`N2Q&KpZdmyFIaeETbT_sKCs(iGWKm?1*la=>rfKe{xul}V{3&lnr>e%o$@q!F@a zFhPVYbHG=#HS@LS1vf*RaQwoarq=wW4V#$DG#^dtbwhkboa!1{2ifqT%5d^k^lhTG3S1abA`g zUqSxYFe@Y-kz*2bM94)4Tqkx-ceEDA>63C$ezAh@wamLt%n_E23C?1g2-)csJI5G` zrh`(`M%pi`VX8hxP1zw=P0v>&t)_>yh?YdrJm?85ERByA1 zhT&j>X4s*0)Cjlx%D!%gab1UZ_mw&nTg(hAguHaX>n|Rut*oa>KD{T<*YR+5i|O4fS5Mx#Nh2f;k~M<~qEu9e+sp1sBWPb1yG?VI3^3nmHZ?>VFLD3bQs~qzA2KE96qnH{(6?MQX zR4)TH#fm(>YP?sd>ft!p%v^VPzROO-!|mo$S3lm_X=hkEB=KT0IICeELV2S|go0_cR zR&xQ*RYq8rDQg}Pb*`(jhKF0!Mk%UU%XbhR@s;HLlm^1l1R3L)97^}-aPPO*D>-?d zsTx1VRUqE?+j=-U959Tzq2!~(tvb6Xj-&B*lFKZK;@;$t^E(W`sxvE`T8?7^v(xqV zfQQ@8T487N)!V{W>A z2I1j$^HJhR=DpkFT#mK}g74k2SEZ{SO6>&uKl+_(yIwyXLqlu0?OR{)MOCs{iVOxSnQ*!@)o%o3~D?vA=5}t%v#!_i4?@E3|+6Qu*Fe zfdFAV@kBDRhAbeJkFMev9`5tXc_Cr)Q}8{ncvS#OXOh<%#m*}J8Qzfh8aO9pd0F3( z{g`vVC$GH*v`}g-`Uob4lG6=W%Gs%uLA_!9oiC*crIDhIU{bn_EB-AkhQ18N9$2-V%J_DkeWmXf0l_x!OeWOXJkuiJO}`9lk(W&?(> z^9P~2H{e>#Gh&eT4|{8mm-Vd+uwu>%N1<_yBXU-|-TC0*mU9}&DOLsD;k7MhI1V^7 z*FLRwy(Hk_cJu1eP5X1m)r{9WAsC7##^*fK)$YQ>?d4Uim*%N~s~NBQOFJCX&HSgM zRsWoB$khrT4(#x~v+=4{0HHX@%+Nxq)(!U!z$;rV>&KJih7h;dit%~_V1#3usYfw2 zl#a&X*3`YCRAcU5#JASPtESEolBUOZ_o7uo7m0uceOM{T+&g3e1iAMPan4|ZDE%bD z?Hc;>QqTf+4aLLKFcG_kt`a&*1ibG5Wu>VF>`{V-rIDibC|T_~Nx;J`>O(bA3)M*i z4a*Yc+eu=DP%nJmuIUSp9*Cr`BSQV&@V-E5Nd=2UjKG~>xHcquk~+j7^agMMhMyBfcFVLHT?#s-`qha<#sYC z_s-3R$q`#GUi$>QLsE9INz4%;XMD~+*Syxl(Q`ZbTsCxhj9KeLIQ%UIZP3u+IiK!D-Y!k>A97neR(t-=Q7(( z2NK+Ya@AC?@oP0*)}mSxZxppAG&G&nj1OVHC|xeXUA6Ne%2zZTtMmStttqcnJ7zdQ zkv@#MA=E~nwcn|RvitdSDmPc7ET=wX(HU*U+`LwzR00#2Z9o3keP2LO+A) z>T1B@;nwv5N>?<_)mt3Ccl%y7;6^yWkT!~`p=95~z24nZsd>GWCl})=xiMb2>m3rB z&I$bpW{Z${54djc?#fnG!&X$YRX49}P5IaDSt03~9Fv$MLMA@o`=)1BjxNdku_#N1 z$>5Tgll- zr?&;e!7#tQUaXd$ezSMT6P^F+hB+bXz~+7wGe^jl2V5ibKFXZTu@*>BzHDC=L%BzPM(wO_d$p7HqrAv*^7VC}8fkq!q(!tOu87u`85U$^&tjS= zb?f13dT&#cYN95@Vri= 199901L +# ifndef STDC99 +# define STDC99 +# endif +# endif +#endif +#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus)) +# define STDC +#endif +#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__)) +# define STDC +#endif +#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32)) +# define STDC +#endif +#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__)) +# define STDC +#endif + +#if defined(__OS400__) && !defined(STDC) /* iSeries (formerly AS/400). */ +# define STDC +#endif + +#ifndef STDC +# ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */ +# define const /* note: need a more gentle solution here */ +# endif +#endif + +/* Some Mac compilers merge all .h files incorrectly: */ +#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__) +# define NO_DUMMY_DECL +#endif + +/* Maximum value for memLevel in deflateInit2 */ +#ifndef MAX_MEM_LEVEL +# ifdef MAXSEG_64K +# define MAX_MEM_LEVEL 8 +# else +# define MAX_MEM_LEVEL 9 +# endif +#endif + +/* Maximum value for windowBits in deflateInit2 and inflateInit2. + * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files + * created by gzip. (Files created by minigzip can still be extracted by + * gzip.) + */ +#ifndef MAX_WBITS +# define MAX_WBITS 15 /* 32K LZ77 window */ +#endif + +/* The memory requirements for deflate are (in bytes): + (1 << (windowBits+2)) + (1 << (memLevel+9)) + that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values) + plus a few kilobytes for small objects. For example, if you want to reduce + the default memory requirements from 256K to 128K, compile with + make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7" + Of course this will generally degrade compression (there's no free lunch). + + The memory requirements for inflate are (in bytes) 1 << windowBits + that is, 32K for windowBits=15 (default value) plus a few kilobytes + for small objects. +*/ + + /* Type declarations */ + +#ifndef OF /* function prototypes */ +# ifdef STDC +# define OF(args) args +# else +# define OF(args) () +# endif +#endif + +/* The following definitions for FAR are needed only for MSDOS mixed + * model programming (small or medium model with some far allocations). + * This was tested only with MSC; for other MSDOS compilers you may have + * to define NO_MEMCPY in zutil.h. If you don't need the mixed model, + * just define FAR to be empty. + */ +#ifdef SYS16BIT +# if defined(M_I86SM) || defined(M_I86MM) + /* MSC small or medium model */ +# define SMALL_MEDIUM +# ifdef _MSC_VER +# define FAR _far +# else +# define FAR far +# endif +# endif +# if (defined(__SMALL__) || defined(__MEDIUM__)) + /* Turbo C small or medium model */ +# define SMALL_MEDIUM +# ifdef __BORLANDC__ +# define FAR _far +# else +# define FAR far +# endif +# endif +#endif + +#if defined(WINDOWS) || defined(WIN32) + /* If building or using zlib as a DLL, define ZLIB_DLL. + * This is not mandatory, but it offers a little performance increase. + */ +# ifdef ZLIB_DLL +# if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500)) +# ifdef ZLIB_INTERNAL +# define ZEXTERN extern __declspec(dllexport) +# else +# define ZEXTERN extern __declspec(dllimport) +# endif +# endif +# endif /* ZLIB_DLL */ + /* If building or using zlib with the WINAPI/WINAPIV calling convention, + * define ZLIB_WINAPI. + * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI. + */ +# ifdef ZLIB_WINAPI +# ifdef FAR +# undef FAR +# endif +# include + /* No need for _export, use ZLIB.DEF instead. */ + /* For complete Windows compatibility, use WINAPI, not __stdcall. */ +# define ZEXPORT WINAPI +# ifdef WIN32 +# define ZEXPORTVA WINAPIV +# else +# define ZEXPORTVA FAR CDECL +# endif +# endif +#endif + +#if defined (__BEOS__) +# ifdef ZLIB_DLL +# ifdef ZLIB_INTERNAL +# define ZEXPORT __declspec(dllexport) +# define ZEXPORTVA __declspec(dllexport) +# else +# define ZEXPORT __declspec(dllimport) +# define ZEXPORTVA __declspec(dllimport) +# endif +# endif +#endif + +#ifndef ZEXTERN +# define ZEXTERN extern +#endif +#ifndef ZEXPORT +# define ZEXPORT +#endif +#ifndef ZEXPORTVA +# define ZEXPORTVA +#endif + +#ifndef FAR +# define FAR +#endif + +#if !defined(__MACTYPES__) +typedef unsigned char Byte; /* 8 bits */ +#endif +typedef unsigned int uInt; /* 16 bits or more */ +typedef unsigned long uLong; /* 32 bits or more */ + +#ifdef SMALL_MEDIUM + /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */ +# define Bytef Byte FAR +#else + typedef Byte FAR Bytef; +#endif +typedef char FAR charf; +typedef int FAR intf; +typedef uInt FAR uIntf; +typedef uLong FAR uLongf; + +#ifdef STDC + typedef void const *voidpc; + typedef void FAR *voidpf; + typedef void *voidp; +#else + typedef Byte const *voidpc; + typedef Byte FAR *voidpf; + typedef Byte *voidp; +#endif + +#if 1 /* HAVE_UNISTD_H -- this line is updated by ./configure */ +# include /* for off_t */ +# include /* for SEEK_* and off_t */ +# ifdef VMS +# include /* for off_t */ +# endif +# define z_off_t off_t +#endif +#ifndef SEEK_SET +# define SEEK_SET 0 /* Seek from beginning of file. */ +# define SEEK_CUR 1 /* Seek from current position. */ +# define SEEK_END 2 /* Set file pointer to EOF plus "offset" */ +#endif +#ifndef z_off_t +# define z_off_t long +#endif + +#if defined(__OS400__) +# define NO_vsnprintf +#endif + +#if defined(__MVS__) +# define NO_vsnprintf +# ifdef FAR +# undef FAR +# endif +#endif + +/* MVS linker does not support external names larger than 8 bytes */ +#if defined(__MVS__) +# pragma map(deflateInit_,"DEIN") +# pragma map(deflateInit2_,"DEIN2") +# pragma map(deflateEnd,"DEEND") +# pragma map(deflateBound,"DEBND") +# pragma map(inflateInit_,"ININ") +# pragma map(inflateInit2_,"ININ2") +# pragma map(inflateEnd,"INEND") +# pragma map(inflateSync,"INSY") +# pragma map(inflateSetDictionary,"INSEDI") +# pragma map(compressBound,"CMBND") +# pragma map(inflate_table,"INTABL") +# pragma map(inflate_fast,"INFA") +# pragma map(inflate_copyright,"INCOPY") +#endif + +#endif /* ZCONF_H */ diff --git a/lib/libz/include/zlib.h b/lib/libz/include/zlib.h new file mode 100755 --- /dev/null +++ b/lib/libz/include/zlib.h @@ -0,0 +1,1357 @@ +/* zlib.h -- interface of the 'zlib' general purpose compression library + version 1.2.3, July 18th, 2005 + + Copyright (C) 1995-2005 Jean-loup Gailly and Mark Adler + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + + Jean-loup Gailly Mark Adler + jloup@gzip.org madler@alumni.caltech.edu + + + The data format used by the zlib library is described by RFCs (Request for + Comments) 1950 to 1952 in the files http://www.ietf.org/rfc/rfc1950.txt + (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format). +*/ + +#ifndef ZLIB_H +#define ZLIB_H + +#include "zconf.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define ZLIB_VERSION "1.2.3" +#define ZLIB_VERNUM 0x1230 + +/* + The 'zlib' compression library provides in-memory compression and + decompression functions, including integrity checks of the uncompressed + data. This version of the library supports only one compression method + (deflation) but other algorithms will be added later and will have the same + stream interface. + + Compression can be done in a single step if the buffers are large + enough (for example if an input file is mmap'ed), or can be done by + repeated calls of the compression function. In the latter case, the + application must provide more input and/or consume the output + (providing more output space) before each call. + + The compressed data format used by default by the in-memory functions is + the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped + around a deflate stream, which is itself documented in RFC 1951. + + The library also supports reading and writing files in gzip (.gz) format + with an interface similar to that of stdio using the functions that start + with "gz". The gzip format is different from the zlib format. gzip is a + gzip wrapper, documented in RFC 1952, wrapped around a deflate stream. + + This library can optionally read and write gzip streams in memory as well. + + The zlib format was designed to be compact and fast for use in memory + and on communications channels. The gzip format was designed for single- + file compression on file systems, has a larger header than zlib to maintain + directory information, and uses a different, slower check method than zlib. + + The library does not install any signal handler. The decoder checks + the consistency of the compressed data, so the library should never + crash even in case of corrupted input. +*/ + +typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size)); +typedef void (*free_func) OF((voidpf opaque, voidpf address)); + +struct internal_state; + +typedef struct z_stream_s { + Bytef *next_in; /* next input byte */ + uInt avail_in; /* number of bytes available at next_in */ + uLong total_in; /* total nb of input bytes read so far */ + + Bytef *next_out; /* next output byte should be put there */ + uInt avail_out; /* remaining free space at next_out */ + uLong total_out; /* total nb of bytes output so far */ + + char *msg; /* last error message, NULL if no error */ + struct internal_state FAR *state; /* not visible by applications */ + + alloc_func zalloc; /* used to allocate the internal state */ + free_func zfree; /* used to free the internal state */ + voidpf opaque; /* private data object passed to zalloc and zfree */ + + int data_type; /* best guess about the data type: binary or text */ + uLong adler; /* adler32 value of the uncompressed data */ + uLong reserved; /* reserved for future use */ +} z_stream; + +typedef z_stream FAR *z_streamp; + +/* + gzip header information passed to and from zlib routines. See RFC 1952 + for more details on the meanings of these fields. +*/ +typedef struct gz_header_s { + int text; /* true if compressed data believed to be text */ + uLong time; /* modification time */ + int xflags; /* extra flags (not used when writing a gzip file) */ + int os; /* operating system */ + Bytef *extra; /* pointer to extra field or Z_NULL if none */ + uInt extra_len; /* extra field length (valid if extra != Z_NULL) */ + uInt extra_max; /* space at extra (only when reading header) */ + Bytef *name; /* pointer to zero-terminated file name or Z_NULL */ + uInt name_max; /* space at name (only when reading header) */ + Bytef *comment; /* pointer to zero-terminated comment or Z_NULL */ + uInt comm_max; /* space at comment (only when reading header) */ + int hcrc; /* true if there was or will be a header crc */ + int done; /* true when done reading gzip header (not used + when writing a gzip file) */ +} gz_header; + +typedef gz_header FAR *gz_headerp; + +/* + The application must update next_in and avail_in when avail_in has + dropped to zero. It must update next_out and avail_out when avail_out + has dropped to zero. The application must initialize zalloc, zfree and + opaque before calling the init function. All other fields are set by the + compression library and must not be updated by the application. + + The opaque value provided by the application will be passed as the first + parameter for calls of zalloc and zfree. This can be useful for custom + memory management. The compression library attaches no meaning to the + opaque value. + + zalloc must return Z_NULL if there is not enough memory for the object. + If zlib is used in a multi-threaded application, zalloc and zfree must be + thread safe. + + On 16-bit systems, the functions zalloc and zfree must be able to allocate + exactly 65536 bytes, but will not be required to allocate more than this + if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS, + pointers returned by zalloc for objects of exactly 65536 bytes *must* + have their offset normalized to zero. The default allocation function + provided by this library ensures this (see zutil.c). To reduce memory + requirements and avoid any allocation of 64K objects, at the expense of + compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h). + + The fields total_in and total_out can be used for statistics or + progress reports. After compression, total_in holds the total size of + the uncompressed data and may be saved for use in the decompressor + (particularly if the decompressor wants to decompress everything in + a single step). +*/ + + /* constants */ + +#define Z_NO_FLUSH 0 +#define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */ +#define Z_SYNC_FLUSH 2 +#define Z_FULL_FLUSH 3 +#define Z_FINISH 4 +#define Z_BLOCK 5 +/* Allowed flush values; see deflate() and inflate() below for details */ + +#define Z_OK 0 +#define Z_STREAM_END 1 +#define Z_NEED_DICT 2 +#define Z_ERRNO (-1) +#define Z_STREAM_ERROR (-2) +#define Z_DATA_ERROR (-3) +#define Z_MEM_ERROR (-4) +#define Z_BUF_ERROR (-5) +#define Z_VERSION_ERROR (-6) +/* Return codes for the compression/decompression functions. Negative + * values are errors, positive values are used for special but normal events. + */ + +#define Z_NO_COMPRESSION 0 +#define Z_BEST_SPEED 1 +#define Z_BEST_COMPRESSION 9 +#define Z_DEFAULT_COMPRESSION (-1) +/* compression levels */ + +#define Z_FILTERED 1 +#define Z_HUFFMAN_ONLY 2 +#define Z_RLE 3 +#define Z_FIXED 4 +#define Z_DEFAULT_STRATEGY 0 +/* compression strategy; see deflateInit2() below for details */ + +#define Z_BINARY 0 +#define Z_TEXT 1 +#define Z_ASCII Z_TEXT /* for compatibility with 1.2.2 and earlier */ +#define Z_UNKNOWN 2 +/* Possible values of the data_type field (though see inflate()) */ + +#define Z_DEFLATED 8 +/* The deflate compression method (the only one supported in this version) */ + +#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ + +#define zlib_version zlibVersion() +/* for compatibility with versions < 1.0.2 */ + + /* basic functions */ + +ZEXTERN const char * ZEXPORT zlibVersion OF((void)); +/* The application can compare zlibVersion and ZLIB_VERSION for consistency. + If the first character differs, the library code actually used is + not compatible with the zlib.h header file used by the application. + This check is automatically made by deflateInit and inflateInit. + */ + +/* +ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level)); + + Initializes the internal stream state for compression. The fields + zalloc, zfree and opaque must be initialized before by the caller. + If zalloc and zfree are set to Z_NULL, deflateInit updates them to + use default allocation functions. + + The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9: + 1 gives best speed, 9 gives best compression, 0 gives no compression at + all (the input data is simply copied a block at a time). + Z_DEFAULT_COMPRESSION requests a default compromise between speed and + compression (currently equivalent to level 6). + + deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_STREAM_ERROR if level is not a valid compression level, + Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible + with the version assumed by the caller (ZLIB_VERSION). + msg is set to null if there is no error message. deflateInit does not + perform any compression: this will be done by deflate(). +*/ + + +ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); +/* + deflate compresses as much data as possible, and stops when the input + buffer becomes empty or the output buffer becomes full. It may introduce some + output latency (reading input without producing any output) except when + forced to flush. + + The detailed semantics are as follows. deflate performs one or both of the + following actions: + + - Compress more input starting at next_in and update next_in and avail_in + accordingly. If not all input can be processed (because there is not + enough room in the output buffer), next_in and avail_in are updated and + processing will resume at this point for the next call of deflate(). + + - Provide more output starting at next_out and update next_out and avail_out + accordingly. This action is forced if the parameter flush is non zero. + Forcing flush frequently degrades the compression ratio, so this parameter + should be set only when necessary (in interactive applications). + Some output may be provided even if flush is not set. + + Before the call of deflate(), the application should ensure that at least + one of the actions is possible, by providing more input and/or consuming + more output, and updating avail_in or avail_out accordingly; avail_out + should never be zero before the call. The application can consume the + compressed output when it wants, for example when the output buffer is full + (avail_out == 0), or after each call of deflate(). If deflate returns Z_OK + and with zero avail_out, it must be called again after making room in the + output buffer because there might be more output pending. + + Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to + decide how much data to accumualte before producing output, in order to + maximize compression. + + If the parameter flush is set to Z_SYNC_FLUSH, all pending output is + flushed to the output buffer and the output is aligned on a byte boundary, so + that the decompressor can get all input data available so far. (In particular + avail_in is zero after the call if enough output space has been provided + before the call.) Flushing may degrade compression for some compression + algorithms and so it should be used only when necessary. + + If flush is set to Z_FULL_FLUSH, all output is flushed as with + Z_SYNC_FLUSH, and the compression state is reset so that decompression can + restart from this point if previous compressed data has been damaged or if + random access is desired. Using Z_FULL_FLUSH too often can seriously degrade + compression. + + If deflate returns with avail_out == 0, this function must be called again + with the same value of the flush parameter and more output space (updated + avail_out), until the flush is complete (deflate returns with non-zero + avail_out). In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that + avail_out is greater than six to avoid repeated flush markers due to + avail_out == 0 on return. + + If the parameter flush is set to Z_FINISH, pending input is processed, + pending output is flushed and deflate returns with Z_STREAM_END if there + was enough output space; if deflate returns with Z_OK, this function must be + called again with Z_FINISH and more output space (updated avail_out) but no + more input data, until it returns with Z_STREAM_END or an error. After + deflate has returned Z_STREAM_END, the only possible operations on the + stream are deflateReset or deflateEnd. + + Z_FINISH can be used immediately after deflateInit if all the compression + is to be done in a single step. In this case, avail_out must be at least + the value returned by deflateBound (see below). If deflate does not return + Z_STREAM_END, then it must be called again as described above. + + deflate() sets strm->adler to the adler32 checksum of all input read + so far (that is, total_in bytes). + + deflate() may update strm->data_type if it can make a good guess about + the input data type (Z_BINARY or Z_TEXT). In doubt, the data is considered + binary. This field is only for information purposes and does not affect + the compression algorithm in any manner. + + deflate() returns Z_OK if some progress has been made (more input + processed or more output produced), Z_STREAM_END if all input has been + consumed and all output has been produced (only when flush is set to + Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example + if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible + (for example avail_in or avail_out was zero). Note that Z_BUF_ERROR is not + fatal, and deflate() can be called again with more input and more output + space to continue compressing. +*/ + + +ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm)); +/* + All dynamically allocated data structures for this stream are freed. + This function discards any unprocessed input and does not flush any + pending output. + + deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the + stream state was inconsistent, Z_DATA_ERROR if the stream was freed + prematurely (some input or output was discarded). In the error case, + msg may be set but then points to a static string (which must not be + deallocated). +*/ + + +/* +ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm)); + + Initializes the internal stream state for decompression. The fields + next_in, avail_in, zalloc, zfree and opaque must be initialized before by + the caller. If next_in is not Z_NULL and avail_in is large enough (the exact + value depends on the compression method), inflateInit determines the + compression method from the zlib header and allocates all data structures + accordingly; otherwise the allocation will be deferred to the first call of + inflate. If zalloc and zfree are set to Z_NULL, inflateInit updates them to + use default allocation functions. + + inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_VERSION_ERROR if the zlib library version is incompatible with the + version assumed by the caller. msg is set to null if there is no error + message. inflateInit does not perform any decompression apart from reading + the zlib header if present: this will be done by inflate(). (So next_in and + avail_in may be modified, but next_out and avail_out are unchanged.) +*/ + + +ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush)); +/* + inflate decompresses as much data as possible, and stops when the input + buffer becomes empty or the output buffer becomes full. It may introduce + some output latency (reading input without producing any output) except when + forced to flush. + + The detailed semantics are as follows. inflate performs one or both of the + following actions: + + - Decompress more input starting at next_in and update next_in and avail_in + accordingly. If not all input can be processed (because there is not + enough room in the output buffer), next_in is updated and processing + will resume at this point for the next call of inflate(). + + - Provide more output starting at next_out and update next_out and avail_out + accordingly. inflate() provides as much output as possible, until there + is no more input data or no more space in the output buffer (see below + about the flush parameter). + + Before the call of inflate(), the application should ensure that at least + one of the actions is possible, by providing more input and/or consuming + more output, and updating the next_* and avail_* values accordingly. + The application can consume the uncompressed output when it wants, for + example when the output buffer is full (avail_out == 0), or after each + call of inflate(). If inflate returns Z_OK and with zero avail_out, it + must be called again after making room in the output buffer because there + might be more output pending. + + The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH, + Z_FINISH, or Z_BLOCK. Z_SYNC_FLUSH requests that inflate() flush as much + output as possible to the output buffer. Z_BLOCK requests that inflate() stop + if and when it gets to the next deflate block boundary. When decoding the + zlib or gzip format, this will cause inflate() to return immediately after + the header and before the first block. When doing a raw inflate, inflate() + will go ahead and process the first block, and will return when it gets to + the end of that block, or when it runs out of data. + + The Z_BLOCK option assists in appending to or combining deflate streams. + Also to assist in this, on return inflate() will set strm->data_type to the + number of unused bits in the last byte taken from strm->next_in, plus 64 + if inflate() is currently decoding the last block in the deflate stream, + plus 128 if inflate() returned immediately after decoding an end-of-block + code or decoding the complete header up to just before the first byte of the + deflate stream. The end-of-block will not be indicated until all of the + uncompressed data from that block has been written to strm->next_out. The + number of unused bits may in general be greater than seven, except when + bit 7 of data_type is set, in which case the number of unused bits will be + less than eight. + + inflate() should normally be called until it returns Z_STREAM_END or an + error. However if all decompression is to be performed in a single step + (a single call of inflate), the parameter flush should be set to + Z_FINISH. In this case all pending input is processed and all pending + output is flushed; avail_out must be large enough to hold all the + uncompressed data. (The size of the uncompressed data may have been saved + by the compressor for this purpose.) The next operation on this stream must + be inflateEnd to deallocate the decompression state. The use of Z_FINISH + is never required, but can be used to inform inflate that a faster approach + may be used for the single inflate() call. + + In this implementation, inflate() always flushes as much output as + possible to the output buffer, and always uses the faster approach on the + first call. So the only effect of the flush parameter in this implementation + is on the return value of inflate(), as noted below, or when it returns early + because Z_BLOCK is used. + + If a preset dictionary is needed after this call (see inflateSetDictionary + below), inflate sets strm->adler to the adler32 checksum of the dictionary + chosen by the compressor and returns Z_NEED_DICT; otherwise it sets + strm->adler to the adler32 checksum of all output produced so far (that is, + total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described + below. At the end of the stream, inflate() checks that its computed adler32 + checksum is equal to that saved by the compressor and returns Z_STREAM_END + only if the checksum is correct. + + inflate() will decompress and check either zlib-wrapped or gzip-wrapped + deflate data. The header type is detected automatically. Any information + contained in the gzip header is not retained, so applications that need that + information should instead use raw inflate, see inflateInit2() below, or + inflateBack() and perform their own processing of the gzip header and + trailer. + + inflate() returns Z_OK if some progress has been made (more input processed + or more output produced), Z_STREAM_END if the end of the compressed data has + been reached and all uncompressed output has been produced, Z_NEED_DICT if a + preset dictionary is needed at this point, Z_DATA_ERROR if the input data was + corrupted (input stream not conforming to the zlib format or incorrect check + value), Z_STREAM_ERROR if the stream structure was inconsistent (for example + if next_in or next_out was NULL), Z_MEM_ERROR if there was not enough memory, + Z_BUF_ERROR if no progress is possible or if there was not enough room in the + output buffer when Z_FINISH is used. Note that Z_BUF_ERROR is not fatal, and + inflate() can be called again with more input and more output space to + continue decompressing. If Z_DATA_ERROR is returned, the application may then + call inflateSync() to look for a good compression block if a partial recovery + of the data is desired. +*/ + + +ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm)); +/* + All dynamically allocated data structures for this stream are freed. + This function discards any unprocessed input and does not flush any + pending output. + + inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state + was inconsistent. In the error case, msg may be set but then points to a + static string (which must not be deallocated). +*/ + + /* Advanced functions */ + +/* + The following functions are needed only in some special applications. +*/ + +/* +ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm, + int level, + int method, + int windowBits, + int memLevel, + int strategy)); + + This is another version of deflateInit with more compression options. The + fields next_in, zalloc, zfree and opaque must be initialized before by + the caller. + + The method parameter is the compression method. It must be Z_DEFLATED in + this version of the library. + + The windowBits parameter is the base two logarithm of the window size + (the size of the history buffer). It should be in the range 8..15 for this + version of the library. Larger values of this parameter result in better + compression at the expense of memory usage. The default value is 15 if + deflateInit is used instead. + + windowBits can also be -8..-15 for raw deflate. In this case, -windowBits + determines the window size. deflate() will then generate raw deflate data + with no zlib header or trailer, and will not compute an adler32 check value. + + windowBits can also be greater than 15 for optional gzip encoding. Add + 16 to windowBits to write a simple gzip header and trailer around the + compressed data instead of a zlib wrapper. The gzip header will have no + file name, no extra data, no comment, no modification time (set to zero), + no header crc, and the operating system will be set to 255 (unknown). If a + gzip stream is being written, strm->adler is a crc32 instead of an adler32. + + The memLevel parameter specifies how much memory should be allocated + for the internal compression state. memLevel=1 uses minimum memory but + is slow and reduces compression ratio; memLevel=9 uses maximum memory + for optimal speed. The default value is 8. See zconf.h for total memory + usage as a function of windowBits and memLevel. + + The strategy parameter is used to tune the compression algorithm. Use the + value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a + filter (or predictor), Z_HUFFMAN_ONLY to force Huffman encoding only (no + string match), or Z_RLE to limit match distances to one (run-length + encoding). Filtered data consists mostly of small values with a somewhat + random distribution. In this case, the compression algorithm is tuned to + compress them better. The effect of Z_FILTERED is to force more Huffman + coding and less string matching; it is somewhat intermediate between + Z_DEFAULT and Z_HUFFMAN_ONLY. Z_RLE is designed to be almost as fast as + Z_HUFFMAN_ONLY, but give better compression for PNG image data. The strategy + parameter only affects the compression ratio but not the correctness of the + compressed output even if it is not set appropriately. Z_FIXED prevents the + use of dynamic Huffman codes, allowing for a simpler decoder for special + applications. + + deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_STREAM_ERROR if a parameter is invalid (such as an invalid + method). msg is set to null if there is no error message. deflateInit2 does + not perform any compression: this will be done by deflate(). +*/ + +ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm, + const Bytef *dictionary, + uInt dictLength)); +/* + Initializes the compression dictionary from the given byte sequence + without producing any compressed output. This function must be called + immediately after deflateInit, deflateInit2 or deflateReset, before any + call of deflate. The compressor and decompressor must use exactly the same + dictionary (see inflateSetDictionary). + + The dictionary should consist of strings (byte sequences) that are likely + to be encountered later in the data to be compressed, with the most commonly + used strings preferably put towards the end of the dictionary. Using a + dictionary is most useful when the data to be compressed is short and can be + predicted with good accuracy; the data can then be compressed better than + with the default empty dictionary. + + Depending on the size of the compression data structures selected by + deflateInit or deflateInit2, a part of the dictionary may in effect be + discarded, for example if the dictionary is larger than the window size in + deflate or deflate2. Thus the strings most likely to be useful should be + put at the end of the dictionary, not at the front. In addition, the + current implementation of deflate will use at most the window size minus + 262 bytes of the provided dictionary. + + Upon return of this function, strm->adler is set to the adler32 value + of the dictionary; the decompressor may later use this value to determine + which dictionary has been used by the compressor. (The adler32 value + applies to the whole dictionary even if only a subset of the dictionary is + actually used by the compressor.) If a raw deflate was requested, then the + adler32 value is not computed and strm->adler is not set. + + deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a + parameter is invalid (such as NULL dictionary) or the stream state is + inconsistent (for example if deflate has already been called for this stream + or if the compression method is bsort). deflateSetDictionary does not + perform any compression: this will be done by deflate(). +*/ + +ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest, + z_streamp source)); +/* + Sets the destination stream as a complete copy of the source stream. + + This function can be useful when several compression strategies will be + tried, for example when there are several ways of pre-processing the input + data with a filter. The streams that will be discarded should then be freed + by calling deflateEnd. Note that deflateCopy duplicates the internal + compression state which can be quite large, so this strategy is slow and + can consume lots of memory. + + deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_STREAM_ERROR if the source stream state was inconsistent + (such as zalloc being NULL). msg is left unchanged in both source and + destination. +*/ + +ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm)); +/* + This function is equivalent to deflateEnd followed by deflateInit, + but does not free and reallocate all the internal compression state. + The stream will keep the same compression level and any other attributes + that may have been set by deflateInit2. + + deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent (such as zalloc or state being NULL). +*/ + +ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, + int level, + int strategy)); +/* + Dynamically update the compression level and compression strategy. The + interpretation of level and strategy is as in deflateInit2. This can be + used to switch between compression and straight copy of the input data, or + to switch to a different kind of input data requiring a different + strategy. If the compression level is changed, the input available so far + is compressed with the old level (and may be flushed); the new level will + take effect only at the next call of deflate(). + + Before the call of deflateParams, the stream state must be set as for + a call of deflate(), since the currently available input may have to + be compressed and flushed. In particular, strm->avail_out must be non-zero. + + deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source + stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR + if strm->avail_out was zero. +*/ + +ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm, + int good_length, + int max_lazy, + int nice_length, + int max_chain)); +/* + Fine tune deflate's internal compression parameters. This should only be + used by someone who understands the algorithm used by zlib's deflate for + searching for the best matching string, and even then only by the most + fanatic optimizer trying to squeeze out the last compressed bit for their + specific input data. Read the deflate.c source code for the meaning of the + max_lazy, good_length, nice_length, and max_chain parameters. + + deflateTune() can be called after deflateInit() or deflateInit2(), and + returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream. + */ + +ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm, + uLong sourceLen)); +/* + deflateBound() returns an upper bound on the compressed size after + deflation of sourceLen bytes. It must be called after deflateInit() + or deflateInit2(). This would be used to allocate an output buffer + for deflation in a single pass, and so would be called before deflate(). +*/ + +ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm, + int bits, + int value)); +/* + deflatePrime() inserts bits in the deflate output stream. The intent + is that this function is used to start off the deflate output with the + bits leftover from a previous deflate stream when appending to it. As such, + this function can only be used for raw deflate, and must be used before the + first deflate() call after a deflateInit2() or deflateReset(). bits must be + less than or equal to 16, and that many of the least significant bits of + value will be inserted in the output. + + deflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent. +*/ + +ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm, + gz_headerp head)); +/* + deflateSetHeader() provides gzip header information for when a gzip + stream is requested by deflateInit2(). deflateSetHeader() may be called + after deflateInit2() or deflateReset() and before the first call of + deflate(). The text, time, os, extra field, name, and comment information + in the provided gz_header structure are written to the gzip header (xflag is + ignored -- the extra flags are set according to the compression level). The + caller must assure that, if not Z_NULL, name and comment are terminated with + a zero byte, and that if extra is not Z_NULL, that extra_len bytes are + available there. If hcrc is true, a gzip header crc is included. Note that + the current versions of the command-line version of gzip (up through version + 1.3.x) do not support header crc's, and will report that it is a "multi-part + gzip file" and give up. + + If deflateSetHeader is not used, the default gzip header has text false, + the time set to zero, and os set to 255, with no extra, name, or comment + fields. The gzip header is returned to the default state by deflateReset(). + + deflateSetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent. +*/ + +/* +ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm, + int windowBits)); + + This is another version of inflateInit with an extra parameter. The + fields next_in, avail_in, zalloc, zfree and opaque must be initialized + before by the caller. + + The windowBits parameter is the base two logarithm of the maximum window + size (the size of the history buffer). It should be in the range 8..15 for + this version of the library. The default value is 15 if inflateInit is used + instead. windowBits must be greater than or equal to the windowBits value + provided to deflateInit2() while compressing, or it must be equal to 15 if + deflateInit2() was not used. If a compressed stream with a larger window + size is given as input, inflate() will return with the error code + Z_DATA_ERROR instead of trying to allocate a larger window. + + windowBits can also be -8..-15 for raw inflate. In this case, -windowBits + determines the window size. inflate() will then process raw deflate data, + not looking for a zlib or gzip header, not generating a check value, and not + looking for any check values for comparison at the end of the stream. This + is for use with other formats that use the deflate compressed data format + such as zip. Those formats provide their own check values. If a custom + format is developed using the raw deflate format for compressed data, it is + recommended that a check value such as an adler32 or a crc32 be applied to + the uncompressed data as is done in the zlib, gzip, and zip formats. For + most applications, the zlib format should be used as is. Note that comments + above on the use in deflateInit2() applies to the magnitude of windowBits. + + windowBits can also be greater than 15 for optional gzip decoding. Add + 32 to windowBits to enable zlib and gzip decoding with automatic header + detection, or add 16 to decode only the gzip format (the zlib format will + return a Z_DATA_ERROR). If a gzip stream is being decoded, strm->adler is + a crc32 instead of an adler32. + + inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_STREAM_ERROR if a parameter is invalid (such as a null strm). msg + is set to null if there is no error message. inflateInit2 does not perform + any decompression apart from reading the zlib header if present: this will + be done by inflate(). (So next_in and avail_in may be modified, but next_out + and avail_out are unchanged.) +*/ + +ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm, + const Bytef *dictionary, + uInt dictLength)); +/* + Initializes the decompression dictionary from the given uncompressed byte + sequence. This function must be called immediately after a call of inflate, + if that call returned Z_NEED_DICT. The dictionary chosen by the compressor + can be determined from the adler32 value returned by that call of inflate. + The compressor and decompressor must use exactly the same dictionary (see + deflateSetDictionary). For raw inflate, this function can be called + immediately after inflateInit2() or inflateReset() and before any call of + inflate() to set the dictionary. The application must insure that the + dictionary that was used for compression is provided. + + inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a + parameter is invalid (such as NULL dictionary) or the stream state is + inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the + expected one (incorrect adler32 value). inflateSetDictionary does not + perform any decompression: this will be done by subsequent calls of + inflate(). +*/ + +ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm)); +/* + Skips invalid compressed data until a full flush point (see above the + description of deflate with Z_FULL_FLUSH) can be found, or until all + available input is skipped. No output is provided. + + inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR + if no more input was provided, Z_DATA_ERROR if no flush point has been found, + or Z_STREAM_ERROR if the stream structure was inconsistent. In the success + case, the application may save the current current value of total_in which + indicates where valid compressed data was found. In the error case, the + application may repeatedly call inflateSync, providing more input each time, + until success or end of the input data. +*/ + +ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest, + z_streamp source)); +/* + Sets the destination stream as a complete copy of the source stream. + + This function can be useful when randomly accessing a large stream. The + first pass through the stream can periodically record the inflate state, + allowing restarting inflate at those points when randomly accessing the + stream. + + inflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_STREAM_ERROR if the source stream state was inconsistent + (such as zalloc being NULL). msg is left unchanged in both source and + destination. +*/ + +ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm)); +/* + This function is equivalent to inflateEnd followed by inflateInit, + but does not free and reallocate all the internal decompression state. + The stream will keep attributes that may have been set by inflateInit2. + + inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent (such as zalloc or state being NULL). +*/ + +ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm, + int bits, + int value)); +/* + This function inserts bits in the inflate input stream. The intent is + that this function is used to start inflating at a bit position in the + middle of a byte. The provided bits will be used before any bytes are used + from next_in. This function should only be used with raw inflate, and + should be used before the first inflate() call after inflateInit2() or + inflateReset(). bits must be less than or equal to 16, and that many of the + least significant bits of value will be inserted in the input. + + inflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent. +*/ + +ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm, + gz_headerp head)); +/* + inflateGetHeader() requests that gzip header information be stored in the + provided gz_header structure. inflateGetHeader() may be called after + inflateInit2() or inflateReset(), and before the first call of inflate(). + As inflate() processes the gzip stream, head->done is zero until the header + is completed, at which time head->done is set to one. If a zlib stream is + being decoded, then head->done is set to -1 to indicate that there will be + no gzip header information forthcoming. Note that Z_BLOCK can be used to + force inflate() to return immediately after header processing is complete + and before any actual data is decompressed. + + The text, time, xflags, and os fields are filled in with the gzip header + contents. hcrc is set to true if there is a header CRC. (The header CRC + was valid if done is set to one.) If extra is not Z_NULL, then extra_max + contains the maximum number of bytes to write to extra. Once done is true, + extra_len contains the actual extra field length, and extra contains the + extra field, or that field truncated if extra_max is less than extra_len. + If name is not Z_NULL, then up to name_max characters are written there, + terminated with a zero unless the length is greater than name_max. If + comment is not Z_NULL, then up to comm_max characters are written there, + terminated with a zero unless the length is greater than comm_max. When + any of extra, name, or comment are not Z_NULL and the respective field is + not present in the header, then that field is set to Z_NULL to signal its + absence. This allows the use of deflateSetHeader() with the returned + structure to duplicate the header. However if those fields are set to + allocated memory, then the application will need to save those pointers + elsewhere so that they can be eventually freed. + + If inflateGetHeader is not used, then the header information is simply + discarded. The header is always checked for validity, including the header + CRC if present. inflateReset() will reset the process to discard the header + information. The application would need to call inflateGetHeader() again to + retrieve the header from the next gzip stream. + + inflateGetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent. +*/ + +/* +ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits, + unsigned char FAR *window)); + + Initialize the internal stream state for decompression using inflateBack() + calls. The fields zalloc, zfree and opaque in strm must be initialized + before the call. If zalloc and zfree are Z_NULL, then the default library- + derived memory allocation routines are used. windowBits is the base two + logarithm of the window size, in the range 8..15. window is a caller + supplied buffer of that size. Except for special applications where it is + assured that deflate was used with small window sizes, windowBits must be 15 + and a 32K byte window must be supplied to be able to decompress general + deflate streams. + + See inflateBack() for the usage of these routines. + + inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of + the paramaters are invalid, Z_MEM_ERROR if the internal state could not + be allocated, or Z_VERSION_ERROR if the version of the library does not + match the version of the header file. +*/ + +typedef unsigned (*in_func) OF((void FAR *, unsigned char FAR * FAR *)); +typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned)); + +ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm, + in_func in, void FAR *in_desc, + out_func out, void FAR *out_desc)); +/* + inflateBack() does a raw inflate with a single call using a call-back + interface for input and output. This is more efficient than inflate() for + file i/o applications in that it avoids copying between the output and the + sliding window by simply making the window itself the output buffer. This + function trusts the application to not change the output buffer passed by + the output function, at least until inflateBack() returns. + + inflateBackInit() must be called first to allocate the internal state + and to initialize the state with the user-provided window buffer. + inflateBack() may then be used multiple times to inflate a complete, raw + deflate stream with each call. inflateBackEnd() is then called to free + the allocated state. + + A raw deflate stream is one with no zlib or gzip header or trailer. + This routine would normally be used in a utility that reads zip or gzip + files and writes out uncompressed files. The utility would decode the + header and process the trailer on its own, hence this routine expects + only the raw deflate stream to decompress. This is different from the + normal behavior of inflate(), which expects either a zlib or gzip header and + trailer around the deflate stream. + + inflateBack() uses two subroutines supplied by the caller that are then + called by inflateBack() for input and output. inflateBack() calls those + routines until it reads a complete deflate stream and writes out all of the + uncompressed data, or until it encounters an error. The function's + parameters and return types are defined above in the in_func and out_func + typedefs. inflateBack() will call in(in_desc, &buf) which should return the + number of bytes of provided input, and a pointer to that input in buf. If + there is no input available, in() must return zero--buf is ignored in that + case--and inflateBack() will return a buffer error. inflateBack() will call + out(out_desc, buf, len) to write the uncompressed data buf[0..len-1]. out() + should return zero on success, or non-zero on failure. If out() returns + non-zero, inflateBack() will return with an error. Neither in() nor out() + are permitted to change the contents of the window provided to + inflateBackInit(), which is also the buffer that out() uses to write from. + The length written by out() will be at most the window size. Any non-zero + amount of input may be provided by in(). + + For convenience, inflateBack() can be provided input on the first call by + setting strm->next_in and strm->avail_in. If that input is exhausted, then + in() will be called. Therefore strm->next_in must be initialized before + calling inflateBack(). If strm->next_in is Z_NULL, then in() will be called + immediately for input. If strm->next_in is not Z_NULL, then strm->avail_in + must also be initialized, and then if strm->avail_in is not zero, input will + initially be taken from strm->next_in[0 .. strm->avail_in - 1]. + + The in_desc and out_desc parameters of inflateBack() is passed as the + first parameter of in() and out() respectively when they are called. These + descriptors can be optionally used to pass any information that the caller- + supplied in() and out() functions need to do their job. + + On return, inflateBack() will set strm->next_in and strm->avail_in to + pass back any unused input that was provided by the last in() call. The + return values of inflateBack() can be Z_STREAM_END on success, Z_BUF_ERROR + if in() or out() returned an error, Z_DATA_ERROR if there was a format + error in the deflate stream (in which case strm->msg is set to indicate the + nature of the error), or Z_STREAM_ERROR if the stream was not properly + initialized. In the case of Z_BUF_ERROR, an input or output error can be + distinguished using strm->next_in which will be Z_NULL only if in() returned + an error. If strm->next is not Z_NULL, then the Z_BUF_ERROR was due to + out() returning non-zero. (in() will always be called before out(), so + strm->next_in is assured to be defined if out() returns non-zero.) Note + that inflateBack() cannot return Z_OK. +*/ + +ZEXTERN int ZEXPORT inflateBackEnd OF((z_streamp strm)); +/* + All memory allocated by inflateBackInit() is freed. + + inflateBackEnd() returns Z_OK on success, or Z_STREAM_ERROR if the stream + state was inconsistent. +*/ + +ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void)); +/* Return flags indicating compile-time options. + + Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other: + 1.0: size of uInt + 3.2: size of uLong + 5.4: size of voidpf (pointer) + 7.6: size of z_off_t + + Compiler, assembler, and debug options: + 8: DEBUG + 9: ASMV or ASMINF -- use ASM code + 10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention + 11: 0 (reserved) + + One-time table building (smaller code, but not thread-safe if true): + 12: BUILDFIXED -- build static block decoding tables when needed + 13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed + 14,15: 0 (reserved) + + Library content (indicates missing functionality): + 16: NO_GZCOMPRESS -- gz* functions cannot compress (to avoid linking + deflate code when not needed) + 17: NO_GZIP -- deflate can't write gzip streams, and inflate can't detect + and decode gzip streams (to avoid linking crc code) + 18-19: 0 (reserved) + + Operation variations (changes in library functionality): + 20: PKZIP_BUG_WORKAROUND -- slightly more permissive inflate + 21: FASTEST -- deflate algorithm with only one, lowest compression level + 22,23: 0 (reserved) + + The sprintf variant used by gzprintf (zero is best): + 24: 0 = vs*, 1 = s* -- 1 means limited to 20 arguments after the format + 25: 0 = *nprintf, 1 = *printf -- 1 means gzprintf() not secure! + 26: 0 = returns value, 1 = void -- 1 means inferred string length returned + + Remainder: + 27-31: 0 (reserved) + */ + + + /* utility functions */ + +/* + The following utility functions are implemented on top of the + basic stream-oriented functions. To simplify the interface, some + default options are assumed (compression level and memory usage, + standard memory allocation functions). The source code of these + utility functions can easily be modified if you need special options. +*/ + +ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen)); +/* + Compresses the source buffer into the destination buffer. sourceLen is + the byte length of the source buffer. Upon entry, destLen is the total + size of the destination buffer, which must be at least the value returned + by compressBound(sourceLen). Upon exit, destLen is the actual size of the + compressed buffer. + This function can be used to compress a whole file at once if the + input file is mmap'ed. + compress returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_BUF_ERROR if there was not enough room in the output + buffer. +*/ + +ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen, + int level)); +/* + Compresses the source buffer into the destination buffer. The level + parameter has the same meaning as in deflateInit. sourceLen is the byte + length of the source buffer. Upon entry, destLen is the total size of the + destination buffer, which must be at least the value returned by + compressBound(sourceLen). Upon exit, destLen is the actual size of the + compressed buffer. + + compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_BUF_ERROR if there was not enough room in the output buffer, + Z_STREAM_ERROR if the level parameter is invalid. +*/ + +ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen)); +/* + compressBound() returns an upper bound on the compressed size after + compress() or compress2() on sourceLen bytes. It would be used before + a compress() or compress2() call to allocate the destination buffer. +*/ + +ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen)); +/* + Decompresses the source buffer into the destination buffer. sourceLen is + the byte length of the source buffer. Upon entry, destLen is the total + size of the destination buffer, which must be large enough to hold the + entire uncompressed data. (The size of the uncompressed data must have + been saved previously by the compressor and transmitted to the decompressor + by some mechanism outside the scope of this compression library.) + Upon exit, destLen is the actual size of the compressed buffer. + This function can be used to decompress a whole file at once if the + input file is mmap'ed. + + uncompress returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_BUF_ERROR if there was not enough room in the output + buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete. +*/ + + +typedef voidp gzFile; + +ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode)); +/* + Opens a gzip (.gz) file for reading or writing. The mode parameter + is as in fopen ("rb" or "wb") but can also include a compression level + ("wb9") or a strategy: 'f' for filtered data as in "wb6f", 'h' for + Huffman only compression as in "wb1h", or 'R' for run-length encoding + as in "wb1R". (See the description of deflateInit2 for more information + about the strategy parameter.) + + gzopen can be used to read a file which is not in gzip format; in this + case gzread will directly read from the file without decompression. + + gzopen returns NULL if the file could not be opened or if there was + insufficient memory to allocate the (de)compression state; errno + can be checked to distinguish the two cases (if errno is zero, the + zlib error is Z_MEM_ERROR). */ + +ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode)); +/* + gzdopen() associates a gzFile with the file descriptor fd. File + descriptors are obtained from calls like open, dup, creat, pipe or + fileno (in the file has been previously opened with fopen). + The mode parameter is as in gzopen. + The next call of gzclose on the returned gzFile will also close the + file descriptor fd, just like fclose(fdopen(fd), mode) closes the file + descriptor fd. If you want to keep fd open, use gzdopen(dup(fd), mode). + gzdopen returns NULL if there was insufficient memory to allocate + the (de)compression state. +*/ + +ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy)); +/* + Dynamically update the compression level or strategy. See the description + of deflateInit2 for the meaning of these parameters. + gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not + opened for writing. +*/ + +ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len)); +/* + Reads the given number of uncompressed bytes from the compressed file. + If the input file was not in gzip format, gzread copies the given number + of bytes into the buffer. + gzread returns the number of uncompressed bytes actually read (0 for + end of file, -1 for error). */ + +ZEXTERN int ZEXPORT gzwrite OF((gzFile file, + voidpc buf, unsigned len)); +/* + Writes the given number of uncompressed bytes into the compressed file. + gzwrite returns the number of uncompressed bytes actually written + (0 in case of error). +*/ + +ZEXTERN int ZEXPORTVA gzprintf OF((gzFile file, const char *format, ...)); +/* + Converts, formats, and writes the args to the compressed file under + control of the format string, as in fprintf. gzprintf returns the number of + uncompressed bytes actually written (0 in case of error). The number of + uncompressed bytes written is limited to 4095. The caller should assure that + this limit is not exceeded. If it is exceeded, then gzprintf() will return + return an error (0) with nothing written. In this case, there may also be a + buffer overflow with unpredictable consequences, which is possible only if + zlib was compiled with the insecure functions sprintf() or vsprintf() + because the secure snprintf() or vsnprintf() functions were not available. +*/ + +ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s)); +/* + Writes the given null-terminated string to the compressed file, excluding + the terminating null character. + gzputs returns the number of characters written, or -1 in case of error. +*/ + +ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len)); +/* + Reads bytes from the compressed file until len-1 characters are read, or + a newline character is read and transferred to buf, or an end-of-file + condition is encountered. The string is then terminated with a null + character. + gzgets returns buf, or Z_NULL in case of error. +*/ + +ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c)); +/* + Writes c, converted to an unsigned char, into the compressed file. + gzputc returns the value that was written, or -1 in case of error. +*/ + +ZEXTERN int ZEXPORT gzgetc OF((gzFile file)); +/* + Reads one byte from the compressed file. gzgetc returns this byte + or -1 in case of end of file or error. +*/ + +ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file)); +/* + Push one character back onto the stream to be read again later. + Only one character of push-back is allowed. gzungetc() returns the + character pushed, or -1 on failure. gzungetc() will fail if a + character has been pushed but not read yet, or if c is -1. The pushed + character will be discarded if the stream is repositioned with gzseek() + or gzrewind(). +*/ + +ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush)); +/* + Flushes all pending output into the compressed file. The parameter + flush is as in the deflate() function. The return value is the zlib + error number (see function gzerror below). gzflush returns Z_OK if + the flush parameter is Z_FINISH and all output could be flushed. + gzflush should be called only when strictly necessary because it can + degrade compression. +*/ + +ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file, + z_off_t offset, int whence)); +/* + Sets the starting position for the next gzread or gzwrite on the + given compressed file. The offset represents a number of bytes in the + uncompressed data stream. The whence parameter is defined as in lseek(2); + the value SEEK_END is not supported. + If the file is opened for reading, this function is emulated but can be + extremely slow. If the file is opened for writing, only forward seeks are + supported; gzseek then compresses a sequence of zeroes up to the new + starting position. + + gzseek returns the resulting offset location as measured in bytes from + the beginning of the uncompressed stream, or -1 in case of error, in + particular if the file is opened for writing and the new starting position + would be before the current position. +*/ + +ZEXTERN int ZEXPORT gzrewind OF((gzFile file)); +/* + Rewinds the given file. This function is supported only for reading. + + gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET) +*/ + +ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file)); +/* + Returns the starting position for the next gzread or gzwrite on the + given compressed file. This position represents a number of bytes in the + uncompressed data stream. + + gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR) +*/ + +ZEXTERN int ZEXPORT gzeof OF((gzFile file)); +/* + Returns 1 when EOF has previously been detected reading the given + input stream, otherwise zero. +*/ + +ZEXTERN int ZEXPORT gzdirect OF((gzFile file)); +/* + Returns 1 if file is being read directly without decompression, otherwise + zero. +*/ + +ZEXTERN int ZEXPORT gzclose OF((gzFile file)); +/* + Flushes all pending output if necessary, closes the compressed file + and deallocates all the (de)compression state. The return value is the zlib + error number (see function gzerror below). +*/ + +ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum)); +/* + Returns the error message for the last error which occurred on the + given compressed file. errnum is set to zlib error number. If an + error occurred in the file system and not in the compression library, + errnum is set to Z_ERRNO and the application may consult errno + to get the exact error code. +*/ + +ZEXTERN void ZEXPORT gzclearerr OF((gzFile file)); +/* + Clears the error and end-of-file flags for file. This is analogous to the + clearerr() function in stdio. This is useful for continuing to read a gzip + file that is being written concurrently. +*/ + + /* checksum functions */ + +/* + These functions are not related to compression but are exported + anyway because they might be useful in applications using the + compression library. +*/ + +ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len)); +/* + Update a running Adler-32 checksum with the bytes buf[0..len-1] and + return the updated checksum. If buf is NULL, this function returns + the required initial value for the checksum. + An Adler-32 checksum is almost as reliable as a CRC32 but can be computed + much faster. Usage example: + + uLong adler = adler32(0L, Z_NULL, 0); + + while (read_buffer(buffer, length) != EOF) { + adler = adler32(adler, buffer, length); + } + if (adler != original_adler) error(); +*/ + +ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2, + z_off_t len2)); +/* + Combine two Adler-32 checksums into one. For two sequences of bytes, seq1 + and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for + each, adler1 and adler2. adler32_combine() returns the Adler-32 checksum of + seq1 and seq2 concatenated, requiring only adler1, adler2, and len2. +*/ + +ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len)); +/* + Update a running CRC-32 with the bytes buf[0..len-1] and return the + updated CRC-32. If buf is NULL, this function returns the required initial + value for the for the crc. Pre- and post-conditioning (one's complement) is + performed within this function so it shouldn't be done by the application. + Usage example: + + uLong crc = crc32(0L, Z_NULL, 0); + + while (read_buffer(buffer, length) != EOF) { + crc = crc32(crc, buffer, length); + } + if (crc != original_crc) error(); +*/ + +ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2)); + +/* + Combine two CRC-32 check values into one. For two sequences of bytes, + seq1 and seq2 with lengths len1 and len2, CRC-32 check values were + calculated for each, crc1 and crc2. crc32_combine() returns the CRC-32 + check value of seq1 and seq2 concatenated, requiring only crc1, crc2, and + len2. +*/ + + + /* various hacks, don't look :) */ + +/* deflateInit and inflateInit are macros to allow checking the zlib version + * and the compiler's view of z_stream: + */ +ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level, + const char *version, int stream_size)); +ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm, + const char *version, int stream_size)); +ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method, + int windowBits, int memLevel, + int strategy, const char *version, + int stream_size)); +ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits, + const char *version, int stream_size)); +ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits, + unsigned char FAR *window, + const char *version, + int stream_size)); +#define deflateInit(strm, level) \ + deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream)) +#define inflateInit(strm) \ + inflateInit_((strm), ZLIB_VERSION, sizeof(z_stream)) +#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \ + deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\ + (strategy), ZLIB_VERSION, sizeof(z_stream)) +#define inflateInit2(strm, windowBits) \ + inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream)) +#define inflateBackInit(strm, windowBits, window) \ + inflateBackInit_((strm), (windowBits), (window), \ + ZLIB_VERSION, sizeof(z_stream)) + + +#if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL) + struct internal_state {int dummy;}; /* hack for buggy compilers */ +#endif + +ZEXTERN const char * ZEXPORT zError OF((int)); +ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp z)); +ZEXTERN const uLongf * ZEXPORT get_crc_table OF((void)); + +#ifdef __cplusplus +} +#endif + +#endif /* ZLIB_H */ diff --git a/src/ChangeLog b/src/ChangeLog --- a/src/ChangeLog +++ b/src/ChangeLog @@ -1,3 +1,10 @@ +2010-06-18 + + * VirtualLeaf.pro: Changed default LIBXML2DIR, LIBICONVDIR and LIBZDIR to corresponding distribution lib directories. + * libplugin.pro: Ditto. + + * Makefile (clean): add if stmt not to `touch` on windows. + 2010-06-17 * VirtualLeaf.pro: Removed perl references. diff --git a/src/Makefile b/src/Makefile --- a/src/Makefile +++ b/src/Makefile @@ -2,28 +2,33 @@ QMAKE = qmake +# Set $(MAKE) to the name of the make command on your machine, e.g. 'make' on Linux and 'mingw32-make' on windows. +MAKE = make # mingw32-make + all: VirtualLeaf libplugin plugins VirtualLeaf: Makefile.VirtualLeaf - make -f Makefile.VirtualLeaf + $(MAKE) -f Makefile.VirtualLeaf Makefile.VirtualLeaf: VirtualLeaf.pro $(QMAKE) -makefile -o $@ $< libplugin: Makefile.libplugin - make -f Makefile.libplugin + $(MAKE) -f Makefile.libplugin Makefile.libplugin: libplugin.pro $(QMAKE) -makefile -o $@ $< plugins: - make -C build_models + $(MAKE) -C build_models clean: - make -f Makefile.libplugin clean - make -f Makefile.VirtualLeaf clean - make -C build_models clean + $(MAKE) -f Makefile.libplugin clean + $(MAKE) -f Makefile.VirtualLeaf clean + $(MAKE) -C build_models clean +ifeq ($(MAKE),make) touch VirtualLeaf.pro touch libplugin.pro +endif #finis diff --git a/src/VirtualLeaf.pro b/src/VirtualLeaf.pro --- a/src/VirtualLeaf.pro +++ b/src/VirtualLeaf.pro @@ -50,27 +50,13 @@ QT += qt3support win32 { CONFIG += console - LIBXML2DIR = C:\libxml2 - LIBICONVDIR = C:\libiconv - LIBZDIR = C:\libz + LIBXML2DIR = ..\lib\libxml2 + LIBICONVDIR = ..\lib\libiconv + LIBZDIR = ..\lib\libz GRAPHICS = qt RC_FILE = VirtualLeaf.rc QMAKE_CXXFLAGS += -DLIBXML_STATIC QMAKE_CXXFLAGS += -I$${LIBXML2DIR}\include -I$${LIBICONVDIR}\include -I$${LIBZDIR}\include - QMAKE_POST_LINK = "\ - C:\Bin\cp release\VirtualLeaf.exe \ - C:\Qt\4.5.3\bin\Qt3Support4.dll \ - C:\Qt\4.5.3\bin\QtGui4.dll \ - C:\Qt\4.5.3\bin\QtSql4.dll \ - C:\Qt\4.5.3\bin\QtXml4.dll \ - C:\Qt\4.5.3\bin\QtCore4.dll \ - C:\Qt\4.5.3\bin\QtNetwork4.dll \ - C:\Qt\4.5.3\bin\QtSvg4.dll \ - C:\bin\iconv.dll \ - C:\bin\libxml2.dll \ - C:\bin\zlib1.dll \ - C:\MinGW\bin\mingwm10.dll \ - $${DESTDIR}" LIBS += -L$${LIBXML2DIR}\lib -lxml2 -L$${LIBICONVDIR}\lib -L$${LIBZDIR}\lib -lz -lm -lwsock32 -liconv } diff --git a/src/build_models/ChangeLog b/src/build_models/ChangeLog --- a/src/build_models/ChangeLog +++ b/src/build_models/ChangeLog @@ -1,3 +1,12 @@ +2010-06-18 + + * plugin_auxingrowth.pro: Changed default LIBXML2DIR, LIBICONVDIR and LIBZDIR to corresponding distribution lib directories. + * plugin_meinhardt.pro: Ditto. + * plugin_test.pro: Ditto. + + * Makefile (clean): add if stmt not to `touch` on windows. + + 2010-06-15 diff --git a/src/build_models/Makefile b/src/build_models/Makefile --- a/src/build_models/Makefile +++ b/src/build_models/Makefile @@ -2,32 +2,37 @@ QMAKE = qmake +# Set $(MAKE) to the name of the make command on your machine, e.g. 'make' on Linux and 'mingw32-make' on windows. +MAKE = make # mingw32-make + all: plugin_auxingrowth plugin_meinhardt plugin_test plugin_auxingrowth: Makefile.plugin_auxingrowth - make -f Makefile.plugin_auxingrowth + $(MAKE) -f Makefile.plugin_auxingrowth Makefile.plugin_auxingrowth: plugin_auxingrowth.pro $(QMAKE) -makefile -o $@ $< plugin_meinhardt: Makefile.plugin_meinhardt - make -f Makefile.plugin_meinhardt + $(MAKE) -f Makefile.plugin_meinhardt Makefile.plugin_meinhardt: plugin_meinhardt.pro $(QMAKE) -makefile -o $@ $< plugin_test: Makefile.plugin_test - make -f Makefile.plugin_test + $(MAKE) -f Makefile.plugin_test Makefile.plugin_test: plugin_test.pro $(QMAKE) -makefile -o $@ $< clean: - make -f Makefile.plugin_auxingrowth clean - make -f Makefile.plugin_meinhardt clean - make -f Makefile.plugin_test clean + $(MAKE) -f Makefile.plugin_auxingrowth clean + $(MAKE) -f Makefile.plugin_meinhardt clean + $(MAKE) -f Makefile.plugin_test clean +ifeq ($(MAKE),make) touch plugin_auxingrowth.pro touch plugin_meinhardt.pro touch plugin_test.pro +endif #finis diff --git a/src/build_models/plugin_auxingrowth.pro b/src/build_models/plugin_auxingrowth.pro --- a/src/build_models/plugin_auxingrowth.pro +++ b/src/build_models/plugin_auxingrowth.pro @@ -44,9 +44,9 @@ unix { } win32 { - LIBXML2DIR = C:\libxml2 - LIBICONVDIR = C:\libiconv - LIBZDIR = C:\libz + LIBXML2DIR = ..\..\lib\libxml2 + LIBICONVDIR = ..\..\lib\libiconv + LIBZDIR = ..\..\lib\libz LIBS += -L$${LIBDIR} -Llib -lvleaf QMAKE_CXXFLAGS += -DLIBXML_STATIC QMAKE_CXXFLAGS += -I$${LIBXML2DIR}\include -I$${LIBICONVDIR}\include -I$${LIBZDIR}\include diff --git a/src/build_models/plugin_meinhardt.pro b/src/build_models/plugin_meinhardt.pro --- a/src/build_models/plugin_meinhardt.pro +++ b/src/build_models/plugin_meinhardt.pro @@ -44,9 +44,9 @@ unix { } win32 { - LIBXML2DIR = C:\libxml2 - LIBICONVDIR = C:\libiconv - LIBZDIR = C:\libz + LIBXML2DIR = ..\..\lib\libxml2 + LIBICONVDIR = ..\..\lib\libiconv + LIBZDIR = ..\..\lib\libz LIBS += -L$${LIBDIR} -Llib -lvleaf QMAKE_CXXFLAGS += -DLIBXML_STATIC QMAKE_CXXFLAGS += -I$${LIBXML2DIR}\include -I$${LIBICONVDIR}\include -I$${LIBZDIR}\include diff --git a/src/build_models/plugin_test.pro b/src/build_models/plugin_test.pro --- a/src/build_models/plugin_test.pro +++ b/src/build_models/plugin_test.pro @@ -44,9 +44,9 @@ unix { } win32 { - LIBXML2DIR = C:\libxml2 - LIBICONVDIR = C:\libiconv - LIBZDIR = C:\libz + LIBXML2DIR = ..\..\lib\libxml2 + LIBICONVDIR = ..\..\lib\libiconv + LIBZDIR = ..\..\lib\libz LIBS += -L$${LIBDIR} -Llib -lvleaf QMAKE_CXXFLAGS += -DLIBXML_STATIC QMAKE_CXXFLAGS += -I$${LIBXML2DIR}\include -I$${LIBICONVDIR}\include -I$${LIBZDIR}\include diff --git a/src/libplugin.pro b/src/libplugin.pro --- a/src/libplugin.pro +++ b/src/libplugin.pro @@ -68,9 +68,9 @@ unix { } win32 { - LIBXML2DIR = C:\libxml2 - LIBICONVDIR = C:\libiconv - LIBZDIR = C:\libz + LIBXML2DIR = ..\lib\libxml2 + LIBICONVDIR = ..\lib\libiconv + LIBZDIR = ..\lib\libz QMAKE_CXXFLAGS += -DLIBXML_STATIC QMAKE_CXXFLAGS += -I$${LIBXML2DIR}\include -I$${LIBICONVDIR}\include -I$${LIBZDIR}\include }