http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/7956696e/thirdparty/libxml2/depcomp ---------------------------------------------------------------------- diff --git a/thirdparty/libxml2/depcomp b/thirdparty/libxml2/depcomp new file mode 100755 index 0000000..fc98710 --- /dev/null +++ b/thirdparty/libxml2/depcomp @@ -0,0 +1,791 @@ +#! /bin/sh +# depcomp - compile a program generating dependencies as side-effects + +scriptversion=2013-05-30.07; # UTC + +# Copyright (C) 1999-2014 Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 2, or (at your option) +# any later version. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. + +# As a special exception to the GNU General Public License, if you +# distribute this file as part of a program that contains a +# configuration script generated by Autoconf, you may include it under +# the same distribution terms that you use for the rest of that program. + +# Originally written by Alexandre Oliva <[email protected]>. + +case $1 in + '') + echo "$0: No command. Try '$0 --help' for more information." 1>&2 + exit 1; + ;; + -h | --h*) + cat <<\EOF +Usage: depcomp [--help] [--version] PROGRAM [ARGS] + +Run PROGRAMS ARGS to compile a file, generating dependencies +as side-effects. + +Environment variables: + depmode Dependency tracking mode. + source Source file read by 'PROGRAMS ARGS'. + object Object file output by 'PROGRAMS ARGS'. + DEPDIR directory where to store dependencies. + depfile Dependency file to output. + tmpdepfile Temporary file to use when outputting dependencies. + libtool Whether libtool is used (yes/no). + +Report bugs to <[email protected]>. +EOF + exit $? + ;; + -v | --v*) + echo "depcomp $scriptversion" + exit $? + ;; +esac + +# Get the directory component of the given path, and save it in the +# global variables '$dir'. Note that this directory component will +# be either empty or ending with a '/' character. This is deliberate. +set_dir_from () +{ + case $1 in + */*) dir=`echo "$1" | sed -e 's|/[^/]*$|/|'`;; + *) dir=;; + esac +} + +# Get the suffix-stripped basename of the given path, and save it the +# global variable '$base'. +set_base_from () +{ + base=`echo "$1" | sed -e 's|^.*/||' -e 's/\.[^.]*$//'` +} + +# If no dependency file was actually created by the compiler invocation, +# we still have to create a dummy depfile, to avoid errors with the +# Makefile "include basename.Plo" scheme. +make_dummy_depfile () +{ + echo "#dummy" > "$depfile" +} + +# Factor out some common post-processing of the generated depfile. +# Requires the auxiliary global variable '$tmpdepfile' to be set. +aix_post_process_depfile () +{ + # If the compiler actually managed to produce a dependency file, + # post-process it. + if test -f "$tmpdepfile"; then + # Each line is of the form 'foo.o: dependency.h'. + # Do two passes, one to just change these to + # $object: dependency.h + # and one to simply output + # dependency.h: + # which is needed to avoid the deleted-header problem. + { sed -e "s,^.*\.[$lower]*:,$object:," < "$tmpdepfile" + sed -e "s,^.*\.[$lower]*:[$tab ]*,," -e 's,$,:,' < "$tmpdepfile" + } > "$depfile" + rm -f "$tmpdepfile" + else + make_dummy_depfile + fi +} + +# A tabulation character. +tab=' ' +# A newline character. +nl=' +' +# Character ranges might be problematic outside the C locale. +# These definitions help. +upper=ABCDEFGHIJKLMNOPQRSTUVWXYZ +lower=abcdefghijklmnopqrstuvwxyz +digits=0123456789 +alpha=${upper}${lower} + +if test -z "$depmode" || test -z "$source" || test -z "$object"; then + echo "depcomp: Variables source, object and depmode must be set" 1>&2 + exit 1 +fi + +# Dependencies for sub/bar.o or sub/bar.obj go into sub/.deps/bar.Po. +depfile=${depfile-`echo "$object" | + sed 's|[^\\/]*$|'${DEPDIR-.deps}'/&|;s|\.\([^.]*\)$|.P\1|;s|Pobj$|Po|'`} +tmpdepfile=${tmpdepfile-`echo "$depfile" | sed 's/\.\([^.]*\)$/.T\1/'`} + +rm -f "$tmpdepfile" + +# Avoid interferences from the environment. +gccflag= dashmflag= + +# Some modes work just like other modes, but use different flags. We +# parameterize here, but still list the modes in the big case below, +# to make depend.m4 easier to write. Note that we *cannot* use a case +# here, because this file can only contain one case statement. +if test "$depmode" = hp; then + # HP compiler uses -M and no extra arg. + gccflag=-M + depmode=gcc +fi + +if test "$depmode" = dashXmstdout; then + # This is just like dashmstdout with a different argument. + dashmflag=-xM + depmode=dashmstdout +fi + +cygpath_u="cygpath -u -f -" +if test "$depmode" = msvcmsys; then + # This is just like msvisualcpp but w/o cygpath translation. + # Just convert the backslash-escaped backslashes to single forward + # slashes to satisfy depend.m4 + cygpath_u='sed s,\\\\,/,g' + depmode=msvisualcpp +fi + +if test "$depmode" = msvc7msys; then + # This is just like msvc7 but w/o cygpath translation. + # Just convert the backslash-escaped backslashes to single forward + # slashes to satisfy depend.m4 + cygpath_u='sed s,\\\\,/,g' + depmode=msvc7 +fi + +if test "$depmode" = xlc; then + # IBM C/C++ Compilers xlc/xlC can output gcc-like dependency information. + gccflag=-qmakedep=gcc,-MF + depmode=gcc +fi + +case "$depmode" in +gcc3) +## gcc 3 implements dependency tracking that does exactly what +## we want. Yay! Note: for some reason libtool 1.4 doesn't like +## it if -MD -MP comes after the -MF stuff. Hmm. +## Unfortunately, FreeBSD c89 acceptance of flags depends upon +## the command line argument order; so add the flags where they +## appear in depend2.am. Note that the slowdown incurred here +## affects only configure: in makefiles, %FASTDEP% shortcuts this. + for arg + do + case $arg in + -c) set fnord "$@" -MT "$object" -MD -MP -MF "$tmpdepfile" "$arg" ;; + *) set fnord "$@" "$arg" ;; + esac + shift # fnord + shift # $arg + done + "$@" + stat=$? + if test $stat -ne 0; then + rm -f "$tmpdepfile" + exit $stat + fi + mv "$tmpdepfile" "$depfile" + ;; + +gcc) +## Note that this doesn't just cater to obsosete pre-3.x GCC compilers. +## but also to in-use compilers like IMB xlc/xlC and the HP C compiler. +## (see the conditional assignment to $gccflag above). +## There are various ways to get dependency output from gcc. Here's +## why we pick this rather obscure method: +## - Don't want to use -MD because we'd like the dependencies to end +## up in a subdir. Having to rename by hand is ugly. +## (We might end up doing this anyway to support other compilers.) +## - The DEPENDENCIES_OUTPUT environment variable makes gcc act like +## -MM, not -M (despite what the docs say). Also, it might not be +## supported by the other compilers which use the 'gcc' depmode. +## - Using -M directly means running the compiler twice (even worse +## than renaming). + if test -z "$gccflag"; then + gccflag=-MD, + fi + "$@" -Wp,"$gccflag$tmpdepfile" + stat=$? + if test $stat -ne 0; then + rm -f "$tmpdepfile" + exit $stat + fi + rm -f "$depfile" + echo "$object : \\" > "$depfile" + # The second -e expression handles DOS-style file names with drive + # letters. + sed -e 's/^[^:]*: / /' \ + -e 's/^['$alpha']:\/[^:]*: / /' < "$tmpdepfile" >> "$depfile" +## This next piece of magic avoids the "deleted header file" problem. +## The problem is that when a header file which appears in a .P file +## is deleted, the dependency causes make to die (because there is +## typically no way to rebuild the header). We avoid this by adding +## dummy dependencies for each header file. Too bad gcc doesn't do +## this for us directly. +## Some versions of gcc put a space before the ':'. On the theory +## that the space means something, we add a space to the output as +## well. hp depmode also adds that space, but also prefixes the VPATH +## to the object. Take care to not repeat it in the output. +## Some versions of the HPUX 10.20 sed can't process this invocation +## correctly. Breaking it into two sed invocations is a workaround. + tr ' ' "$nl" < "$tmpdepfile" \ + | sed -e 's/^\\$//' -e '/^$/d' -e "s|.*$object$||" -e '/:$/d' \ + | sed -e 's/$/ :/' >> "$depfile" + rm -f "$tmpdepfile" + ;; + +hp) + # This case exists only to let depend.m4 do its work. It works by + # looking at the text of this script. This case will never be run, + # since it is checked for above. + exit 1 + ;; + +sgi) + if test "$libtool" = yes; then + "$@" "-Wp,-MDupdate,$tmpdepfile" + else + "$@" -MDupdate "$tmpdepfile" + fi + stat=$? + if test $stat -ne 0; then + rm -f "$tmpdepfile" + exit $stat + fi + rm -f "$depfile" + + if test -f "$tmpdepfile"; then # yes, the sourcefile depend on other files + echo "$object : \\" > "$depfile" + # Clip off the initial element (the dependent). Don't try to be + # clever and replace this with sed code, as IRIX sed won't handle + # lines with more than a fixed number of characters (4096 in + # IRIX 6.2 sed, 8192 in IRIX 6.5). We also remove comment lines; + # the IRIX cc adds comments like '#:fec' to the end of the + # dependency line. + tr ' ' "$nl" < "$tmpdepfile" \ + | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' \ + | tr "$nl" ' ' >> "$depfile" + echo >> "$depfile" + # The second pass generates a dummy entry for each header file. + tr ' ' "$nl" < "$tmpdepfile" \ + | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' -e 's/$/:/' \ + >> "$depfile" + else + make_dummy_depfile + fi + rm -f "$tmpdepfile" + ;; + +xlc) + # This case exists only to let depend.m4 do its work. It works by + # looking at the text of this script. This case will never be run, + # since it is checked for above. + exit 1 + ;; + +aix) + # The C for AIX Compiler uses -M and outputs the dependencies + # in a .u file. In older versions, this file always lives in the + # current directory. Also, the AIX compiler puts '$object:' at the + # start of each line; $object doesn't have directory information. + # Version 6 uses the directory in both cases. + set_dir_from "$object" + set_base_from "$object" + if test "$libtool" = yes; then + tmpdepfile1=$dir$base.u + tmpdepfile2=$base.u + tmpdepfile3=$dir.libs/$base.u + "$@" -Wc,-M + else + tmpdepfile1=$dir$base.u + tmpdepfile2=$dir$base.u + tmpdepfile3=$dir$base.u + "$@" -M + fi + stat=$? + if test $stat -ne 0; then + rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" + exit $stat + fi + + for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" + do + test -f "$tmpdepfile" && break + done + aix_post_process_depfile + ;; + +tcc) + # tcc (Tiny C Compiler) understand '-MD -MF file' since version 0.9.26 + # FIXME: That version still under development at the moment of writing. + # Make that this statement remains true also for stable, released + # versions. + # It will wrap lines (doesn't matter whether long or short) with a + # trailing '\', as in: + # + # foo.o : \ + # foo.c \ + # foo.h \ + # + # It will put a trailing '\' even on the last line, and will use leading + # spaces rather than leading tabs (at least since its commit 0394caf7 + # "Emit spaces for -MD"). + "$@" -MD -MF "$tmpdepfile" + stat=$? + if test $stat -ne 0; then + rm -f "$tmpdepfile" + exit $stat + fi + rm -f "$depfile" + # Each non-empty line is of the form 'foo.o : \' or ' dep.h \'. + # We have to change lines of the first kind to '$object: \'. + sed -e "s|.*:|$object :|" < "$tmpdepfile" > "$depfile" + # And for each line of the second kind, we have to emit a 'dep.h:' + # dummy dependency, to avoid the deleted-header problem. + sed -n -e 's|^ *\(.*\) *\\$|\1:|p' < "$tmpdepfile" >> "$depfile" + rm -f "$tmpdepfile" + ;; + +## The order of this option in the case statement is important, since the +## shell code in configure will try each of these formats in the order +## listed in this file. A plain '-MD' option would be understood by many +## compilers, so we must ensure this comes after the gcc and icc options. +pgcc) + # Portland's C compiler understands '-MD'. + # Will always output deps to 'file.d' where file is the root name of the + # source file under compilation, even if file resides in a subdirectory. + # The object file name does not affect the name of the '.d' file. + # pgcc 10.2 will output + # foo.o: sub/foo.c sub/foo.h + # and will wrap long lines using '\' : + # foo.o: sub/foo.c ... \ + # sub/foo.h ... \ + # ... + set_dir_from "$object" + # Use the source, not the object, to determine the base name, since + # that's sadly what pgcc will do too. + set_base_from "$source" + tmpdepfile=$base.d + + # For projects that build the same source file twice into different object + # files, the pgcc approach of using the *source* file root name can cause + # problems in parallel builds. Use a locking strategy to avoid stomping on + # the same $tmpdepfile. + lockdir=$base.d-lock + trap " + echo '$0: caught signal, cleaning up...' >&2 + rmdir '$lockdir' + exit 1 + " 1 2 13 15 + numtries=100 + i=$numtries + while test $i -gt 0; do + # mkdir is a portable test-and-set. + if mkdir "$lockdir" 2>/dev/null; then + # This process acquired the lock. + "$@" -MD + stat=$? + # Release the lock. + rmdir "$lockdir" + break + else + # If the lock is being held by a different process, wait + # until the winning process is done or we timeout. + while test -d "$lockdir" && test $i -gt 0; do + sleep 1 + i=`expr $i - 1` + done + fi + i=`expr $i - 1` + done + trap - 1 2 13 15 + if test $i -le 0; then + echo "$0: failed to acquire lock after $numtries attempts" >&2 + echo "$0: check lockdir '$lockdir'" >&2 + exit 1 + fi + + if test $stat -ne 0; then + rm -f "$tmpdepfile" + exit $stat + fi + rm -f "$depfile" + # Each line is of the form `foo.o: dependent.h', + # or `foo.o: dep1.h dep2.h \', or ` dep3.h dep4.h \'. + # Do two passes, one to just change these to + # `$object: dependent.h' and one to simply `dependent.h:'. + sed "s,^[^:]*:,$object :," < "$tmpdepfile" > "$depfile" + # Some versions of the HPUX 10.20 sed can't process this invocation + # correctly. Breaking it into two sed invocations is a workaround. + sed 's,^[^:]*: \(.*\)$,\1,;s/^\\$//;/^$/d;/:$/d' < "$tmpdepfile" \ + | sed -e 's/$/ :/' >> "$depfile" + rm -f "$tmpdepfile" + ;; + +hp2) + # The "hp" stanza above does not work with aCC (C++) and HP's ia64 + # compilers, which have integrated preprocessors. The correct option + # to use with these is +Maked; it writes dependencies to a file named + # 'foo.d', which lands next to the object file, wherever that + # happens to be. + # Much of this is similar to the tru64 case; see comments there. + set_dir_from "$object" + set_base_from "$object" + if test "$libtool" = yes; then + tmpdepfile1=$dir$base.d + tmpdepfile2=$dir.libs/$base.d + "$@" -Wc,+Maked + else + tmpdepfile1=$dir$base.d + tmpdepfile2=$dir$base.d + "$@" +Maked + fi + stat=$? + if test $stat -ne 0; then + rm -f "$tmpdepfile1" "$tmpdepfile2" + exit $stat + fi + + for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" + do + test -f "$tmpdepfile" && break + done + if test -f "$tmpdepfile"; then + sed -e "s,^.*\.[$lower]*:,$object:," "$tmpdepfile" > "$depfile" + # Add 'dependent.h:' lines. + sed -ne '2,${ + s/^ *// + s/ \\*$// + s/$/:/ + p + }' "$tmpdepfile" >> "$depfile" + else + make_dummy_depfile + fi + rm -f "$tmpdepfile" "$tmpdepfile2" + ;; + +tru64) + # The Tru64 compiler uses -MD to generate dependencies as a side + # effect. 'cc -MD -o foo.o ...' puts the dependencies into 'foo.o.d'. + # At least on Alpha/Redhat 6.1, Compaq CCC V6.2-504 seems to put + # dependencies in 'foo.d' instead, so we check for that too. + # Subdirectories are respected. + set_dir_from "$object" + set_base_from "$object" + + if test "$libtool" = yes; then + # Libtool generates 2 separate objects for the 2 libraries. These + # two compilations output dependencies in $dir.libs/$base.o.d and + # in $dir$base.o.d. We have to check for both files, because + # one of the two compilations can be disabled. We should prefer + # $dir$base.o.d over $dir.libs/$base.o.d because the latter is + # automatically cleaned when .libs/ is deleted, while ignoring + # the former would cause a distcleancheck panic. + tmpdepfile1=$dir$base.o.d # libtool 1.5 + tmpdepfile2=$dir.libs/$base.o.d # Likewise. + tmpdepfile3=$dir.libs/$base.d # Compaq CCC V6.2-504 + "$@" -Wc,-MD + else + tmpdepfile1=$dir$base.d + tmpdepfile2=$dir$base.d + tmpdepfile3=$dir$base.d + "$@" -MD + fi + + stat=$? + if test $stat -ne 0; then + rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" + exit $stat + fi + + for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" + do + test -f "$tmpdepfile" && break + done + # Same post-processing that is required for AIX mode. + aix_post_process_depfile + ;; + +msvc7) + if test "$libtool" = yes; then + showIncludes=-Wc,-showIncludes + else + showIncludes=-showIncludes + fi + "$@" $showIncludes > "$tmpdepfile" + stat=$? + grep -v '^Note: including file: ' "$tmpdepfile" + if test $stat -ne 0; then + rm -f "$tmpdepfile" + exit $stat + fi + rm -f "$depfile" + echo "$object : \\" > "$depfile" + # The first sed program below extracts the file names and escapes + # backslashes for cygpath. The second sed program outputs the file + # name when reading, but also accumulates all include files in the + # hold buffer in order to output them again at the end. This only + # works with sed implementations that can handle large buffers. + sed < "$tmpdepfile" -n ' +/^Note: including file: *\(.*\)/ { + s//\1/ + s/\\/\\\\/g + p +}' | $cygpath_u | sort -u | sed -n ' +s/ /\\ /g +s/\(.*\)/'"$tab"'\1 \\/p +s/.\(.*\) \\/\1:/ +H +$ { + s/.*/'"$tab"'/ + G + p +}' >> "$depfile" + echo >> "$depfile" # make sure the fragment doesn't end with a backslash + rm -f "$tmpdepfile" + ;; + +msvc7msys) + # This case exists only to let depend.m4 do its work. It works by + # looking at the text of this script. This case will never be run, + # since it is checked for above. + exit 1 + ;; + +#nosideeffect) + # This comment above is used by automake to tell side-effect + # dependency tracking mechanisms from slower ones. + +dashmstdout) + # Important note: in order to support this mode, a compiler *must* + # always write the preprocessed file to stdout, regardless of -o. + "$@" || exit $? + + # Remove the call to Libtool. + if test "$libtool" = yes; then + while test "X$1" != 'X--mode=compile'; do + shift + done + shift + fi + + # Remove '-o $object'. + IFS=" " + for arg + do + case $arg in + -o) + shift + ;; + $object) + shift + ;; + *) + set fnord "$@" "$arg" + shift # fnord + shift # $arg + ;; + esac + done + + test -z "$dashmflag" && dashmflag=-M + # Require at least two characters before searching for ':' + # in the target name. This is to cope with DOS-style filenames: + # a dependency such as 'c:/foo/bar' could be seen as target 'c' otherwise. + "$@" $dashmflag | + sed "s|^[$tab ]*[^:$tab ][^:][^:]*:[$tab ]*|$object: |" > "$tmpdepfile" + rm -f "$depfile" + cat < "$tmpdepfile" > "$depfile" + # Some versions of the HPUX 10.20 sed can't process this sed invocation + # correctly. Breaking it into two sed invocations is a workaround. + tr ' ' "$nl" < "$tmpdepfile" \ + | sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' \ + | sed -e 's/$/ :/' >> "$depfile" + rm -f "$tmpdepfile" + ;; + +dashXmstdout) + # This case only exists to satisfy depend.m4. It is never actually + # run, as this mode is specially recognized in the preamble. + exit 1 + ;; + +makedepend) + "$@" || exit $? + # Remove any Libtool call + if test "$libtool" = yes; then + while test "X$1" != 'X--mode=compile'; do + shift + done + shift + fi + # X makedepend + shift + cleared=no eat=no + for arg + do + case $cleared in + no) + set ""; shift + cleared=yes ;; + esac + if test $eat = yes; then + eat=no + continue + fi + case "$arg" in + -D*|-I*) + set fnord "$@" "$arg"; shift ;; + # Strip any option that makedepend may not understand. Remove + # the object too, otherwise makedepend will parse it as a source file. + -arch) + eat=yes ;; + -*|$object) + ;; + *) + set fnord "$@" "$arg"; shift ;; + esac + done + obj_suffix=`echo "$object" | sed 's/^.*\././'` + touch "$tmpdepfile" + ${MAKEDEPEND-makedepend} -o"$obj_suffix" -f"$tmpdepfile" "$@" + rm -f "$depfile" + # makedepend may prepend the VPATH from the source file name to the object. + # No need to regex-escape $object, excess matching of '.' is harmless. + sed "s|^.*\($object *:\)|\1|" "$tmpdepfile" > "$depfile" + # Some versions of the HPUX 10.20 sed can't process the last invocation + # correctly. Breaking it into two sed invocations is a workaround. + sed '1,2d' "$tmpdepfile" \ + | tr ' ' "$nl" \ + | sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' \ + | sed -e 's/$/ :/' >> "$depfile" + rm -f "$tmpdepfile" "$tmpdepfile".bak + ;; + +cpp) + # Important note: in order to support this mode, a compiler *must* + # always write the preprocessed file to stdout. + "$@" || exit $? + + # Remove the call to Libtool. + if test "$libtool" = yes; then + while test "X$1" != 'X--mode=compile'; do + shift + done + shift + fi + + # Remove '-o $object'. + IFS=" " + for arg + do + case $arg in + -o) + shift + ;; + $object) + shift + ;; + *) + set fnord "$@" "$arg" + shift # fnord + shift # $arg + ;; + esac + done + + "$@" -E \ + | sed -n -e '/^# [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \ + -e '/^#line [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \ + | sed '$ s: \\$::' > "$tmpdepfile" + rm -f "$depfile" + echo "$object : \\" > "$depfile" + cat < "$tmpdepfile" >> "$depfile" + sed < "$tmpdepfile" '/^$/d;s/^ //;s/ \\$//;s/$/ :/' >> "$depfile" + rm -f "$tmpdepfile" + ;; + +msvisualcpp) + # Important note: in order to support this mode, a compiler *must* + # always write the preprocessed file to stdout. + "$@" || exit $? + + # Remove the call to Libtool. + if test "$libtool" = yes; then + while test "X$1" != 'X--mode=compile'; do + shift + done + shift + fi + + IFS=" " + for arg + do + case "$arg" in + -o) + shift + ;; + $object) + shift + ;; + "-Gm"|"/Gm"|"-Gi"|"/Gi"|"-ZI"|"/ZI") + set fnord "$@" + shift + shift + ;; + *) + set fnord "$@" "$arg" + shift + shift + ;; + esac + done + "$@" -E 2>/dev/null | + sed -n '/^#line [0-9][0-9]* "\([^"]*\)"/ s::\1:p' | $cygpath_u | sort -u > "$tmpdepfile" + rm -f "$depfile" + echo "$object : \\" > "$depfile" + sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::'"$tab"'\1 \\:p' >> "$depfile" + echo "$tab" >> "$depfile" + sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::\1\::p' >> "$depfile" + rm -f "$tmpdepfile" + ;; + +msvcmsys) + # This case exists only to let depend.m4 do its work. It works by + # looking at the text of this script. This case will never be run, + # since it is checked for above. + exit 1 + ;; + +none) + exec "$@" + ;; + +*) + echo "Unknown depmode $depmode" 1>&2 + exit 1 + ;; +esac + +exit 0 + +# Local Variables: +# mode: shell-script +# sh-indentation: 2 +# eval: (add-hook 'write-file-hooks 'time-stamp) +# time-stamp-start: "scriptversion=" +# time-stamp-format: "%:y-%02m-%02d.%02H" +# time-stamp-time-zone: "UTC" +# time-stamp-end: "; # UTC" +# End:
http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/7956696e/thirdparty/libxml2/dict.c ---------------------------------------------------------------------- diff --git a/thirdparty/libxml2/dict.c b/thirdparty/libxml2/dict.c new file mode 100644 index 0000000..8c8f931 --- /dev/null +++ b/thirdparty/libxml2/dict.c @@ -0,0 +1,1262 @@ +/* + * dict.c: dictionary of reusable strings, just used to avoid allocation + * and freeing operations. + * + * Copyright (C) 2003-2012 Daniel Veillard. + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF + * MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE AUTHORS AND + * CONTRIBUTORS ACCEPT NO RESPONSIBILITY IN ANY CONCEIVABLE MANNER. + * + * Author: [email protected] + */ + +#define IN_LIBXML +#include "libxml.h" + +#include <limits.h> +#ifdef HAVE_STDLIB_H +#include <stdlib.h> +#endif +#ifdef HAVE_TIME_H +#include <time.h> +#endif + +/* + * Following http://www.ocert.org/advisories/ocert-2011-003.html + * it seems that having hash randomization might be a good idea + * when using XML with untrusted data + * Note1: that it works correctly only if compiled with WITH_BIG_KEY + * which is the default. + * Note2: the fast function used for a small dict won't protect very + * well but since the attack is based on growing a very big hash + * list we will use the BigKey algo as soon as the hash size grows + * over MIN_DICT_SIZE so this actually works + */ +#if defined(HAVE_RAND) && defined(HAVE_SRAND) && defined(HAVE_TIME) +#define DICT_RANDOMIZATION +#endif + +#include <string.h> +#ifdef HAVE_STDINT_H +#include <stdint.h> +#else +#ifdef HAVE_INTTYPES_H +#include <inttypes.h> +#elif defined(WIN32) +typedef unsigned __int32 uint32_t; +#endif +#endif +#include <libxml/tree.h> +#include <libxml/dict.h> +#include <libxml/xmlmemory.h> +#include <libxml/xmlerror.h> +#include <libxml/globals.h> + +/* #define DEBUG_GROW */ +/* #define DICT_DEBUG_PATTERNS */ + +#define MAX_HASH_LEN 3 +#define MIN_DICT_SIZE 128 +#define MAX_DICT_HASH 8 * 2048 +#define WITH_BIG_KEY + +#ifdef WITH_BIG_KEY +#define xmlDictComputeKey(dict, name, len) \ + (((dict)->size == MIN_DICT_SIZE) ? \ + xmlDictComputeFastKey(name, len, (dict)->seed) : \ + xmlDictComputeBigKey(name, len, (dict)->seed)) + +#define xmlDictComputeQKey(dict, prefix, plen, name, len) \ + (((prefix) == NULL) ? \ + (xmlDictComputeKey(dict, name, len)) : \ + (((dict)->size == MIN_DICT_SIZE) ? \ + xmlDictComputeFastQKey(prefix, plen, name, len, (dict)->seed) : \ + xmlDictComputeBigQKey(prefix, plen, name, len, (dict)->seed))) + +#else /* !WITH_BIG_KEY */ +#define xmlDictComputeKey(dict, name, len) \ + xmlDictComputeFastKey(name, len, (dict)->seed) +#define xmlDictComputeQKey(dict, prefix, plen, name, len) \ + xmlDictComputeFastQKey(prefix, plen, name, len, (dict)->seed) +#endif /* WITH_BIG_KEY */ + +/* + * An entry in the dictionnary + */ +typedef struct _xmlDictEntry xmlDictEntry; +typedef xmlDictEntry *xmlDictEntryPtr; +struct _xmlDictEntry { + struct _xmlDictEntry *next; + const xmlChar *name; + unsigned int len; + int valid; + unsigned long okey; +}; + +typedef struct _xmlDictStrings xmlDictStrings; +typedef xmlDictStrings *xmlDictStringsPtr; +struct _xmlDictStrings { + xmlDictStringsPtr next; + xmlChar *free; + xmlChar *end; + size_t size; + size_t nbStrings; + xmlChar array[1]; +}; +/* + * The entire dictionnary + */ +struct _xmlDict { + int ref_counter; + + struct _xmlDictEntry *dict; + size_t size; + unsigned int nbElems; + xmlDictStringsPtr strings; + + struct _xmlDict *subdict; + /* used for randomization */ + int seed; + /* used to impose a limit on size */ + size_t limit; +}; + +/* + * A mutex for modifying the reference counter for shared + * dictionaries. + */ +static xmlRMutexPtr xmlDictMutex = NULL; + +/* + * Whether the dictionary mutex was initialized. + */ +static int xmlDictInitialized = 0; + +#ifdef DICT_RANDOMIZATION +#ifdef HAVE_RAND_R +/* + * Internal data for random function, protected by xmlDictMutex + */ +static unsigned int rand_seed = 0; +#endif +#endif + +/** + * xmlInitializeDict: + * + * Do the dictionary mutex initialization. + * this function is deprecated + * + * Returns 0 if initialization was already done, and 1 if that + * call led to the initialization + */ +int xmlInitializeDict(void) { + return(0); +} + +/** + * __xmlInitializeDict: + * + * This function is not public + * Do the dictionary mutex initialization. + * this function is not thread safe, initialization should + * normally be done once at setup when called from xmlOnceInit() + * we may also land in this code if thread support is not compiled in + * + * Returns 0 if initialization was already done, and 1 if that + * call led to the initialization + */ +int __xmlInitializeDict(void) { + if (xmlDictInitialized) + return(1); + + if ((xmlDictMutex = xmlNewRMutex()) == NULL) + return(0); + xmlRMutexLock(xmlDictMutex); + +#ifdef DICT_RANDOMIZATION +#ifdef HAVE_RAND_R + rand_seed = time(NULL); + rand_r(& rand_seed); +#else + srand(time(NULL)); +#endif +#endif + xmlDictInitialized = 1; + xmlRMutexUnlock(xmlDictMutex); + return(1); +} + +#ifdef DICT_RANDOMIZATION +int __xmlRandom(void) { + int ret; + + if (xmlDictInitialized == 0) + __xmlInitializeDict(); + + xmlRMutexLock(xmlDictMutex); +#ifdef HAVE_RAND_R + ret = rand_r(& rand_seed); +#else + ret = rand(); +#endif + xmlRMutexUnlock(xmlDictMutex); + return(ret); +} +#endif + +/** + * xmlDictCleanup: + * + * Free the dictionary mutex. Do not call unless sure the library + * is not in use anymore ! + */ +void +xmlDictCleanup(void) { + if (!xmlDictInitialized) + return; + + xmlFreeRMutex(xmlDictMutex); + + xmlDictInitialized = 0; +} + +/* + * xmlDictAddString: + * @dict: the dictionnary + * @name: the name of the userdata + * @len: the length of the name + * + * Add the string to the array[s] + * + * Returns the pointer of the local string, or NULL in case of error. + */ +static const xmlChar * +xmlDictAddString(xmlDictPtr dict, const xmlChar *name, unsigned int namelen) { + xmlDictStringsPtr pool; + const xmlChar *ret; + size_t size = 0; /* + sizeof(_xmlDictStrings) == 1024 */ + size_t limit = 0; + +#ifdef DICT_DEBUG_PATTERNS + fprintf(stderr, "-"); +#endif + pool = dict->strings; + while (pool != NULL) { + if (pool->end - pool->free > namelen) + goto found_pool; + if (pool->size > size) size = pool->size; + limit += pool->size; + pool = pool->next; + } + /* + * Not found, need to allocate + */ + if (pool == NULL) { + if ((dict->limit > 0) && (limit > dict->limit)) { + return(NULL); + } + + if (size == 0) size = 1000; + else size *= 4; /* exponential growth */ + if (size < 4 * namelen) + size = 4 * namelen; /* just in case ! */ + pool = (xmlDictStringsPtr) xmlMalloc(sizeof(xmlDictStrings) + size); + if (pool == NULL) + return(NULL); + pool->size = size; + pool->nbStrings = 0; + pool->free = &pool->array[0]; + pool->end = &pool->array[size]; + pool->next = dict->strings; + dict->strings = pool; +#ifdef DICT_DEBUG_PATTERNS + fprintf(stderr, "+"); +#endif + } +found_pool: + ret = pool->free; + memcpy(pool->free, name, namelen); + pool->free += namelen; + *(pool->free++) = 0; + pool->nbStrings++; + return(ret); +} + +/* + * xmlDictAddQString: + * @dict: the dictionnary + * @prefix: the prefix of the userdata + * @plen: the prefix length + * @name: the name of the userdata + * @len: the length of the name + * + * Add the QName to the array[s] + * + * Returns the pointer of the local string, or NULL in case of error. + */ +static const xmlChar * +xmlDictAddQString(xmlDictPtr dict, const xmlChar *prefix, unsigned int plen, + const xmlChar *name, unsigned int namelen) +{ + xmlDictStringsPtr pool; + const xmlChar *ret; + size_t size = 0; /* + sizeof(_xmlDictStrings) == 1024 */ + size_t limit = 0; + + if (prefix == NULL) return(xmlDictAddString(dict, name, namelen)); + +#ifdef DICT_DEBUG_PATTERNS + fprintf(stderr, "="); +#endif + pool = dict->strings; + while (pool != NULL) { + if (pool->end - pool->free > namelen + plen + 1) + goto found_pool; + if (pool->size > size) size = pool->size; + limit += pool->size; + pool = pool->next; + } + /* + * Not found, need to allocate + */ + if (pool == NULL) { + if ((dict->limit > 0) && (limit > dict->limit)) { + return(NULL); + } + + if (size == 0) size = 1000; + else size *= 4; /* exponential growth */ + if (size < 4 * (namelen + plen + 1)) + size = 4 * (namelen + plen + 1); /* just in case ! */ + pool = (xmlDictStringsPtr) xmlMalloc(sizeof(xmlDictStrings) + size); + if (pool == NULL) + return(NULL); + pool->size = size; + pool->nbStrings = 0; + pool->free = &pool->array[0]; + pool->end = &pool->array[size]; + pool->next = dict->strings; + dict->strings = pool; +#ifdef DICT_DEBUG_PATTERNS + fprintf(stderr, "+"); +#endif + } +found_pool: + ret = pool->free; + memcpy(pool->free, prefix, plen); + pool->free += plen; + *(pool->free++) = ':'; + memcpy(pool->free, name, namelen); + pool->free += namelen; + *(pool->free++) = 0; + pool->nbStrings++; + return(ret); +} + +#ifdef WITH_BIG_KEY +/* + * xmlDictComputeBigKey: + * + * Calculate a hash key using a good hash function that works well for + * larger hash table sizes. + * + * Hash function by "One-at-a-Time Hash" see + * http://burtleburtle.net/bob/hash/doobs.html + */ + +static uint32_t +xmlDictComputeBigKey(const xmlChar* data, int namelen, int seed) { + uint32_t hash; + int i; + + if (namelen <= 0 || data == NULL) return(0); + + hash = seed; + + for (i = 0;i < namelen; i++) { + hash += data[i]; + hash += (hash << 10); + hash ^= (hash >> 6); + } + hash += (hash << 3); + hash ^= (hash >> 11); + hash += (hash << 15); + + return hash; +} + +/* + * xmlDictComputeBigQKey: + * + * Calculate a hash key for two strings using a good hash function + * that works well for larger hash table sizes. + * + * Hash function by "One-at-a-Time Hash" see + * http://burtleburtle.net/bob/hash/doobs.html + * + * Neither of the two strings must be NULL. + */ +static unsigned long +xmlDictComputeBigQKey(const xmlChar *prefix, int plen, + const xmlChar *name, int len, int seed) +{ + uint32_t hash; + int i; + + hash = seed; + + for (i = 0;i < plen; i++) { + hash += prefix[i]; + hash += (hash << 10); + hash ^= (hash >> 6); + } + hash += ':'; + hash += (hash << 10); + hash ^= (hash >> 6); + + for (i = 0;i < len; i++) { + hash += name[i]; + hash += (hash << 10); + hash ^= (hash >> 6); + } + hash += (hash << 3); + hash ^= (hash >> 11); + hash += (hash << 15); + + return hash; +} +#endif /* WITH_BIG_KEY */ + +/* + * xmlDictComputeFastKey: + * + * Calculate a hash key using a fast hash function that works well + * for low hash table fill. + */ +static unsigned long +xmlDictComputeFastKey(const xmlChar *name, int namelen, int seed) { + unsigned long value = seed; + + if (name == NULL) return(0); + value = *name; + value <<= 5; + if (namelen > 10) { + value += name[namelen - 1]; + namelen = 10; + } + switch (namelen) { + case 10: value += name[9]; + case 9: value += name[8]; + case 8: value += name[7]; + case 7: value += name[6]; + case 6: value += name[5]; + case 5: value += name[4]; + case 4: value += name[3]; + case 3: value += name[2]; + case 2: value += name[1]; + default: break; + } + return(value); +} + +/* + * xmlDictComputeFastQKey: + * + * Calculate a hash key for two strings using a fast hash function + * that works well for low hash table fill. + * + * Neither of the two strings must be NULL. + */ +static unsigned long +xmlDictComputeFastQKey(const xmlChar *prefix, int plen, + const xmlChar *name, int len, int seed) +{ + unsigned long value = (unsigned long) seed; + + if (plen == 0) + value += 30 * (unsigned long) ':'; + else + value += 30 * (*prefix); + + if (len > 10) { + int offset = len - (plen + 1 + 1); + if (offset < 0) + offset = len - (10 + 1); + value += name[offset]; + len = 10; + if (plen > 10) + plen = 10; + } + switch (plen) { + case 10: value += prefix[9]; + case 9: value += prefix[8]; + case 8: value += prefix[7]; + case 7: value += prefix[6]; + case 6: value += prefix[5]; + case 5: value += prefix[4]; + case 4: value += prefix[3]; + case 3: value += prefix[2]; + case 2: value += prefix[1]; + case 1: value += prefix[0]; + default: break; + } + len -= plen; + if (len > 0) { + value += (unsigned long) ':'; + len--; + } + switch (len) { + case 10: value += name[9]; + case 9: value += name[8]; + case 8: value += name[7]; + case 7: value += name[6]; + case 6: value += name[5]; + case 5: value += name[4]; + case 4: value += name[3]; + case 3: value += name[2]; + case 2: value += name[1]; + case 1: value += name[0]; + default: break; + } + return(value); +} + +/** + * xmlDictCreate: + * + * Create a new dictionary + * + * Returns the newly created dictionnary, or NULL if an error occured. + */ +xmlDictPtr +xmlDictCreate(void) { + xmlDictPtr dict; + + if (!xmlDictInitialized) + if (!__xmlInitializeDict()) + return(NULL); + +#ifdef DICT_DEBUG_PATTERNS + fprintf(stderr, "C"); +#endif + + dict = xmlMalloc(sizeof(xmlDict)); + if (dict) { + dict->ref_counter = 1; + dict->limit = 0; + + dict->size = MIN_DICT_SIZE; + dict->nbElems = 0; + dict->dict = xmlMalloc(MIN_DICT_SIZE * sizeof(xmlDictEntry)); + dict->strings = NULL; + dict->subdict = NULL; + if (dict->dict) { + memset(dict->dict, 0, MIN_DICT_SIZE * sizeof(xmlDictEntry)); +#ifdef DICT_RANDOMIZATION + dict->seed = __xmlRandom(); +#else + dict->seed = 0; +#endif + return(dict); + } + xmlFree(dict); + } + return(NULL); +} + +/** + * xmlDictCreateSub: + * @sub: an existing dictionnary + * + * Create a new dictionary, inheriting strings from the read-only + * dictionnary @sub. On lookup, strings are first searched in the + * new dictionnary, then in @sub, and if not found are created in the + * new dictionnary. + * + * Returns the newly created dictionnary, or NULL if an error occured. + */ +xmlDictPtr +xmlDictCreateSub(xmlDictPtr sub) { + xmlDictPtr dict = xmlDictCreate(); + + if ((dict != NULL) && (sub != NULL)) { +#ifdef DICT_DEBUG_PATTERNS + fprintf(stderr, "R"); +#endif + dict->seed = sub->seed; + dict->subdict = sub; + xmlDictReference(dict->subdict); + } + return(dict); +} + +/** + * xmlDictReference: + * @dict: the dictionnary + * + * Increment the reference counter of a dictionary + * + * Returns 0 in case of success and -1 in case of error + */ +int +xmlDictReference(xmlDictPtr dict) { + if (!xmlDictInitialized) + if (!__xmlInitializeDict()) + return(-1); + + if (dict == NULL) return -1; + xmlRMutexLock(xmlDictMutex); + dict->ref_counter++; + xmlRMutexUnlock(xmlDictMutex); + return(0); +} + +/** + * xmlDictGrow: + * @dict: the dictionnary + * @size: the new size of the dictionnary + * + * resize the dictionnary + * + * Returns 0 in case of success, -1 in case of failure + */ +static int +xmlDictGrow(xmlDictPtr dict, size_t size) { + unsigned long key, okey; + size_t oldsize, i; + xmlDictEntryPtr iter, next; + struct _xmlDictEntry *olddict; +#ifdef DEBUG_GROW + unsigned long nbElem = 0; +#endif + int ret = 0; + int keep_keys = 1; + + if (dict == NULL) + return(-1); + if (size < 8) + return(-1); + if (size > 8 * 2048) + return(-1); + +#ifdef DICT_DEBUG_PATTERNS + fprintf(stderr, "*"); +#endif + + oldsize = dict->size; + olddict = dict->dict; + if (olddict == NULL) + return(-1); + if (oldsize == MIN_DICT_SIZE) + keep_keys = 0; + + dict->dict = xmlMalloc(size * sizeof(xmlDictEntry)); + if (dict->dict == NULL) { + dict->dict = olddict; + return(-1); + } + memset(dict->dict, 0, size * sizeof(xmlDictEntry)); + dict->size = size; + + /* If the two loops are merged, there would be situations where + a new entry needs to allocated and data copied into it from + the main dict. It is nicer to run through the array twice, first + copying all the elements in the main array (less probability of + allocate) and then the rest, so we only free in the second loop. + */ + for (i = 0; i < oldsize; i++) { + if (olddict[i].valid == 0) + continue; + + if (keep_keys) + okey = olddict[i].okey; + else + okey = xmlDictComputeKey(dict, olddict[i].name, olddict[i].len); + key = okey % dict->size; + + if (dict->dict[key].valid == 0) { + memcpy(&(dict->dict[key]), &(olddict[i]), sizeof(xmlDictEntry)); + dict->dict[key].next = NULL; + dict->dict[key].okey = okey; + } else { + xmlDictEntryPtr entry; + + entry = xmlMalloc(sizeof(xmlDictEntry)); + if (entry != NULL) { + entry->name = olddict[i].name; + entry->len = olddict[i].len; + entry->okey = okey; + entry->next = dict->dict[key].next; + entry->valid = 1; + dict->dict[key].next = entry; + } else { + /* + * we don't have much ways to alert from herei + * result is loosing an entry and unicity garantee + */ + ret = -1; + } + } +#ifdef DEBUG_GROW + nbElem++; +#endif + } + + for (i = 0; i < oldsize; i++) { + iter = olddict[i].next; + while (iter) { + next = iter->next; + + /* + * put back the entry in the new dict + */ + + if (keep_keys) + okey = iter->okey; + else + okey = xmlDictComputeKey(dict, iter->name, iter->len); + key = okey % dict->size; + if (dict->dict[key].valid == 0) { + memcpy(&(dict->dict[key]), iter, sizeof(xmlDictEntry)); + dict->dict[key].next = NULL; + dict->dict[key].valid = 1; + dict->dict[key].okey = okey; + xmlFree(iter); + } else { + iter->next = dict->dict[key].next; + iter->okey = okey; + dict->dict[key].next = iter; + } + +#ifdef DEBUG_GROW + nbElem++; +#endif + + iter = next; + } + } + + xmlFree(olddict); + +#ifdef DEBUG_GROW + xmlGenericError(xmlGenericErrorContext, + "xmlDictGrow : from %lu to %lu, %u elems\n", oldsize, size, nbElem); +#endif + + return(ret); +} + +/** + * xmlDictFree: + * @dict: the dictionnary + * + * Free the hash @dict and its contents. The userdata is + * deallocated with @f if provided. + */ +void +xmlDictFree(xmlDictPtr dict) { + size_t i; + xmlDictEntryPtr iter; + xmlDictEntryPtr next; + int inside_dict = 0; + xmlDictStringsPtr pool, nextp; + + if (dict == NULL) + return; + + if (!xmlDictInitialized) + if (!__xmlInitializeDict()) + return; + + /* decrement the counter, it may be shared by a parser and docs */ + xmlRMutexLock(xmlDictMutex); + dict->ref_counter--; + if (dict->ref_counter > 0) { + xmlRMutexUnlock(xmlDictMutex); + return; + } + + xmlRMutexUnlock(xmlDictMutex); + + if (dict->subdict != NULL) { + xmlDictFree(dict->subdict); + } + + if (dict->dict) { + for(i = 0; ((i < dict->size) && (dict->nbElems > 0)); i++) { + iter = &(dict->dict[i]); + if (iter->valid == 0) + continue; + inside_dict = 1; + while (iter) { + next = iter->next; + if (!inside_dict) + xmlFree(iter); + dict->nbElems--; + inside_dict = 0; + iter = next; + } + } + xmlFree(dict->dict); + } + pool = dict->strings; + while (pool != NULL) { + nextp = pool->next; + xmlFree(pool); + pool = nextp; + } + xmlFree(dict); +} + +/** + * xmlDictLookup: + * @dict: the dictionnary + * @name: the name of the userdata + * @len: the length of the name, if -1 it is recomputed + * + * Add the @name to the dictionnary @dict if not present. + * + * Returns the internal copy of the name or NULL in case of internal error + */ +const xmlChar * +xmlDictLookup(xmlDictPtr dict, const xmlChar *name, int len) { + unsigned long key, okey, nbi = 0; + xmlDictEntryPtr entry; + xmlDictEntryPtr insert; + const xmlChar *ret; + unsigned int l; + + if ((dict == NULL) || (name == NULL)) + return(NULL); + + if (len < 0) + l = strlen((const char *) name); + else + l = len; + + if (((dict->limit > 0) && (l >= dict->limit)) || + (l > INT_MAX / 2)) + return(NULL); + + /* + * Check for duplicate and insertion location. + */ + okey = xmlDictComputeKey(dict, name, l); + key = okey % dict->size; + if (dict->dict[key].valid == 0) { + insert = NULL; + } else { + for (insert = &(dict->dict[key]); insert->next != NULL; + insert = insert->next) { +#ifdef __GNUC__ + if ((insert->okey == okey) && (insert->len == l)) { + if (!memcmp(insert->name, name, l)) + return(insert->name); + } +#else + if ((insert->okey == okey) && (insert->len == l) && + (!xmlStrncmp(insert->name, name, l))) + return(insert->name); +#endif + nbi++; + } +#ifdef __GNUC__ + if ((insert->okey == okey) && (insert->len == l)) { + if (!memcmp(insert->name, name, l)) + return(insert->name); + } +#else + if ((insert->okey == okey) && (insert->len == l) && + (!xmlStrncmp(insert->name, name, l))) + return(insert->name); +#endif + } + + if (dict->subdict) { + unsigned long skey; + + /* we cannot always reuse the same okey for the subdict */ + if (((dict->size == MIN_DICT_SIZE) && + (dict->subdict->size != MIN_DICT_SIZE)) || + ((dict->size != MIN_DICT_SIZE) && + (dict->subdict->size == MIN_DICT_SIZE))) + skey = xmlDictComputeKey(dict->subdict, name, l); + else + skey = okey; + + key = skey % dict->subdict->size; + if (dict->subdict->dict[key].valid != 0) { + xmlDictEntryPtr tmp; + + for (tmp = &(dict->subdict->dict[key]); tmp->next != NULL; + tmp = tmp->next) { +#ifdef __GNUC__ + if ((tmp->okey == skey) && (tmp->len == l)) { + if (!memcmp(tmp->name, name, l)) + return(tmp->name); + } +#else + if ((tmp->okey == skey) && (tmp->len == l) && + (!xmlStrncmp(tmp->name, name, l))) + return(tmp->name); +#endif + nbi++; + } +#ifdef __GNUC__ + if ((tmp->okey == skey) && (tmp->len == l)) { + if (!memcmp(tmp->name, name, l)) + return(tmp->name); + } +#else + if ((tmp->okey == skey) && (tmp->len == l) && + (!xmlStrncmp(tmp->name, name, l))) + return(tmp->name); +#endif + } + key = okey % dict->size; + } + + ret = xmlDictAddString(dict, name, l); + if (ret == NULL) + return(NULL); + if (insert == NULL) { + entry = &(dict->dict[key]); + } else { + entry = xmlMalloc(sizeof(xmlDictEntry)); + if (entry == NULL) + return(NULL); + } + entry->name = ret; + entry->len = l; + entry->next = NULL; + entry->valid = 1; + entry->okey = okey; + + + if (insert != NULL) + insert->next = entry; + + dict->nbElems++; + + if ((nbi > MAX_HASH_LEN) && + (dict->size <= ((MAX_DICT_HASH / 2) / MAX_HASH_LEN))) { + if (xmlDictGrow(dict, MAX_HASH_LEN * 2 * dict->size) != 0) + return(NULL); + } + /* Note that entry may have been freed at this point by xmlDictGrow */ + + return(ret); +} + +/** + * xmlDictExists: + * @dict: the dictionnary + * @name: the name of the userdata + * @len: the length of the name, if -1 it is recomputed + * + * Check if the @name exists in the dictionnary @dict. + * + * Returns the internal copy of the name or NULL if not found. + */ +const xmlChar * +xmlDictExists(xmlDictPtr dict, const xmlChar *name, int len) { + unsigned long key, okey, nbi = 0; + xmlDictEntryPtr insert; + unsigned int l; + + if ((dict == NULL) || (name == NULL)) + return(NULL); + + if (len < 0) + l = strlen((const char *) name); + else + l = len; + if (((dict->limit > 0) && (l >= dict->limit)) || + (l > INT_MAX / 2)) + return(NULL); + + /* + * Check for duplicate and insertion location. + */ + okey = xmlDictComputeKey(dict, name, l); + key = okey % dict->size; + if (dict->dict[key].valid == 0) { + insert = NULL; + } else { + for (insert = &(dict->dict[key]); insert->next != NULL; + insert = insert->next) { +#ifdef __GNUC__ + if ((insert->okey == okey) && (insert->len == l)) { + if (!memcmp(insert->name, name, l)) + return(insert->name); + } +#else + if ((insert->okey == okey) && (insert->len == l) && + (!xmlStrncmp(insert->name, name, l))) + return(insert->name); +#endif + nbi++; + } +#ifdef __GNUC__ + if ((insert->okey == okey) && (insert->len == l)) { + if (!memcmp(insert->name, name, l)) + return(insert->name); + } +#else + if ((insert->okey == okey) && (insert->len == l) && + (!xmlStrncmp(insert->name, name, l))) + return(insert->name); +#endif + } + + if (dict->subdict) { + unsigned long skey; + + /* we cannot always reuse the same okey for the subdict */ + if (((dict->size == MIN_DICT_SIZE) && + (dict->subdict->size != MIN_DICT_SIZE)) || + ((dict->size != MIN_DICT_SIZE) && + (dict->subdict->size == MIN_DICT_SIZE))) + skey = xmlDictComputeKey(dict->subdict, name, l); + else + skey = okey; + + key = skey % dict->subdict->size; + if (dict->subdict->dict[key].valid != 0) { + xmlDictEntryPtr tmp; + + for (tmp = &(dict->subdict->dict[key]); tmp->next != NULL; + tmp = tmp->next) { +#ifdef __GNUC__ + if ((tmp->okey == skey) && (tmp->len == l)) { + if (!memcmp(tmp->name, name, l)) + return(tmp->name); + } +#else + if ((tmp->okey == skey) && (tmp->len == l) && + (!xmlStrncmp(tmp->name, name, l))) + return(tmp->name); +#endif + nbi++; + } +#ifdef __GNUC__ + if ((tmp->okey == skey) && (tmp->len == l)) { + if (!memcmp(tmp->name, name, l)) + return(tmp->name); + } +#else + if ((tmp->okey == skey) && (tmp->len == l) && + (!xmlStrncmp(tmp->name, name, l))) + return(tmp->name); +#endif + } + } + + /* not found */ + return(NULL); +} + +/** + * xmlDictQLookup: + * @dict: the dictionnary + * @prefix: the prefix + * @name: the name + * + * Add the QName @prefix:@name to the hash @dict if not present. + * + * Returns the internal copy of the QName or NULL in case of internal error + */ +const xmlChar * +xmlDictQLookup(xmlDictPtr dict, const xmlChar *prefix, const xmlChar *name) { + unsigned long okey, key, nbi = 0; + xmlDictEntryPtr entry; + xmlDictEntryPtr insert; + const xmlChar *ret; + unsigned int len, plen, l; + + if ((dict == NULL) || (name == NULL)) + return(NULL); + if (prefix == NULL) + return(xmlDictLookup(dict, name, -1)); + + l = len = strlen((const char *) name); + plen = strlen((const char *) prefix); + len += 1 + plen; + + /* + * Check for duplicate and insertion location. + */ + okey = xmlDictComputeQKey(dict, prefix, plen, name, l); + key = okey % dict->size; + if (dict->dict[key].valid == 0) { + insert = NULL; + } else { + for (insert = &(dict->dict[key]); insert->next != NULL; + insert = insert->next) { + if ((insert->okey == okey) && (insert->len == len) && + (xmlStrQEqual(prefix, name, insert->name))) + return(insert->name); + nbi++; + } + if ((insert->okey == okey) && (insert->len == len) && + (xmlStrQEqual(prefix, name, insert->name))) + return(insert->name); + } + + if (dict->subdict) { + unsigned long skey; + + /* we cannot always reuse the same okey for the subdict */ + if (((dict->size == MIN_DICT_SIZE) && + (dict->subdict->size != MIN_DICT_SIZE)) || + ((dict->size != MIN_DICT_SIZE) && + (dict->subdict->size == MIN_DICT_SIZE))) + skey = xmlDictComputeQKey(dict->subdict, prefix, plen, name, l); + else + skey = okey; + + key = skey % dict->subdict->size; + if (dict->subdict->dict[key].valid != 0) { + xmlDictEntryPtr tmp; + for (tmp = &(dict->subdict->dict[key]); tmp->next != NULL; + tmp = tmp->next) { + if ((tmp->okey == skey) && (tmp->len == len) && + (xmlStrQEqual(prefix, name, tmp->name))) + return(tmp->name); + nbi++; + } + if ((tmp->okey == skey) && (tmp->len == len) && + (xmlStrQEqual(prefix, name, tmp->name))) + return(tmp->name); + } + key = okey % dict->size; + } + + ret = xmlDictAddQString(dict, prefix, plen, name, l); + if (ret == NULL) + return(NULL); + if (insert == NULL) { + entry = &(dict->dict[key]); + } else { + entry = xmlMalloc(sizeof(xmlDictEntry)); + if (entry == NULL) + return(NULL); + } + entry->name = ret; + entry->len = len; + entry->next = NULL; + entry->valid = 1; + entry->okey = okey; + + if (insert != NULL) + insert->next = entry; + + dict->nbElems++; + + if ((nbi > MAX_HASH_LEN) && + (dict->size <= ((MAX_DICT_HASH / 2) / MAX_HASH_LEN))) + xmlDictGrow(dict, MAX_HASH_LEN * 2 * dict->size); + /* Note that entry may have been freed at this point by xmlDictGrow */ + + return(ret); +} + +/** + * xmlDictOwns: + * @dict: the dictionnary + * @str: the string + * + * check if a string is owned by the disctionary + * + * Returns 1 if true, 0 if false and -1 in case of error + * -1 in case of error + */ +int +xmlDictOwns(xmlDictPtr dict, const xmlChar *str) { + xmlDictStringsPtr pool; + + if ((dict == NULL) || (str == NULL)) + return(-1); + pool = dict->strings; + while (pool != NULL) { + if ((str >= &pool->array[0]) && (str <= pool->free)) + return(1); + pool = pool->next; + } + if (dict->subdict) + return(xmlDictOwns(dict->subdict, str)); + return(0); +} + +/** + * xmlDictSize: + * @dict: the dictionnary + * + * Query the number of elements installed in the hash @dict. + * + * Returns the number of elements in the dictionnary or + * -1 in case of error + */ +int +xmlDictSize(xmlDictPtr dict) { + if (dict == NULL) + return(-1); + if (dict->subdict) + return(dict->nbElems + dict->subdict->nbElems); + return(dict->nbElems); +} + +/** + * xmlDictSetLimit: + * @dict: the dictionnary + * @limit: the limit in bytes + * + * Set a size limit for the dictionary + * Added in 2.9.0 + * + * Returns the previous limit of the dictionary or 0 + */ +size_t +xmlDictSetLimit(xmlDictPtr dict, size_t limit) { + size_t ret; + + if (dict == NULL) + return(0); + ret = dict->limit; + dict->limit = limit; + return(ret); +} + +/** + * xmlDictGetUsage: + * @dict: the dictionnary + * + * Get how much memory is used by a dictionary for strings + * Added in 2.9.0 + * + * Returns the amount of strings allocated + */ +size_t +xmlDictGetUsage(xmlDictPtr dict) { + xmlDictStringsPtr pool; + size_t limit = 0; + + if (dict == NULL) + return(0); + pool = dict->strings; + while (pool != NULL) { + limit += pool->size; + pool = pool->next; + } + return(limit); +} + +#define bottom_dict +#include "elfgcchack.h" http://git-wip-us.apache.org/repos/asf/nifi-minifi-cpp/blob/7956696e/thirdparty/libxml2/doc/APIchunk0.html ---------------------------------------------------------------------- diff --git a/thirdparty/libxml2/doc/APIchunk0.html b/thirdparty/libxml2/doc/APIchunk0.html new file mode 100644 index 0000000..c90e042 --- /dev/null +++ b/thirdparty/libxml2/doc/APIchunk0.html @@ -0,0 +1,301 @@ +<?xml version="1.0" encoding="UTF-8"?> +<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd";> +<html xmlns="http://www.w3.org/1999/xhtml";><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><link rel="SHORTCUT ICON" href="/favicon.ico" /><style type="text/css"> +TD {font-family: Verdana,Arial,Helvetica} +BODY {font-family: Verdana,Arial,Helvetica; margin-top: 2em; margin-left: 0em; margin-right: 0em} +H1 {font-family: Verdana,Arial,Helvetica} +H2 {font-family: Verdana,Arial,Helvetica} +H3 {font-family: Verdana,Arial,Helvetica} +A:link, A:visited, A:active { text-decoration: underline } +</style><title>API Alphabetic Index A-B for libxml2</title></head><body bgcolor="#8b7765" text="#000000" link="#a06060" vlink="#000000"><table border="0" width="100%" cellpadding="5" cellspacing="0" align="center"><tr><td width="120"><a href="http://swpat.ffii.org/";><img src="epatents.png" alt="Action against software patents" /></a></td><td width="180"><a href="http://www.gnome.org/";><img src="gnome2.png" alt="Gnome2 Logo" /></a><a href="http://www.w3.org/Status";><img src="w3c.png" alt="W3C Logo" /></a><a href="http://www.redhat.com/";><img src="redhat.gif" alt="Red Hat Logo" /></a><div align="left"><a href="http://xmlsoft.org/";><img src="Libxml2-Logo-180x168.gif" alt="Made with Libxml2 Logo" /></a></div></td><td><table border="0" width="90%" cellpadding="2" cellspacing="0" align="center" bgcolor="#000000"><tr><td><table width="100%" border="0" cellspacing="1" cellpadding="3" bgcolor="#fffacd"><tr><td align="center"><h1>The XML C parser and toolkit of Gnome</h1><h2>API Alphabetic In dex A-B for libxml2</h2></td></tr></table></td></tr></table></td></tr></table><table border="0" cellpadding="4" cellspacing="0" width="100%" align="center"><tr><td bgcolor="#8b7765"><table border="0" cellspacing="0" cellpadding="2" width="100%"><tr><td valign="top" width="200" bgcolor="#8b7765"><table border="0" cellspacing="0" cellpadding="1" width="100%" bgcolor="#000000"><tr><td><table width="100%" border="0" cellspacing="1" cellpadding="3"><tr><td colspan="1" bgcolor="#eecfa1" align="center"><center><b>Developer Menu</b></center></td></tr><tr><td bgcolor="#fffacd"><form action="search.php" enctype="application/x-www-form-urlencoded" method="get"><input name="query" type="text" size="20" value="" /><input name="submit" type="submit" value="Search ..." /></form><ul><li><a href="index.html" style="font-weight:bold">Main Menu</a></li><li><a href="html/index.html" style="font-weight:bold">Reference Manual</a></li><li><a href="examples/index.html" style="font-weight:bold">Code Example s</a></li><li><a href="guidelines.html">XML Guidelines</a></li><li><a href="tutorial/index.html">Tutorial</a></li><li><a href="xmlreader.html">The Reader Interface</a></li><li><a href="ChangeLog.html">ChangeLog</a></li><li><a href="XSLT.html">XSLT</a></li><li><a href="python.html">Python and bindings</a></li><li><a href="architecture.html">libxml2 architecture</a></li><li><a href="tree.html">The tree output</a></li><li><a href="interface.html">The SAX interface</a></li><li><a href="xmlmem.html">Memory Management</a></li><li><a href="xmlio.html">I/O Interfaces</a></li><li><a href="library.html">The parser interfaces</a></li><li><a href="entities.html">Entities or no entities</a></li><li><a href="namespaces.html">Namespaces</a></li><li><a href="upgrade.html">Upgrading 1.x code</a></li><li><a href="threads.html">Thread safety</a></li><li><a href="DOM.html">DOM Principles</a></li><li><a href="example.html">A real example</a></li><li><a href="xml.html">flat page</a>, <a href="site.xsl">s tylesheet</a></li></ul></td></tr></table><table width="100%" border="0" cellspacing="1" cellpadding="3"><tr><td colspan="1" bgcolor="#eecfa1" align="center"><center><b>API Indexes</b></center></td></tr><tr><td bgcolor="#fffacd"><ul><li><a href="APIchunk0.html">Alphabetic</a></li><li><a href="APIconstructors.html">Constructors</a></li><li><a href="APIfunctions.html">Functions/Types</a></li><li><a href="APIfiles.html">Modules</a></li><li><a href="APIsymbols.html">Symbols</a></li></ul></td></tr></table><table width="100%" border="0" cellspacing="1" cellpadding="3"><tr><td colspan="1" bgcolor="#eecfa1" align="center"><center><b>Related links</b></center></td></tr><tr><td bgcolor="#fffacd"><ul><li><a href="http://mail.gnome.org/archives/xml/";>Mail archive</a></li><li><a href="http://xmlsoft.org/XSLT/";>XSLT libxslt</a></li><li><a href="http://phd.cs.unibo.it/gdome2/";>DOM gdome2</a></li><li><a href="http://www.aleksey.com/xmlsec/";>XML-DSig xmlsec</a></li><li><a href="ftp://xmlsoft.org/";>FT P</a></li><li><a href="http://www.zlatkovic.com/projects/libxml/";>Windows binaries</a></li><li><a href="http://opencsw.org/packages/libxml2";>Solaris binaries</a></li><li><a href="http://www.explain.com.au/oss/libxml2xslt.html";>MacOsX binaries</a></li><li><a href="http://lxml.de/";>lxml Python bindings</a></li><li><a href="http://cpan.uwinnipeg.ca/dist/XML-LibXML";>Perl bindings</a></li><li><a href="http://libxmlplusplus.sourceforge.net/";>C++ bindings</a></li><li><a href="http://www.zend.com/php5/articles/php5-xmlphp.php#Heading4";>PHP bindings</a></li><li><a href="http://sourceforge.net/projects/libxml2-pas/";>Pascal bindings</a></li><li><a href="http://libxml.rubyforge.org/";>Ruby bindings</a></li><li><a href="http://tclxml.sourceforge.net/";>Tcl bindings</a></li><li><a href="http://bugzilla.gnome.org/buglist.cgi?product=libxml2";>Bug Tracker</a></li></ul></td></tr></table></td></tr></table></td><td valign="top" bgcolor="#8b7765"><table border="0" cellspacing="0" cellpadding="1" width="10 0%"><tr><td><table border="0" cellspacing="0" cellpadding="1" width="100%" bgcolor="#000000"><tr><td><table border="0" cellpadding="3" cellspacing="1" width="100%"><tr><td bgcolor="#fffacd"><h2 align="center"><a href="APIchunk0.html">A-B</a> +<a href="APIchunk1.html">C-C</a> +<a href="APIchunk2.html">D-E</a> +<a href="APIchunk3.html">F-I</a> +<a href="APIchunk4.html">J-N</a> +<a href="APIchunk5.html">O-P</a> +<a href="APIchunk6.html">Q-R</a> +<a href="APIchunk7.html">S-S</a> +<a href="APIchunk8.html">T-U</a> +<a href="APIchunk9.html">V-X</a> +<a href="APIchunk10.html">Y-a</a> +<a href="APIchunk11.html">b-b</a> +<a href="APIchunk12.html">c-c</a> +<a href="APIchunk13.html">d-d</a> +<a href="APIchunk14.html">e-e</a> +<a href="APIchunk15.html">f-f</a> +<a href="APIchunk16.html">g-h</a> +<a href="APIchunk17.html">i-i</a> +<a href="APIchunk18.html">j-l</a> +<a href="APIchunk19.html">m-m</a> +<a href="APIchunk20.html">n-n</a> +<a href="APIchunk21.html">o-o</a> +<a href="APIchunk22.html">p-p</a> +<a href="APIchunk23.html">q-r</a> +<a href="APIchunk24.html">s-s</a> +<a href="APIchunk25.html">t-t</a> +<a href="APIchunk26.html">u-v</a> +<a href="APIchunk27.html">w-w</a> +<a href="APIchunk28.html">x-x</a> +<a href="APIchunk29.html">y-z</a> +</h2><h2>Letter A:</h2><dl><dt>A-Z</dt><dd><a href="html/libxml-parserInternals.html#xmlCheckLanguageID">xmlCheckLanguageID</a><br /> +</dd><dt>A-Za-z</dt><dd><a href="html/libxml-parserInternals.html#xmlParseEncName">xmlParseEncName</a><br /> +</dd><dt>A-Za-z0-9</dt><dd><a href="html/libxml-parserInternals.html#xmlParseEncName">xmlParseEncName</a><br /> +</dd><dt>ABC</dt><dd><a href="html/libxml-xpathInternals.html#xmlXPathTranslateFunction">xmlXPathTranslateFunction</a><br /> +</dd><dt>ABI</dt><dd><a href="html/libxml-xmlerror.html#_xmlError">_xmlError</a><br /> +</dd><dt>ALL</dt><dd><a href="html/libxml-xmlautomata.html#xmlAutomataNewAllTrans">xmlAutomataNewAllTrans</a><br /> +</dd><dt>ANY</dt><dd><a href="html/libxml-valid.html#xmlIsMixedElement">xmlIsMixedElement</a><br /> +<a href="html/libxml-parserInternals.html#xmlParseElementContentDecl">xmlParseElementContentDecl</a><br /> +</dd><dt>APIs</dt><dd><a href="html/libxml-xmlversion.html#LIBXML_LEGACY_ENABLED">LIBXML_LEGACY_ENABLED</a><br /> +<a href="html/libxml-xmlschemas.html#xmlSchemaValidateSetFilename">xmlSchemaValidateSetFilename</a><br /> +</dd><dt>ARRAY</dt><dd><a href="html/libxml-xmlstring.html#xmlStrlen">xmlStrlen</a><br /> +<a href="html/libxml-xmlstring.html#xmlUTF8Strsize">xmlUTF8Strsize</a><br /> +</dd><dt>ASCII</dt><dd><a href="html/libxml-HTMLparser.html#UTF8ToHtml">UTF8ToHtml</a><br /> +<a href="html/libxml-DOCBparser.html#docbEncodeEntities">docbEncodeEntities</a><br /> +<a href="html/libxml-HTMLparser.html#htmlEncodeEntities">htmlEncodeEntities</a><br /> +<a href="html/libxml-encoding.html#xmlAddEncodingAlias">xmlAddEncodingAlias</a><br /> +<a href="html/libxml-encoding.html#xmlDelEncodingAlias">xmlDelEncodingAlias</a><br /> +<a href="html/libxml-entities.html#xmlEncodeEntitiesReentrant">xmlEncodeEntitiesReentrant</a><br /> +<a href="html/libxml-encoding.html#xmlGetEncodingAlias">xmlGetEncodingAlias</a><br /> +<a href="html/libxml-xmlmodule.html#xmlModuleOpen">xmlModuleOpen</a><br /> +<a href="html/libxml-xmlmodule.html#xmlModuleSymbol">xmlModuleSymbol</a><br /> +<a href="html/libxml-encoding.html#xmlNewCharEncodingHandler">xmlNewCharEncodingHandler</a><br /> +<a href="html/libxml-encoding.html#xmlParseCharEncoding">xmlParseCharEncoding</a><br /> +</dd><dt>ATTLIST</dt><dd><a href="html/libxml-xmlwriter.html#xmlTextWriterStartDTDAttlist">xmlTextWriterStartDTDAttlist</a><br /> +<a href="html/libxml-xmlwriter.html#xmlTextWriterStartDTDEntity">xmlTextWriterStartDTDEntity</a><br /> +<a href="html/libxml-xmlwriter.html#xmlTextWriterWriteDTDAttlist">xmlTextWriterWriteDTDAttlist</a><br /> +<a href="html/libxml-xmlwriter.html#xmlTextWriterWriteFormatDTDAttlist">xmlTextWriterWriteFormatDTDAttlist</a><br /> +<a href="html/libxml-xmlwriter.html#xmlTextWriterWriteVFormatDTDAttlist">xmlTextWriterWriteVFormatDTDAttlist</a><br /> +</dd><dt>ATTRIBUTE</dt><dd><a href="html/libxml-tree.html#xmlAddChild">xmlAddChild</a><br /> +<a href="html/libxml-tree.html#xmlAddNextSibling">xmlAddNextSibling</a><br /> +<a href="html/libxml-tree.html#xmlAddPrevSibling">xmlAddPrevSibling</a><br /> +</dd><dt>Absolute</dt><dd><a href="html/libxml-uri.html#xmlBuildURI">xmlBuildURI</a><br /> +</dd><dt>Accessor</dt><dd><a href="html/libxml-xmlschemastypes.html#xmlSchemaGetValType">xmlSchemaGetValType</a><br /> +<a href="html/libxml-xmlschemastypes.html#xmlSchemaValueGetAsBoolean">xmlSchemaValueGetAsBoolean</a><br /> +<a href="html/libxml-xmlschemastypes.html#xmlSchemaValueGetAsString">xmlSchemaValueGetAsString</a><br /> +<a href="html/libxml-xmlschemastypes.html#xmlSchemaValueGetNext">xmlSchemaValueGetNext</a><br /> +</dd><dt>Activation</dt><dd><a href="html/libxml-xmlreader.html#xmlTextReaderRelaxNGSetSchema">xmlTextReaderRelaxNGSetSchema</a><br /> +<a href="html/libxml-xmlreader.html#xmlTextReaderRelaxNGValidate">xmlTextReaderRelaxNGValidate</a><br /> +<a href="html/libxml-xmlreader.html#xmlTextReaderRelaxNGValidateCtxt">xmlTextReaderRelaxNGValidateCtxt</a><br /> +<a href="html/libxml-xmlreader.html#xmlTextReaderSchemaValidate">xmlTextReaderSchemaValidate</a><br /> +<a href="html/libxml-xmlreader.html#xmlTextReaderSchemaValidateCtxt">xmlTextReaderSchemaValidateCtxt</a><br /> +<a href="html/libxml-xmlreader.html#xmlTextReaderSetSchema">xmlTextReaderSetSchema</a><br /> +</dd><dt>Actually</dt><dd><a href="html/libxml-schemasInternals.html#XML_SCHEMAS_TYPE_VARIETY_ABSENT">XML_SCHEMAS_TYPE_VARIETY_ABSENT</a><br /> +</dd><dt>Add</dt><dd><a href="html/libxml-catalog.html#xmlACatalogAdd">xmlACatalogAdd</a><br /> +<a href="html/libxml-tree.html#xmlAddChild">xmlAddChild</a><br /> +<a href="html/libxml-tree.html#xmlAddChildList">xmlAddChildList</a><br /> +<a href="html/libxml-tree.html#xmlAddNextSibling">xmlAddNextSibling</a><br /> +<a href="html/libxml-tree.html#xmlAddPrevSibling">xmlAddPrevSibling</a><br /> +<a href="html/libxml-tree.html#xmlAddSibling">xmlAddSibling</a><br /> +<a href="html/libxml-tree.html#xmlBufferAdd">xmlBufferAdd</a><br /> +<a href="html/libxml-tree.html#xmlBufferAddHead">xmlBufferAddHead</a><br /> +<a href="html/libxml-catalog.html#xmlCatalogAdd">xmlCatalogAdd</a><br /> +<a href="html/libxml-catalog.html#xmlCatalogAddLocal">xmlCatalogAddLocal</a><br /> +<a href="html/libxml-dict.html#xmlDictLookup">xmlDictLookup</a><br /> +<a href="html/libxml-dict.html#xmlDictQLookup">xmlDictQLookup</a><br /> +<a href="html/libxml-hash.html#xmlHashAddEntry">xmlHashAddEntry</a><br /> +<a href="html/libxml-hash.html#xmlHashAddEntry2">xmlHashAddEntry2</a><br /> +<a href="html/libxml-hash.html#xmlHashAddEntry3">xmlHashAddEntry3</a><br /> +<a href="html/libxml-hash.html#xmlHashUpdateEntry">xmlHashUpdateEntry</a><br /> +<a href="html/libxml-hash.html#xmlHashUpdateEntry2">xmlHashUpdateEntry2</a><br /> +<a href="html/libxml-hash.html#xmlHashUpdateEntry3">xmlHashUpdateEntry3</a><br /> +</dd><dt>Added</dt><dd><a href="html/libxml-dict.html#xmlDictGetUsage">xmlDictGetUsage</a><br /> +<a href="html/libxml-dict.html#xmlDictSetLimit">xmlDictSetLimit</a><br /> +</dd><dt>Additional</dt><dd><a href="html/libxml-HTMLparser.html#_htmlElemDesc">_htmlElemDesc</a><br /> +<a href="html/libxml-globals.html#xmlCleanupGlobals">xmlCleanupGlobals</a><br /> +<a href="html/libxml-globals.html#xmlInitGlobals">xmlInitGlobals</a><br /> +</dd><dt>AegeanNumbers</dt><dd><a href="html/libxml-xmlunicode.html#xmlUCSIsAegeanNumbers">xmlUCSIsAegeanNumbers</a><br /> +</dd><dt>All</dt><dd><a href="html/libxml-schemasInternals.html#_xmlSchema">_xmlSchema</a><br /> +<a href="html/libxml-schemasInternals.html#_xmlSchemaType">_xmlSchemaType</a><br /> +<a href="html/libxml-nanoftp.html#xmlNanoFTPGet">xmlNanoFTPGet</a><br /> +<a href="html/libxml-nanoftp.html#xmlNanoFTPList">xmlNanoFTPList</a><br /> +<a href="html/libxml-parserInternals.html#xmlParseAttValue">xmlParseAttValue</a><br /> +<a href="html/libxml-xmlwriter.html#xmlTextWriterEndDocument">xmlTextWriterEndDocument</a><br /> +</dd><dt>Allocate</dt><dd><a href="html/libxml-HTMLparser.html#htmlNewParserCtxt">htmlNewParserCtxt</a><br /> +<a href="html/libxml-nanoftp.html#xmlNanoFTPNewCtxt">xmlNanoFTPNewCtxt</a><br /> +<a href="html/libxml-valid.html#xmlNewDocElementContent">xmlNewDocElementContent</a><br /> +<a href="html/libxml-valid.html#xmlNewElementContent">xmlNewElementContent</a><br /> +<a href="html/libxml-parser.html#xmlNewParserCtxt">xmlNewParserCtxt</a><br /> +<a href="html/libxml-valid.html#xmlNewValidCtxt">xmlNewValidCtxt</a><br /> +<a href="html/libxml-xmlschemastypes.html#xmlSchemaNewFacet">xmlSchemaNewFacet</a><br /> +<a href="html/libxml-xmlschemastypes.html#xmlSchemaNewNOTATIONValue">xmlSchemaNewNOTATIONValue</a><br /> +<a href="html/libxml-xmlschemastypes.html#xmlSchemaNewQNameValue">xmlSchemaNewQNameValue</a><br /> +<a href="html/libxml-xmlschemastypes.html#xmlSchemaNewStringValue">xmlSchemaNewStringValue</a><br /> +</dd><dt>Allocates</dt><dd><a href="html/libxml-tree.html#xmlDOMWrapNewCtxt">xmlDOMWrapNewCtxt</a><br /> +</dd><dt>Allows</dt><dd><a href="html/libxml-catalog.html#xmlCatalogSetDefaultPrefer">xmlCatalogSetDefaultPrefer</a><br /> +<a href="html/libxml-xmlschemas.html#xmlSchemaValidateSetLocator">xmlSchemaValidateSetLocator</a><br /> +</dd><dt>AlphabeticPresentationForms</dt><dd><a href="html/libxml-xmlunicode.html#xmlUCSIsAlphabeticPresentationForms">xmlUCSIsAlphabeticPresentationForms</a><br /> +</dd><dt>Also</dt><dd><a href="html/libxml-xmlstring.html#xmlCheckUTF8">xmlCheckUTF8</a><br /> +<a href="html/libxml-parserInternals.html#xmlParseAttribute">xmlParseAttribute</a><br /> +<a href="html/libxml-valid.html#xmlValidCtxtNormalizeAttributeValue">xmlValidCtxtNormalizeAttributeValue</a><br /> +</dd><dt>Always</dt><dd><a href="html/libxml-parserInternals.html#IS_COMBINING_CH">IS_COMBINING_CH</a><br /> +</dd><dt>Append</dt><dd><a href="html/libxml-tree.html#xmlBufferCCat">xmlBufferCCat</a><br /> +<a href="html/libxml-tree.html#xmlBufferCat">xmlBufferCat</a><br /> +<a href="html/libxml-tree.html#xmlNodeAddContent">xmlNodeAddContent</a><br /> +<a href="html/libxml-tree.html#xmlNodeAddContentLen">xmlNodeAddContentLen</a><br /> +</dd><dt>Appendix</dt><dd><a href="html/libxml-xmlregexp.html#xmlRegexpCompile">xmlRegexpCompile</a><br /> +</dd><dt>Appends</dt><dd><a href="html/libxml-xmlschemastypes.html#xmlSchemaValueAppend">xmlSchemaValueAppend</a><br /> +</dd><dt>Applies</dt><dd><a href="html/libxml-HTMLparser.html#htmlCtxtUseOptions">htmlCtxtUseOptions</a><br /> +<a href="html/libxml-parser.html#xmlCtxtUseOptions">xmlCtxtUseOptions</a><br /> +<a href="html/libxml-uri.html#xmlNormalizeURIPath">xmlNormalizeURIPath</a><br /> +<a href="html/libxml-xpath.html#xmlXPathCompiledEvalToBoolean">xmlXPathCompiledEvalToBoolean</a><br /> +</dd><dt>Apply</dt><dd><a href="html/libxml-schemasInternals.html#XML_SCHEMAS_ANYATTR_STRICT">XML_SCHEMAS_ANYATTR_STRICT</a><br /> +<a href="html/libxml-schemasInternals.html#XML_SCHEMAS_ANY_STRICT">XML_SCHEMAS_ANY_STRICT</a><br /> +</dd><dt>Arabic</dt><dd><a href="html/libxml-xmlunicode.html#xmlUCSIsArabic">xmlUCSIsArabic</a><br /> +</dd><dt>ArabicPresentationForms-A</dt><dd><a href="html/libxml-xmlunicode.html#xmlUCSIsArabicPresentationFormsA">xmlUCSIsArabicPresentationFormsA</a><br /> +</dd><dt>ArabicPresentationForms-B</dt><dd><a href="html/libxml-xmlunicode.html#xmlUCSIsArabicPresentationFormsB">xmlUCSIsArabicPresentationFormsB</a><br /> +</dd><dt>Armenian</dt><dd><a href="html/libxml-xmlunicode.html#xmlUCSIsArmenian">xmlUCSIsArmenian</a><br /> +</dd><dt>Array</dt><dd><a href="html/libxml-xpath.html#_xmlXPathContext">_xmlXPathContext</a><br /> +</dd><dt>Arrows</dt><dd><a href="html/libxml-xmlunicode.html#xmlUCSIsArrows">xmlUCSIsArrows</a><br /> +</dd><dt>Associate</dt><dd><a href="html/libxml-tree.html#xmlSetNs">xmlSetNs</a><br /> +</dd><dt>Att</dt><dd><a href="html/libxml-parserInternals.html#xmlParseStartTag">xmlParseStartTag</a><br /> +</dd><dt>AttDef</dt><dd><a href="html/libxml-parserInternals.html#xmlParseAttributeListDecl">xmlParseAttributeListDecl</a><br /> +</dd><dt>AttType</dt><dd><a href="html/libxml-parserInternals.html#xmlParseAttributeListDecl">xmlParseAttributeListDecl</a><br /> +<a href="html/libxml-parserInternals.html#xmlParseAttributeType">xmlParseAttributeType</a><br /> +</dd><dt>AttValue</dt><dd><a href="html/libxml-HTMLparser.html#htmlParseElement">htmlParseElement</a><br /> +<a href="html/libxml-parserInternals.html#xmlParseAttValue">xmlParseAttValue</a><br /> +<a href="html/libxml-parserInternals.html#xmlParseAttribute">xmlParseAttribute</a><br /> +<a href="html/libxml-parserInternals.html#xmlParseDefaultDecl">xmlParseDefaultDecl</a><br /> +</dd><dt>AttlistDecl</dt><dd><a href="html/libxml-parserInternals.html#xmlParseAttributeListDecl">xmlParseAttributeListDecl</a><br /> +<a href="html/libxml-parserInternals.html#xmlParseMarkupDecl">xmlParseMarkupDecl</a><br /> +</dd><dt>Attribute</dt><dd><a href="html/libxml-tree.html#_xmlAttribute">_xmlAttribute</a><br /> +<a href="html/libxml-HTMLparser.html#htmlNodeStatus">htmlNodeStatus</a><br /> +<a href="html/libxml-HTMLparser.html#htmlParseElement">htmlParseElement</a><br /> +<a href="html/libxml-parserInternals.html#xmlParseAttribute">xmlParseAttribute</a><br /> +<a href="html/libxml-parserInternals.html#xmlParseAttributeListDecl">xmlParseAttributeListDecl</a><br /> +<a href="html/libxml-parserInternals.html#xmlParseAttributeType">xmlParseAttributeType</a><br /> +<a href="html/libxml-parserInternals.html#xmlParseDefaultDecl">xmlParseDefaultDecl</a><br /> +<a href="html/libxml-parserInternals.html#xmlParseStartTag">xmlParseStartTag</a><br /> +<a href="html/libxml-xmlreader.html#xmlTextReaderIsDefault">xmlTextReaderIsDefault</a><br /> +<a href="html/libxml-xmlreader.html#xmlTextReaderMoveToElement">xmlTextReaderMoveToElement</a><br /> +<a href="html/libxml-valid.html#xmlValidateAttributeDecl">xmlValidateAttributeDecl</a><br /> +<a href="html/libxml-valid.html#xmlValidateOneAttribute">xmlValidateOneAttribute</a><br /> +<a href="html/libxml-valid.html#xmlValidateOneElement">xmlValidateOneElement</a><br /> +<a href="html/libxml-valid.html#xmlValidateOneNamespace">xmlValidateOneNamespace</a><br /> +</dd><dt>Attribute-Value</dt><dd><a href="html/libxml-parserInternals.html#xmlParseAttValue">xmlParseAttValue</a><br /> +</dd><dt>Attributes</dt><dd><a href="html/libxml-HTMLparser.html#_htmlElemDesc">_htmlElemDesc</a><br /> +<a href="html/libxml-parserInternals.html#xmlParseNotationType">xmlParseNotationType</a><br /> +<a href="html/libxml-valid.html#xmlValidateOneAttribute">xmlValidateOneAttribute</a><br /> +<a href="html/libxml-valid.html#xmlValidateOneNamespace">xmlValidateOneNamespace</a><br /> +<a href="html/libxml-xpointer.html#xmlXPtrBuildNodeList">xmlXPtrBuildNodeList</a><br /> +</dd><dt>Automatic</dt><dd><a href="html/libxml-DOCBparser.html#docbCreateFileParserCtxt">docbCreateFileParserCtxt</a><br /> +<a href="html/libxml-DOCBparser.html#docbParseFile">docbParseFile</a><br /> +<a href="html/libxml-DOCBparser.html#docbSAXParseFile">docbSAXParseFile</a><br /> +<a href="html/libxml-parserInternals.html#htmlCreateFileParserCtxt">htmlCreateFileParserCtxt</a><br /> +<a href="html/libxml-HTMLparser.html#htmlParseFile">htmlParseFile</a><br /> +<a href="html/libxml-HTMLparser.html#htmlSAXParseFile">htmlSAXParseFile</a><br /> +<a href="html/libxml-parserInternals.html#xmlCreateEntityParserCtxt">xmlCreateEntityParserCtxt</a><br /> +<a href="html/libxml-parserInternals.html#xmlCreateFileParserCtxt">xmlCreateFileParserCtxt</a><br /> +<a href="html/libxml-parserInternals.html#xmlCreateURLParserCtxt">xmlCreateURLParserCtxt</a><br /> +<a href="html/libxml-xmlIO.html#xmlOutputBufferCreateFilename">xmlOutputBufferCreateFilename</a><br /> +<a href="html/libxml-parser.html#xmlParseFile">xmlParseFile</a><br /> +<a href="html/libxml-xmlIO.html#xmlParserInputBufferCreateFilename">xmlParserInputBufferCreateFilename</a><br /> +<a href="html/libxml-parser.html#xmlRecoverFile">xmlRecoverFile</a><br /> +<a href="html/libxml-parser.html#xmlSAXParseFile">xmlSAXParseFile</a><br /> +<a href="html/libxml-parser.html#xmlSAXParseFileWithData">xmlSAXParseFileWithData</a><br /> +<a href="html/libxml-parser.html#xmlSAXUserParseFile">xmlSAXUserParseFile</a><br /> +</dd><dt>Automatically</dt><dd><a href="html/libxml-chvalid.html#xmlIsBaseCharQ">xmlIsBaseCharQ</a><br /> +<a href="html/libxml-chvalid.html#xmlIsBaseChar_ch">xmlIsBaseChar_ch</a><br /> +<a href="html/libxml-chvalid.html#xmlIsBlankQ">xmlIsBlankQ</a><br /> +<a href="html/libxml-chvalid.html#xmlIsBlank_ch">xmlIsBlank_ch</a><br /> +<a href="html/libxml-chvalid.html#xmlIsCharQ">xmlIsCharQ</a><br /> +<a href="html/libxml-chvalid.html#xmlIsChar_ch">xmlIsChar_ch</a><br /> +<a href="html/libxml-chvalid.html#xmlIsCombiningQ">xmlIsCombiningQ</a><br /> +<a href="html/libxml-chvalid.html#xmlIsDigitQ">xmlIsDigitQ</a><br /> +<a href="html/libxml-chvalid.html#xmlIsDigit_ch">xmlIsDigit_ch</a><br /> +<a href="html/libxml-chvalid.html#xmlIsExtenderQ">xmlIsExtenderQ</a><br /> +<a href="html/libxml-chvalid.html#xmlIsExtender_ch">xmlIsExtender_ch</a><br /> +<a href="html/libxml-chvalid.html#xmlIsIdeographicQ">xmlIsIdeographicQ</a><br /> +<a href="html/libxml-chvalid.html#xmlIsPubidCharQ">xmlIsPubidCharQ</a><br /> +<a href="html/libxml-chvalid.html#xmlIsPubidChar_ch">xmlIsPubidChar_ch</a><br /> +</dd></dl><h2>Letter B:</h2><dl><dt>BASE</dt><dd><a href="html/libxml-tree.html#xmlNodeGetBase">xmlNodeGetBase</a><br /> +</dd><dt>BAr</dt><dd><a href="html/libxml-xpathInternals.html#xmlXPathTranslateFunction">xmlXPathTranslateFunction</a><br /> +</dd><dt>BOM</dt><dd><a href="html/libxml-encoding.html#xmlCharEncOutFunc">xmlCharEncOutFunc</a><br /> +</dd><dt>Balanced</dt><dd><a href="html/libxml-parser.html#xmlParseBalancedChunkMemory">xmlParseBalancedChunkMemory</a><br /> +<a href="html/libxml-parser.html#xmlParseBalancedChunkMemoryRecover">xmlParseBalancedChunkMemoryRecover</a><br /> +<a href="html/libxml-parser.html#xmlParseEntity">xmlParseEntity</a><br /> +<a href="html/libxml-parser.html#xmlParseInNodeContext">xmlParseInNodeContext</a><br /> +<a href="html/libxml-parser.html#xmlSAXParseEntity">xmlSAXParseEntity</a><br /> +</dd><dt>Base</dt><dd><a href="html/libxml-parser.html#_xmlParserInput">_xmlParserInput</a><br /> +<a href="html/libxml-schemasInternals.html#_xmlSchemaType">_xmlSchemaType</a><br /> +<a href="html/libxml-tree.html#xmlNodeGetBase">xmlNodeGetBase</a><br /> +</dd><dt>BaseChar</dt><dd><a href="html/libxml-parserInternals.html#IS_BASECHAR">IS_BASECHAR</a><br /> +<a href="html/libxml-parserInternals.html#IS_LETTER">IS_LETTER</a><br /> +<a href="html/libxml-parserInternals.html#xmlIsLetter">xmlIsLetter</a><br /> +</dd><dt>Based</dt><dd><a href="html/libxml-xmlregexp.html#xmlExpExpDerive">xmlExpExpDerive</a><br /> +<a href="html/libxml-xpath.html#xmlXPathIsInf">xmlXPathIsInf</a><br /> +<a href="html/libxml-xpath.html#xmlXPathIsNaN">xmlXPathIsNaN</a><br /> +</dd><dt>BasicLatin</dt><dd><a href="html/libxml-xmlunicode.html#xmlUCSIsBasicLatin">xmlUCSIsBasicLatin</a><br /> +</dd><dt>Basically</dt><dd><a href="html/libxml-valid.html#xmlValidateDtd">xmlValidateDtd</a><br /> +</dd><dt>Before</dt><dd><a href="html/libxml-parserInternals.html#xmlParseAttValue">xmlParseAttValue</a><br /> +</dd><dt>Behaves</dt><dd><a href="html/libxml-parserInternals.html#IS_CHAR_CH">IS_CHAR_CH</a><br /> +<a href="html/libxml-parserInternals.html#IS_DIGIT_CH">IS_DIGIT_CH</a><br /> +<a href="html/libxml-parserInternals.html#IS_EXTENDER_CH">IS_EXTENDER_CH</a><br /> +</dd><dt>Behaviour</dt><dd><a href="html/libxml-parserInternals.html#IS_BLANK_CH">IS_BLANK_CH</a><br /> +</dd><dt>Bengali</dt><dd><a href="html/libxml-xmlunicode.html#xmlUCSIsBengali">xmlUCSIsBengali</a><br /> +</dd><dt>Best</dt><dd><a href="html/libxml-xmlreader.html#xmlTextReaderGetRemainder">xmlTextReaderGetRemainder</a><br /> +</dd><dt>BinHex</dt><dd><a href="html/libxml-xmlwriter.html#xmlTextWriterWriteBinHex">xmlTextWriterWriteBinHex</a><br /> +</dd><dt>Bit</dt><dd><a href="html/libxml-parser.html#XML_COMPLETE_ATTRS">XML_COMPLETE_ATTRS</a><br /> +<a href="html/libxml-parser.html#XML_DETECT_IDS">XML_DETECT_IDS</a><br /> +<a href="html/libxml-parser.html#XML_SKIP_IDS">XML_SKIP_IDS</a><br /> +</dd><dt>BlockElements</dt><dd><a href="html/libxml-xmlunicode.html#xmlUCSIsBlockElements">xmlUCSIsBlockElements</a><br /> +</dd><dt>Blocks</dt><dd><a href="html/libxml-parser.html#xmlStopParser">xmlStopParser</a><br /> +</dd><dt>Bopomofo</dt><dd><a href="html/libxml-xmlunicode.html#xmlUCSIsBopomofo">xmlUCSIsBopomofo</a><br /> +</dd><dt>BopomofoExtended</dt><dd><a href="html/libxml-xmlunicode.html#xmlUCSIsBopomofoExtended">xmlUCSIsBopomofoExtended</a><br /> +</dd><dt>Both</dt><dd><a href="html/libxml-parserInternals.html#XML_SUBSTITUTE_BOTH">XML_SUBSTITUTE_BOTH</a><br /> +<a href="html/libxml-pattern.html#xmlStreamPush">xmlStreamPush</a><br /> +<a href="html/libxml-pattern.html#xmlStreamPushAttr">xmlStreamPushAttr</a><br /> +<a href="html/libxml-pattern.html#xmlStreamPushNode">xmlStreamPushNode</a><br /> +</dd><dt>BoxDrawing</dt><dd><a href="html/libxml-xmlunicode.html#xmlUCSIsBoxDrawing">xmlUCSIsBoxDrawing</a><br /> +</dd><dt>BraillePatterns</dt><dd><a href="html/libxml-xmlunicode.html#xmlUCSIsBraillePatterns">xmlUCSIsBraillePatterns</a><br /> +</dd><dt>Brzozowski</dt><dd><a href="html/libxml-xmlregexp.html#xmlExpExpDerive">xmlExpExpDerive</a><br /> +<a href="html/libxml-xmlregexp.html#xmlExpStringDerive">xmlExpStringDerive</a><br /> +</dd><dt>Buffer</dt><dd><a href="html/libxml-parser.html#xmlIOParseDTD">xmlIOParseDTD</a><br /> +</dd><dt>Bugs:</dt><dd><a href="html/libxml-HTMLparser.html#_htmlElemDesc">_htmlElemDesc</a><br /> +</dd><dt>Buhid</dt><dd><a href="html/libxml-xmlunicode.html#xmlUCSIsBuhid">xmlUCSIsBuhid</a><br /> +</dd><dt>Build</dt><dd><a href="html/libxml-valid.html#xmlCopyAttributeTable">xmlCopyAttributeTable</a><br /> +<a href="html/libxml-valid.html#xmlCopyDocElementContent">xmlCopyDocElementContent</a><br /> +<a href="html/libxml-valid.html#xmlCopyElementContent">xmlCopyElementContent</a><br /> +<a href="html/libxml-valid.html#xmlCopyElementTable">xmlCopyElementTable</a><br /> +<a href="html/libxml-entities.html#xmlCopyEntitiesTable">xmlCopyEntitiesTable</a><br /> +<a href="html/libxml-valid.html#xmlCopyNotationTable">xmlCopyNotationTable</a><br /> +<a href="html/libxml-tree.html#xmlGetNodePath">xmlGetNodePath</a><br /> +<a href="html/libxml-tree.html#xmlNodeListGetString">xmlNodeListGetString</a><br /> +<a href="html/libxml-xmlregexp.html#xmlRegNewExecCtxt">xmlRegNewExecCtxt</a><br /> +<a href="html/libxml-valid.html#xmlValidBuildContentModel">xmlValidBuildContentModel</a><br /> +<a href="html/libxml-valid.html#xmlValidGetPotentialChildren">xmlValidGetPotentialChildren</a><br /> +<a href="html/libxml-xpointer.html#xmlXPtrBuildNodeList">xmlXPtrBuildNodeList</a><br /> +</dd><dt>Builds</dt><dd><a href="html/libxml-tree.html#xmlBuildQName">xmlBuildQName</a><br /> +<a href="html/libxml-tree.html#xmlNodeListGetRawString">xmlNodeListGetRawString</a><br /> +</dd><dt>But</dt><dd><a href="html/libxml-valid.html#xmlValidateNotationDecl">xmlValidateNotationDecl</a><br /> +</dd><dt>ByzantineMusicalSymbols</dt><dd><a href="html/libxml-xmlunicode.html#xmlUCSIsByzantineMusicalSymbols">xmlUCSIsByzantineMusicalSymbols</a><br /> +</dd></dl><h2 align="center"><a href="APIchunk0.html">A-B</a> +<a href="APIchunk1.html">C-C</a> +<a href="APIchunk2.html">D-E</a> +<a href="APIchunk3.html">F-I</a> +<a href="APIchunk4.html">J-N</a> +<a href="APIchunk5.html">O-P</a> +<a href="APIchunk6.html">Q-R</a> +<a href="APIchunk7.html">S-S</a> +<a href="APIchunk8.html">T-U</a> +<a href="APIchunk9.html">V-X</a> +<a href="APIchunk10.html">Y-a</a> +<a href="APIchunk11.html">b-b</a> +<a href="APIchunk12.html">c-c</a> +<a href="APIchunk13.html">d-d</a> +<a href="APIchunk14.html">e-e</a> +<a href="APIchunk15.html">f-f</a> +<a href="APIchunk16.html">g-h</a> +<a href="APIchunk17.html">i-i</a> +<a href="APIchunk18.html">j-l</a> +<a href="APIchunk19.html">m-m</a> +<a href="APIchunk20.html">n-n</a> +<a href="APIchunk21.html">o-o</a> +<a href="APIchunk22.html">p-p</a> +<a href="APIchunk23.html">q-r</a> +<a href="APIchunk24.html">s-s</a> +<a href="APIchunk25.html">t-t</a> +<a href="APIchunk26.html">u-v</a> +<a href="APIchunk27.html">w-w</a> +<a href="APIchunk28.html">x-x</a> +<a href="APIchunk29.html">y-z</a> +</h2><p><a href="bugs.html">Daniel Veillard</a></p></td></tr></table></td></tr></table></td></tr></table></td></tr></table></td></tr></table></body></html>
