2020-08-21  Rolf Ade  <rolf@pointsman.de>

        Added tdom::schema command.

2020-08-21  Rolf Ade  <rolf@pointsman.de>

        Added -onlyContents and -breakLines to asHTML.

2020-08-17  Rolf Ade  <rolf@pointsman.de>

        Updated TEA.

2020-07-23  Rolf Ade  <rolf@pointsman.de>

        Added -indent value "tab" to asXML and asJSON.

2020-07-03  Rolf Ade  <rolf@pointsman.de>

        User configurable separator character between namespace URI
        and local name for XML namespace-aware SAX parser:  Added the
        option -namespaceseparator to the expat command.

2020-05-14  Rolf Ade  <rolf@pointsman.de>

        Added method clearString to the dom command.

2019-12-31  Rolf Ade  <rolf@pointsman.de>

        Updated to expat 2.2.9.

2018-10-12  Rolf Ade  <rolf@pointsman.de>

        Updated to expat 2.2.6.

2018-08-08  Rolf Ade  <rolf@pointsman.de>

        Changed the license to MPL 2.0.

## tDOM - a XML / DOM / XPath / XSLT / HTML / JSON implementation for Tcl
### Version 0.9.2





### tDOM contains:

   *  for convenience expat 2.2.9, the XML parser originated from
      James Clark, although you're able to link tDOM with other
      expat versions or the library provided by the system.

   *  building a DOM tree from XML in one go implemented in C for
      maximum performance and minimum memory usage, and DOM I and II
      methods to work on such a tree using either a OO-like or a
      handle syntax.

   *  a Tcl interface to expat for event-like (SAX-like) XML parsing.

   *  a complete, compliant and fast XPath implementation in C
      following the November 99 W3C recommendation for navigating and
      data extraction.

   *  a fast XSLT implementation in C following the W3C Recommendation
      16 November 1999.
   
   *  optional DTD validation.

   *  a rich and Tcl'ish language to describe structures and to
      validate XML data or DOM trees or other forms of hierarchically
      data with that.
   
   *  a JSON parser which parses any possible JSON input into a DOM
      tree without losing information.

   *  an efficient and Tcl'ish way to create XML and HTML documents
      and JSON strings.

   *  as build option an interface to the gumbo HTML5 parser, which
      also digests almost any other HTML.

   *  an even faster simple XML parser for trusted XML input.

   *  a slim Tcl interface to use expat as pull-parser.

   *  a secure way to share DOM trees by threads

   *  additional convenience methods.

   *  and more.


### Documentation

The documentation is included into the source distribution in HTML and
man format. Alternatively, read it
[online](http://tdom.org/index.html/doc/trunk/doc/index.html).


### Getting the code

The development repository is hosted at <http://tdom.org> and is
mirrored at <http://core.tcl.tk/tdom>. You are invited to use trunk
which you get as
[tarball](http://tdom.org/index.html/tarball/trunk/tdom-trunk.tar.gz)
or as [zip archive](http://tdom.org/index.html/zip/trunk/tdom-trunk.zip)



The latest release is 0.9.2. Get the source code as
[tarball](http://tdom.org/downloads/tdom-0.9.2-src.tgz) or
as [zip archive](http://tdom.org/downloads/tdom-0.9.2-src.zip).


Windows binaries of the 0.9.2 release are also available. Get it for
[64 bit](http://tdom.org/downloads/tdom-0.9.2-windows-x64.zip) or [32
bit](http://tdom.org/downloads/tdom-0.9.2-windows-x86.zip).

The provided windows binaries include (statically linked) the
HTML5 parser.


### Compiling tdom

Depending on your platform (unix/mac or win), go to the
corresponding directory and invoke the configure script:

    ../configure
    make 
    make test
    make install

Alternatively, you can build the tDOM package in just about any
directory elsewhere on the filesystem (since TEA-compatible).

You might also want to do "../configure --help" to get a list of
all supported options of the configure script. In the "unix"
directory there is a "CONFIG" file containing some examples on how
to invoke the "configure" script for some common cases. You can
peek there. This file also includes a short description of the
tDOM specific configure options.

Since tDOM is TEA-compatible you should be able to build it using
the MinGW build environment for Windows. There is also the MSVC
nmake file so you can compile the package with Microsoft tools.
Refer to the README in the win directory for more details about
building on Windows.

The compile process will build the tDOM shared library suitable for
loading into the Tcl shell using standard "package require" mechanism.


### Reporting bugs

Open a [ticket](http://tdom.org/index.html/ticket). Log in as
anonymous and report your findings. If you prefer to have an
individual login write Rolf a mail.


### History

tDOM was started by Jochen Loewer (loewerj@hotmail.com) and
developed by Jochen and Rolf Ade (rolf@pointsman.de) with
contributions by Zoran Vasiljevic (zv@archiware.com). Since more
than a dozen years it is maintained and developed by Rolf Ade.


### ... ahh, Licensing!!

Sigh. See LICENSE file.

# This is a (too) simple DTD to tDOM schema converter.
#
# It should work for not namespaced document types and namespaced
# document types with the elements in a default namespace. In case of
# namespaced document types with prefixed elements the generated
# schema file will not be usable, but may be a starting point.

package require tdom
package require uri

variable dtdStart ""
variable dtdFinished 0
variable indent 4

}
    
proc fromDTD_generate {} {
    variable dtdStart
    variable dtdElements
    variable dtdAttributes
    variable nslookup
    
    if {$dtdStart ne ""} {
        if {![info exists dtdElements($dtdStart)]} {
            puts "Document element not defined."
            exit 1
        }
        set ns ""
        foreach {attkey attDef} [array get dtdAttributes $dtdStart,*] {
            lassign $attDef attname type default isRequired
            if {$attname eq "xmlns"} {
                set ns $default
            }
        }
        if {$ns eq ""} {
            puts "start $dtdStart"
        } else {
            puts "start $dtdStart $ns"
        }
    }
    set elements [lsort [array names dtdElements]]
    if {$dtdStart ne "" && [info exists dtdElements($dtdStart)]} {
        set startInd [lsearch -exact $elements $dtdStart]
        set elements [lreplace $elements $startInd $startInd]
        set elements [linsert $elements 0 $dtdStart]
    }
    set level 1

proc fromDTDfile {file} {
    setupFromDTDParser $file
    p parse "<!DOCTYPE svg SYSTEM \"$file\"><svg/>"
    p free
}

proc usage {} {
    puts "$argv0 <XML-with-DTD>"
}

proc run {args} {
    if {[llength $args] == 1} {
        set file [lindex $args 0]
        if {![file readable $file] || ![file isfile $file]} {
            puts stderr "Can't open '$file'"

# include <stdint.h>
#endif
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif"

ac_subst_vars='LTLIBOBJS

PKG_STUB_LIB_PATH
PKG_BUILD_STUB_LIB_PATH
PKG_STUB_LIB_SPEC
PKG_BUILD_STUB_LIB_SPEC
TDOMSHELL
TCLSH_PROG
VC_MANIFEST_EMBED_EXE
VC_MANIFEST_EMBED_DLL
RANLIB_STUB
MAKE_STUB_LIB
MAKE_STATIC_LIB
MAKE_SHARED_LIB
MAKE_LIB

LDFLAGS_DEFAULT
CFLAGS_DEFAULT
TDOM_LD_SEARCH_FLAGS
LD_LIBRARY_PATH_VAR
SHLIB_CFLAGS
SHLIB_LD_LIBS
SHLIB_LD
STLIB_LD
LDFLAGS_OPTIMIZE
LDFLAGS_DEBUG
CFLAGS_WARNING
CFLAGS_OPTIMIZE
CFLAGS_DEBUG
LIBOBJS
RC

AR
STUBS_BUILD
SHARED_BUILD
TCL_THREADS
TCL_INCLUDES
PKG_CONFIG
PKG_OBJECTS

pdfdir
dvidir
htmldir
infodir
docdir
oldincludedir
includedir
runstatedir
localstatedir
sharedstatedir
sysconfdir
datadir
datarootdir
libexecdir
sbindir

with_tclinclude
enable_threads
enable_shared
enable_stubs
enable_64bit
enable_64bit_vis
enable_rpath


enable_symbols
enable_dtd
enable_ns
enable_ucmd
enable_tdomalloc
enable_lessns
enable_schema

sbindir='${exec_prefix}/sbin'
libexecdir='${exec_prefix}/libexec'
datarootdir='${prefix}/share'
datadir='${datarootdir}'
sysconfdir='${prefix}/etc'
sharedstatedir='${prefix}/com'
localstatedir='${prefix}/var'
runstatedir='${localstatedir}/run'
includedir='${prefix}/include'
oldincludedir='/usr/include'
docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
infodir='${datarootdir}/info'
htmldir='${docdir}'
dvidir='${docdir}'
pdfdir='${docdir}'

    ac_prev=psdir ;;
  -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
    psdir=$ac_optarg ;;

  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
  | -silent | --silent | --silen | --sile | --sil)
    silent=yes ;;

  -runstatedir | --runstatedir | --runstatedi | --runstated \
  | --runstate | --runstat | --runsta | --runst | --runs \
  | --run | --ru | --r)
    ac_prev=runstatedir ;;
  -runstatedir=* | --runstatedir=* | --runstatedi=* | --runstated=* \
  | --runstate=* | --runstat=* | --runsta=* | --runst=* | --runs=* \
  | --run=* | --ru=* | --r=*)
    runstatedir=$ac_optarg ;;

  -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
    ac_prev=sbindir ;;
  -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
  | --sbi=* | --sb=*)
    sbindir=$ac_optarg ;;

  esac
fi

# Check all directory arguments for consistency.
for ac_var in	exec_prefix prefix bindir sbindir libexecdir datarootdir \
		datadir sysconfdir sharedstatedir localstatedir includedir \
		oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
		libdir localedir mandir runstatedir
do
  eval ac_val=\$$ac_var
  # Remove trailing slashes.
  case $ac_val in
    */ )
      ac_val=`expr "X$ac_val" : 'X\(.*[^/]\)' \| "X$ac_val" : 'X\(.*\)'`
      eval $ac_var=\$ac_val;;

Fine tuning of the installation directories:
  --bindir=DIR            user executables [EPREFIX/bin]
  --sbindir=DIR           system admin executables [EPREFIX/sbin]
  --libexecdir=DIR        program executables [EPREFIX/libexec]
  --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
  --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
  --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
  --runstatedir=DIR       modifiable per-process data [LOCALSTATEDIR/run]
  --libdir=DIR            object code libraries [EPREFIX/lib]
  --includedir=DIR        C header files [PREFIX/include]
  --oldincludedir=DIR     C header files for non-gcc [/usr/include]
  --datarootdir=DIR       read-only arch.-independent data root [PREFIX/share]
  --datadir=DIR           read-only architecture-independent data [DATAROOTDIR]
  --infodir=DIR           info documentation [DATAROOTDIR/info]
  --localedir=DIR         locale-dependent data [DATAROOTDIR/locale]

  --enable-threads        build with threads (default: on)
  --enable-shared         build and link with shared libraries (default: on)
  --enable-stubs          build and link with stub libraries. Always true for
                          shared builds (default: on)
  --enable-64bit          enable 64bit support (default: off)
  --enable-64bit-vis      enable 64bit Sparc VIS support (default: off)
  --disable-rpath         disable rpath support (default: on)

  --enable-symbols        build with debugging symbols (default: off)
  --enable-dtd            build with dtd support (default: on)
  --enable-ns             build with XML namespace support (default: on)
  --enable-unknown        enable built-in unknown command (default: off)
  --enable-tdomalloc      build with the tDOM allocator (default: off)
  --enable-lessns         build with lower limit for XML ns declarations
                          (default: off)
  --enable-schema         build with valiation features (default: on)

Optional Packages:
  --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
  --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
  --with-tcl              directory containing tcl configuration
                          (tclConfig.sh)
  --with-aolserver        directory with AOLserver distribution
  --with-expat            directory with expat installation
  --with-entropy          source of entropy to use
  --with-tclinclude       directory containing the public Tcl header files


Some influential environment variables:
  CC          C compiler command
  CFLAGS      C compiler flags
  LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
              nonstandard directory <lib dir>
  LIBS        libraries to pass to the linker, e.g. -l<library>

fi
eval ac_res=\$$3
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno

} # ac_fn_c_check_func

# ac_fn_c_check_type LINENO TYPE VAR INCLUDES
# -------------------------------------------
# Tests whether TYPE exists after having included INCLUDES, setting cache
# variable VAR accordingly.
ac_fn_c_check_type ()
{
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
$as_echo_n "checking for $2... " >&6; }
if eval \${$3+:} false; then :
  $as_echo_n "(cached) " >&6
else
  eval "$3=no"
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
$4
int
main ()
{
if (sizeof ($2))
	 return 0;
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
$4
int
main ()
{
if (sizeof (($2)))
	    return 0;
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :

else
  eval "$3=yes"
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
eval ac_res=\$$3
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno

} # ac_fn_c_check_type

# ac_fn_c_check_header_mongrel LINENO HEADER VAR INCLUDES
# -------------------------------------------------------
# Tests whether HEADER exists, giving a warning if it cannot be compiled using
# the include files in INCLUDES and setting the cache variable VAR
# accordingly.
ac_fn_c_check_header_mongrel ()
{
  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
  if eval \${$3+:} false; then :
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
$as_echo_n "checking for $2... " >&6; }
if eval \${$3+:} false; then :
  $as_echo_n "(cached) " >&6
fi
eval ac_res=\$$3
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
else
  # Is the header compilable?
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
$as_echo_n "checking $2 usability... " >&6; }
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
$4
#include <$2>
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  ac_header_compiler=yes
else
  ac_header_compiler=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
$as_echo "$ac_header_compiler" >&6; }

# Is the header present?
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
$as_echo_n "checking $2 presence... " >&6; }
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include <$2>
_ACEOF
if ac_fn_c_try_cpp "$LINENO"; then :
  ac_header_preproc=yes
else
  ac_header_preproc=no
fi
rm -f conftest.err conftest.i conftest.$ac_ext
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
$as_echo "$ac_header_preproc" >&6; }

# So?  What about this header?
case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in #((
  yes:no: )
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
$as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
    ;;
  no:yes:* )
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
$as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
$as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
$as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
$as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
    ;;
esac
  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
$as_echo_n "checking for $2... " >&6; }
if eval \${$3+:} false; then :
  $as_echo_n "(cached) " >&6
else
  eval "$3=\$ac_header_compiler"
fi
eval ac_res=\$$3
	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
$as_echo "$ac_res" >&6; }
fi
  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno

} # ac_fn_c_check_header_mongrel
cat >config.log <<_ACEOF
This file contains any messages produced by compilers while
running configure, to aid debugging if configure makes a mistake.

It was created by tdom $as_me 0.9.2, which was
generated by GNU Autoconf 2.69.  Invocation command line was

    # If the user did not set CFLAGS, set it now to keep macros
    # like AC_PROG_CC and AC_TRY_COMPILE from adding "-g -O2".
    if test "${CFLAGS+set}" != "set" ; then
	CFLAGS=""
    fi

    case "`uname -s`" in
	*win32*|*WIN32*|*MINGW32_*|*MINGW64_*|*MSYS_*)
	    # Extract the first word of "cygpath", so it can be a program name with args.
set dummy cygpath; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_prog_CYGPATH+:} false; then :
  $as_echo_n "(cached) " >&6
else

	    if test "$?" -ne 0 ; then
		{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: can't find uname command" >&5
$as_echo "$as_me: WARNING: can't find uname command" >&2;}
		tcl_cv_sys_version=unknown
	    else
		if test "`uname -s`" = "AIX" ; then
		    tcl_cv_sys_version=AIX-`uname -v`.`uname -r`
		fi
		if test "`uname -s`" = "NetBSD" -a -f /etc/debian_version ; then
		    tcl_cv_sys_version=NetBSD-Debian
		fi
	    fi
	fi

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_sys_version" >&5
$as_echo "$tcl_cv_sys_version" >&6; }

	    fi

	    # on Darwin, check in Framework installation locations
	    if test "`uname -s`" = "Darwin" -a x"${ac_cv_c_tclconfig}" = x ; then
		for i in `ls -d ~/Library/Frameworks 2>/dev/null` \
			`ls -d /Library/Frameworks 2>/dev/null` \
			`ls -d /Network/Library/Frameworks 2>/dev/null` \

			`ls -d /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/Library/Frameworks/Tcl.framework 2>/dev/null` \
			`ls -d /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/Network/Library/Frameworks/Tcl.framework 2>/dev/null` \
			`ls -d /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/Tcl.framework 2>/dev/null` \
			; do
		    if test -f "$i/Tcl.framework/tclConfig.sh" ; then
			ac_cv_c_tclconfig="`(cd $i/Tcl.framework; pwd)`"
			break

$as_echo "loading" >&6; }
	. "${TCL_BIN_DIR}/tclConfig.sh"
    else
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: could not find ${TCL_BIN_DIR}/tclConfig.sh" >&5
$as_echo "could not find ${TCL_BIN_DIR}/tclConfig.sh" >&6; }
    fi





    # If the TCL_BIN_DIR is the build directory (not the install directory),
    # then set the common variable name to the value of the build variables.
    # For example, the variable TCL_LIB_SPEC will be set to the value
    # of TCL_BUILD_LIB_SPEC. An extension should make use of TCL_LIB_SPEC
    # instead of TCL_BUILD_LIB_SPEC since it will work with both an
    # installed and uninstalled version of Tcl.
    if test -f "${TCL_BIN_DIR}/Makefile" ; then

		    TCL_STUB_LIB_SPEC="-L`echo "${TCL_BIN_DIR}"  | sed -e 's/ /\\\\ /g'` ${TCL_STUB_LIB_FLAG}"
		    TCL_STUB_LIB_PATH="${TCL_BIN_DIR}/${TCL_STUB_LIB_FILE}"
		fi
		;;
	esac
    fi

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :

	    # first test we've already retrieved platform (cross-compile), fallback to unix otherwise:
	    TEA_PLATFORM="${TEA_PLATFORM-unix}"
	    CYGPATH=echo

else

	    TEA_PLATFORM="windows"
	    # Extract the first word of "cygpath", so it can be a program name with args.
set dummy cygpath; ac_word=$2

    if test x"${ac_cv_c_expat}" = x ; then
        { $as_echo "$as_me:${as_lineno-$LINENO}: result: Using bundled expat distribution" >&5
$as_echo "Using bundled expat distribution" >&6; }

    vars="expat/xmlrole.c \
                         expat/xmltok.c \
                         expat/xmlparse.c"

    for i in $vars; do
	case $i in
	    \$*)
		# allow $-var names
		PKG_SOURCES="$PKG_SOURCES $i"
		PKG_OBJECTS="$PKG_OBJECTS $i"
		;;

    vars="-lexpat"
    for i in $vars; do
	if test "${TEA_PLATFORM}" = "windows" -a "$GCC" = "yes" ; then
	    # Convert foo.lib to -lfoo for GCC.  No-op if not *.lib
	    i=`echo "$i" | sed -e 's/^\([^-].*\)\.[lL][iI][bB]$/-l\1/'`
	fi
	PKG_LIBS="$PKG_LIBS $i"
    done


    fi

$as_echo "#define XML_POOR_ENTROPY 1" >>confdefs.h

            ;;
            *)
                as_fn_error $? "${with_entropy} not known." "$LINENO" 5
        esac


#--------------------------------------------------------------------
# We need the UINT2PTR and PTR2UINT macros, so make sure that intptr_t
# is defined.
#--------------------------------------------------------------------

ac_fn_c_check_type "$LINENO" "uintptr_t" "ac_cv_type_uintptr_t" "$ac_includes_default"
if test "x$ac_cv_type_uintptr_t" = xyes; then :


$as_echo "#define HAVE_UINTPTR_T 1" >>confdefs.h

else

    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for pointer-size unsigned integer type" >&5
$as_echo_n "checking for pointer-size unsigned integer type... " >&6; }
if ${tcl_cv_uintptr_t+:} false; then :
  $as_echo_n "(cached) " >&6
else

    for tcl_cv_uintptr_t in "unsigned int" "unsigned long" "unsigned long long" \
	    none; do
	if test "$tcl_cv_uintptr_t" != none; then
	    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
$ac_includes_default
int
main ()
{
static int test_array [1 - 2 * !(sizeof (void *) <= sizeof ($tcl_cv_uintptr_t))];
test_array [0] = 0;
return test_array [0];

  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  tcl_ok=yes
else
  tcl_ok=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
	    test "$tcl_ok" = yes && break; fi
    done
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_uintptr_t" >&5
$as_echo "$tcl_cv_uintptr_t" >&6; }
    if test "$tcl_cv_uintptr_t" != none; then

cat >>confdefs.h <<_ACEOF
#define uintptr_t $tcl_cv_uintptr_t
_ACEOF

    fi

fi


#--------------------------------------------------------------------
# Add HTML5 parsing support.
#--------------------------------------------------------------------


    if test -n "$ac_tool_prefix"; then

    vars="${AOL_LIBS} ${HTML5_LIBS}"
    for i in $vars; do
	if test "${TEA_PLATFORM}" = "windows" -a "$GCC" = "yes" ; then
	    # Convert foo.lib to -lfoo for GCC.  No-op if not *.lib
	    i=`echo "$i" | sed -e 's/^\([^-].*\)\.[lL][iI][bB]$/-l\1/'`
	fi
	PKG_LIBS="$PKG_LIBS $i"
    done



    PKG_CFLAGS="$PKG_CFLAGS "

    Building ${PACKAGE_NAME} without threads enabled, but building against Tcl
    that IS thread-enabled.  It is recommended to use --enable-threads." >&5
$as_echo "$as_me: WARNING:
    Building ${PACKAGE_NAME} without threads enabled, but building against Tcl
    that IS thread-enabled.  It is recommended to use --enable-threads." >&2;}
	    fi
	    ;;












    esac



#--------------------------------------------------------------------
# The statement below defines a collection of symbols related to
# building as a shared library instead of a static library.

else
  doRpath=yes
fi

    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $doRpath" >&5
$as_echo "$doRpath" >&6; }



















    # Set the variable "system" to hold the name and version number
    # for the system.


    { $as_echo "$as_me:${as_lineno-$LINENO}: checking system version" >&5
$as_echo_n "checking system version... " >&6; }
if ${tcl_cv_sys_version+:} false; then :

	    if test "$?" -ne 0 ; then
		{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: can't find uname command" >&5
$as_echo "$as_me: WARNING: can't find uname command" >&2;}
		tcl_cv_sys_version=unknown
	    else
		if test "`uname -s`" = "AIX" ; then
		    tcl_cv_sys_version=AIX-`uname -v`.`uname -r`
		fi
		if test "`uname -s`" = "NetBSD" -a -f /etc/debian_version ; then
		    tcl_cv_sys_version=NetBSD-Debian
		fi
	    fi
	fi

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_sys_version" >&5
$as_echo "$tcl_cv_sys_version" >&6; }

  SHLIB_VERSION=""
else
  SHLIB_VERSION=".$SHLIB_VERSION"
fi
    case $system in
	# TEA specific:
	windows)





	    MACHINE="X86"
	    if test "$do64bit" != "no" ; then





		case "$do64bit" in
		    amd64|x64|yes)
			MACHINE="AMD64" ; # default to AMD64 64-bit build

			;;
		    ia64)
			MACHINE="IA64"

			;;
		esac

































































































































	    fi

	    if test "$GCC" != "yes" ; then
	        if test "${SHARED_BUILD}" = "0" ; then
		    runtime=-MT
	        else
		    runtime=-MD
	        fi
	        case "x`echo \${VisualStudioVersion}`" in
	            x1[4-9]*)
		        lflags="${lflags} -nodefaultlib:libucrt.lib"

    vars="ucrt.lib"
    for i in $vars; do
	if test "${TEA_PLATFORM}" = "windows" -a "$GCC" = "yes" ; then
	    # Convert foo.lib to -lfoo for GCC.  No-op if not *.lib
	    i=`echo "$i" | sed -e 's/^\([^-].*\)\.[lL][iI][bB]$/-l\1/'`
	fi
	PKG_LIBS="$PKG_LIBS $i"
    done


	            ;;
	            *)
	            ;;
	        esac

                if test "$do64bit" != "no" ; then

		    CC="cl.exe"

		    RC="rc.exe"
		    lflags="${lflags} -nologo -MACHINE:${MACHINE} "
		    LINKBIN="link.exe"
		    CFLAGS_DEBUG="-nologo -Zi -Od -W3 ${runtime}d"
		    CFLAGS_OPTIMIZE="-nologo -O2 -W2 ${runtime}"
		    # Avoid 'unresolved external symbol __security_cookie'
		    # errors, c.f. http://support.microsoft.com/?id=894573

    vars="bufferoverflowU.lib"
    for i in $vars; do
	if test "${TEA_PLATFORM}" = "windows" -a "$GCC" = "yes" ; then
	    # Convert foo.lib to -lfoo for GCC.  No-op if not *.lib
	    i=`echo "$i" | sed -e 's/^\([^-].*\)\.[lL][iI][bB]$/-l\1/'`
	fi
	PKG_LIBS="$PKG_LIBS $i"
    done








































		else
		    RC="rc"
		    lflags="${lflags} -nologo"
		    LINKBIN="link"
		    CFLAGS_DEBUG="-nologo -Z7 -Od -W3 -WX ${runtime}d"
		    CFLAGS_OPTIMIZE="-nologo -O2 -W2 ${runtime}"
		fi

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cross" >&5
$as_echo "$ac_cv_cross" >&6; }
		      if test "$ac_cv_cross" = "yes"; then
			case "$do64bit" in
			    amd64|x64|yes)
				CC="x86_64-w64-mingw32-${CC}"
				LD="x86_64-w64-mingw32-ld"
				AR="x86_64-w64-mingw32-ar"
				RANLIB="x86_64-w64-mingw32-ranlib"
				RC="x86_64-w64-mingw32-windres"
			    ;;
			    *)
				CC="i686-w64-mingw32-${CC}"
				LD="i686-w64-mingw32-ld"
				AR="i686-w64-mingw32-ar"
				RANLIB="i686-w64-mingw32-ranlib"
				RC="i686-w64-mingw32-windres"
			    ;;
			esac
		fi

		# For information on what debugtype is most useful, see:
		# http://msdn.microsoft.com/library/en-us/dnvc60/html/gendepdebug.asp
		# and also
		# http://msdn2.microsoft.com/en-us/library/y0zzbyt4%28VS.80%29.aspx
		# This essentially turns it all on.
		LDFLAGS_DEBUG="-debug -debugtype:cv"
		LDFLAGS_OPTIMIZE="-release"




		LDFLAGS_CONSOLE="-link -subsystem:console ${lflags}"
		LDFLAGS_WINDOW="-link -subsystem:windows ${lflags}"

	    fi

	    SHLIB_SUFFIX=".dll"
	    SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}.dll'

	    TCL_LIB_VERSIONS_OK=nodots
    	    ;;
	AIX-*)
	    if test "$GCC" != "yes"; then :

		# AIX requires the _r compiler when gcc isn't being used
		case "${CC}" in
		    *_r|*_r\ *)
			# ok ...
			;;
		    *)

	    if test "`uname -m`" = ia64; then :

		# AIX-5 uses ELF style dynamic libraries on IA-64, but not PPC
		SHLIB_LD="/usr/ccs/bin/ld -G -z text"
		if test "$GCC" = yes; then :

		    CC_SEARCH_FLAGS='"-Wl,-R,${LIB_RUNTIME_DIR}"'

else

		    CC_SEARCH_FLAGS='"-R${LIB_RUNTIME_DIR}"'

fi
		LD_SEARCH_FLAGS='-R "${LIB_RUNTIME_DIR}"'

else

		if test "$GCC" = yes; then :

		    SHLIB_LD='${CC} -shared -Wl,-bexpall'

else

		    SHLIB_LD="/bin/ld -bhalt:4 -bM:SRE -bexpall -H512 -T512 -bnoentry"
		    LDFLAGS="$LDFLAGS -brtl"

fi
		SHLIB_LD="${SHLIB_LD} ${SHLIB_LD_FLAGS}"
		CC_SEARCH_FLAGS='"-L${LIB_RUNTIME_DIR}"'
		LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}

fi
	    ;;
	BeOS*)
	    SHLIB_CFLAGS="-fPIC"
	    SHLIB_LD='${CC} -nostart'

{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_bind_inet_ntoa" >&5
$as_echo "$ac_cv_lib_bind_inet_ntoa" >&6; }
if test "x$ac_cv_lib_bind_inet_ntoa" = xyes; then :
  LIBS="$LIBS -lbind -lsocket"
fi

	    ;;
	BSD/OS-2.1*|BSD/OS-3*)
	    SHLIB_CFLAGS=""
	    SHLIB_LD="shlicc -r"
	    SHLIB_SUFFIX=".so"
	    CC_SEARCH_FLAGS=""
	    LD_SEARCH_FLAGS=""
	    ;;
	BSD/OS-4.*)
	    SHLIB_CFLAGS="-export-dynamic -fPIC"
	    SHLIB_LD='${CC} -shared'
	    SHLIB_SUFFIX=".so"
	    LDFLAGS="$LDFLAGS -export-dynamic"
	    CC_SEARCH_FLAGS=""
	    LD_SEARCH_FLAGS=""
	    ;;
	CYGWIN_*)
	    SHLIB_CFLAGS=""
	    SHLIB_LD='${CC} -shared'

	    SHLIB_SUFFIX=".dll"
	    SHLIB_LD_LIBS="${SHLIB_LD_LIBS} -Wl,--out-implib,\$@.a"
	    EXEEXT=".exe"
	    do64bit_ok=yes
	    CC_SEARCH_FLAGS=""
	    LD_SEARCH_FLAGS=""
	    ;;
	dgux*)
	    SHLIB_CFLAGS="-K PIC"
	    SHLIB_LD='${CC} -G'
	    SHLIB_LD_LIBS=""
	    SHLIB_SUFFIX=".so"
	    CC_SEARCH_FLAGS=""
	    LD_SEARCH_FLAGS=""
	    ;;
	Haiku*)
	    LDFLAGS="$LDFLAGS -Wl,--export-dynamic"
	    SHLIB_CFLAGS="-fPIC"
	    SHLIB_SUFFIX=".so"

	    # TEA specific: Needed by Tcl, but not most extensions
	    #AC_DEFINE(_XOPEN_SOURCE, 1, [Do we want to use the XOPEN network library?])
	    #LIBS="$LIBS -lxnet"               # Use the XOPEN network library

	    if test "`uname -m`" = ia64; then :

		SHLIB_SUFFIX=".so"





else

		SHLIB_SUFFIX=".sl"

fi
	    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for shl_load in -ldld" >&5

  tcl_ok=yes
else
  tcl_ok=no
fi

	    if test "$tcl_ok" = yes; then :

		SHLIB_CFLAGS="+z"
		SHLIB_LD="ld -b"
		LDFLAGS="$LDFLAGS -Wl,-E"
		CC_SEARCH_FLAGS='"-Wl,+s,+b,${LIB_RUNTIME_DIR}:."'
		LD_SEARCH_FLAGS='+s +b "${LIB_RUNTIME_DIR}:."'
		LD_LIBRARY_PATH_VAR="SHLIB_PATH"

fi
	    if test "$GCC" = yes; then :

		SHLIB_LD='${CC} -shared'
		LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}

else

		CFLAGS="$CFLAGS -z"





fi

	    # Check to enable 64-bit flags for compiler/linker
	    if test "$do64bit" = "yes"; then :

		if test "$GCC" = yes; then :

		    case `${CC} -dumpmachine` in
			hppa64*)
			    # 64-bit gcc in use.  Fix flags for GNU ld.
			    do64bit_ok=yes
			    SHLIB_LD='${CC} -shared'
			    if test $doRpath = yes; then :

				CC_SEARCH_FLAGS='"-Wl,-rpath,${LIB_RUNTIME_DIR}"'
fi
			    LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
			    ;;
			*)
			    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: 64bit mode not supported with GCC on $system" >&5
$as_echo "$as_me: WARNING: 64bit mode not supported with GCC on $system" >&2;}
			    ;;
		    esac

else

		    do64bit_ok=yes
		    CFLAGS="$CFLAGS +DD64"
		    LDFLAGS_ARCH="+DD64"

fi

fi ;;
	HP-UX-*.08.*|HP-UX-*.09.*|HP-UX-*.10.*)
	    SHLIB_SUFFIX=".sl"
	    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for shl_load in -ldld" >&5
$as_echo_n "checking for shl_load in -ldld... " >&6; }
if ${ac_cv_lib_dld_shl_load+:} false; then :
  $as_echo_n "(cached) " >&6
else
  ac_check_lib_save_LIBS=$LIBS
LIBS="-ldld  $LIBS"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

/* Override any GCC internal prototype to avoid an error.
   Use char because int might match the return type of a GCC
   builtin and then its argument prototype would still apply.  */
#ifdef __cplusplus
extern "C"
#endif
char shl_load ();
int
main ()
{
return shl_load ();
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_link "$LINENO"; then :
  ac_cv_lib_dld_shl_load=yes
else
  ac_cv_lib_dld_shl_load=no
fi
rm -f core conftest.err conftest.$ac_objext \
    conftest$ac_exeext conftest.$ac_ext
LIBS=$ac_check_lib_save_LIBS
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_shl_load" >&5
$as_echo "$ac_cv_lib_dld_shl_load" >&6; }
if test "x$ac_cv_lib_dld_shl_load" = xyes; then :
  tcl_ok=yes
else
  tcl_ok=no
fi

	    if test "$tcl_ok" = yes; then :

		SHLIB_CFLAGS="+z"
		SHLIB_LD="ld -b"
		SHLIB_LD_LIBS=""
		LDFLAGS="$LDFLAGS -Wl,-E"
		CC_SEARCH_FLAGS='"-Wl,+s,+b,${LIB_RUNTIME_DIR}:."'
		LD_SEARCH_FLAGS='+s +b "${LIB_RUNTIME_DIR}:."'
		LD_LIBRARY_PATH_VAR="SHLIB_PATH"

fi ;;
	IRIX-5.*)
	    SHLIB_CFLAGS=""
	    SHLIB_LD="ld -shared -rdata_shared"
	    SHLIB_SUFFIX=".so"
	    case " $LIBOBJS " in
  *" mkstemp.$ac_objext "* ) ;;
  *) LIBOBJS="$LIBOBJS mkstemp.$ac_objext"
 ;;
esac

	    if test $doRpath = yes; then :

		CC_SEARCH_FLAGS='"-Wl,-rpath,${LIB_RUNTIME_DIR}"'
		LD_SEARCH_FLAGS='-rpath "${LIB_RUNTIME_DIR}"'
fi
	    ;;
	IRIX-6.*)
	    SHLIB_CFLAGS=""
	    SHLIB_LD="ld -n32 -shared -rdata_shared"
	    SHLIB_SUFFIX=".so"
	    if test $doRpath = yes; then :

		CC_SEARCH_FLAGS='"-Wl,-rpath,${LIB_RUNTIME_DIR}"'
		LD_SEARCH_FLAGS='-rpath "${LIB_RUNTIME_DIR}"'
fi
	    if test "$GCC" = yes; then :

		CFLAGS="$CFLAGS -mabi=n32"
		LDFLAGS="$LDFLAGS -mabi=n32"

else

	    ;;
	IRIX64-6.*)
	    SHLIB_CFLAGS=""
	    SHLIB_LD="ld -n32 -shared -rdata_shared"
	    SHLIB_SUFFIX=".so"
	    if test $doRpath = yes; then :

		CC_SEARCH_FLAGS='"-Wl,-rpath,${LIB_RUNTIME_DIR}"'
		LD_SEARCH_FLAGS='-rpath "${LIB_RUNTIME_DIR}"'
fi

	    # Check to enable 64-bit flags for compiler/linker

	    if test "$do64bit" = yes; then :

	        if test "$GCC" = yes; then :

	            CFLAGS="$CFLAGS -64"
	            LDFLAGS_ARCH="-64"

fi

fi
	    ;;
	Linux*|GNU*|NetBSD-Debian|DragonFly-*|FreeBSD-*)
	    SHLIB_CFLAGS="-fPIC"
	    SHLIB_SUFFIX=".so"

	    # TEA specific:
	    CFLAGS_OPTIMIZE="-O2 -fomit-frame-pointer"

	    # TEA specific: use LDFLAGS_DEFAULT instead of LDFLAGS
	    SHLIB_LD='${CC} ${CFLAGS} ${LDFLAGS_DEFAULT} -shared'
	    LDFLAGS="$LDFLAGS -Wl,--export-dynamic"

	    case $system in
	    DragonFly-*|FreeBSD-*)
		if test "${TCL_THREADS}" = "1"; then :

		    # The -pthread needs to go in the LDFLAGS, not LIBS
		    LIBS=`echo $LIBS | sed s/-pthread//`
		    CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
		    LDFLAGS="$LDFLAGS $PTHREAD_LIBS"
fi
	    ;;
            esac

	    if test $doRpath = yes; then :

		CC_SEARCH_FLAGS='"-Wl,-rpath,${LIB_RUNTIME_DIR}"'
fi
	    LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
	    if test "`uname -m`" = "alpha"; then :
  CFLAGS="$CFLAGS -mieee"
fi
	    if test $do64bit = yes; then :

	    SHLIB_CFLAGS="-fPIC"
	    SHLIB_SUFFIX=".so"
	    CFLAGS_OPTIMIZE=-02
	    SHLIB_LD='${CC} -shared'
	    LD_FLAGS="-Wl,--export-dynamic"
	    if test $doRpath = yes; then :

		CC_SEARCH_FLAGS='"-Wl,-rpath,${LIB_RUNTIME_DIR}"'
		LD_SEARCH_FLAGS='"-Wl,-rpath,${LIB_RUNTIME_DIR}"'
fi
	    ;;
	OpenBSD-*)
	    arch=`arch -s`
	    case "$arch" in
	    alpha|sparc64)
		SHLIB_CFLAGS="-fPIC"
		;;
	    *)
		SHLIB_CFLAGS="-fpic"
		;;
	    esac
	    SHLIB_LD='${CC} ${SHLIB_CFLAGS} -shared'
	    SHLIB_SUFFIX=".so"
	    if test $doRpath = yes; then :

		CC_SEARCH_FLAGS='"-Wl,-rpath,${LIB_RUNTIME_DIR}"'
fi
	    LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
	    SHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}.so${SHLIB_VERSION}'
	    LDFLAGS="$LDFLAGS -Wl,-export-dynamic"
	    CFLAGS_OPTIMIZE="-O2"


	    # On OpenBSD:	Compile with -pthread
	    #		Don't link with -lpthread
	    LIBS=`echo $LIBS | sed s/-lpthread//`
	    CFLAGS="$CFLAGS -pthread"


	    # OpenBSD doesn't do version numbers with dots.
	    UNSHARED_LIB_SUFFIX='${TCL_TRIM_DOTS}.a'
	    TCL_LIB_VERSIONS_OK=nodots
	    ;;
	NetBSD-*)
	    # NetBSD has ELF and can use 'cc -shared' to build shared libs
	    SHLIB_CFLAGS="-fPIC"
	    SHLIB_LD='${CC} ${SHLIB_CFLAGS} -shared'
	    SHLIB_SUFFIX=".so"
	    LDFLAGS="$LDFLAGS -export-dynamic"
	    if test $doRpath = yes; then :

		CC_SEARCH_FLAGS='"-Wl,-rpath,${LIB_RUNTIME_DIR}"'
fi
	    LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}


	    # The -pthread needs to go in the CFLAGS, not LIBS
	    LIBS=`echo $LIBS | sed s/-pthread//`
	    CFLAGS="$CFLAGS -pthread"
	    LDFLAGS="$LDFLAGS -pthread"































	    ;;
	Darwin-*)
	    CFLAGS_OPTIMIZE="-Os"
	    SHLIB_CFLAGS="-fno-common"
	    # To avoid discrepancies between what headers configure sees during
	    # preprocessing tests and compiling tests, move any -isysroot and
	    # -mmacosx-version-min flags from CFLAGS to CPPFLAGS:

		SHLIB_LD="${SHLIB_LD} -Wl,-single_module"

fi
	    # TEA specific: link shlib with current and compatibility version flags
	    vers=`echo ${PACKAGE_VERSION} | sed -e 's/^\([0-9]\{1,5\}\)\(\(\.[0-9]\{1,3\}\)\{0,2\}\).*$/\1\2/p' -e d`
	    SHLIB_LD="${SHLIB_LD} -current_version ${vers:-0} -compatibility_version ${vers:-0}"
	    SHLIB_SUFFIX=".dylib"






	    LDFLAGS="$LDFLAGS -headerpad_max_install_names"
	    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if ld accepts -search_paths_first flag" >&5
$as_echo_n "checking if ld accepts -search_paths_first flag... " >&6; }
if ${tcl_cv_ld_search_paths_first+:} false; then :
  $as_echo_n "(cached) " >&6
else

	        SHLIB_LD='ld -non_shared -expect_unresolved "*"'

fi
	    SHLIB_SUFFIX=".so"
	    if test $doRpath = yes; then :

		CC_SEARCH_FLAGS='"-Wl,-rpath,${LIB_RUNTIME_DIR}"'
		LD_SEARCH_FLAGS='-rpath ${LIB_RUNTIME_DIR}'
fi
	    if test "$GCC" = yes; then :
  CFLAGS="$CFLAGS -mieee"
else

		CFLAGS="$CFLAGS -DHAVE_TZSET -std1 -ieee"
fi
	    # see pthread_intro(3) for pthread support on osf1, k.furukawa


	    CFLAGS="$CFLAGS -DHAVE_PTHREAD_ATTR_SETSTACKSIZE"
	    CFLAGS="$CFLAGS -DTCL_THREAD_STACK_MIN=PTHREAD_STACK_MIN*64"
	    LIBS=`echo $LIBS | sed s/-lpthreads//`
	    if test "$GCC" = yes; then :

		LIBS="$LIBS -lpthread -lmach -lexc"

else

		CFLAGS="$CFLAGS -pthread"
		LDFLAGS="$LDFLAGS -pthread"



fi
	    ;;
	QNX-6*)
	    # QNX RTP
	    # This may work for all QNX, but it was only reported for v6.
	    SHLIB_CFLAGS="-fPIC"

	    SHLIB_CFLAGS="-KPIC"
	    SHLIB_SUFFIX=".so"
	    if test "$GCC" = yes; then :

		SHLIB_LD='${CC} -shared'
		CC_SEARCH_FLAGS='"-Wl,-R,${LIB_RUNTIME_DIR}"'
		LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}

else

		SHLIB_LD="/usr/ccs/bin/ld -G -z text"
		CC_SEARCH_FLAGS='-R "${LIB_RUNTIME_DIR}"'
		LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}

fi
	    ;;
	SunOS-5*)
	    # Note: If _REENTRANT isn't defined, then Solaris
	    # won't define thread-safe library routines.

fi

	    SHLIB_SUFFIX=".so"
	    if test "$GCC" = yes; then :

		SHLIB_LD='${CC} -shared'
		CC_SEARCH_FLAGS='"-Wl,-R,${LIB_RUNTIME_DIR}"'
		LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS}
		if test "$do64bit_ok" = yes; then :

		    if test "$arch" = "sparcv9 sparc"; then :

			# We need to specify -static-libgcc or we need to
			# add the path to the sparv9 libgcc.

		case $system in
		    SunOS-5.[1-9][0-9]*)
			# TEA specific: use LDFLAGS_DEFAULT instead of LDFLAGS
			SHLIB_LD='${CC} -G -z text ${LDFLAGS_DEFAULT}';;
		    *)
			SHLIB_LD='/usr/ccs/bin/ld -G -z text';;
		esac
		CC_SEARCH_FLAGS='"-Wl,-R,${LIB_RUNTIME_DIR}"'
		LD_SEARCH_FLAGS='-R "${LIB_RUNTIME_DIR}"'

fi
	    ;;
	UNIX_SV* | UnixWare-5*)
	    SHLIB_CFLAGS="-KPIC"
	    SHLIB_LD='${CC} -G'
	    SHLIB_LD_LIBS=""

    # standard manufacturer compiler.

    if test "$GCC" = yes; then :

	case $system in
	    AIX-*) ;;
	    BSD/OS*) ;;
	    CYGWIN_*|MINGW32_*|MINGW64_*|MSYS_*) ;;
	    IRIX*) ;;
	    NetBSD-*|DragonFly-*|FreeBSD-*|OpenBSD-*) ;;
	    Darwin-*) ;;
	    SCO_SV-3.2*) ;;
	    windows) ;;
	    *) SHLIB_CFLAGS="-fPIC" ;;
	esac
fi

$as_echo "$tcl_cv_cast_to_union" >&6; }
	if test "$tcl_cv_cast_to_union" = "yes"; then

$as_echo "#define HAVE_CAST_TO_UNION 1" >>confdefs.h

	fi

	ac_fn_c_check_header_mongrel "$LINENO" "stdbool.h" "ac_cv_header_stdbool_h" "$ac_includes_default"
if test "x$ac_cv_header_stdbool_h" = xyes; then :

$as_echo "#define HAVE_STDBOOL_H 1" >>confdefs.h

fi

_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  tcl_type_64bit=__int64
else
  tcl_type_64bit="long long"
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
	# See if we could use long anyway  Note that we substitute in the
	# type that is our current guess for a 64-bit type inside this check
	# program, so it should be modified only carefully...
        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

int
main ()

rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi

    if test "${tcl_cv_type_64bit}" = none ; then

$as_echo "#define TCL_WIDE_INT_IS_LONG 1" >>confdefs.h

	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
    elif test "${tcl_cv_type_64bit}" = "__int64" \
		-a "${TEA_PLATFORM}" = "windows" ; then
	# TEA specific: We actually want to use the default tcl.h checks in
	# this case to handle both TCL_WIDE_INT_TYPE and TCL_LL_MODIFIER*
	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: using Tcl header defaults" >&5
$as_echo "using Tcl header defaults" >&6; }
    else

fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_struct_dirent64" >&5
$as_echo "$tcl_cv_struct_dirent64" >&6; }
	if test "x${tcl_cv_struct_dirent64}" = "xyes" ; then

$as_echo "#define HAVE_STRUCT_DIRENT64 1" >>confdefs.h

	fi

	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIR64" >&5
$as_echo_n "checking for DIR64... " >&6; }
if ${tcl_cv_DIR64+:} false; then :
  $as_echo_n "(cached) " >&6
else

	    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */
#include <sys/types.h>
#include <dirent.h>
int
main ()
{
struct dirent64 *p; DIR64 d = opendir64(".");
            p = readdir64(d); rewinddir64(d); closedir64(d);
  ;
  return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
  tcl_cv_DIR64=yes
else
  tcl_cv_DIR64=no
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
fi
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $tcl_cv_DIR64" >&5
$as_echo "$tcl_cv_DIR64" >&6; }
	if test "x${tcl_cv_DIR64}" = "xyes" ; then

$as_echo "#define HAVE_DIR64 1" >>confdefs.h

	fi

	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for struct stat64" >&5
$as_echo_n "checking for struct stat64... " >&6; }
if ${tcl_cv_struct_stat64+:} false; then :
  $as_echo_n "(cached) " >&6
else

    # Check whether --enable-symbols was given.
if test "${enable_symbols+set}" = set; then :
  enableval=$enable_symbols; tcl_ok=$enableval
else
  tcl_ok=no
fi


    if test "$tcl_ok" = "no"; then
	CFLAGS_DEFAULT="${CFLAGS_OPTIMIZE} -DNDEBUG"
	LDFLAGS_DEFAULT="${LDFLAGS_OPTIMIZE}"
	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
    else
	CFLAGS_DEFAULT="${CFLAGS_DEBUG}"
	LDFLAGS_DEFAULT="${LDFLAGS_DEBUG}"
	if test "$tcl_ok" = "yes"; then
	    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes (standard debugging)" >&5
$as_echo "yes (standard debugging)" >&6; }
	fi
    fi








    if test "$tcl_ok" = "mem" -o "$tcl_ok" = "all"; then

$as_echo "#define TCL_MEM_DEBUG 1" >>confdefs.h

# depends on values set by the TEA_ENABLE_SHARED, TEA_ENABLE_SYMBOLS,
# and TEA_LOAD_TCLCONFIG macros above.
#--------------------------------------------------------------------


    if test "${TEA_PLATFORM}" = "windows" -a "$GCC" != "yes"; then
	MAKE_STATIC_LIB="\${STLIB_LD} -out:\$@ \$(PKG_OBJECTS)"
	MAKE_SHARED_LIB="\${SHLIB_LD} \${LDFLAGS} \${LDFLAGS_DEFAULT} -out:\$@ \$(PKG_OBJECTS) \${SHLIB_LD_LIBS}"
	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h.  */

#if defined(_MSC_VER) && _MSC_VER >= 1400
print("manifest needed")
#endif

fi
rm -f conftest*

	MAKE_STUB_LIB="\${STLIB_LD} -nodefaultlib -out:\$@ \$(PKG_STUB_OBJECTS)"
    else
	MAKE_STATIC_LIB="\${STLIB_LD} \$@ \$(PKG_OBJECTS)"
	MAKE_SHARED_LIB="\${SHLIB_LD} \${LDFLAGS} \${LDFLAGS_DEFAULT} -o \$@ \$(PKG_OBJECTS) \${SHLIB_LD_LIBS}"
	MAKE_STUB_LIB="\${STLIB_LD} \$@ \$(PKG_STUB_OBJECTS)"
    fi

    if test "${SHARED_BUILD}" = "1" ; then
	MAKE_LIB="${MAKE_SHARED_LIB} "
    else
	MAKE_LIB="${MAKE_STATIC_LIB} "

    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for tclsh" >&5
$as_echo_n "checking for tclsh... " >&6; }
    if test -f "${TCL_BIN_DIR}/Makefile" ; then
        # tclConfig.sh is in Tcl build directory
        if test "${TEA_PLATFORM}" = "windows"; then
          if test -f "${TCL_BIN_DIR}/tclsh${TCL_MAJOR_VERSION}${TCL_MINOR_VERSION}${EXEEXT}" ; then
            TCLSH_PROG="${TCL_BIN_DIR}/tclsh${TCL_MAJOR_VERSION}${TCL_MINOR_VERSION}${EXEEXT}"
          elif test -f "${TCL_BIN_DIR}/tclsh${TCL_MAJOR_VERSION}${TCL_MINOR_VERSION}s${EXEEXT}" ; then
            TCLSH_PROG="${TCL_BIN_DIR}/tclsh${TCL_MAJOR_VERSION}${TCL_MINOR_VERSION}s${EXEEXT}"
          elif test -f "${TCL_BIN_DIR}/tclsh${TCL_MAJOR_VERSION}${TCL_MINOR_VERSION}t${EXEEXT}" ; then
            TCLSH_PROG="${TCL_BIN_DIR}/tclsh${TCL_MAJOR_VERSION}${TCL_MINOR_VERSION}t${EXEEXT}"
          elif test -f "${TCL_BIN_DIR}/tclsh${TCL_MAJOR_VERSION}${TCL_MINOR_VERSION}st${EXEEXT}" ; then
            TCLSH_PROG="${TCL_BIN_DIR}/tclsh${TCL_MAJOR_VERSION}${TCL_MINOR_VERSION}st${EXEEXT}"
          fi
        else
            TCLSH_PROG="${TCL_BIN_DIR}/tclsh"
        fi
    else
        # tclConfig.sh is in install location
        if test "${TEA_PLATFORM}" = "windows"; then
            TCLSH_PROG="tclsh${TCL_MAJOR_VERSION}${TCL_MINOR_VERSION}${EXEEXT}"
        else
            TCLSH_PROG="tclsh${TCL_MAJOR_VERSION}.${TCL_MINOR_VERSION}"
        fi
        list="`ls -d ${TCL_BIN_DIR}/../bin 2>/dev/null` \
              `ls -d ${TCL_BIN_DIR}/..     2>/dev/null` \
              `ls -d ${TCL_PREFIX}/bin     2>/dev/null`"
        for i in $list ; do
            if test -f "$i/${TCLSH_PROG}" ; then
                REAL_TCL_BIN_DIR="`cd "$i"; pwd`/"

#--------------------------------------------------------------------
# Add shared expat includes and expat entropy
#--------------------------------------------------------------------

TDOM_PATH_EXPAT
TDOM_EXPAT_ENTROPY

#--------------------------------------------------------------------
# We need the UINT2PTR and PTR2UINT macros, so make sure that intptr_t
# is defined.
#--------------------------------------------------------------------

AC_CHECK_TYPE([uintptr_t], [
    AC_DEFINE([HAVE_UINTPTR_T], 1, [Do we have the uintptr_t type?])], [
    AC_CACHE_CHECK([for pointer-size unsigned integer type], tcl_cv_uintptr_t, [
    for tcl_cv_uintptr_t in "unsigned int" "unsigned long" "unsigned long long" \
	    none; do
	if test "$tcl_cv_uintptr_t" != none; then
	    AC_COMPILE_IFELSE([AC_LANG_BOOL_COMPILE_TRY([AC_INCLUDES_DEFAULT],
		    [[sizeof (void *) <= sizeof ($tcl_cv_uintptr_t)]])],
		[tcl_ok=yes], [tcl_ok=no])
	    test "$tcl_ok" = yes && break; fi
    done])
    if test "$tcl_cv_uintptr_t" != none; then
	AC_DEFINE_UNQUOTED([uintptr_t], [$tcl_cv_uintptr_t], [Unsigned integer
	   type wide enough to hold a pointer.])
    fi
])

#--------------------------------------------------------------------
# Add HTML5 parsing support.
#--------------------------------------------------------------------

TDOM_ENABLE_HTML5

    <KWD name="XML" manpage="pullparser"/>
    <KWD name="pull" manpage="pullparser"/>
    <KWD name="parsing" manpage="pullparser"/>
    <MAN id="schema" title="schema"/>
    <DEF cat="manpage" name="schema" manpage="schema"/>
    <DEF cat="schema" name="tdom::schema" manpage="schema"/>
    <DEF cat="cmd" name="tdom::schema" manpage="schema"/>
    <KWD name="Validation" manpage="schema"/>
    <KWD name="Postvalidation" manpage="schema"/>
    <KWD name="DOM" manpage="schema"/>
    <KWD name="SAX" manpage="schema"/>
    <MAN id="tdomcmd" title="tdom"/>
    <DEF cat="manpage" name="tdomcmd" manpage="tdomcmd"/>
    <DEF cat="cmd" name="tdom" manpage="tdomcmd"/>
    <KWD name="DOM" manpage="tdomcmd"/>
    <KWD name="SAX" manpage="tdomcmd"/>
    <KWD name="C handler set" manpage="tdomcmd"/>
    <MAN id="tnc" title="tnc"/>
    <DEF cat="manpage" name="tnc" manpage="tnc"/>
    <DEF cat="cmd" name="tnc" manpage="tnc"/>
    <KWD name="Validation" manpage="tnc"/>
    <KWD name="DTD" manpage="tnc"/>
</INDEX>

<html>
<head>
<link rel="stylesheet" href="manpage.css"><title>tDOM manual: dom</title><meta name="xsl-processor" content="Jochen Loewer (loewerj@hotmail.com), Rolf Ade (rolf@pointsman.de) et. al."><meta name="generator" content="$RCSfile: tmml-html.xsl,v $ $Revision: 1.11 $"><meta charset="utf-8">
</head><body>
<div class="header">
<div class="navbar" align="center">
<a href="#SECTid0x5579b5f8c910">NAME</a> · <a href="#SECTid0x5579b5edbb80">SYNOPSIS</a> · <a href="#SECTid0x5579b5f83930">DESCRIPTION </a> · <a href="#SECTid0x5579b5ff2110">KEYWORDS</a>
</div><hr class="navsep">
</div><div class="body">
  <h2><a name="SECTid0x5579b5f8c910">NAME</a></h2><p class="namesection">
<b class="names">dom - </b><br>Create an in-memory DOM tree from XML</p>
  
  <h2><a name="SECTid0x5579b5edbb80">SYNOPSIS</a></h2><pre class="syntax">package require tdom

<b class="cmd">dom</b> <i class="m">method</i> ?<i class="m">arg arg ...</i>?</pre>

  <h2><a name="SECTid0x5579b5f83930">DESCRIPTION </a></h2><p>This command provides the creation of DOM trees in memory. In
the usual case a string containing a XML information is parsed and converted
into a DOM tree. Other possible parse input may be HTML or JSON.
The <i class="m">method</i> indicates a specific subcommand. </p><p>The valid methods are:</p><dl class="commandlist">
        
          <dt>
<b class="cmd">dom</b> <b class="method">parse</b> ?<i class="m">options</i>? ?<i class="m">data</i>?</dt>
          <dd>Parses the XML information and builds up the DOM tree in memory

                investigated or modified with the full range of the
                doc and node methods. Please note that the element
                node names and the text node values within the tree
                may be outside of what the appropriate XML productions
                allow.</dd>
              

              
                <dt><b>-jsonroot &lt;document element name&gt;</b></dt>
                <dd>If given makes the given element name the
                document element of the resulting doc. The parsed
                content of the JSON string will be the childs of this
                document element node.</dd>
              
              
              
                <dt>
<b>-jsonmaxnesting</b> <i>integer</i>
</dt>
                
                <dd>This option only has effect if used together
                with the <i class="m">-json</i> option. The current
                implementation uses a recursive descent JSON parser.
                In order to avoid using excess stack space, any JSON
                input that has more than a certain levels of nesting
                is considered invalid. The default maximum nesting is
                2000. The option -jsonmaxnesting allows the user to
                adjust that.</dd>
              
              
              
                <dt><b>--</b></dt> 
                <dd>The option <i class="m">--</i> marks the end of options.
                While respected in general this option is only needed
                in case of parsing JSON data, which may start with a

                with the <i class="m">-html5</i> option. If this option is
                given, no node within the created DOM tree will be
                internally marked as placed into an XML Namespace,
                even if there is a default namespace in scope for
                un-prefixed elements or even if the element has a
                defined namespace prefix. One consequence is that
                XPath node expressions on such a DOM tree doesn't work
                as may be expected. Prefixed element nodes can't be
                selected naively and element nodes without prefix will
                be seen by XPath expressions as if they are not in any
                namespace (no matter if they are in fact should be in
                a default namespace). If you need to inject prefixed
                node names into an XPath expression use the '%' syntax
                described in the documentation of the of the
                <b class="command">domNode</b> command method
                <b class="method">&gt;selectNodes</b>.
                </dd>
              

            </dl>
<p></p>
</dd>
        

<i class="m">string</i>
</dt>
          <dd>Returns 1 if every character in <i class="m">string</i> is
a valid XML Char according to production 2 of the <a href="http://www.w3.org/TR/2000/REC-xml-20001006.html">XML 1.0</a>
recommendation. Otherwise it returns 0.</dd>
        

        
          <dt>
<b class="cmd">dom</b> <b class="method">clearString</b> <i class="m">string</i>
</dt>
          <dd>Returns the string given as argument cleared out from any characters not
          allowed as XML parsed character data.</dd>
        
        
        
          <dt>
<b class="cmd">dom</b> <b class="method">isBMPCharData</b>
<i class="m">string</i>
</dt>
          <dd>Returns 1 if every character in <i class="m">string</i> is
a valid XML Char with a Unicode code point within the Basic

                    are build in.</dd>
                
            </dl>
            </dd>   
        
    </dl>

<h2><a name="SECTid0x5579b5ff2110">KEYWORDS</a></h2><p class="keywords">
<a class="keyword" href="keyword-index.html#KW-XML">XML</a>, <a class="keyword" href="keyword-index.html#KW-DOM">DOM</a>, <a class="keyword" href="keyword-index.html#KW-document">document</a>, <a class="keyword" href="keyword-index.html#KW-node">node</a>, <a class="keyword" href="keyword-index.html#KW-parsing">parsing</a>
</p>
</div><hr class="navsep"><div class="navbar" align="center">
<a class="navaid" href="index.html">Contents</a> · <a class="navaid" href="category-index.html">Index</a> · <a class="navaid" href="keyword-index.html">Keywords</a> · <a class="navaid" href="http://tdom.org">Repository</a>
</div>
</body>
</html>

from this JSON type information the returned doc
command or handle is an ordinary DOM doc, which may be
investigated or modified with the full range of the
doc and node methods. Please note that the element
node names and the text node values within the tree
may be outside of what the appropriate XML productions
allow.
.IP "\fB-jsonroot <document element name>\fR"
If given makes the given element name the
document element of the resulting doc. The parsed
content of the JSON string will be the childs of this
document element node.
.IP "\fB-jsonmaxnesting  \fIinteger\fP\fR"
This option only has effect if used together
with the \fI-json\fR option. The current
implementation uses a recursive descent JSON parser.
In order to avoid using excess stack space, any JSON
input that has more than a certain levels of nesting
is considered invalid. The default maximum nesting is
2000. The option -jsonmaxnesting allows the user to
adjust that.
.IP "\fB--\fR"
The option \fI--\fR marks the end of options.
While respected in general this option is only needed
in case of parsing JSON data, which may start with a
"-".
.IP "\fB-keepEmpties\fR"
If \fI-keepEmpties\fR is

with the \fI-html5\fR option. If this option is
given, no node within the created DOM tree will be
internally marked as placed into an XML Namespace,
even if there is a default namespace in scope for
un-prefixed elements or even if the element has a
defined namespace prefix. One consequence is that
XPath node expressions on such a DOM tree doesn't work
as may be expected. Prefixed element nodes can't be
selected naively and element nodes without prefix will
be seen by XPath expressions as if they are not in any
namespace (no matter if they are in fact should be in
a default namespace). If you need to inject prefixed
node names into an XPath expression use the '%' syntax
described in the documentation of the of the
.TP
\&\fBdomNode
\&\fR command method
\&\fB>selectNodes\fP.
.PP
.RE
.TP
\&\fB\fBdom\fP \fBcreateDocument\fP \fIdocElemName\fB ?\fIobjVar\fB?
\&\fRCreates a new DOM document object with one element node with
node name \fIdocElemName\fR. The \fIobjVar\fR controls the
memory handling as explained above.

to production 6 of the of the Namespaces in XML recommendation. Otherwise it returns
0.
.TP
\&\fB\fBdom\fP \fBisCharData\fP \fIstring\fB
\&\fRReturns 1 if every character in \fIstring\fR is
a valid XML Char according to production 2 of the XML 1.0
recommendation. Otherwise it returns 0.
.TP
\&\fB\fBdom\fP \fBclearString\fP \fIstring\fB
\&\fRReturns the string given as argument cleared out from any characters not
allowed as XML parsed character data.
.TP
\&\fB\fBdom\fP \fBisBMPCharData\fP \fIstring\fB
\&\fRReturns 1 if every character in \fIstring\fR is
a valid XML Char with a Unicode code point within the Basic
Multilingual Plane (that means, that every character within the string
is at most 3 bytes long). Otherwise it returns 0.
.TP

                investigated or modified with the full range of the
                doc and node methods. Please note that the element
                node names and the text node values within the tree
                may be outside of what the appropriate XML productions
                allow.</desc>
              </optdef>

              <optdef>
                <optname>-jsonroot &lt;document element name&gt;</optname>
                <desc>If given makes the given element name the
                document element of the resulting doc. The parsed
                content of the JSON string will be the childs of this
                document element node.</desc>
              </optdef>
              
              <optdef>
                <optname>-jsonmaxnesting</optname>
                <optarg>integer</optarg>
                <desc>This option only has effect if used together
                with the <m>-json</m> option. The current
                implementation uses a recursive descent JSON parser.
                In order to avoid using excess stack space, any JSON
                input that has more than a certain levels of nesting
                is considered invalid. The default maximum nesting is
                2000. The option -jsonmaxnesting allows the user to
                adjust that.</desc>
              </optdef>
              
              <optdef>
                <optname>--</optname> 
                <desc>The option <m>--</m> marks the end of options.
                While respected in general this option is only needed
                in case of parsing JSON data, which may start with a

                with the <m>-html5</m> option. If this option is
                given, no node within the created DOM tree will be
                internally marked as placed into an XML Namespace,
                even if there is a default namespace in scope for
                un-prefixed elements or even if the element has a
                defined namespace prefix. One consequence is that
                XPath node expressions on such a DOM tree doesn't work
                as may be expected. Prefixed element nodes can't be
                selected naively and element nodes without prefix will
                be seen by XPath expressions as if they are not in any
                namespace (no matter if they are in fact should be in
                a default namespace). If you need to inject prefixed
                node names into an XPath expression use the '%' syntax
                described in the documentation of the of the
                <command>domNode</command> command method
                <method>>selectNodes</method>.
                </desc>
              </optdef>

            </optlist>
<p/>
</desc>
        </commanddef>

          <command><cmd>dom</cmd> <method>isCharData</method>
<m>string</m></command>
          <desc>Returns 1 if every character in <m>string</m> is
a valid XML Char according to production 2 of the <ref href="http://www.w3.org/TR/2000/REC-xml-20001006.html">XML 1.0</ref>
recommendation. Otherwise it returns 0.</desc>
        </commanddef>

        <commanddef>
          <command><cmd>dom</cmd> <method>clearString</method> <m>string</m></command>
          <desc>Returns the string given as argument cleared out from any characters not
          allowed as XML parsed character data.</desc>
        </commanddef>
        
        <commanddef>
          <command><cmd>dom</cmd> <method>isBMPCharData</method>
<m>string</m></command>
          <desc>Returns 1 if every character in <m>string</m> is
a valid XML Char with a Unicode code point within the Basic
Multilingual Plane (that means, that every character within the string
is at most 3 bytes long). Otherwise it returns 0.</desc>

<html>
<head>
<link rel="stylesheet" href="manpage.css"><title>tDOM manual: domDoc</title><meta name="xsl-processor" content="Jochen Loewer (loewerj@hotmail.com), Rolf Ade (rolf@pointsman.de) et. al."><meta name="generator" content="$RCSfile: tmml-html.xsl,v $ $Revision: 1.11 $"><meta charset="utf-8">
</head><body>
<div class="header">
<div class="navbar" align="center">
<a href="#SECTid0x555cdce50630">NAME</a> · <a href="#SECTid0x555cdcd86bb0">SYNOPSIS</a> · <a href="#SECTid0x555cdce2ed50">DESCRIPTION </a> · <a href="#SECTid0x555cdce9c530">SEE ALSO</a> · <a href="#SECTid0x555cdce9c8c0">KEYWORDS</a>
</div><hr class="navsep">
</div><div class="body">
  <h2><a name="SECTid0x555cdce50630">NAME</a></h2><p class="namesection">
<b class="names">domDoc - </b><br>Manipulates an instance of a DOM document object</p>
  
  <h2><a name="SECTid0x555cdcd86bb0">SYNOPSIS</a></h2><pre class="syntax">domDocObjCmd <i class="m">method</i> ?<i class="m">arg arg ...</i>?</pre><pre class="syntax">domDoc <i class="m">docToken</i> <i class="m">method</i> ?<i class="m">arg arg ...</i>?</pre>

  <h2><a name="SECTid0x555cdce2ed50">DESCRIPTION </a></h2><p>This command manipulates one particular instance of a document
object. <i class="m">method</i> indicates a specific method of the document class. These
methods should closely conform to the W3C recommendation "Document Object Model
(Core) Level 1" (<a href="http://www.w3.org/TR/REC-DOM-Level-1/level-one-core.html">http://www.w3.org/TR/REC-DOM-Level-1/level-one-core.html</a>). Look
at these documents for a deeper understanding of the functionality.</p><p>The valid methods are:</p><dl class="commandlist">
        
          <dt>
<b class="method">documentElement</b> ?<i class="m">objVar</i>?</dt>

          <dt><b class="method">getDefaultOutputMethod</b></dt>
          <dd>Returns the default output method of the document. This is
usually a result of a XSLT transformation.</dd>
        

      
        <dt>
<b class="method">asXML</b> <b class="option">?-indent none/tabs/1..8?</b> <b class="option">?-channel channelId?</b> <b class="option">?-escapeNonASCII?</b> <b class="option">?-doctypeDeclaration &lt;boolean&gt;?</b> <b class="option">-xmlDeclaration &lt;boolean&gt;?</b> <b class="option">-encString &lt;string&gt;</b> <b class="option">?-escapeAllQuot?</b> <b class="option">?-indentAttrs?</b> <b class="option">?-nogtescape?</b> <b class="option">?-noEmptyElementTag?</b>
</dt>
        <dd>
<p>Returns the DOM tree as an (optional indented) XML
        string or sends the output directly to the given
        channelId.</p>

        <p>The -indent option requires "no", "none", "tabs" or a
        natural number betwenn 0 and 8, both included, as value. With
        the values "no" or "none" no additional white space outside of
        markup will be added to the serialization. I. Otherwise, it's
        a "pretty-print" serialization, due to inserting white space
        between end and the next start tag according to the nesting
        level. The level indentation wide is given with the number. If
        the value is "tabs", then indentation is done with tabs, one
        tab per level.</p>
        
        <p>If the option <i class="m">-escapeNonASCII</i> is given,
        every non 7 bit ASCII character in attribute values or element
        PCDATA content will be escaped as character reference in
        decimal representation.</p>

        <p>The flag <i class="m">-doctypeDeclaration</i> determines whether
        there will be a DOCTYPE declaration emitted before the first

</dd>

      

      
        <dt>
<b class="method">asHTML</b> <b class="option">?-channel
channelId?</b> <b class="option">?-escapeNonASCII?</b> <b class="option">?-htmlEntities?</b> <b class="option">?-doctypeDeclaration &lt;boolean&gt;?</b> <b class="option">?-breakLines?</b> <b class="option">?-onlyContents?</b>
</dt> 
        <dd>
<p>Returns the DOM tree serialized according to HTML rules
        (HTML elements are recognized regardless of case, without end
        tags for empty HTML elements etc.) as string or sends the
        output directly to the given channelId.</p>

        <p>If the option <i class="m">-escapeNonASCII</i> is given, every non 7
        bit ASCII character in attribute values or element PCDATA
        content will be escaped as character reference in decimal
        representation.</p>
        
        <p>If the option <i class="m">-htmlEntities</i> is given, a character is
        written using its HTML 4.01 character entity reference, if it
        has one.</p>

        <p>If the option <i class="m">-breakLines</i> is given the serialization
        outputs "\n&gt;" instead of "&gt;" for the opening tags of
        elements.</p>

        <p>If the option <i class="m">-onlyContents</i> is given only all child
        nodes are serialized. This option is ignored by document
        nodes.</p>
        
        <p>If the flag <i class="m">-doctypeDeclaration</i> is given there will
        be a DOCTYPE declaration emitted before the first node of the
        document. The default is, to do not. The DOCTYPE name will
        always be the element name of the document element without
        case normalization. An external entity declaration of the
        external subset is only emitted, if the document has a system
        identifier. The doctype declaration will be written from the
        available information, without check, if this is a known (w3c)
        HTML version information or if the document confirms to the
        given HTML version. All nodes types other than document nodes
        ignore this option.</p>
</dd>
      

      
        <dt><b class="method">asText</b></dt>
          <dd>The asText method returns the tree by serializing the
          string-value of every text node in document order without
          any escaping. In effect, this is what the xslt output method

<i class="m">xpathQuery</i> to the document. The context node of the query is the root
node in the sense of the XPath recommendation (not the document element). The
result can be a string/value, a list of strings, a list of nodes or a list
of attribute name / value pairs. If <i class="m">typeVar</i> is given
the result type name is stored into that variable (empty,
bool, number, string, nodes, attrnodes or mixed).</p>











          <p>See the documentation of the of the













          <b class="command">domNode</b> command method


















          <b class="method">selectNodes</b> for a detailed description of





          the arguments.</p>




          </dd>
      

      
        <dt>
<b class="method">baseURI</b> <i class="m">?URI?</i>
</dt>

  </dl><p>Otherwise, if an unknown method name is given, the command with the
same name as the given method within the namespace <tt class="samp">::dom::domDoc</tt> is
tried to be executed. This allows quick method additions on Tcl level.</p><p>Newly created nodes are appended to a hidden fragment list. If they
are not moved into the tree they are automatically deleted as soon as the whole
document gets deleted.</p>

    <h2><a name="SECTid0x555cdce9c530">SEE ALSO</a></h2><p class="seealso">dom, domNode</p>

    <h2><a name="SECTid0x555cdce9c8c0">KEYWORDS</a></h2><p class="keywords">
<a class="keyword" href="keyword-index.html#KW-DOMnodecreation">DOM node creation</a>, <a class="keyword" href="keyword-index.html#KW-documentelement">document element</a>
</p>

</div><hr class="navsep"><div class="navbar" align="center">
<a class="navaid" href="index.html">Contents</a> · <a class="navaid" href="category-index.html">Index</a> · <a class="navaid" href="keyword-index.html">Keywords</a> · <a class="navaid" href="http://tdom.org">Repository</a>
</div>
</body>
</html>

Tcl object commands (for nodes, fragment/new nodes, the document object itself)
and the underlying DOM tree.
.TP
\&\fB\fBgetDefaultOutputMethod\fP
\&\fRReturns the default output method of the document. This is
usually a result of a XSLT transformation.
.TP
\&\fB\fBasXML\fP \fB?-indent none/tabs/1..8?\fP \fB?-channel channelId?\fP \fB?-escapeNonASCII?\fP \fB?-doctypeDeclaration <boolean>?\fP \fB-xmlDeclaration <boolean>?\fP \fB-encString <string>\fP \fB?-escapeAllQuot?\fP \fB?-indentAttrs?\fP \fB?-nogtescape?\fP \fB?-noEmptyElementTag?\fP
\&\fR
.RS
.PP
Returns the DOM tree as an (optional indented) XML
string or sends the output directly to the given
channelId.
.PP
The -indent option requires "no", "none", "tabs" or a
natural number betwenn 0 and 8, both included, as value. With
the values "no" or "none" no additional white space outside of
markup will be added to the serialization. I. Otherwise, it's
a "pretty-print" serialization, due to inserting white space
between end and the next start tag according to the nesting
level. The level indentation wide is given with the number. If
the value is "tabs", then indentation is done with tabs, one
tab per level.
.PP
If the option \fI-escapeNonASCII\fR is given,
every non 7 bit ASCII character in attribute values or element
PCDATA content will be escaped as character reference in
decimal representation.
.PP
The flag \fI-doctypeDeclaration\fR determines whether

.PP
If the option \fI-noEmptyElementTag\fR is given then no
empty tag syntax will be used. Instead, if an element has
empty content it will be serialized with an element start tag
and an immediately following element end tag.
.RE
.TP
\&\fB\fBasHTML\fP \fB?-channel channelId?\fP \fB?-escapeNonASCII?\fP \fB?-htmlEntities?\fP \fB?-doctypeDeclaration <boolean>?\fP \fB?-breakLines?\fP \fB?-onlyContents?\fP
\&\fR
.RS
.PP
Returns the DOM tree serialized according to HTML rules
(HTML elements are recognized regardless of case, without end
tags for empty HTML elements etc.) as string or sends the
output directly to the given channelId.
.PP
If the option \fI-escapeNonASCII\fR is given, every non 7
bit ASCII character in attribute values or element PCDATA
content will be escaped as character reference in decimal
representation.
.PP
If the option \fI-htmlEntities\fR is given, a character is
written using its HTML 4.01 character entity reference, if it
has one.
.PP
If the option \fI-breakLines\fR is given the serialization
outputs "\en>" instead of ">" for the opening tags of
elements.
.PP
If the option \fI-onlyContents\fR is given only all child
nodes are serialized. This option is ignored by document
nodes.
.PP
If the flag \fI-doctypeDeclaration\fR is given there will
be a DOCTYPE declaration emitted before the first node of the
document. The default is, to do not. The DOCTYPE name will
always be the element name of the document element without
case normalization. An external entity declaration of the
external subset is only emitted, if the document has a system
identifier. The doctype declaration will be written from the
available information, without check, if this is a known (w3c)
HTML version information or if the document confirms to the
given HTML version. All nodes types other than document nodes
ignore this option.
.RE
.TP
\&\fB\fBasText\fP
\&\fRThe asText method returns the tree by serializing the
string-value of every text node in document order without
any escaping. In effect, this is what the xslt output method
"text" (XSLT 1.0 recommendation, section 16.3) does.
.TP

\&\fIxpathQuery\fR to the document. The context node of the query is the root
node in the sense of the XPath recommendation (not the document element). The
result can be a string/value, a list of strings, a list of nodes or a list
of attribute name / value pairs. If \fItypeVar\fR is given
the result type name is stored into that variable (empty,
bool, number, string, nodes, attrnodes or mixed).
.PP



















See the documentation of the of the




.TP




















\&\fBdomNode
\&\fR command method





\&\fBselectNodes\fP for a detailed description of

the arguments.


.RE
.TP
\&\fB\fBbaseURI\fP \fI?URI?\fB
\&\fRReturns the present baseURI of the document. If the optional
argument URI is given, sets the base URI of the document to the given URI.
.TP
\&\fB\fBappendFromScript\fP \fItclScript\fB

        <commanddef>
          <command><method>getDefaultOutputMethod</method></command>
          <desc>Returns the default output method of the document. This is
usually a result of a XSLT transformation.</desc>
        </commanddef>

      <commanddef>
        <command><method>asXML</method> <option>?-indent none/tabs/1..8?</option> <option>?-channel channelId?</option> <option>?-escapeNonASCII?</option> <option>?-doctypeDeclaration &lt;boolean&gt;?</option> <option>-xmlDeclaration &lt;boolean&gt;?</option> <option>-encString &lt;string&gt;</option> <option>?-escapeAllQuot?</option> <option>?-indentAttrs?</option> <option>?-nogtescape?</option> <option>?-noEmptyElementTag?</option></command>
        <desc><p>Returns the DOM tree as an (optional indented) XML
        string or sends the output directly to the given
        channelId.</p>

        <p>The -indent option requires "no", "none", "tabs" or a
        natural number betwenn 0 and 8, both included, as value. With
        the values "no" or "none" no additional white space outside of
        markup will be added to the serialization. I. Otherwise, it's
        a "pretty-print" serialization, due to inserting white space
        between end and the next start tag according to the nesting
        level. The level indentation wide is given with the number. If
        the value is "tabs", then indentation is done with tabs, one
        tab per level.</p>
        
        <p>If the option <m>-escapeNonASCII</m> is given,
        every non 7 bit ASCII character in attribute values or element
        PCDATA content will be escaped as character reference in
        decimal representation.</p>

        <p>The flag <m>-doctypeDeclaration</m> determines whether
        there will be a DOCTYPE declaration emitted before the first

        empty content it will be serialized with an element start tag
        and an immediately following element end tag.</p></desc>

      </commanddef>

      <commanddef>
        <command><method>asHTML</method> <option>?-channel
channelId?</option> <option>?-escapeNonASCII?</option> <option>?-htmlEntities?</option> <option>?-doctypeDeclaration &lt;boolean&gt;?</option> <option>?-breakLines?</option> <option>?-onlyContents?</option></command> 
        <desc><p>Returns the DOM tree serialized according to HTML rules
        (HTML elements are recognized regardless of case, without end
        tags for empty HTML elements etc.) as string or sends the
        output directly to the given channelId.</p>

        <p>If the option <m>-escapeNonASCII</m> is given, every non 7
        bit ASCII character in attribute values or element PCDATA
        content will be escaped as character reference in decimal
        representation.</p>
        
        <p>If the option <m>-htmlEntities</m> is given, a character is
        written using its HTML 4.01 character entity reference, if it
        has one.</p>

        <p>If the option <m>-breakLines</m> is given the serialization
        outputs "\n>" instead of ">" for the opening tags of
        elements.</p>

        <p>If the option <m>-onlyContents</m> is given only all child
        nodes are serialized. This option is ignored by document
        nodes.</p>
        
        <p>If the flag <m>-doctypeDeclaration</m> is given there will
        be a DOCTYPE declaration emitted before the first node of the
        document. The default is, to do not. The DOCTYPE name will
        always be the element name of the document element without
        case normalization. An external entity declaration of the
        external subset is only emitted, if the document has a system
        identifier. The doctype declaration will be written from the
        available information, without check, if this is a known (w3c)
        HTML version information or if the document confirms to the
        given HTML version. All nodes types other than document nodes
        ignore this option.</p></desc>
      </commanddef>

      <commanddef>
        <command><method>asText</method></command>
          <desc>The asText method returns the tree by serializing the
          string-value of every text node in document order without
          any escaping. In effect, this is what the xslt output method

<m>xpathQuery</m> to the document. The context node of the query is the root
node in the sense of the XPath recommendation (not the document element). The
result can be a string/value, a list of strings, a list of nodes or a list
of attribute name / value pairs. If <m>typeVar</m> is given
the result type name is stored into that variable (empty,
bool, number, string, nodes, attrnodes or mixed).</p>











          <p>See the documentation of the of the













          <command>domNode</command> command method


















          <method>selectNodes</method> for a detailed description of





          the arguments.</p>




          </desc>
      </commanddef>

      <commanddef>
        <command><method>baseURI</method> <m>?URI?</m></command>
        <desc>Returns the present baseURI of the document. If the optional 
argument URI is given, sets the base URI of the document to the given URI.</desc>

<html>
<head>
<link rel="stylesheet" href="manpage.css"><title>tDOM manual: domNode</title><meta name="xsl-processor" content="Jochen Loewer (loewerj@hotmail.com), Rolf Ade (rolf@pointsman.de) et. al."><meta name="generator" content="$RCSfile: tmml-html.xsl,v $ $Revision: 1.11 $"><meta charset="utf-8">
</head><body>
<div class="header">
<div class="navbar" align="center">
<a href="#SECTid0x56161ba06630">NAME</a> · <a href="#SECTid0x56161b93cbb0">SYNOPSIS</a> · <a href="#SECTid0x56161b9e4c90"> DESCRIPTION </a> · <a href="#SECTid0x56161ba56370">SEE ALSO</a> · <a href="#SECTid0x56161ba56700">KEYWORDS</a>
</div><hr class="navsep">
</div><div class="body">
  <h2><a name="SECTid0x56161ba06630">NAME</a></h2><p class="namesection">
<b class="names">domNode - </b><br>Manipulates an instance of a DOM node object</p>



  <h2><a name="SECTid0x56161b93cbb0">SYNOPSIS</a></h2><pre class="syntax">$nodeObject <i class="m">method</i> <i class="m">arg arg ...</i>
</pre><pre class="syntax">domNode <i class="m">nodeToken</i> <i class="m">method</i> <i class="m">arg arg ...</i>
</pre>
  <h2><a name="SECTid0x56161b9e4c90"> DESCRIPTION </a></h2><p>This command manipulates one particular instance of a DOM node object.
<i class="m">method</i> indicates a specific method of the node class. These methods
should closely conform to the W3C recommendation "Document Object Model
(Core) Level 1" (<a href="http://www.w3.org/TR/REC-DOM-Level-1/level-one-core.html">http://www.w3.org/TR/REC-DOM-Level-1/level-one-core.html</a>)
as well to parts of the W3C draft "XML Pointer Language (XPointer)"
(<a href="http://www.w3.org/TR/1998/WD-xptr-19980303">http://www.w3.org/TR/1998/WD-xptr-19980303</a>).
Please note, that the XPointer methods are deprecated. Use DOM methods
or XPath expressions instead of them.</p><p>The selectNodes method implements the "XML Path

        <dt><b class="method">asList</b></dt>
        <dd>Returns the DOM substree starting form the current node as a
nested Tcl list.</dd>
      

      
        <dt>
<b class="method">asXML</b> <b class="option">?-indent none/tabs/1..8?</b> <b class="option">?-channel channelId?</b> <b class="option">?-escapeNonASCII?</b> <b class="option">?-doctypeDeclaration &lt;boolean&gt;?</b> <b class="option">-xmlDeclaration &lt;boolean&gt;?</b> <b class="option">-encString &lt;string&gt;</b> <b class="option">?-escapeAllQuot?</b> <b class="option">?-indentAttrs?</b> <b class="option">?-nogtescape?</b> <b class="option">?-noEmptyElementTag?</b>
</dt>
        <dd>
<p>Returns the DOM substree starting from the current
        node as the root node of the result as an (optional indented)
        XML string or sends the output directly to the given
        channelId.</p>





        <p>See the documentation of the of the




        <b class="command">domDoc</b> command method







        <b class="method">asXML</b> for a detailed description of the


        arguments.</p>















        </dd>
      

      

        <dt>
<b class="method">asHTML</b> <b class="option">?-channel
channelId?</b> <b class="option">?-escapeNonASCII?</b> <b class="option">?-htmlEntities?</b> <b class="option">?-doctypeDeclaration &lt;boolean&gt;?</b> <b class="option">?-breakLines?</b> <b class="option">?-onlyContents?</b>
</dt>
        <dd>
<p>Returns the DOM substree starting from the current
        node as the root node of the result serialized according to
        HTML rules (HTML elements are recognized regardless of case,
        without end tags for empty HTML elements etc.), as string or
        sends the output directly to the given channelId.</p>


        <p>See the documentation of the the <b class="command">domDoc</b>
        method <b class="method">asHTML</b> for a detailed description of

        the arguments.</p>
        </dd>
      

      
        <dt><b class="method">asText</b></dt>
          <dd>For ELEMENT_NODEs, the asText method outputs 
the string-value of every text node descendant of node in document
order without any escaping. For every other node type, this method outputs the XPath string value of that node.</dd>

      

    </dl><p>Otherwise, if an unknown method name is given, the command with the same
name as the given method within the namespace <tt class="l">::dom::domNode</tt> is tried to
be executed. This allows quick method additions on Tcl level.</p>


  <h2><a name="SECTid0x56161ba56370">SEE ALSO</a></h2><p class="seealso">dom, domDoc</p>
  
  <h2><a name="SECTid0x56161ba56700">KEYWORDS</a></h2><p class="keywords">
<a class="keyword" href="keyword-index.html#KW-XML">XML</a>, <a class="keyword" href="keyword-index.html#KW-DOM">DOM</a>, <a class="keyword" href="keyword-index.html#KW-document">document</a>, <a class="keyword" href="keyword-index.html#KW-node">node</a>, <a class="keyword" href="keyword-index.html#KW-parsing">parsing</a>
</p>
  
</div><hr class="navsep"><div class="navbar" align="center">
<a class="navaid" href="index.html">Contents</a> · <a class="navaid" href="category-index.html">Index</a> · <a class="navaid" href="keyword-index.html">Keywords</a> · <a class="navaid" href="http://tdom.org">Repository</a>
</div>
</body>
</html>

\&\fRReturns the column number of that node in the originally parsed
XML.
.TP
\&\fB\fBasList\fP
\&\fRReturns the DOM substree starting form the current node as a
nested Tcl list.
.TP
\&\fB\fBasXML\fP \fB?-indent none/tabs/1..8?\fP \fB?-channel channelId?\fP \fB?-escapeNonASCII?\fP \fB?-doctypeDeclaration <boolean>?\fP \fB-xmlDeclaration <boolean>?\fP \fB-encString <string>\fP \fB?-escapeAllQuot?\fP \fB?-indentAttrs?\fP \fB?-nogtescape?\fP \fB?-noEmptyElementTag?\fP
\&\fR
.RS
.PP
Returns the DOM substree starting from the current
node as the root node of the result as an (optional indented)
XML string or sends the output directly to the given
channelId.
.PP



See the documentation of the of the
.TP





\&\fBdomDoc

\&\fR command method
\&\fBasXML\fP for a detailed description of the






arguments.















.RE
.TP
\&\fB\fBasHTML\fP \fB?-channel channelId?\fP \fB?-escapeNonASCII?\fP \fB?-htmlEntities?\fP \fB?-doctypeDeclaration <boolean>?\fP \fB?-breakLines?\fP \fB?-onlyContents?\fP
\&\fR
.RS
.PP
Returns the DOM substree starting from the current
node as the root node of the result serialized according to
HTML rules (HTML elements are recognized regardless of case,
without end tags for empty HTML elements etc.), as string or
sends the output directly to the given channelId.
.PP
See the documentation of the the
.TP
\&\fBdomDoc
\&\fR

method \fBasHTML\fP for a detailed description of

the arguments.
.RE
.TP
\&\fB\fBasText\fP
\&\fRFor ELEMENT_NODEs, the asText method outputs
the string-value of every text node descendant of node in document
order without any escaping. For every other node type, this method outputs the XPath string value of that node.
.TP
\&\fB\fBappendFromList\fP \fIlist\fB

      <commanddef>
        <command><method>asList</method></command>
        <desc>Returns the DOM substree starting form the current node as a
nested Tcl list.</desc>
      </commanddef>

      <commanddef>
        <command><method>asXML</method> <option>?-indent none/tabs/1..8?</option> <option>?-channel channelId?</option> <option>?-escapeNonASCII?</option> <option>?-doctypeDeclaration &lt;boolean&gt;?</option> <option>-xmlDeclaration &lt;boolean&gt;?</option> <option>-encString &lt;string&gt;</option> <option>?-escapeAllQuot?</option> <option>?-indentAttrs?</option> <option>?-nogtescape?</option> <option>?-noEmptyElementTag?</option></command>
        <desc><p>Returns the DOM substree starting from the current
        node as the root node of the result as an (optional indented)
        XML string or sends the output directly to the given
        channelId.</p>





        <p>See the documentation of the of the




        <command>domDoc</command> command method






        <method>asXML</method> for a detailed description of the


        arguments.</p>
        </desc>















      </commanddef>

      <commanddef>
        <command><method>asHTML</method> <option>?-channel
channelId?</option> <option>?-escapeNonASCII?</option> <option>?-htmlEntities?</option> <option>?-doctypeDeclaration &lt;boolean&gt;?</option> <option>?-breakLines?</option> <option>?-onlyContents?</option></command>
        <desc><p>Returns the DOM substree starting from the current
        node as the root node of the result serialized according to
        HTML rules (HTML elements are recognized regardless of case,
        without end tags for empty HTML elements etc.), as string or
        sends the output directly to the given channelId.</p>


        <p>See the documentation of the the <command>domDoc</command>
        method <method>asHTML</method> for a detailed description of
        the arguments.</p>
        </desc>
      </commanddef>

      <commanddef>
        <command><method>asText</method></command>
          <desc>For ELEMENT_NODEs, the asText method outputs 
the string-value of every text node descendant of node in document
order without any escaping. For every other node type, this method outputs the XPath string value of that node.</desc>

<html>
<head>
<link rel="stylesheet" href="manpage.css"><title>tDOM manual: expat</title><meta name="xsl-processor" content="Jochen Loewer (loewerj@hotmail.com), Rolf Ade (rolf@pointsman.de) et. al."><meta name="generator" content="$RCSfile: tmml-html.xsl,v $ $Revision: 1.11 $"><meta charset="utf-8">
</head><body>
<div class="header">
<div class="navbar" align="center">
<a href="#SECTid0x5575961dc910">NAME</a> · <a href="#SECTid0x55759612bd60">SYNOPSIS</a> · <a href="#SECTid0x5575961d3ef0">DESCRIPTION</a> · <a href="#SECTid0x5575961d4cc0">COMMAND OPTIONS</a> · <a href="#SECTid0x557596234b50"> COMMAND METHODS </a> · <a href="#SECTid0x55759623b630">Callback Command Return Codes</a> · <a href="#SECTid0x55759623c1c0">SEE ALSO</a> · <a href="#SECTid0x55759623c580">KEYWORDS</a>
</div><hr class="navsep">
</div><div class="body">
    <h2><a name="SECTid0x5575961dc910">NAME</a></h2><p class="namesection">
<b class="names">expat - </b><br>Creates an instance of an expat parser object</p>



    <h2><a name="SECTid0x55759612bd60">SYNOPSIS</a></h2><pre class="syntax">package require tdom

<b class="cmd">expat</b> ?<i class="m">parsername</i>? ?<i class="m">-namespace</i>? ?<i class="m">arg arg ..</i>

<b class="cmd">xml::parser</b> ?<i class="m">parsername</i>? ?<i class="m">-namespace</i>? ?<i class="m">arg arg ..</i>
</pre>
    <h2><a name="SECTid0x5575961d3ef0">DESCRIPTION</a></h2><p>The parser created with <i class="m">expat</i> or <i class="m">xml::parser</i>
(which is just another name for the same command in an own namespace) are able
to parse any kind of well-formed XML. The parsers are stream oriented XML
parser. This means that you register handler scripts with the parser prior to
starting the parse. These handler scripts are called when the parser discovers
the associated structures in the document being parsed.  A start tag is an
example of the kind of structures for which you may register a handler
script.</p><p>The parsers always check for XML well-formedness of the input (and
report error, if the input isn't well-formed). They parse the internal
DTD and, at request, external DTD and external entities, if you
resolve the identifier of the external entities with the
-externalentitycommand script (see there). If you use the -validateCmd
option (see there), the input is additionally validated.</p><p>Additionly, the Tcl extension code that implements this command provides an
API for adding C level coded handlers. Up to now, there exists the parser
extension command "tdom". The handler set installed by this extension build an
in memory "tDOM" DOM tree, while the parser is parsing the input.</p><p>It is possible to register an arbitrary amount of different handler scripts
and C level handlers for most of the events. If the event occurs, they are
called in turn.</p>

    <h2><a name="SECTid0x5575961d4cc0">COMMAND OPTIONS</a></h2><dl class="optlist">
        
          <dt><b>-namespace</b></dt>

          <dd>
<p>Enables namespace parsing. You must use this option while
creating the parser with the <tt class="samp">expat</tt> or <tt class="samp">xml::parser</tt>
command. You can't enable (nor disable) namespace parsing with
<tt class="samp">&lt;parserobj&gt; configure ...</tt>.</p>
</dd>
        

        
          <dt>
<b>-namespaceseparator</b> <i>char</i>
</dt>
          

          <dd><p>This option has only effect, if used together with
          the option <i class="m">-namespace</i>. If given, this option
          determines the character inserted between namespace URI and
          the local name, while reporting an XML element name to a
          handler script. The default is the character ':'. The
          value must be a one-character string less or equal to
          \u00FF, preferably a 7-bit ASCII character or the empty
          string. If the value is the empty string (as well, as if the
          value is \x00) the namespace URI and the local name will be
          concatenated without any separator.</p></dd>
        
        
        
          <dt>
<b>-final</b> <i>boolean</i>
</dt>
          

          <dd>

-paramentityparsing value of "never" (which is the default) suppresses any call
to the -externalentitycommand script. Pleace notice, that, if the document also
doesn't have an internal subset, the -startdoctypedeclcommand and
enddoctypedeclcommand scripts, if set, are not called.</dd>
        

      </dl>
    <h2><a name="SECTid0x557596234b50"> COMMAND METHODS </a></h2><dl class="commandlist">
        
          <dt>
<b class="cmd">parser</b> <b class="method">configure</b> <i class="m">option value ?option value?</i>
</dt>

          <dd><p>Sets configuration options for the parser. Every command
option, except <i class="m">-namespace</i> can be set or modified with this method.</p></dd>

          <dd><p>Resets the parser in preparation for parsing another
document. A parser cannot be reset from within one of its handler callbacks
(neither directly nor indirectly) and will raise a tcl error in this
cases.</p></dd>
        
      </dl>

    <h2><a name="SECTid0x55759623b630">Callback Command Return Codes</a></h2><p>A script invoked for any of the parser callback commands, such as
-elementstartcommand, -elementendcommand, etc, may return an error code other
than "ok" or "error". All callbacks may in addition return
"break" or "continue".</p><p>If a callback script returns an "error" error code then
processing of the document is terminated and the error is propagated in the
usual fashion.</p><p>If a callback script returns a "break" error code then all
further processing of every handler script out of this Tcl handler set is
suppressed for the further parsing. This does not influence any other handler
set.</p><p>If a callback script returns a "continue" error code then
processing of the current element, and its children, ceases for every handler
script out of this Tcl handler set and processing continues with the next
(sibling) element. This does not influence any other handler set.</p><p>If a callback script returns a "return" error
code then parsing is canceled altogether, but no error is raised.</p>

    <h2><a name="SECTid0x55759623c1c0">SEE ALSO</a></h2><p class="seealso">
<a href="expatapi.html">expatapi</a>, <a href="tdomcmd.html">tdom</a>
</p>

    <h2><a name="SECTid0x55759623c580">KEYWORDS</a></h2><p class="keywords">
<a class="keyword" href="keyword-index.html#KW-SAX">SAX</a>, <a class="keyword" href="keyword-index.html#KW-push">push</a>, <a class="keyword" href="keyword-index.html#KW-pushparser">pushparser</a>
</p>
  </div><hr class="navsep"><div class="navbar" align="center">
<a class="navaid" href="index.html">Contents</a> · <a class="navaid" href="category-index.html">Index</a> · <a class="navaid" href="keyword-index.html">Keywords</a> · <a class="navaid" href="http://tdom.org">Repository</a>
</div>
</body>
</html>

.IP "\fB-namespace\fR"
.RS
.PP
Enables namespace parsing. You must use this option while
creating the parser with the \fBexpat\fR or \fBxml::parser\fR
command. You can't enable (nor disable) namespace parsing with
\&\fB<parserobj> configure ...\fR.
.RE
.IP "\fB-namespaceseparator  \fIchar\fP\fR"
.RS
.PP
This option has only effect, if used together with
the option \fI-namespace\fR. If given, this option
determines the character inserted between namespace URI and
the local name, while reporting an XML element name to a
handler script. The default is the character ':'. The
value must be a one-character string less or equal to
\&\eu00FF, preferably a 7-bit ASCII character or the empty
string. If the value is the empty string (as well, as if the
value is \ex00) the namespace URI and the local name will be
concatenated without any separator.
.RE
.IP "\fB-final  \fIboolean\fP\fR"
.RS
.PP
This option indicates whether the document data next
presented to the parse method is the final part of the document. A value of "0"
indicates that more data is expected. A value of "1" indicates that no more is

          <desc><p>Enables namespace parsing. You must use this option while
creating the parser with the <samp>expat</samp> or <samp>xml::parser</samp>
command. You can't enable (nor disable) namespace parsing with
<samp>&lt;parserobj&gt; configure ...</samp>.</p>
</desc>
        </optdef>

        <optdef>
          <optname>-namespaceseparator</optname>
          <optarg>char</optarg>

          <desc><p>This option has only effect, if used together with
          the option <m>-namespace</m>. If given, this option
          determines the character inserted between namespace URI and
          the local name, while reporting an XML element name to a
          handler script. The default is the character ':'. The
          value must be a one-character string less or equal to
          \u00FF, preferably a 7-bit ASCII character or the empty
          string. If the value is the empty string (as well, as if the
          value is \x00) the namespace URI and the local name will be
          concatenated without any separator.</p></desc>
        </optdef>
        
        <optdef>
          <optname>-final</optname>
          <optarg>boolean</optarg>

          <desc><p>This option indicates whether the document data next
presented to the parse method is the final part of the document. A value of "0"
indicates that more data is expected. A value of "1" indicates that no more is

<td width="35%"><a name="KW-document">document</a></td><td width="65%">
<a href="dom.html">dom</a> · <a href="domNode.html">domNode</a>
</td>
</tr><tr class="row0">
<td width="35%"><a name="KW-documentelement">document element</a></td><td width="65%"><a href="domDoc.html">domDoc</a></td>
</tr><tr class="row1">
<td width="35%"><a name="KW-dom">dom</a></td><td width="65%">
<a href="dom.html">dom</a> · <a href="domNode.html">domNode</a> · <a href="schema.html">schema</a> · <a href="tdomcmd.html">tdom</a>
</td>
</tr><tr class="row0">
<td width="35%"><a name="KW-DOMnodecreation">DOM node creation</a></td><td width="65%"><a href="domDoc.html">domDoc</a></td>
</tr><tr class="row1">
<td width="35%"><a name="KW-domDoc">domDoc</a></td><td width="65%"><a href="domDoc.html">domDoc</a></td>
</tr><tr class="row0">
<td width="35%"><a name="KW-domNode">domNode</a></td><td width="65%"><a href="domNode.html">domNode</a></td>

<a href="dom.html">dom</a> · <a href="domNode.html">domNode</a>
</td>
</tr><tr class="header"><th colspan="2"><a name="KEYWORDS-P">Keywords: P</a></th></tr><tr class="row1">
<td width="35%"><a name="KW-parsing">parsing</a></td><td width="65%">
<a href="dom.html">dom</a> · <a href="domNode.html">domNode</a> · <a href="pullparser.html">pullparser</a>
</td>
</tr><tr class="row0">
<td width="35%"><a name="KW-Postvalidation">Postvalidation</a></td><td width="65%"><a href="schema.html">schema</a></td>
</tr><tr class="row1">
<td width="35%"><a name="KW-pull">pull</a></td><td width="65%"><a href="pullparser.html">pullparser</a></td>
</tr><tr class="row0">
<td width="35%"><a name="KW-pullparser">pullparser</a></td><td width="65%"><a href="pullparser.html">pullparser</a></td>
</tr><tr class="row1">
<td width="35%"><a name="KW-push">push</a></td><td width="65%"><a href="expat.html">expat</a></td>
</tr><tr class="row0">
<td width="35%"><a name="KW-pushparser">pushparser</a></td><td width="65%"><a href="expat.html">expat</a></td>
</tr><tr class="header"><th colspan="2"><a name="KEYWORDS-S">Keywords: S</a></th></tr><tr class="row1">
<td width="35%"><a name="KW-SAX">SAX</a></td><td width="65%">
<a href="expat.html">expat</a> · <a href="schema.html">schema</a> · <a href="tdomcmd.html">tdom</a>
</td>
</tr><tr class="row0">
<td width="35%"><a name="KW-schema">schema</a></td><td width="65%"><a href="schema.html">schema</a></td>
</tr><tr class="header"><th colspan="2"><a name="KEYWORDS-T">Keywords: T</a></th></tr><tr class="row1">
<td width="35%"><a name="KW-tdom">tdom</a></td><td width="65%"><a href="tdomcmd.html">tdom</a></td>
</tr><tr class="row0">
<td width="35%"><a name="KW-tdom::pullparser">tdom::pullparser</a></td><td width="65%"><a href="pullparser.html">pullparser</a></td>
</tr><tr class="row1">
<td width="35%"><a name="KW-tdom::schema">tdom::schema</a></td><td width="65%"><a href="schema.html">schema</a></td>
</tr><tr class="row0">
<td width="35%"><a name="KW-tdomcmd">tdomcmd</a></td><td width="65%"><a href="tdomcmd.html">tdom</a></td>
</tr><tr class="row1">
<td width="35%"><a name="KW-tnc">tnc</a></td><td width="65%"><a href="tnc.html">tnc</a></td>
</tr><tr class="header"><th colspan="2"><a name="KEYWORDS-V">Keywords: V</a></th></tr><tr class="row0">
<td width="35%"><a name="KW-Validation">Validation</a></td><td width="65%">
<a href="schema.html">schema</a> · <a href="tnc.html">tnc</a>
</td>
</tr><tr class="header"><th colspan="2"><a name="KEYWORDS-X">Keywords: X</a></th></tr><tr class="row1">
<td width="35%"><a name="KW-XML">XML</a></td><td width="65%">
<a href="dom.html">dom</a> · <a href="domNode.html">domNode</a> · <a href="pullparser.html">pullparser</a>
</td>
</tr><tr class="row0">
<td width="35%"><a name="KW-xml::parser">xml::parser</a></td><td width="65%"><a href="expat.html">expat</a></td>
</tr>
</table></div></div><div class="footer">
<hr class="navsep"><div class="navbar" align="center">
<a class="navaid" href="index.html">Contents</a> · <a class="navaid" href="category-index.html">Index</a> · <a class="navaid" href="keyword-index.html">Keywords</a> · <a class="navaid" href="http://tdom.org">Repository</a>
</div>
</div>
</body>
</html>

<html>
<head>
<link rel="stylesheet" href="manpage.css"><title>tDOM manual: schema</title><meta name="xsl-processor" content="Jochen Loewer (loewerj@hotmail.com), Rolf Ade (rolf@pointsman.de) et. al."><meta name="generator" content="$RCSfile: tmml-html.xsl,v $ $Revision: 1.11 $"><meta charset="utf-8">
</head><body>
<div class="header">
<div class="navbar" align="center">
<a href="#SECTid0x56487d590630">NAME</a> · <a href="#SECTid0x56487d4e1110">SYNOPSIS</a> · <a href="#SECTid0x56487d56e810">DESCRIPTION </a> · <a href="#SECTid0x56487d5e4a10">Schema definition scripts</a> · <a href="#SECTid0x56487d5f3e50">Quantity specifier</a> · <a href="#SECTid0x56487d5f5de0">Text constraint scripts</a> · <a href="#SECTid0x56487d6090e0">Local key constraints</a> · <a href="#SECTid0x56487d60af00">Recovering</a> · <a href="#SECTid0x56487d60ced0">Examples</a> · <a href="#SECTid0x56487d60ee40">KEYWORDS</a>
</div><hr class="navsep">
</div><div class="body">
  <h2><a name="SECTid0x56487d590630">NAME</a></h2><p class="namesection">
<b class="names">tdom::schema - </b><br>Creates a schema validation command</p>

  <h2><a name="SECTid0x56487d4e1110">SYNOPSIS</a></h2><pre class="syntax">package require tdom

<b class="cmd">tdom::schema</b> <i class="m">?create?</i> <i class="m">cmdName</i>
    </pre>

  <h2><a name="SECTid0x56487d56e810">DESCRIPTION </a></h2><p>Every call of this command creates a new validation command. A
    validation command has methods to define a schema and is able
    to validate XML data or to post-validate a tDOM DOM tree (and to
    some degree other kind of hierarchical data) against this
    schema.</p><p>Also, a validation command may be used as argument to the
    <i class="m">-validateCmd</i> option of the <i class="m">dom parse</i> and the
    <i class="m">expat</i> commands to enable validation additionally to what
    they do otherwise.</p><p>The methods of created commands are:</p><dl class="commandlist">
      
          <dt>
<b class="method">prefixns</b> <i class="m">?prefixUriList?</i>
</dt>
          <dd>This method controls prefix (or abbreviation) to
          namespace URI mapping. Wherever a namespace argument is
          expected in the schema command methods the
          "prefix" could be used instead of the namespace

          URI. If the list maps the same prefix to different namespace
          URIs, the first one wins. If there is no such prefix, the
          namespace argument is used literally as namespace URI. If
          the method is called without argument, it returns the
          current prefixUriList. If the method is called with the
          empty string, any namespace URI arguments are used
          literally. This is the default.
          </dd>
      

      
        <dt>
<b class="method">defelement</b> <i class="m">name</i> <i class="m">?namespace?</i> <i class="m">&lt;definition script&gt;</i>
</dt>
        <dd>This method defines the element <i class="m">name</i> (optional in
        the namespace <i class="m">namespace</i>) in the schema. The
        <i class="m">definition script</i> is evaluated and defines the content
        model of the element. If the <i class="m">namespace</i> argument is
        given, any <i class="m">element</i> or <i class="m">ref</i> references in the
        definition script not wrapped inside a <i class="m">namespace</i>
        command are resolved in that namespace. If there is already a
        element definition for the name/namespace combination, the
        command raises error.</dd>
      

      
        <dt>
<b class="method">defelementtype</b> <i class="m">typename</i> <i class="m">name</i> <i class="m">?namespace?</i> <i class="m">&lt;definition script&gt;</i>
</dt>
        <dd>This method defines the element type <i class="m">typename</i>
        (optional in the namespace <i class="m">namespace</i>) in the schema. If
        the element type is used in a definition script with the
        schema command elementtype, the validation engine expects an
        element named <i class="m">name</i> (in the namespace <i class="m">namespace</i>,
        if given) and the content model <i class="m">definition script</i>.
        Defining element types seems only sensible if you really have
        elements with the same name and namespace but different
        content models. The <i class="m">definition script</i> is evaluated and
        defines the content model of the element. If the
        <i class="m">namespace</i> argument is given, any <i class="m">element</i> or
        <i class="m">ref</i> references in the definition script not wrapped
        inside a <i class="m">namespace</i> command are resolved in that
        namespace. If there is already an elementtype definition for
        the name/namespace combination, the command raises error. The
        document element of any XML to validate cannot be a
        <i class="m">defelementtype</i> defined element.</dd>
      

      
        <dt>
<b class="method">defpattern</b> <i class="m">name</i> <i class="m">?namespace?</i> <i class="m">&lt;definition script&gt;</i>
</dt>
        <dd>This method defines a (maybe complex) content particle
        with the <i class="m">name</i> (optional in the namespace
        <i class="m">namespace</i>) in the schema, to be used in other
        definition scripts with the definition command <i class="m">ref</i>. The
        <i class="m">definition script</i> is evaluated and defines the content
        model of the content particle. If the <i class="m">namespace</i>
        argument is given, any <i class="m">element</i> or <i class="m">ref</i> references
        in the definition script not wrapped inside a <i class="m">namespace</i>
        command are resolved in that namespace. If there is already a
        pattern definition for the name/namespace combination, the
        command raises error.</dd>
      

      
        <dt>
<b class="method">deftexttype</b> <i class="m">name</i> <i class="m">&lt;constraint script&gt;</i>
</dt>
        <dd>This method defines a bundle of text constraints that
        can be referred to by <i class="m">name</i> while defining constraints on
        text element or attribute values. If there is already a text
        type definition with this name, the command raises error. A
        text type must be defined before it can be used in schema
        definition scripts.</dd>
      
      
      
        <dt>
<b class="method">start</b> <i class="m">documentElement</i> <i class="m">?namespace?</i>
</dt>
        <dd>This method defines the name and namespace of the root
        element of a tree to validate. If this method is used, the
        root element must match for validity. If <i class="m">start</i> is not
        used, any element defined by <i class="m">defelement</i> may be the root
        of a valid document. The <i class="m">start</i> method may be used
        several times with varying arguments during the lifetime of a
        validation command. If the command is called with just the
        empty string (and no namespace argument), the validation
        constraint for the root element is removed and any defined
        element will be valid as root of a tree to validate.</dd>
      

      
        <dt>
<b class="method">define</b> <i class="m">&lt;definition script&gt;</i>
</dt>
        <dd>This method allows to define several elements or patterns
        or a whole schema with one call. All schema command methods so
        far (<i class="m">prefixns</i>, <i class="m">defelement</i>,
        <i class="m">defelementtype</i>, <i class="m">defpattern</i>, <i class="m">deftexttype</i> and
        <i class="m">start</i>) are allowed top level in the <i class="m">definition
        script</i>. The <i class="m">define</i> method itself isn't allowed
        recursively.</dd>
      
      
      
        <dt>
<b class="method">event</b> <i class="m">(start|end|text)</i> <i class="m">?event specific data?</i>
</dt>
        <dd>This method allows the validation of hierarchical data against
        the content constraints of the validation command.

        <dl class="optlist">
          
            <dt>
<b>start</b> <i>name ?attributes? ?namespace? </i>
</dt>
            
            <dd>Checks if the current validation state allows the
            element <i class="m">name</i> in the <i class="m">namespace</i> to start here.
            It raises error if not.</dd>
          

          
            <dt><b>end</b></dt>
            <dd>Checks if the current innermost open element may end
            there in the current state without violation of validation
            constraints. It raises error if not.</dd>
          
          
          
            <dt>
<b>text</b> <i>text</i>
</dt>
            
            <dd>Checks if the current validation state allows the
            given text content. It raises error if not.</dd>
          

        </dl>
        </dd>
      

      
        <dt>
<b class="method">validate</b> <i class="m">&lt;XML string&gt;</i> <i class="m">?objVar?</i>
</dt>
        <dd>Returns true if the <i class="m">&lt;XML string&gt;</i> is valid, or
        false, otherwise. If validation has failed and the optional
        <i class="m">objVar</i> argument is given, the variable with that
        name is set to a validation error message. If the XML string
        is valid and the optional <i class="m">objVar</i> argument is given,
        the variable with that name is set to the empty string.</dd>
      

      
        <dt>
<b class="method">validatefile</b> <i class="m">filename</i> <i class="m">?objVar?</i>
</dt>
        <dd>Returns true if the content of <i class="m">filename</i> is valid,
        or false, otherwise. The given file is feeded as binary stream
        to expat, therefore only US-ASCII, ISO-8859-1, UTF-8 or UTF-16
        encoded data will work with this method. If validation has
        failed and the optional <i class="m">objVar</i> argument is given, the
        variable with that name is set to a validation error message.
        If the XML string is valid and the optional <i class="m">objVar</i>
        argument is given, the variable with that name is set to the
        empty string.</dd>
      

      
        <dt>
<b class="method">validatechannel</b> <i class="m">channel</i> <i class="m">?objVar?</i>
</dt>
        <dd>Returns true if the content read from the Tcl channel
        <i class="m">channel</i> is valid, or false, otherwise. Since data read
        out of a Tcl channel is UTF-8 encoded, any misleading encoding
        declaration at the beginning of the data will lead to errors.
        If the validation fails and the optional <i class="m">objVar</i>
        argument is given, the variable with that name is set to a
        validation error message. If the XML string is valid and the
        optional <i class="m">objVar</i> argument is given, the variable with
        that name is set to the empty string.</dd>
      
      
      
        <dt>
<b class="method">domvalidate</b> <i class="m">domNode</i> <i class="m">?objVar?</i>
</dt>
        <dd>Returns true if the first argument is a valid tree, or
        false, otherwise. If validation has failed and the optional
        <i class="m">objVar</i> argument is given, the variable with that name
        is set to a validation error message. If the dom tree is valid
        and the optional <i class="m">objVar</i> argument is given, the variable
        with that name is set to the empty string. </dd>
      

      
        <dt>
<b class="method">reportcmd</b> <i class="m">?cmd?</i>
</dt>
        <dd>This method expects the name of a Tcl command to be
        called in case of validation error. The command will be
        called with two arguments appended: the schema command which
        raises the validation error, and a validation error code.

        <p>The possible error codes are:</p>
        <dl>
            <dt>MISSING_ELEMENT</dt><dd></dd>
            <dt>MISSING_TEXT</dt><dd></dd>
            <dt>UNEXPECTED_ELEMENT</dt><dd></dd>
            <dt>UNEXPECTED_ROOT_ELEMENT</dt><dd></dd>
            <dt>UNEXPECTED_TEXT</dt><dd></dd>
            <dt>UNKNOWN_ROOT_ELEMENT</dt><dd></dd>
            <dt>UNKNOWN_ATTRIBUTE</dt><dd></dd>
            <dt>MISSING_ATTRIBUTE</dt><dd></dd>
            <dt>INVALID_ATTRIBUTE_VALUE</dt><dd></dd>
            <dt>DOM_KEYCONSTRAINT</dt><dd></dd>
            <dt>DOM_XPATH_BOOLEAN</dt><dd></dd>
            <dt>INVALID_KEYREF</dt><dd></dd>
            <dt>INVALID_VALUE</dt><dd></dd>
            <dt>UNKOWN_GLOBAL_ID</dt><dd></dd>
            <dt>UNKOWN_ID</dt><dd></dd>
        </dl>
        <p> For more detailed information see section <a href="#SECTid0x56487d60af00">Recovering</a>.</p>
        </dd>
      

      
        <dt><b class="method">delete</b></dt>
        <dd>This method deletes the validation command.</dd>
      

      
          <dt>

                  with respect to validation state. The possible return values
                  and their meanings are:
                  <dl>
                      <dt>READY</dt><dd>The validation command is ready to start
                      validation</dd>
                      <dt>VALIDATING</dt><dd>The validation command is in the
                      process of validating input.</dd>
                      <dt>FINISHED</dt><dd>The validation has finished, no further
                      events are expected.</dd>
                  </dl>
                  </dd>
              
              
                  <dt><b>vstate</b></dt>
                  <dd>This method is a shorter alias for validationstate; see there.</dd>
              
              
                  <dt><b>line</b></dt>
                  <dd>If the schema command is currently validating,
                  this method returns the line part of the parsing
                  position information, and the empty string in all
                  other cases. If the schema command is currently
                  post-validating a DOM tree, there may be no position
                  information stored at some or all nodes. The
                  empty string is returned in these cases.</dd>
              
              
                  <dt><b>column</b></dt>
                  <dd>If the schema command is currently validating
                  this method returns the column part of the parsing
                  position information, and the empty string in all
                  other cases. If the schema command is currently
                  post-validating a DOM tree, there may be no position
                  information stored at some or all nodes. The
                  empty string is returned in these cases.</dd>
              
              
                  <dt><b>domNode</b></dt>
                  <dd>If the schema command isn't currently
                  post-validating a DOM tree this method returns the
                  empty string. Otherwise, if the schema command waits
                  for the reportcmd script to finish while recovering
                  from a validation error it returns the node on which
                  the validation engine is currently looking at in
                  case the node is an ELEMENT_NODE or, if not, its
                  parent node. It is recommended that you do not use
                  this method. Or at least leave the DOM tree alone,
                  use it read-only.</dd>
              
              
                  <dt><b>nrForwardDefinitions</b></dt>
                  <dd>Returns how many elements, element types and
                  ref patterns are referenced that aren't defined so
                  far (summed together).</dd>
              
              
                  <dt><b>definedElements</b></dt>
                  <dd>Returns in no particular order the defined
                  elements in the grammar as list. If an element is
                  namespaced, its list entry will be itself a list with
                  two elements, with the name as first and the
                  namespace as second element.</dd>
              
              
                  <dt><b>definedElementtypes</b></dt>
                  <dd>Returns in no particular order the defined
                  element types in the grammar as list. If an element
                  type is namespaced, its list entry will be itself a
                  list with two elements, with the name as first and
                  the namespace as second element.</dd>
              
              
                  <dt><b>definedPatterns</b></dt>
                  <dd>Returns in no particular order the defined
                  named pattern in the grammar as list. If a named
                  pattern is namespaced, its list entry will be itself
                  a list with two elements, with the name as first and
                  the namespace as second element.</dd>
              
              
                  <dt><b>expected</b></dt>
                  <dd>Returns in no particular order all possible
                  next events (since the last successful event match,
                  if there was one) as a list. If an element is
                  namespaced its list entry will be itself a list with
                  two elements, with the name as first and the
                  namespace as second element. If text is a possible
                  next event, the list entry will be a two elements
                  list, with #text as first element and the empty
                  string as second. If an any element constraint is
                  possible. the list entry will be a two elements list,
                  with &lt;any&gt; as first element and the empty string
                  as second. If an any element in a certain namespace
                  constraint is possible, the list entry will be a two
                  elements list, with &lt;any&gt; as first element and
                  the namespace as second. If element end is a
                  possible event, the list entry will be a two elements
                  list with &lt;elementend&gt; as first element and the
                  empty string as second element.</dd>
              
              
                  <dt><b>definition name ?namespace?</b></dt>
                  <dd>Returns the code that defines the given
                  element. The command raises error if there is no
                  definition of that element.
                  </dd>
              
              
                  <dt><b>typedefinition name ?namespace?</b></dt>
                  <dd>Returns the code that defines the given
                  element type definition. The command raises error if
                  there is no definition of that element.
                  </dd>
              
              
                  <dt><b>patterndefinition name ?namespace?</b></dt>
                  <dd>Returns the code that defines the given
                  pattern definition. The command raises error if
                  there is no definition of a pattern with that name
                  and, if given, namespace.
                  </dd>
              
              
                  <dt><b>vaction ?name|namespace|text?</b></dt>
                  <dd>
<p>This method returns useful information only if
                  the schema command waits for the reportcmd script to
                  finish while recovering from a validation error.
                  Otherwise it returns NONE.</p>
                  <p>If the command is called without the optional
                  argument the possible return values and their
                  meanings are:</p>
                  <dl>
                      <dt>NONE</dt><dd>The schema command currently
                      does not recover from a validation event.</dd>
                      <dt>MATCH_ELEMENT_START</dt><dd>Element start event, which includes looking for missing or unknown attributes.</dd>
                      <dt>MATCH_ELEMENT_END</dt><dd>Element end event.</dd>
                      <dt>MATCH_TEXT</dt><dd>Validating text between tags.</dd>
                      <dt>MATCH_ATTRIBUTE_TEXT</dt><dd>Attribute text value constraint check</dd>
                      <dt>MATCH_GLOBAL</dt><dd>Checking global IDs</dd>
                      <dt>MATCH_DOM_KEYCONSTRAINT</dt><dd>Checking domunique constraint</dd>
                      <dt>MATCH_DOM_XPATH_BOOLEAN</dt><dd>Checking domxpathboolean constant</dd>
                  </dl>
                  <p>If called with one of the possible optional
                  arguments, the command returns detail information
                  depending on current action.</p>
                  <dl>
                      <dt>name</dt><dd>Returns the name of the element
                      that has to match in case of
                      MATCH_ELEMENT_START. Returns the name of the
                      closed element in case of MATCH_ELEMENT_END.
                      Returns the name of the attribute in case of

                      MATCH_ATTRIBUTE_TEXT. Returns the name of the
                      parent element in case of MATCH_TEXT.</dd>
                      

                      <dt>namespace</dt><dd>Returns the namespace of
                      the element that has to match in case of
                      MATCH_ELEMENT_START. Returns the namespace of the
                      closed element in case of MATCH_ELEMENT_END.
                      Returns the namespace of the attribute in case
                      of MATCH_ATTRIBUTE_TEXT. Returns the namespace of
                      the parent element in case of MATCH_TEXT.</dd>
                      
                      <dt>text</dt><dd>Returns the text to match in
                      case of MATCH_TEXT. Returns the value of the
                      attribute in case of MATCH_ATTRIBUTE_TEXT.</dd>
                  </dl>
                  </dd>
              
              
                  <dt><b>stack top|inside|associated</b></dt>
                  <dd>In Tcl scripts evaluated by validation this method
                  provides information about the current validation stack.
                  Called outside this context the method returns the empty
                  string.
                  <dl class="optlist">
                      
                          <dt><b>top</b></dt>
                          <dd>Returns the element whose content is currently
                          checked (the open element tag at this moment).
                          </dd>
                      
                      
                      
                          <dt><b>inside</b></dt>
                          <dd>Returns all currently open elements as a list.</dd>
                      
                      
                      
                          <dt><b>associated</b></dt>
                          <dd>Returns the data associated with the
                          current top most stack content particle or
                          the empty string if there isn't any.
                          </dd>
                      
                  </dl>
                  </dd>
              
          </dl>
          </dd>
      
      
      
        <dt><b class="method">reset</b></dt>
        <dd>This method resets the validation command into state
        READY (while preserving the defined grammar).</dd>
      

    </dl>

  <h2><a name="SECTid0x56487d5e4a10">Schema definition scripts</a></h2><p>Schema definition scripts are ordinary Tcl scripts evaluated in
    the namespace tdom::schema. The schema definition commands listed
    below in this Tcl namespace allow the definition of a wide variety
    of document structures. Every schema definition command
    establishes a validation constraint on the content which has to
    match or must be optional to qualify the content as valid. It is a
    validation error if there is additional (not matched) content.
    White-space-only text (in the XML sense of white space) between
    any different tags is ignored, with the exception of text only
    elements (for which even white-space-only text will be considered
    as significant content).</p><p>The schema definition commands are:</p><dl class="commandlist">
      
        <dt>
<b class="method">element</b> <i class="m">name</i> <i class="m">?quant?</i> <i class="m">?&lt;definition script&gt;?</i>
</dt>
        <dd>If the optional argument <i class="m">definition script</i> is not
        given this command refers to the element defined with
        <i class="m">defelement</i> with the name <i class="m">name</i> in the current
        context namespace. If the <i class="m">defelement script</i> argument is
        given, the validation constraint expects an element with the
        name <i class="m">name</i> in the current namespace with content
        "locally" defined by the <i class="m">definition script</i>. Forward
        references to so far not defined elements or patterns or other
        local definitions of the same name inside the <i class="m">definition
        script</i> are allowed. If a forward referenced element is not
        defined until validation, only an empty element with name
        <i class="m">name</i> and namespace <i class="m">namespace</i> and no attributes
        matches. </dd>
      

      
        <dt>
<b class="method">elementtype</b> <i class="m">name</i> <i class="m">?quant?</i>
</dt>
        <dd>This command refers to the element defined with
        <i class="m">defelementtype</i> with the type name <i class="m">name</i> in the
        current context namespace. Forward references to so far not
        defined element types or recursive references are allowed. If
        a forward referenced element type is not defined until
        validation any empty element without attributes will be
        accepted.</dd>
      
      
      
        <dt>
<b class="method">ref</b> <i class="m">name</i> <i class="m">?quant?</i>
</dt>
        <dd>This command refers to the content particle defined with
        <i class="m">defpattern</i> with the name <i class="m">name</i> in the current
        context namespace. Forward references to a so far not defined
        pattern and recursive references are allowed. If a forward
        referenced pattern is not defined until validation no content
        whatsoever is expected ("empty match").</dd>
      

      
        <dt>
<b class="method">group</b> <i class="m">?quant?</i> <i class="m">&lt;definition script&gt;</i>
</dt>
        <dd>This method allows to group a sequence of content
        particles defined by the <i class="m">definition script&gt;</i>, which have
        to match in this sequence order.</dd>
      
      
      
        <dt>
<b class="method">choice</b> <i class="m">?quant?</i> <i class="m">&lt;definition script&gt;</i>
</dt>
        <dd>This schema constraint matches if one of the top level
        content particles defined by the <i class="m">definition script&gt;</i>
        matches. If one of this top level content particle is optional
        this constraint matches the "empty match".
        </dd>
      

      
        <dt>
<b class="method">interleave</b> <i class="m">?quant?</i> <i class="m">&lt;definition script&gt;</i>
</dt>
        <dd>This schema constraint matches after every of the required
        top level content particles defined by the <i class="m">definition
        script&gt;</i> have matched (and, optional, some or all other) in
        any arbitrary order.</dd>
      

      
        <dt>
<b class="method">mixed</b> <i class="m">?quant?</i> <i class="m">&lt;definition script&gt;</i>
</dt>
        <dd>This schema constraint matches for any text (including the
        empty one) and every top level content particle defined by the
        <i class="m">definition script&gt;</i> with default quantifier *.</dd>
      

      
        <dt>
<b class="method">text</b> <i class="m">?&lt;constraint script&gt;|"type" typename?</i>

      
        <dt>
<b class="method">any</b> <i class="m">?namespace?</i> <i class="m">?quant?</i>
</dt>
        <dd>The any command matches every element (in the namespace
        <i class="m">namespace</i>, if that is given) (with whatever attributes)
        or subtree, no matter if known within the schema or not.
        Please note that in case of no <i class="m">namespace</i> argument is
        given that means that the quantifier * and + will eat up any
        elements until the enclosing element ends. If you really have
        a namespace that looks like a valid tDOM schema quantifier
        you will have to spell out always both arguments.</dd>
      

      
        <dt>
<b class="method">attribute</b> <i class="m">name</i> <i class="m">?quant?</i> <i class="m">(?&lt;constraint script&gt;|"type" typename?)</i>
</dt>
        <dd>The attribute command defines an attribute (in no
        namespace) to the enclosing element. The first definition of
        <i class="m">name</i> inside an element definition wins; later
        definitions of the same name are silently ignored. After the
        <i class="m">name</i> argument there may be one of the quantifiers ? or
        !. If there is, it will be used. Otherwise the attribute will
        be required (must be present in the XML source). If there is
        one argument more this argument is evaluated as constraint
        script, defining the value constraints of the attribute.
        Otherwise, if there are two more arguments and the first of
        them is the bare-word "type" the following argument is used as
        a text type name. This command is only allowed at top level in
        the definition script of an defelement/element script.</dd>
      

      
        <dt>
<b class="method">nsattribute</b> <i class="m">name</i> <i class="m">namespace</i> <i class="m">?quant?</i> <i class="m">(?&lt;constraint script&gt;|"type" typename?)</i>
</dt>
        <dd>This command does the same as the command
        <i class="m">attribute</i>, for the attribute <i class="m">name</i> in the
        namespace <i class="m">namespace</i>.</dd>
      

      
        <dt>
<b class="method">namespace</b> <i class="m">URI</i> <i class="m">&lt;definition script&gt;</i>
</dt>
        <dd>Evaluates the <i class="m">definition script</i> with context
        namespace <i class="m">URI</i>. Every element, element type or ref
        command name will be looked up in the namespace <i class="m">URI</i>,
        and local defined elements will be in that namespace. An
        empty string as <i class="m">URI</i> means no namespace.</dd>
      

      
        <dt>
<b class="method">tcl</b> <i class="m">tclcmd</i> <i class="m">?arg arg ...?</i>
</dt>
        <dd>Evaluates the Tcl script <i class="m">tclcmd arg arg ... </i>.

        This validation command is only allowed in strict sequential
        context (not in choice, mixed and interleave). If the return
        code is something else than TCL_OK, this is an error (which
        is not catched and reported by reportcmd).</dd>
      

      
        <dt><b class="method">self</b></dt>
        <dd>Returns the schema command.</dd>
      
      
      
        <dt>
<b class="method">associate</b> <i class="m">data</i>
</dt>
        <dd>This command is only allowed top-level inside definition
        scripts of the element, elementtype, pattern or interleave
        content particles. Associates the <i class="m">data</i> given as argument
        with the currently defined content particle and may be
        requested in scripts evaluated while validating the content of
        that particle with the schema command method call <i class="m">info
        stack associated</i>.</dd>
      

      
        <dt>
<b class="method">domunique</b> <i class="m">selector</i> <i class="m">fieldlist</i> <i class="m">?name?</i> <i class="m">?"IGNORE_EMPTY_FIELD_SET"|("EMPTY_FIELD_SET_VALUE" emptyFieldSetValue)?</i>
</dt>
        <dd>If not postvalidating a DOM tree with <i class="m">domvalidate</i>
        this constraint always matches. If postvalidating this
        constraint resembles the xsd key/keyref mechanism. The
        <i class="m">selector</i> argument may be any valid XPath expression
        (without the xsd limits). Several <i class="m">domunique</i> commands
        within one element definition are allowed. They are checked in
        definition order. The argument name is available in the
        recovering script per <i class="m">info vaction name</i>. If the
        <i class="m">fieldlist</i> does not select something for a node of the
        result set of the <i class="m">selector</i> the key value will be the
        empty string by default. If the arguments
        <i class="m">EMPTY_FIELD_SET_VALUE &lt;value&gt;</i> are given an empty
        node set will have the key value <i class="m">value</i>. If instead the
        flag <i class="m">IGNORE_EMPTY_FIELD_SET</i> flag is given an empty
        node set result will not have any key value.</dd>
      

      
        <dt>
<b class="method">domxpathboolean</b> <i class="m">XPath_expr</i> <i class="m">?name?</i>
</dt>
        <dd>
<p>If not postvalidating a DOM tree with
        <i class="m">domvalidate</i> this constraint always matches. If
        postvalidating the <i class="m">XPath_expr</i> argument is evaluated
        (with the node matching the schema parent of the
        <i class="m">domxpathboolean</i> command as context node). The
        constraint maches if the result of this XPath expression,
        converted to boolean by XPath rules, is true. Several
        <i class="m">domxpathboolean</i> commands within one element definition
        are allowed. They are checked in definition order.</p>

        <p>This enables checks depending on more than one element. Consider</p>

        <pre class="example">
tdom::schema s
s define {
    defelement doc {
        element a ! text
        element b ! text
        element c ! text
        domxpathboolean "a * b * c &gt;= 20000" volume
        domxpathboolean "a &gt; b and b &gt; c" sequence
    }
}
        </pre>
        </dd>
      

      
        <dt>
<b class="method">prefixns</b> <i class="m">?prefixUriList?</i>
</dt>
        <dd>This defines a prefix to namespace URI mapping exactly
        as a <i>schemacmd prefixns</i> would. It is meant as top-level
        command of a <i>schemacmd define</i> script. This command is
        not allowed nested in another definition script command and
        will raise error, if you call it there.</dd>
      

      
        <dt>
<b class="method">defelement</b> <i class="m">name</i> <i class="m">?namespace?</i> <i class="m">&lt;definition script&gt;</i>
</dt>
        <dd>This defines an element exactly as a <i>schemacmd
        defelement</i> call would. It is meant as top-level command of a
        <i>schemacmd define</i> script. This command is not allowed
        nested in another definition script command and will raise
        error, if you call it there.</dd>
      

      
        <dt>
<b class="method">defelementtype</b> <i class="m">name</i> <i class="m">?namespace?</i> <i class="m">&lt;definition script&gt;</i>
</dt>
        <dd>This defines an elementtype exactly as a <i>schemacmd
        defelementtype</i> call would. It is meant as top-level
        command of a <i>schemacmd define</i> script. This command is
        not allowed nested in another definition script command and
        will raise error, if you call it there.</dd>
      

      
        <dt>
<b class="method">defpattern</b> <i class="m">name</i> <i class="m">?namespace?</i> <i class="m">&lt;definition script&gt;</i>
</dt>
        <dd>This defines a named pattern exactly as a <i>schemacmd
        defpattern</i> call would. It is meant as top-level command of a
        <i>schemacmd define</i> script. This command is not allowed
        nested in another definition script command and will raise
        error, if you call it there.</dd>
      

      
        <dt>
<b class="method">deftexttype</b> <i class="m">name</i> <i class="m">&lt;constraint script&gt;</i>
</dt>
        <dd>This defines a named bundle of text constraints exactly
        as a <i>schemacmd deftexttype</i> call would. It is meant as
        top-level command of a <i>schemacmd define</i> script. This
        command is not allowed nested in another definition script
        command and will raise error, if you call it there.</dd>
      
      
      
        <dt>
<b class="method">start</b> <i class="m">name</i> <i class="m">?namespace?</i>
</dt>
        <dd>This command works exactly as a <i>schemacmd start</i>
        call would. It is meant as top-level command of a <i>schemacmd
        define</i> script. This command is not allowed nested in
        another definition script command and will raise error, if you
        call it there.</dd>
      
    </dl>

  <h2><a name="SECTid0x56487d5f3e50">Quantity specifier</a></h2><p>Several schema definition commands expect a quantifier as
    one of their arguments which determines how often the content
    particle specified by the command is expected. The valid values
    for a <i class="m">quant</i> argument are:</p><dl class="optlist">
      
        <dt><b>!</b></dt>
        <dd>The content particle has to occur exactly once in valid
        documents.</dd>
      
    
      
        <dt><b>?</b></dt>
        <dd>The content particle may not occur more than once in
        valid documents - the particle is optional.</dd>
      
    
      
        <dt><b>*</b></dt>
        <dd>The content particle may occur zero or more times in a
        row in valid documents.</dd>
      

        <dd>The content particle must occur n times in a row in
        valid documents. The quantifier must be an integer greater
        zero.</dd>
      
    
      
        <dt><b>{n m}</b></dt> <dd>The content particle must occur
        at least n and at most m times in a row in valid documents.
        The quantifier must be a Tcl list with two elements. Both
        elements must be integers, with n &gt;= 0 and n &lt; m.</dd>
      
    </dl><p>If an optional quantifier is not given, it defaults to * in
    case of the <i class="m">mixed</i> command and to ! for all other commands.</p>

  <h2><a name="SECTid0x56487d5f5de0">Text constraint scripts</a></h2><p>Text (parsed character data, as XML calls it) sometimes has to
    be of a certain kind or comply with certain rules to be valid. The
    text constraint script arguments to text, attribute, nsattribute
    and deftexttype commands are evaluated in the Tcl namespace
    <i class="m">tdom::schema::text</i> namespace and allow the ensuing text
    constraint commands to check text for certain properties. The
    commands are defined in the Tcl namespace

    <i class="m">tdom::schema::text</i>. They raise error in case they are

    called outside of a text constraint script.</p><p>A few of the ensuing text type commands are exposed as general
    Tcl commands. They are defined in the namespace tdom::type and are

    called as documented below with the text to check appended to the
    argument list. They return a logical value. Please note that the



    commands may not accept starting or ending white space. If a
    command is available in the tdom::type namespace is recorded in
    its documentation.


    </p>
        <h3><a name="SECTid0x56487d5f67e0">The tcl text constraint command</a></h3>
        <p>The <i class="m">tcl</i> text constraint command dispatches the check

        to an arbitrary Tcl command, thus enable any programmable
        decision rules.</p>
        <dl class="commandlist">
            
                <dt>
<b class="cmd">tcl</b> <i class="m">tclcmd</i> <i class="m">?arg arg ...?</i>
</dt>
                <dd>Evaluates the Tcl script <i class="m">tclcmd arg arg ... </i> and
                the text to validate appended to the argument list. The return
                value of the Tcl command is interpreted as a boolean.</dd>
            
        </dl>
    
        <h3><a name="SECTid0x56487d5f75c0">Basic XML types</a></h3>
        <dl class="commandlist">
            

                <dt><b class="cmd">name</b></dt>

                <dd>This text constraint matches if the text value

                matches the XML name production
                <a href="https://www.w3.org/TR/xml/#NT-Name">https://www.w3.org/TR/xml/#NT-Name</a>. This
                means that the text value must start with a letter,
                underscore (_), or colon (:), and may contain only
                letters, digits, underscores (_), colons (:), hyphens
                (-), and periods (.).</dd>
            
            


                <dt><b class="cmd">ncname</b></dt>
                <dd>This text constraint matches if the text value

                matches the XML ncname production
                <a href="https://www.w3.org/TR/xml-names/#NT-NCName">https://www.w3.org/TR/xml-names/#NT-NCName</a>.
                This means that the text value must start with a
                letter or underscore (_), and may contain only
                letters, digits, underscores (_), hyphens (-), and
                periods (.) (The only difference to the name
                constraint is that colons are not permitted.)</dd>
            
            

                <dt><b class="cmd">qname</b></dt>

                <dd>This text constraint matches if the text value
                matches the XML qname production
                <a href="https://www.w3.org/TR/xml-names/#NT-QName">https://www.w3.org/TR/xml-names/#NT-QName</a>.
                This means that the text value is either a ncname or
                two ncnames joined by a colon (:).</dd>
            
            
                <dt><b class="cmd">nmtoken</b></dt>
                <dd>This text constraint matches if the text value
                matches the XML nmtoken production
                <a href="https://www.w3.org/TR/xml/#NT-Nmtoken">https://www.w3.org/TR/xml/#NT-Nmtoken</a>
</dd>
            
            
                <dt><b class="cmd">nmtokens</b></dt>
                <dd>This text constraint matches if the text value
                matches the XML nmtokens production
                <a href="https://www.w3.org/TR/xml/#NT-Nmtokens">https://www.w3.org/TR/xml/#NT-Nmtokens</a>
</dd>
            
        </dl>
    
        <h3><a name="SECTid0x56487d5f95d0">Basic type tests</a></h3>
        <p>
        </p>
        <dl class="commandlist">
            
                <dt>
<b class="cmd">integer</b> <i class="m">?(xsd|tcl)?</i>
</dt>
                <dd>This text constraint matches if the text value could be
                parsed as an integer. If the optional argument to the command
                is <i class="m">tcl</i>, everything that returns TCL_OK if feeded into
                Tcl_GetInt() matches. If the optional argument to the command
                is <i class="m">xsd</i>, the constraint matches if the value is a
                valid xsd:integer. Without argument <i class="m">xsd</i> is the
                default.</dd>
            

            
                <dt>
<b class="cmd">negativeInteger</b> <i class="m">?(xsd|tcl)?</i>
</dt>
                <dd>This text constraint matches the same text values as the
                <i class="m">integer</i> text constraint (see there), with the additional
                constraint, that the value must be &lt; zero.</dd>
            
            
            
                <dt>
<b class="cmd">nonNegativeInteger</b> <i class="m">?(xsd|tcl)?</i>
</dt>
                <dd>This text constraint matches the same text values as the
                <i class="m">integer</i> text constraint (see there), with the additional
                constraint, that the value must be &gt;= zero.</dd>
            

            
                <dt>
<b class="cmd">nonPositiveInteger</b> <i class="m">?(xsd|tcl)?</i>
</dt>
                <dd>This text constraint matches the same text values as the
                <i class="m">integer</i> text constraint (see there), with the additional
                constraint, that the value must be &lt;= zero.</dd>
            

            
                <dt>
<b class="cmd">positiveInteger</b> <i class="m">?(xsd|tcl)?</i>
</dt>
                <dd>This text constraint matches the same text values as the
                <i class="m">integer</i> text constraint (see there), with the additional
                constraint, that the value must be &gt; zero.</dd>
            

            
                <dt>
<b class="cmd">number</b> <i class="m">?(xsd|tcl)?</i>
</dt>
                <dd>This text constraint matches if the text value could be
                parsed as a number. If the optional argument to the command is
                <i class="m">tcl</i>, everything that returns TCL_OK if feeded into
                Tcl_GetDouble() matches. If the optional argument to the command
                is <i class="m">xsd</i>, the constraint matches if the value is a
                valid xsd:decimal. Without argument <i class="m">xsd</i> is the
                default.</dd>
            
            
                <dt>
<b class="cmd">boolean</b> <i class="m">?(xsd|tcl)?</i>
</dt>
                <dd>This text constraint matches if the text value could be
                parsed as a boolean. If the optional argument to the command is
                <i class="m">tcl</i>, everything that returns TCL_OK if feeded into
                Tcl_GetBoolean() matches. If the optional argument to the command
                is <i class="m">xsd</i>, the constraint matches if the value is a
                valid xsd:boolean. Without argument <i class="m">xsd</i> is the
                default.</dd>
            
            
                <dt><b class="cmd">date</b></dt>
                <dd>This text constraint matches if the text value is
                a xsd:date, which is basically like an ISO 8601 date of
                the form YYYY-MM-DD, with optional time zone part
                (either the letter Z or plus (+) or minus (-) followed
                by hh:mm and with maximum allowed positive or negative
                time zone 14:00). It follows the date rules of the
                Gregorian calendar for all dates. A preceding minus
                sign for bce dates is allowed. There is no year 0. The
                year may have more than 4 digits, but only if needed
                (no extra leading zeros). This is available as common
                Tcl command tdom::type::date.</dd>
            
            
                <dt><b class="cmd">time</b></dt>
                <dd>This text constraint matches if the text value is
                a xsd:time, which is basically like an ISO 8601 time of
                the form hh:mm:ss with optional time zone part. The
                time zone part follow the rules of the <i class="m">date</i>
                command; see there. All three parts of the time value
                (hours, minutes, seconds) must be spelled out with 2
                digits. Additional fractional seconds (with a point
                ('.') as separator) are allowed, but not just a
                dangling point. The time value 24:00:00 (without
                fractional part) is allowed. This is available as
                common Tcl command tdom::type::time.</dd>
            
            
                <dt><b class="cmd">dateTime</b></dt>
                <dd>This text constraint matches if the text value
                is a xsd:dateTime, which is basically like an ISO 8601
                date time of the form YYYY-MM-DDThh:mm:ss with
                optional time zone part. The date and time zone parts
                follows the rules of the <i class="m">date</i> and <i class="m">time</i>
                command; see there. The time part (including the
                signaling 'T' character) is mandatory. This is
                available as common Tcl command
                tdom::type::dateTime.</dd>
            
            
                <dt><b class="cmd">duration</b></dt>
                <dd>This text constraint matches if the text value is
                a xsd:duration, which is basically like an ISO 8601
                duration of the form PnYnMnDTnHnMnS. All parts other
                than the starting P and - if one of H, M or S is given
                - T are optional. In case the following sign letter is
                S, n may be a decimal (with at least one digit before
                and after the dot), otherwise it must be a (positive)
                integer. This is available as common Tcl command
                tdom::type::duration.</dd>
            
            
                <dt><b class="cmd">base64</b></dt>
                <dd>This text constraint matches if text is valid according to
                RFC 4648.</dd>
            
            
                <dt><b class="cmd">hexBinary</b></dt>
                <dd>This text constraint matches if text is a sequence of
                binary octets in hexadecimal encoding, where each binary octet
                is a two-character hexadecimal number. Lowercase and uppercase
                letters A through F are permitted.</dd>
            
            
                <dt><b class="cmd">unsignedByte</b></dt>
                <dd>This text constraint matches if the text value is a
                xsd:unsignedByte. This is an integer between 0 and 255, both
                included, optionally preceded by a + sign and leading
                zeros.</dd>
            
            
                <dt><b class="cmd">unsignedShort</b></dt>
                <dd>This text constraint matches if the text value is a
                xsd:unsignedShort. This is an integer between 0 and 65535,
                both included, optionally preceded by a + sign and leading
                zeros.</dd>
            
            
                <dt><b class="cmd">unsignedInt</b></dt>
                <dd>This text constraint matches if the text value is a
                xsd:unsignedInt. This is an integer between 0 and 4294967295,
                both included, optionally preceded by a + sign and leading
                zeros.</dd>
            
            
                <dt><b class="cmd">unsignedLong</b></dt>
                <dd>This text constraint matches if the text value is a
                xsd:unsignedLong. This is an integer between 0 and
                18446744073709551615, both included, optionally preceded by a
                + sign and leading zeros.</dd>
            
        </dl>
    
        <h3><a name="SECTid0x56487d600880">Logical constructs</a></h3>
        <dl class="commandlist">
        
            <dt>
<b class="cmd">oneOf</b> <i class="m">&lt;constraint script&gt;</i>
</dt>
            <dd>This text constraint matches if one of the text
            constraints defined in the argument <i class="m">constraint script</i>
            matches the text. It stops after the first matches and probes the
            text constraints in the order of definition.</dd>
        
        
            <dt>
<b class="cmd">allOf</b> <i class="m">&lt;constraint script&gt;</i>
</dt>
            <dd>This text constraint matches if all of the text
            constraints defined in the argument <i class="m">constraint script</i>
            matches the text. It stops after the first match failure and
            probes the text constraints in the order of definition. Since
            the schema definition command <i class="m">text</i> also expects all
            text constraints to match the text constraint, <i class="m">allOf</i> is
            useful mostly in connection with the <i class="m">oneOf</i> text constraint
            command.</dd>
        
        
            <dt>
<b class="cmd">not</b> <i class="m">&lt;constraint script&gt;</i>
</dt>
            <dd>This text constraint matches if none of the text
            constraints defined in the argument <i class="m">constraint
            script</i> matches the text. It stops after the first
            matching constraint in the <i class="m">constraint script</i> and
            reports validation error. The text constraints in the
            <i class="m">constraint script</i> are probed in the order of
            definition.</dd>
        
        </dl>
    
        <h3><a name="SECTid0x56487d6026b0">Constraints on processed text value</a></h3>
        <dl class="commandlist">
            
            <dt>
<b class="cmd">whitespace</b> <i class="m">(preserve|replace|collapse)</i> <i class="m">&lt;constraint script&gt;</i>
</dt>
            <dd>This text constraint command does white-space (#x20
            (space, ' '), #x9 (tab, \t), #xA (linefeed, \n), and #xD
            (carriage return, \r) normalization to the text value and
            checks the resulting text with the text constraints of the
            constraint script argument. The normalization method
            <i class="m">preserve</i> keeps everything as it is; this is another way
            to say <i class="m">allOf</i>. The <i class="m">replace</i> normalization method
            replaces any single white-space character (as above) to a
            space. The <i class="m">collapse</i> normalization method removes all
            leading and trailing white-space, and all the other sequences of
            contiguous white-space are replaced by a single space.</dd>
        
        
            <dt>
<b class="cmd">split</b> <i class="m">?type ?args??</i><i class="m">&lt;constraint script&gt;</i>
</dt>
            <dd>
<p>This text constraint command splits the text to test
            into a list of values and tests all elements of that list for
            the text constraints in the evaluated <i class="m">constraint
            script&gt;</i>.</p>
            <p>The available types are:</p>
            <dl>
                <dt>whitespace</dt><dd>The text to split is stripped
                of all white space at start and end and splitted into
                a list at any successive white space.</dd>
                <dt>tcl tclcmd ?arg ...?</dt><dd>The text to split is
                handed to the <i class="m">tclcmd</i>, which is evaluated on
                global level, appended with every given arg and the
                text to split as last argument. This call must return
                a valid Tcl list whose elements are tested.</dd>
            </dl>
            <p>The default in case no split type argument is given is
            <i class="m">whitespace</i>.</p>
</dd>
        
        
            <dt>
<b class="cmd">strip</b> <i class="m">&lt;constraint script&gt;</i>
</dt>
            <dd>This text constraint command tests all text constraints
            in the evaluated <i class="m">constraint script&gt;</i> with the text to
            test stripped of all white space at start and end.</dd>
        
        </dl>
    
        <h3><a name="SECTid0x56487d605080">Various other string properties</a></h3>
        <dl class="commandlist">
        
            <dt>
<b class="cmd">fixed</b> <i class="m">value</i>
</dt>
            <dd>The text constraint only matches if the text value is
            string equal to the given value.</dd>
        
        
        
            <dt>
<b class="cmd">enumeration</b> <i class="m">list</i>
</dt>
            <dd>This text constraint matches if the text value is equal to
            one element (respecting case and any white-space) of the
            argument <i class="m">list</i>, which has to be a valid Tcl list.
            </dd>
        
        
            <dt>
<b class="cmd">match</b> <i class="m">?-nocase?</i> <i class="m">glob_style_match_pattern&gt;</i>
</dt>
            <dd>This text constraint matches if the text value matches the
            glob style pattern given as argument. It follows the rules of
            the Tcl [string match] command, see
            <a href="https://www.tcl.tk/man/tcl8.6/TclCmd/string.htm#M35">https://www.tcl.tk/man/tcl8.6/TclCmd/string.htm#M35</a>.</dd>
        
        
            <dt>
<b class="cmd">regexp</b> <i class="m">expression</i>
</dt>
            <dd>This text constraint matches if the text value matches the
            regular expression given as argument. <a href="https://www.tcl.tk/man/tcl8.6/TclCmd/re_syntax.htm">https://www.tcl.tk/man/tcl8.6/TclCmd/re_syntax.htm</a> describes the regular expression syntax</dd>
        
        
            <dt>
<b class="cmd">length</b> <i class="m">length</i>
</dt>
            <dd>This text constraint matches if the length of the text
            value (in characters, not bytes) is <i class="m">length</i>. The
            length argument must be a positive integer or zero.</dd>
        
        
            <dt>
<b class="cmd">maxLength</b> <i class="m">length</i>
</dt>
            <dd>This text constraint matches if the length of the text
            value (in characters, not bytes) is at most <i class="m">length</i>. The
            length argument must be an integer greater zero.</dd>
        
        
            <dt>
<b class="cmd">minLength</b> <i class="m">length</i>
</dt>
            <dd>This text constraint matches if the length of the text
            value (in characters, not bytes) is at least <i class="m">length</i>.
            The length argument must be an integer greater zero.</dd>
        
        
            <dt>
<b class="cmd">id</b> <i class="m">?keySpace?</i>
</dt>
            <dd>This text constraint command marks the text as a
            document wide ID (to be referenced by an idref). Every ID
            value within a document must be unique. It isn't an error if
            the ID isn't actually referenced within the document. The
            optional argument <i class="m">keySpace</i> does all this for a named
            key space. The key space "" (the empty sting) is another key
            space then the <i class="m">id</i> command without keySpace
            argument.</dd>
        
        
            <dt>
<b class="cmd">idref</b> <i class="m">?keySpace?</i>
</dt>
            <dd>This text constraint command expects the text to be a
            reference to an ID within the document. The referenced ID may
            appear later in the document, that the reference. Several
            references within the document to one ID are possible.</dd>
        
        </dl>



    


  <h2><a name="SECTid0x56487d6090e0">Local key constraints</a></h2><p>Document wide uniqueness and foreign key constraints are
    available with the text constraint commands id and idref.
    Keyspaces allow for sub-tree local uniqueness and foreign key
    constraints.</p><dl class="commandlist">
        
            <dt>
<b class="cmd">keyspace</b> <i class="m">&lt;names list&gt;</i> <i class="m">&lt;constraint script&gt;</i>
</dt>
            <dd>Any number of keyspaces are possible. A keyspace is
            either active or not. An inside a <i class="m">constraint
            script</i> called keyspace with the same name does
            nothing.</dd>
        
    </dl><p>This text constraint commands work with keyspaces:</p><dl class="commandlist">
        
            <dt>
<b class="cmd">key</b> <i class="m">&lt;name&gt;</i>
</dt>
            <dd>If the keyspace with the name <i class="m">&lt;name&gt;</i> is
            not active the constraint always matches. If the keyspace
            is active, reports error if there is already a key with
            the value. Otherwise it stores the value as key in this
            keyspace and matches.</dd>
        
        
            <dt>
<b class="cmd">keyref</b> <i class="m">&lt;name&gt;</i>
</dt>
            <dd>If the keyspace with the name <i class="m">&lt;name&gt;</i> is not
            active always matches. If the keyspace is active then
            reports error if there is still no key as the value at the
            end of the keyspace <i class="m">&lt;name&gt;</i>. Otherwise, it
            matches.</dd>
        
    </dl>

  <h2><a name="SECTid0x56487d60af00">Recovering</a></h2><p>By default the validation engine stops at the first detected
      validation violation and reports that finding. It does so by
      return false (and sets, if given, the result variable with an
      error message) in case the schema command itself is used to
      validate input. If the schema command is used by a SAX parser or
      the DOM parser, it does so by throwing error.</p><p>If a <i class="m">reportcmd</i> is set this command is called on global
      level appended with the schema command and an error type as
      arguments in case a validation violation is detected. Then the
      validation recovers from the error and continues. For some
      validation errors the recover strategy can be determined with
      the script result of the reportcmd.</p><p>With a <i class="m">reportcmd</i> (which does not throw error if
      called) the validation engine will never report validation
      failure to its caller. The validation engine recovers,
      continues, and reports the next error (if occuring) and so on
      until the end of the input. The schema command will return true
      and the SAX parser and DOM builder will process normally until
      the end of the input, as if there had not been a validation
      error.</p><p>Please note that this happens only for validation errors. It
      is not possible to recover from well-formedness errors. If the
      input is not well-formed, the schema command returns false and
      sets (if given) the result variable with an error message about
      the well-formedness error.</p><p>If the <i class="m">reportcmd</i> throws error while called by the
      validation engine then validation stops and the schema command
      throws error with the error message of the script.</p><p>While validating basically three events can happen: an
      element start tag has to match, a piece of text has to match or
      an element end tag has to match. The method <i class="m">info vaction</i>
      called in the recovering script or any script code called from
      there returns, which event has triggered the error report
      (MATCH_ELEMENT_START, MATCH_TEXT, MATCH_ELEMENT_END,
      respectively). While the command walks throu the schema looking
      whether the event matches other, data driven events (as, for example
      checking, if any keyref within a keyspace exists) may happen.</p><p>Several of the validation error codes, appended as second
      argument to the <i class="m">reportcmd</i> calls, may happen at more than
      one kind of validation event. The <i class="m">info vaction</i> method and
      its subcommands provide information about the current validation
      event, if called from the report command.</p><p>If a structural validation error happens, the default
      recovering strategy is to ignore any following (or missing)
      content within the current subtree and to continue with the
      element end event of the subtree.</p><p>Returning "ignore" from the recovering script in case of
      error type MISSING_ELEMENT recovers by ignoring the failed
      contraint and continues to match the event further against the
      schema.</p><p>Returning "vanish" from the recover script in case of the
      error types MISSING_ELEMENT and UNEXPECTED_ELEMENT recovers by
      ignoring the event.</p>

  <h2><a name="SECTid0x56487d60ced0">Examples</a></h2><p>The XML Schema Part 0: Primer Second Edition
    (<a href="https://www.w3.org/TR/xmlschema-0/">https://www.w3.org/TR/xmlschema-0/</a>) starts with this
    example schema:</p><pre class="example">
&lt;xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"&gt;

  &lt;xsd:annotation&gt;
    &lt;xsd:documentation xml:lang="en"&gt;
     Purchase order schema for Example.com.

  <xsd:simpleType name="SKU">
    <xsd:restriction base="xsd:string">
      <xsd:pattern value="\d{3}-[A-Z]{2}"/>
    </xsd:restriction>
  </xsd:simpleType>

</xsd:schema>
    </pre><p>A likely one-to-one translation of that into a tDOM schema
    definition script would be:</p><pre class="example">
tdom::schema schema      
schema define {

    # Purchase order schema for Example.com.
    # Copyright 2000 Example.com. All rights reserved.

    defelement purchaseOrder {ref PurchaseOrderType}

    foreach elm {comment name street city state product} {
        defelement $elm text
    }

    defpattern PurchaseOrderType {
        element shipTo ! {ref USAddress}
        element billTo ! {ref USAddress}
        element comment ?
        element items
        attribute orderDate date
    }

    defpattern USAddress {
        element name
        element street
        element city
        element state
        element zip ! {text number}
        attribute country ! {fixed "US"}
    }

    defelement items {
        element item * {
            element product
            element quantity ! {text integer}
            element USPrice ! {text number}
            element comment
            element shipDate ? {text date}
            attribute partNum ! {pattern "^\d{3}-[A-Z]{2}$"}
        }
    }
}
      
    </pre><p>The RELAX NG Tutorial
    (<a href="http://relaxng.org/tutorial-20011203.html">http://relaxng.org/tutorial-20011203.html</a>) starts with

        element card *
    }
    defelement card {
        element name
        element email
    }
    foreach e {name email} {
        defelement $e text
    }
}
      
    </pre>

<h2><a name="SECTid0x56487d60ee40">KEYWORDS</a></h2><p class="keywords">
<a class="keyword" href="keyword-index.html#KW-Validation">Validation</a>, <a class="keyword" href="keyword-index.html#KW-Postvalidation">Postvalidation</a>, <a class="keyword" href="keyword-index.html#KW-DOM">DOM</a>, <a class="keyword" href="keyword-index.html#KW-SAX">SAX</a>
</p>
</div><hr class="navsep"><div class="navbar" align="center">
<a class="navaid" href="index.html">Contents</a> · <a class="navaid" href="category-index.html">Index</a> · <a class="navaid" href="keyword-index.html">Keywords</a> · <a class="navaid" href="http://tdom.org">Repository</a>
</div>
</body>
</html>

.de UL
\\$1\l'|0\(ul'\\$2
..
'\" END man.macros
.TH schema n "" Tcl ""
.BS
.SH NAME
tdom::schema \- Creates a schema validation command
.SH SYNOPSIS
.nf
package require tdom

\&\fBtdom::schema\fP \fI?create?\fR \fIcmdName\fR
    
.fi
.BE
.SH "DESCRIPTION "
.PP
Every call of this command creates a new validation command. A
validation command has methods to define a schema and is able
to validate XML data or to post-validate a tDOM DOM tree (and to
some degree other kind of hierarchical data) against this
schema.
.PP
Also, a validation command may be used as argument to the
\&\fI-validateCmd\fR option of the \fIdom parse\fR and the
\&\fIexpat\fR commands to enable validation additionally to what
they do otherwise.
.PP
The methods of created commands are:
.TP
\&\fB\fBprefixns\fP \fI?prefixUriList?\fB
\&\fRThis method controls prefix (or abbreviation) to
namespace URI mapping. Wherever a namespace argument is
expected in the schema command methods the
"prefix" could be used instead of the namespace

URI. If the list maps the same prefix to different namespace
URIs, the first one wins. If there is no such prefix, the
namespace argument is used literally as namespace URI. If
the method is called without argument, it returns the
current prefixUriList. If the method is called with the
empty string, any namespace URI arguments are used
literally. This is the default.
.TP
\&\fB\fBdefelement\fP \fIname\fB \fI?namespace?\fB \fI<definition script>\fB
\&\fRThis method defines the element \fIname\fR (optional in
the namespace \fInamespace\fR) in the schema. The
\&\fIdefinition script\fR is evaluated and defines the content
model of the element. If the \fInamespace\fR argument is
given, any \fIelement\fR or \fIref\fR references in the
definition script not wrapped inside a \fInamespace\fR
command are resolved in that namespace. If there is already a
element definition for the name/namespace combination, the
command raises error.
.TP
\&\fB\fBdefelementtype\fP \fItypename\fB \fIname\fB \fI?namespace?\fB \fI<definition script>\fB
\&\fRThis method defines the element type \fItypename\fR
(optional in the namespace \fInamespace\fR) in the schema. If
the element type is used in a definition script with the
schema command elementtype, the validation engine expects an
element named \fIname\fR (in the namespace \fInamespace\fR,
if given) and the content model \fIdefinition script\fR.
Defining element types seems only sensible if you really have
elements with the same name and namespace but different
content models. The \fIdefinition script\fR is evaluated and
defines the content model of the element. If the
\&\fInamespace\fR argument is given, any \fIelement\fR or
\&\fIref\fR references in the definition script not wrapped
inside a \fInamespace\fR command are resolved in that
namespace. If there is already an elementtype definition for
the name/namespace combination, the command raises error. The
document element of any XML to validate cannot be a
\&\fIdefelementtype\fR defined element.
.TP
\&\fB\fBdefpattern\fP \fIname\fB \fI?namespace?\fB \fI<definition script>\fB
\&\fRThis method defines a (maybe complex) content particle
with the \fIname\fR (optional in the namespace
\&\fInamespace\fR) in the schema, to be used in other
definition scripts with the definition command \fIref\fR. The
\&\fIdefinition script\fR is evaluated and defines the content
model of the content particle. If the \fInamespace\fR
argument is given, any \fIelement\fR or \fIref\fR references
in the definition script not wrapped inside a \fInamespace\fR
command are resolved in that namespace. If there is already a
pattern definition for the name/namespace combination, the
command raises error.
.TP
\&\fB\fBdeftexttype\fP \fIname\fB \fI<constraint script>\fB
\&\fRThis method defines a bundle of text constraints that
can be referred to by \fIname\fR while defining constraints on
text element or attribute values. If there is already a text
type definition with this name, the command raises error. A
text type must be defined before it can be used in schema
definition scripts.
.TP
\&\fB\fBstart\fP \fIdocumentElement\fB \fI?namespace?\fB
\&\fRThis method defines the name and namespace of the root
element of a tree to validate. If this method is used, the
root element must match for validity. If \fIstart\fR is not
used, any element defined by \fIdefelement\fR may be the root
of a valid document. The \fIstart\fR method may be used
several times with varying arguments during the lifetime of a
validation command. If the command is called with just the
empty string (and no namespace argument), the validation
constraint for the root element is removed and any defined
element will be valid as root of a tree to validate.
.TP
\&\fB\fBdefine\fP \fI<definition script>\fB
\&\fRThis method allows to define several elements or patterns
or a whole schema with one call. All schema command methods so
far (\fIprefixns\fR, \fIdefelement\fR,
\&\fIdefelementtype\fR, \fIdefpattern\fR, \fIdeftexttype\fR and
\&\fIstart\fR) are allowed top level in the \fIdefinition
script\fR. The \fIdefine\fR method itself isn't allowed
recursively.
.TP
\&\fB\fBevent\fP \fI(start|end|text)\fB \fI?event specific data?\fB
\&\fRThis method allows the validation of hierarchical data against
the content constraints of the validation command.
.RS
.IP "\fBstart  \fIname ?attributes? ?namespace? \fP\fR"
Checks if the current validation state allows the
element \fIname\fR in the \fInamespace\fR to start here.
It raises error if not.
.IP "\fBend\fR"
Checks if the current innermost open element may end
there in the current state without violation of validation
constraints. It raises error if not.
.IP "\fBtext  \fItext\fP\fR"
Checks if the current validation state allows the
given text content. It raises error if not.
.RE
.TP
\&\fB\fBvalidate\fP \fI<XML string>\fB \fI?objVar?\fB
\&\fRReturns true if the \fI<XML string>\fR is valid, or
false, otherwise. If validation has failed and the optional
\&\fIobjVar\fR argument is given, the variable with that
name is set to a validation error message. If the XML string
is valid and the optional \fIobjVar\fR argument is given,
the variable with that name is set to the empty string.
.TP
\&\fB\fBvalidatefile\fP \fIfilename\fB \fI?objVar?\fB
\&\fRReturns true if the content of \fIfilename\fR is valid,
or false, otherwise. The given file is feeded as binary stream
to expat, therefore only US-ASCII, ISO-8859-1, UTF-8 or UTF-16
encoded data will work with this method. If validation has
failed and the optional \fIobjVar\fR argument is given, the
variable with that name is set to a validation error message.
If the XML string is valid and the optional \fIobjVar\fR
argument is given, the variable with that name is set to the
empty string.
.TP
\&\fB\fBvalidatechannel\fP \fIchannel\fB \fI?objVar?\fB
\&\fRReturns true if the content read from the Tcl channel
\&\fIchannel\fR is valid, or false, otherwise. Since data read
out of a Tcl channel is UTF-8 encoded, any misleading encoding
declaration at the beginning of the data will lead to errors.
If the validation fails and the optional \fIobjVar\fR
argument is given, the variable with that name is set to a
validation error message. If the XML string is valid and the
optional \fIobjVar\fR argument is given, the variable with
that name is set to the empty string.
.TP
\&\fB\fBdomvalidate\fP \fIdomNode\fB \fI?objVar?\fB
\&\fRReturns true if the first argument is a valid tree, or
false, otherwise. If validation has failed and the optional
\&\fIobjVar\fR argument is given, the variable with that name
is set to a validation error message. If the dom tree is valid
and the optional \fIobjVar\fR argument is given, the variable
with that name is set to the empty string.
.TP
\&\fB\fBreportcmd\fP \fI?cmd?\fB
\&\fRThis method expects the name of a Tcl command to be
called in case of validation error. The command will be
called with two arguments appended: the schema command which
raises the validation error, and a validation error code.
.RS
.PP
The possible error codes are:
.TP
MISSING_ELEMENT
.TP
MISSING_TEXT
.TP
UNEXPECTED_ELEMENT
.TP
UNEXPECTED_ROOT_ELEMENT
.TP
UNEXPECTED_TEXT
.TP
UNKNOWN_ROOT_ELEMENT
.TP
UNKNOWN_ATTRIBUTE
.TP
MISSING_ATTRIBUTE
.TP
INVALID_ATTRIBUTE_VALUE
.TP
DOM_KEYCONSTRAINT
.TP
DOM_XPATH_BOOLEAN
.TP
INVALID_KEYREF
.TP
INVALID_VALUE
.TP
UNKOWN_GLOBAL_ID
.TP
UNKOWN_ID
.PP
For more detailed information see section Recovering.
.RE
.TP
\&\fB\fBdelete\fP
\&\fRThis method deletes the validation command.
.TP
\&\fB\fBinfo\fP \fI?args?\fB
\&\fRThis method bundles methods to query the state of and
details about the schema command.

validation
.TP
VALIDATING
The validation command is in the
process of validating input.
.TP
FINISHED
The validation has finished, no further
events are expected.
.RE
.IP "\fBvstate\fR"
This method is a shorter alias for validationstate; see there.
.IP "\fBline\fR"
If the schema command is currently validating,
this method returns the line part of the parsing
position information, and the empty string in all
other cases. If the schema command is currently
post-validating a DOM tree, there may be no position
information stored at some or all nodes. The
empty string is returned in these cases.
.IP "\fBcolumn\fR"
If the schema command is currently validating
this method returns the column part of the parsing
position information, and the empty string in all
other cases. If the schema command is currently
post-validating a DOM tree, there may be no position
information stored at some or all nodes. The
empty string is returned in these cases.
.IP "\fBdomNode\fR"
If the schema command isn't currently
post-validating a DOM tree this method returns the
empty string. Otherwise, if the schema command waits
for the reportcmd script to finish while recovering
from a validation error it returns the node on which
the validation engine is currently looking at in
case the node is an ELEMENT_NODE or, if not, its
parent node. It is recommended that you do not use
this method. Or at least leave the DOM tree alone,
use it read-only.
.IP "\fBnrForwardDefinitions\fR"
Returns how many elements, element types and
ref patterns are referenced that aren't defined so
far (summed together).
.IP "\fBdefinedElements\fR"
Returns in no particular order the defined
elements in the grammar as list. If an element is
namespaced, its list entry will be itself a list with
two elements, with the name as first and the
namespace as second element.
.IP "\fBdefinedElementtypes\fR"
Returns in no particular order the defined
element types in the grammar as list. If an element
type is namespaced, its list entry will be itself a
list with two elements, with the name as first and
the namespace as second element.
.IP "\fBdefinedPatterns\fR"
Returns in no particular order the defined
named pattern in the grammar as list. If a named
pattern is namespaced, its list entry will be itself
a list with two elements, with the name as first and
the namespace as second element.
.IP "\fBexpected\fR"
Returns in no particular order all possible
next events (since the last successful event match,
if there was one) as a list. If an element is
namespaced its list entry will be itself a list with
two elements, with the name as first and the
namespace as second element. If text is a possible
next event, the list entry will be a two elements
list, with #text as first element and the empty
string as second. If an any element constraint is
possible. the list entry will be a two elements list,
with <any> as first element and the empty string
as second. If an any element in a certain namespace
constraint is possible, the list entry will be a two
elements list, with <any> as first element and
the namespace as second. If element end is a
possible event, the list entry will be a two elements
list with <elementend> as first element and the
empty string as second element.
.IP "\fBdefinition name ?namespace?\fR"
Returns the code that defines the given
element. The command raises error if there is no
definition of that element.
.IP "\fBtypedefinition name ?namespace?\fR"
Returns the code that defines the given
element type definition. The command raises error if
there is no definition of that element.
.IP "\fBpatterndefinition name ?namespace?\fR"
Returns the code that defines the given
pattern definition. The command raises error if
there is no definition of a pattern with that name
and, if given, namespace.
.IP "\fBvaction ?name|namespace|text?\fR"
.RS
.PP
This method returns useful information only if
the schema command waits for the reportcmd script to
finish while recovering from a validation error.
Otherwise it returns NONE.
.PP
If the command is called without the optional
argument the possible return values and their
meanings are:

.TP
NONE
The schema command currently
does not recover from a validation event.
.TP
MATCH_ELEMENT_START
Element start event, which includes looking for missing or unknown attributes.
.TP
MATCH_ELEMENT_END
Element end event.
.TP
MATCH_TEXT
Validating text between tags.
.TP
MATCH_ATTRIBUTE_TEXT
Attribute text value constraint check
.TP
MATCH_GLOBAL
Checking global IDs
.TP
MATCH_DOM_KEYCONSTRAINT
Checking domunique constraint
.TP
MATCH_DOM_XPATH_BOOLEAN
Checking domxpathboolean constant
.PP
If called with one of the possible optional
arguments, the command returns detail information
depending on current action.
.TP
name
Returns the name of the element
that has to match in case of
MATCH_ELEMENT_START. Returns the name of the
closed element in case of MATCH_ELEMENT_END.
Returns the name of the attribute in case of
MATCH_ATTRIBUTE_TEXT. Returns the name of the
parent element in case of MATCH_TEXT.
.TP
namespace
Returns the namespace of
the element that has to match in case of
MATCH_ELEMENT_START. Returns the namespace of the
closed element in case of MATCH_ELEMENT_END.
Returns the namespace of the attribute in case
of MATCH_ATTRIBUTE_TEXT. Returns the namespace of
the parent element in case of MATCH_TEXT.
.TP
text
Returns the text to match in
case of MATCH_TEXT. Returns the value of the
attribute in case of MATCH_ATTRIBUTE_TEXT.
.RE
.IP "\fBstack top|inside|associated\fR"
In Tcl scripts evaluated by validation this method
provides information about the current validation stack.
Called outside this context the method returns the empty
string.
.RS
.IP "\fBtop\fR"
Returns the element whose content is currently
checked (the open element tag at this moment).
.IP "\fBinside\fR"
Returns all currently open elements as a list.
.IP "\fBassociated\fR"
Returns the data associated with the
current top most stack content particle or
the empty string if there isn't any.
.RE
.RE
.TP
\&\fB\fBreset\fP
\&\fRThis method resets the validation command into state
READY (while preserving the defined grammar).
.SH "Schema definition scripts"
.PP
Schema definition scripts are ordinary Tcl scripts evaluated in
the namespace tdom::schema. The schema definition commands listed
below in this Tcl namespace allow the definition of a wide variety
of document structures. Every schema definition command
establishes a validation constraint on the content which has to
match or must be optional to qualify the content as valid. It is a
validation error if there is additional (not matched) content.
White-space-only text (in the XML sense of white space) between
any different tags is ignored, with the exception of text only
elements (for which even white-space-only text will be considered
as significant content).
.PP
The schema definition commands are:
.TP
\&\fB\fBelement\fP \fIname\fB \fI?quant?\fB \fI?<definition script>?\fB
\&\fRIf the optional argument \fIdefinition script\fR is not
given this command refers to the element defined with
\&\fIdefelement\fR with the name \fIname\fR in the current
context namespace. If the \fIdefelement script\fR argument is
given, the validation constraint expects an element with the
name \fIname\fR in the current namespace with content
"locally" defined by the \fIdefinition script\fR. Forward
references to so far not defined elements or patterns or other
local definitions of the same name inside the \fIdefinition
script\fR are allowed. If a forward referenced element is not
defined until validation, only an empty element with name
\&\fIname\fR and namespace \fInamespace\fR and no attributes
matches.
.TP
\&\fB\fBelementtype\fP \fIname\fB \fI?quant?\fB
\&\fRThis command refers to the element defined with
\&\fIdefelementtype\fR with the type name \fIname\fR in the
current context namespace. Forward references to so far not
defined element types or recursive references are allowed. If
a forward referenced element type is not defined until
validation any empty element without attributes will be
accepted.
.TP
\&\fB\fBref\fP \fIname\fB \fI?quant?\fB
\&\fRThis command refers to the content particle defined with
\&\fIdefpattern\fR with the name \fIname\fR in the current
context namespace. Forward references to a so far not defined
pattern and recursive references are allowed. If a forward
referenced pattern is not defined until validation no content
whatsoever is expected ("empty match").
.TP
\&\fB\fBgroup\fP \fI?quant?\fB \fI<definition script>\fB
\&\fRThis method allows to group a sequence of content
particles defined by the \fIdefinition script>\fR, which have
to match in this sequence order.
.TP
\&\fB\fBchoice\fP \fI?quant?\fB \fI<definition script>\fB
\&\fRThis schema constraint matches if one of the top level
content particles defined by the \fIdefinition script>\fR
matches. If one of this top level content particle is optional
this constraint matches the "empty match".
.TP
\&\fB\fBinterleave\fP \fI?quant?\fB \fI<definition script>\fB
\&\fRThis schema constraint matches after every of the required
top level content particles defined by the \fIdefinition
script>\fR have matched (and, optional, some or all other) in
any arbitrary order.
.TP
\&\fB\fBmixed\fP \fI?quant?\fB \fI<definition script>\fB
\&\fRThis schema constraint matches for any text (including the
empty one) and every top level content particle defined by the
\&\fIdefinition script>\fR with default quantifier *.
.TP
\&\fB\fBtext\fP \fI?<constraint script>|\*(lqtype\*(lq typename?\fB
\&\fRWithout the optional constraint script this validation
constraint matches every string (including the empty one).
With \fIconstraint script\fR or with a given text type
argument a text matching this script or the text type is
expected.
.TP
\&\fB\fBany\fP \fI?namespace?\fB \fI?quant?\fB
\&\fRThe any command matches every element (in the namespace
\&\fInamespace\fR, if that is given) (with whatever attributes)
or subtree, no matter if known within the schema or not.
Please note that in case of no \fInamespace\fR argument is
given that means that the quantifier * and + will eat up any
elements until the enclosing element ends. If you really have
a namespace that looks like a valid tDOM schema quantifier
you will have to spell out always both arguments.
.TP
\&\fB\fBattribute\fP \fIname\fB \fI?quant?\fB \fI(?<constraint script>|\*(lqtype\*(lq typename?)\fB
\&\fRThe attribute command defines an attribute (in no
namespace) to the enclosing element. The first definition of
\&\fIname\fR inside an element definition wins; later
definitions of the same name are silently ignored. After the
\&\fIname\fR argument there may be one of the quantifiers ? or
!. If there is, it will be used. Otherwise the attribute will
be required (must be present in the XML source). If there is
one argument more this argument is evaluated as constraint
script, defining the value constraints of the attribute.
Otherwise, if there are two more arguments and the first of
them is the bare-word "type" the following argument is used as
a text type name. This command is only allowed at top level in
the definition script of an defelement/element script.
.TP
\&\fB\fBnsattribute\fP \fIname\fB \fInamespace\fB \fI?quant?\fB \fI(?<constraint script>|\*(lqtype\*(lq typename?)\fB
\&\fRThis command does the same as the command
\&\fIattribute\fR, for the attribute \fIname\fR in the
namespace \fInamespace\fR.
.TP
\&\fB\fBnamespace\fP \fIURI\fB \fI<definition script>\fB
\&\fREvaluates the \fIdefinition script\fR with context
namespace \fIURI\fR. Every element, element type or ref
command name will be looked up in the namespace \fIURI\fR,
and local defined elements will be in that namespace. An
empty string as \fIURI\fR means no namespace.
.TP
\&\fB\fBtcl\fP \fItclcmd\fB \fI?arg arg ...?\fB
\&\fREvaluates the Tcl script \fItclcmd arg arg ... \fR.

This validation command is only allowed in strict sequential
context (not in choice, mixed and interleave). If the return
code is something else than TCL_OK, this is an error (which
is not catched and reported by reportcmd).
.TP
\&\fB\fBself\fP
\&\fRReturns the schema command.
.TP
\&\fB\fBassociate\fP \fIdata\fB
\&\fRThis command is only allowed top-level inside definition
scripts of the element, elementtype, pattern or interleave
content particles. Associates the \fIdata\fR given as argument
with the currently defined content particle and may be
requested in scripts evaluated while validating the content of
that particle with the schema command method call \fIinfo
stack associated\fR.
.TP
\&\fB\fBdomunique\fP \fIselector\fB \fIfieldlist\fB \fI?name?\fB \fI?\*(lqIGNORE_EMPTY_FIELD_SET\*(lq|(\*(lqEMPTY_FIELD_SET_VALUE\*(lq emptyFieldSetValue)?\fB
\&\fRIf not postvalidating a DOM tree with \fIdomvalidate\fR
this constraint always matches. If postvalidating this
constraint resembles the xsd key/keyref mechanism. The
\&\fIselector\fR argument may be any valid XPath expression
(without the xsd limits). Several \fIdomunique\fR commands
within one element definition are allowed. They are checked in
definition order. The argument name is available in the
recovering script per \fIinfo vaction name\fR. If the
\&\fIfieldlist\fR does not select something for a node of the
result set of the \fIselector\fR the key value will be the
empty string by default. If the arguments
\&\fIEMPTY_FIELD_SET_VALUE <value>\fR are given an empty
node set will have the key value \fIvalue\fR. If instead the
flag \fIIGNORE_EMPTY_FIELD_SET\fR flag is given an empty
node set result will not have any key value.
.TP
\&\fB\fBdomxpathboolean\fP \fIXPath_expr\fB \fI?name?\fB
\&\fR
.RS
.PP
If not postvalidating a DOM tree with
\&\fIdomvalidate\fR this constraint always matches. If
postvalidating the \fIXPath_expr\fR argument is evaluated
(with the node matching the schema parent of the
\&\fIdomxpathboolean\fR command as context node). The
constraint maches if the result of this XPath expression,
converted to boolean by XPath rules, is true. Several
\&\fIdomxpathboolean\fR commands within one element definition
are allowed. They are checked in definition order.
.PP
This enables checks depending on more than one element. Consider


        
.CS

tdom::schema s
s define {
    defelement doc {
        element a ! text
        element b ! text
        element c ! text
        domxpathboolean "a * b * c >= 20000" volume
        domxpathboolean "a > b and b > c" sequence
    }
}
        
.CE
.RE
.TP
\&\fB\fBprefixns\fP \fI?prefixUriList?\fB
\&\fRThis defines a prefix to namespace URI mapping exactly
as a \fIschemacmd prefixns\fR would. It is meant as top-level
command of a \fIschemacmd define\fR script. This command is
not allowed nested in another definition script command and
will raise error, if you call it there.
.TP
\&\fB\fBdefelement\fP \fIname\fB \fI?namespace?\fB \fI<definition script>\fB
\&\fRThis defines an element exactly as a \fIschemacmd
defelement\fR call would. It is meant as top-level command of a
\&\fIschemacmd define\fR script. This command is not allowed
nested in another definition script command and will raise
error, if you call it there.
.TP
\&\fB\fBdefelementtype\fP \fIname\fB \fI?namespace?\fB \fI<definition script>\fB
\&\fRThis defines an elementtype exactly as a \fIschemacmd
defelementtype\fR call would. It is meant as top-level
command of a \fIschemacmd define\fR script. This command is
not allowed nested in another definition script command and
will raise error, if you call it there.
.TP
\&\fB\fBdefpattern\fP \fIname\fB \fI?namespace?\fB \fI<definition script>\fB
\&\fRThis defines a named pattern exactly as a \fIschemacmd
defpattern\fR call would. It is meant as top-level command of a
\&\fIschemacmd define\fR script. This command is not allowed
nested in another definition script command and will raise
error, if you call it there.
.TP
\&\fB\fBdeftexttype\fP \fIname\fB \fI<constraint script>\fB
\&\fRThis defines a named bundle of text constraints exactly
as a \fIschemacmd deftexttype\fR call would. It is meant as
top-level command of a \fIschemacmd define\fR script. This
command is not allowed nested in another definition script
command and will raise error, if you call it there.
.TP
\&\fB\fBstart\fP \fIname\fB \fI?namespace?\fB
\&\fRThis command works exactly as a \fIschemacmd start\fR
call would. It is meant as top-level command of a \fIschemacmd
define\fR script. This command is not allowed nested in
another definition script command and will raise error, if you
call it there.
.SH "Quantity specifier"
.PP
Several schema definition commands expect a quantifier as
one of their arguments which determines how often the content
particle specified by the command is expected. The valid values
for a \fIquant\fR argument are:
.IP "\fB!\fR"
The content particle has to occur exactly once in valid
documents.
.IP "\fB?\fR"
The content particle may not occur more than once in
valid documents - the particle is optional.
.IP "\fB*\fR"
The content particle may occur zero or more times in a
row in valid documents.
.IP "\fB+\fR"
The content particle may occur one or more times in a
row in valid documents.
.IP "\fBn\fR"
The content particle must occur n times in a row in
valid documents. The quantifier must be an integer greater
zero.
.IP "\fB{n m}\fR"
The content particle must occur
at least n and at most m times in a row in valid documents.
The quantifier must be a Tcl list with two elements. Both
elements must be integers, with n >= 0 and n < m.
.PP
If an optional quantifier is not given, it defaults to * in
case of the \fImixed\fR command and to ! for all other commands.
.SH "Text constraint scripts"
.PP
Text (parsed character data, as XML calls it) sometimes has to
be of a certain kind or comply with certain rules to be valid. The
text constraint script arguments to text, attribute, nsattribute
and deftexttype commands are evaluated in the Tcl namespace
\&\fItdom::schema::text\fR namespace and allow the ensuing text
constraint commands to check text for certain properties. The
commands are defined in the Tcl namespace
\&\fItdom::schema::text\fR. They raise error in case they are
called outside of a text constraint script.
.PP
A few of the ensuing text type commands are exposed as general
Tcl commands. They are defined in the namespace tdom::type and are
called as documented below with the text to check appended to the
argument list. They return a logical value. Please note that the
commands may not accept starting or ending white space. If a
command is available in the tdom::type namespace is recorded in
its documentation.
.SS "The tcl text constraint command"
.PP

The \fItcl\fR text constraint command dispatches the check





to an arbitrary Tcl command, thus enable any programmable
decision rules.
.TP




\&\fB\fBtcl\fP \fItclcmd\fB \fI?arg arg ...?\fB
\&\fREvaluates the Tcl script \fItclcmd arg arg ... \fR and
the text to validate appended to the argument list. The return
value of the Tcl command is interpreted as a boolean.
.SS "Basic XML types"
.TP
\&\fB\fBname\fP
.UR "https://www.w3.org/TR/xml/#NT-Name"
<URL: https://www.w3.org/TR/xml/#NT-Name>
.UE
\&\fRThis text constraint matches if the text value
matches the XML name production
\&. This
means that the text value must start with a letter,
underscore (_), or colon (:), and may contain only
letters, digits, underscores (_), colons (:), hyphens
(-), and periods (.).

.TP
\&\fB\fBncname\fP
.UR "https://www.w3.org/TR/xml-names/#NT-NCName"
<URL: https://www.w3.org/TR/xml-names/#NT-NCName>
.UE
\&\fRThis text constraint matches if the text value

matches the XML ncname production
\&.
This means that the text value must start with a
letter or underscore (_), and may contain only
letters, digits, underscores (_), hyphens (-), and
periods (.) (The only difference to the name
constraint is that colons are not permitted.)
.TP
\&\fB\fBqname\fP
.UR "https://www.w3.org/TR/xml-names/#NT-QName"
<URL: https://www.w3.org/TR/xml-names/#NT-QName>
.UE
\&\fRThis text constraint matches if the text value
matches the XML qname production
\&.
This means that the text value is either a ncname or
two ncnames joined by a colon (:).
.TP
\&\fB\fBnmtoken\fP
.UR "https://www.w3.org/TR/xml/#NT-Nmtoken"
<URL: https://www.w3.org/TR/xml/#NT-Nmtoken>
.UE
\&\fRThis text constraint matches if the text value
matches the XML nmtoken production
.TP
\&\fB\fBnmtokens\fP
.UR "https://www.w3.org/TR/xml/#NT-Nmtokens"
<URL: https://www.w3.org/TR/xml/#NT-Nmtokens>
.UE
\&\fRThis text constraint matches if the text value
matches the XML nmtokens production
.SS "Basic type tests"
.PP
.TP
\&\fB\fBinteger\fP \fI?(xsd|tcl)?\fB
\&\fRThis text constraint matches if the text value could be
parsed as an integer. If the optional argument to the command
is \fItcl\fR, everything that returns TCL_OK if feeded into
Tcl_GetInt() matches. If the optional argument to the command
is \fIxsd\fR, the constraint matches if the value is a
valid xsd:integer. Without argument \fIxsd\fR is the
default.
.TP
\&\fB\fBnegativeInteger\fP \fI?(xsd|tcl)?\fB
\&\fRThis text constraint matches the same text values as the
\&\fIinteger\fR text constraint (see there), with the additional
constraint, that the value must be < zero.
.TP
\&\fB\fBnonNegativeInteger\fP \fI?(xsd|tcl)?\fB
\&\fRThis text constraint matches the same text values as the
\&\fIinteger\fR text constraint (see there), with the additional
constraint, that the value must be >= zero.
.TP
\&\fB\fBnonPositiveInteger\fP \fI?(xsd|tcl)?\fB
\&\fRThis text constraint matches the same text values as the
\&\fIinteger\fR text constraint (see there), with the additional
constraint, that the value must be <= zero.
.TP
\&\fB\fBpositiveInteger\fP \fI?(xsd|tcl)?\fB
\&\fRThis text constraint matches the same text values as the
\&\fIinteger\fR text constraint (see there), with the additional
constraint, that the value must be > zero.
.TP
\&\fB\fBnumber\fP \fI?(xsd|tcl)?\fB
\&\fRThis text constraint matches if the text value could be
parsed as a number. If the optional argument to the command is
\&\fItcl\fR, everything that returns TCL_OK if feeded into
Tcl_GetDouble() matches. If the optional argument to the command
is \fIxsd\fR, the constraint matches if the value is a
valid xsd:decimal. Without argument \fIxsd\fR is the
default.
.TP
\&\fB\fBboolean\fP \fI?(xsd|tcl)?\fB
\&\fRThis text constraint matches if the text value could be
parsed as a boolean. If the optional argument to the command is
\&\fItcl\fR, everything that returns TCL_OK if feeded into
Tcl_GetBoolean() matches. If the optional argument to the command
is \fIxsd\fR, the constraint matches if the value is a
valid xsd:boolean. Without argument \fIxsd\fR is the
default.
.TP
\&\fB\fBdate\fP
\&\fRThis text constraint matches if the text value is
a xsd:date, which is basically like an ISO 8601 date of
the form YYYY-MM-DD, with optional time zone part
(either the letter Z or plus (+) or minus (-) followed
by hh:mm and with maximum allowed positive or negative
time zone 14:00). It follows the date rules of the
Gregorian calendar for all dates. A preceding minus
sign for bce dates is allowed. There is no year 0. The
year may have more than 4 digits, but only if needed
(no extra leading zeros). This is available as common
Tcl command tdom::type::date.
.TP
\&\fB\fBtime\fP
\&\fRThis text constraint matches if the text value is
a xsd:time, which is basically like an ISO 8601 time of
the form hh:mm:ss with optional time zone part. The
time zone part follow the rules of the \fIdate\fR
command; see there. All three parts of the time value
(hours, minutes, seconds) must be spelled out with 2
digits. Additional fractional seconds (with a point
('.') as separator) are allowed, but not just a
dangling point. The time value 24:00:00 (without
fractional part) is allowed. This is available as
common Tcl command tdom::type::time.
.TP
\&\fB\fBdateTime\fP
\&\fRThis text constraint matches if the text value
is a xsd:dateTime, which is basically like an ISO 8601
date time of the form YYYY-MM-DDThh:mm:ss with
optional time zone part. The date and time zone parts
follows the rules of the \fIdate\fR and \fItime\fR
command; see there. The time part (including the
signaling 'T' character) is mandatory. This is
available as common Tcl command
tdom::type::dateTime.
.TP
\&\fB\fBduration\fP
\&\fRThis text constraint matches if the text value is
a xsd:duration, which is basically like an ISO 8601
duration of the form PnYnMnDTnHnMnS. All parts other
than the starting P and - if one of H, M or S is given
- T are optional. In case the following sign letter is
S, n may be a decimal (with at least one digit before
and after the dot), otherwise it must be a (positive)
integer. This is available as common Tcl command
tdom::type::duration.
.TP
\&\fB\fBbase64\fP
\&\fRThis text constraint matches if text is valid according to
RFC 4648.
.TP
\&\fB\fBhexBinary\fP
\&\fRThis text constraint matches if text is a sequence of
binary octets in hexadecimal encoding, where each binary octet
is a two-character hexadecimal number. Lowercase and uppercase
letters A through F are permitted.
.TP
\&\fB\fBunsignedByte\fP
\&\fRThis text constraint matches if the text value is a
xsd:unsignedByte. This is an integer between 0 and 255, both
included, optionally preceded by a + sign and leading
zeros.
.TP
\&\fB\fBunsignedShort\fP
\&\fRThis text constraint matches if the text value is a
xsd:unsignedShort. This is an integer between 0 and 65535,
both included, optionally preceded by a + sign and leading
zeros.
.TP
\&\fB\fBunsignedInt\fP
\&\fRThis text constraint matches if the text value is a
xsd:unsignedInt. This is an integer between 0 and 4294967295,
both included, optionally preceded by a + sign and leading
zeros.
.TP
\&\fB\fBunsignedLong\fP
\&\fRThis text constraint matches if the text value is a
xsd:unsignedLong. This is an integer between 0 and
18446744073709551615, both included, optionally preceded by a
+ sign and leading zeros.
.SS "Logical constructs"
.TP
\&\fB\fBoneOf\fP \fI<constraint script>\fB
\&\fRThis text constraint matches if one of the text
constraints defined in the argument \fIconstraint script\fR
matches the text. It stops after the first matches and probes the
text constraints in the order of definition.
.TP
\&\fB\fBallOf\fP \fI<constraint script>\fB
\&\fRThis text constraint matches if all of the text
constraints defined in the argument \fIconstraint script\fR
matches the text. It stops after the first match failure and
probes the text constraints in the order of definition. Since
the schema definition command \fItext\fR also expects all
text constraints to match the text constraint, \fIallOf\fR is
useful mostly in connection with the \fIoneOf\fR text constraint
command.
.TP
\&\fB\fBnot\fP \fI<constraint script>\fB
\&\fRThis text constraint matches if none of the text
constraints defined in the argument \fIconstraint
script\fR matches the text. It stops after the first
matching constraint in the \fIconstraint script\fR and
reports validation error. The text constraints in the
\&\fIconstraint script\fR are probed in the order of
definition.
.SS "Constraints on processed text value"
.TP
\&\fB\fBwhitespace\fP \fI(preserve|replace|collapse)\fB \fI<constraint script>\fB
\&\fRThis text constraint command does white-space (#x20
(space, ' '), #x9 (tab, \et), #xA (linefeed, \en), and #xD
(carriage return, \er) normalization to the text value and
checks the resulting text with the text constraints of the
constraint script argument. The normalization method
\&\fIpreserve\fR keeps everything as it is; this is another way
to say \fIallOf\fR. The \fIreplace\fR normalization method
replaces any single white-space character (as above) to a
space. The \fIcollapse\fR normalization method removes all
leading and trailing white-space, and all the other sequences of
contiguous white-space are replaced by a single space.
.TP
\&\fB\fBsplit\fP \fI?type ?args??\fB\fI<constraint script>\fB
\&\fR
.RS
.PP
This text constraint command splits the text to test
into a list of values and tests all elements of that list for
the text constraints in the evaluated \fIconstraint
script>\fR.
.PP
The available types are:
.TP
whitespace
The text to split is stripped
of all white space at start and end and splitted into
a list at any successive white space.
.TP
tcl tclcmd ?arg ...?
The text to split is
handed to the \fItclcmd\fR, which is evaluated on
global level, appended with every given arg and the
text to split as last argument. This call must return
a valid Tcl list whose elements are tested.
.PP
The default in case no split type argument is given is
\&\fIwhitespace\fR.
.RE
.TP
\&\fB\fBstrip\fP \fI<constraint script>\fB
\&\fRThis text constraint command tests all text constraints
in the evaluated \fIconstraint script>\fR with the text to
test stripped of all white space at start and end.
.SS "Various other string properties"
.TP
\&\fB\fBfixed\fP \fIvalue\fB
\&\fRThe text constraint only matches if the text value is
string equal to the given value.
.TP
\&\fB\fBenumeration\fP \fIlist\fB
\&\fRThis text constraint matches if the text value is equal to
one element (respecting case and any white-space) of the
argument \fIlist\fR, which has to be a valid Tcl list.
.TP
\&\fB\fBmatch\fP \fI?-nocase?\fB \fIglob_style_match_pattern>\fB
.UR "https://www.tcl.tk/man/tcl8.6/TclCmd/string.htm#M35"
<URL: https://www.tcl.tk/man/tcl8.6/TclCmd/string.htm#M35>
.UE
\&\fRThis text constraint matches if the text value matches the
glob style pattern given as argument. It follows the rules of
the Tcl [string match] command, see
\&.
.TP
\&\fB\fBregexp\fP \fIexpression\fB
.UR "https://www.tcl.tk/man/tcl8.6/TclCmd/re_syntax.htm"
<URL: https://www.tcl.tk/man/tcl8.6/TclCmd/re_syntax.htm>
.UE
\&\fRThis text constraint matches if the text value matches the
regular expression given as argument.  describes the regular expression syntax
.TP
\&\fB\fBlength\fP \fIlength\fB
\&\fRThis text constraint matches if the length of the text
value (in characters, not bytes) is \fIlength\fR. The
length argument must be a positive integer or zero.
.TP
\&\fB\fBmaxLength\fP \fIlength\fB
\&\fRThis text constraint matches if the length of the text
value (in characters, not bytes) is at most \fIlength\fR. The
length argument must be an integer greater zero.
.TP
\&\fB\fBminLength\fP \fIlength\fB
\&\fRThis text constraint matches if the length of the text
value (in characters, not bytes) is at least \fIlength\fR.
The length argument must be an integer greater zero.
.TP
\&\fB\fBid\fP \fI?keySpace?\fB
\&\fRThis text constraint command marks the text as a
document wide ID (to be referenced by an idref). Every ID
value within a document must be unique. It isn't an error if
the ID isn't actually referenced within the document. The
optional argument \fIkeySpace\fR does all this for a named
key space. The key space "" (the empty sting) is another key
space then the \fIid\fR command without keySpace
argument.
.TP
\&\fB\fBidref\fP \fI?keySpace?\fB
\&\fRThis text constraint command expects the text to be a
reference to an ID within the document. The referenced ID may
appear later in the document, that the reference. Several
references within the document to one ID are possible.




.SH "Local key constraints"
.PP
Document wide uniqueness and foreign key constraints are
available with the text constraint commands id and idref.
Keyspaces allow for sub-tree local uniqueness and foreign key
constraints.
.TP
\&\fB\fBkeyspace\fP \fI<names list>\fB \fI<constraint script>\fB
\&\fRAny number of keyspaces are possible. A keyspace is
either active or not. An inside a \fIconstraint
script\fR called keyspace with the same name does
nothing.
.PP
This text constraint commands work with keyspaces:
.TP
\&\fB\fBkey\fP \fI<name>\fB
\&\fRIf the keyspace with the name \fI<name>\fR is
not active the constraint always matches. If the keyspace
is active, reports error if there is already a key with
the value. Otherwise it stores the value as key in this
keyspace and matches.
.TP
\&\fB\fBkeyref\fP \fI<name>\fB
\&\fRIf the keyspace with the name \fI<name>\fR is not
active always matches. If the keyspace is active then
reports error if there is still no key as the value at the
end of the keyspace \fI<name>\fR. Otherwise, it
matches.
.SH Recovering
.PP
By default the validation engine stops at the first detected
validation violation and reports that finding. It does so by
return false (and sets, if given, the result variable with an
error message) in case the schema command itself is used to
validate input. If the schema command is used by a SAX parser or
the DOM parser, it does so by throwing error.
.PP
If a \fIreportcmd\fR is set this command is called on global
level appended with the schema command and an error type as
arguments in case a validation violation is detected. Then the
validation recovers from the error and continues. For some
validation errors the recover strategy can be determined with
the script result of the reportcmd.
.PP
With a \fIreportcmd\fR (which does not throw error if
called) the validation engine will never report validation
failure to its caller. The validation engine recovers,
continues, and reports the next error (if occuring) and so on
until the end of the input. The schema command will return true
and the SAX parser and DOM builder will process normally until
the end of the input, as if there had not been a validation
error.
.PP
Please note that this happens only for validation errors. It
is not possible to recover from well-formedness errors. If the
input is not well-formed, the schema command returns false and
sets (if given) the result variable with an error message about
the well-formedness error.
.PP
If the \fIreportcmd\fR throws error while called by the
validation engine then validation stops and the schema command
throws error with the error message of the script.
.PP
While validating basically three events can happen: an
element start tag has to match, a piece of text has to match or
an element end tag has to match. The method \fIinfo vaction\fR
called in the recovering script or any script code called from
there returns, which event has triggered the error report
(MATCH_ELEMENT_START, MATCH_TEXT, MATCH_ELEMENT_END,
respectively). While the command walks throu the schema looking
whether the event matches other, data driven events (as, for example
checking, if any keyref within a keyspace exists) may happen.
.PP
Several of the validation error codes, appended as second
argument to the \fIreportcmd\fR calls, may happen at more than
one kind of validation event. The \fIinfo vaction\fR method and
its subcommands provide information about the current validation
event, if called from the report command.
.PP
If a structural validation error happens, the default
recovering strategy is to ignore any following (or missing)
content within the current subtree and to continue with the
element end event of the subtree.
.PP
Returning "ignore" from the recovering script in case of
error type MISSING_ELEMENT recovers by ignoring the failed
contraint and continues to match the event further against the
schema.
.PP
Returning "vanish" from the recover script in case of the
error types MISSING_ELEMENT and UNEXPECTED_ELEMENT recovers by
ignoring the event.
.SH Examples
.PP
.UR "https://www.w3.org/TR/xmlschema-0/"
<URL: https://www.w3.org/TR/xmlschema-0/>
.UE
The XML Schema Part 0: Primer Second Edition
() starts with this
example schema: