if (!clen) return 0;
        if (UTF8_XMLCHAR((unsigned const char *)p,clen))
            p += clen;
        else return 0;
    }
    return 1;
}

/*---------------------------------------------------------------------------
|   domIsHTML5CustomName 
|
\--------------------------------------------------------------------------*/
int
domIsHTML5CustomName (
    const char *str
    )
{
    const char *p;
    int clen, dashseen = 0;
    Tcl_UniChar uniChar;

    p = str;
    if (*p < 'a' || *p > 'z') {
        return 0;
    }
    p++;
    while (*p) {
        clen = UTF8_CHAR_LEN(*p);
        if (clen == 0) return 0;
        if (clen == 1) {
            if (*p == '-') {
                dashseen = 1;
                p++;
            } else {
                if (*p == '.'
                    || (*p >= '0' && *p <= '9')
                    || *p == '_'
                    || (*p >= 'a' && *p <= 'z')) {
                    p++;
                } else {
                    return 0;
                }
            }
            continue;
        } 
        if (clen == 4) {
            p += clen;
            continue;
        }
        clen = Tcl_UtfToUniChar (p, &uniChar);
        if (uniChar == 0xB7
            || (uniChar >= 0xC0 && uniChar <= 0xD6)
            || (uniChar >= 0xD8 && uniChar <= 0xF6) 
            || (uniChar >= 0xF8 && uniChar <= 0x37D) 
            || (uniChar >= 0x37F && uniChar <= 0x1FFF) 
            || (uniChar >= 0x200C && uniChar <= 0x200D) 
            || (uniChar >= 0x203F && uniChar <= 0x2040)
            || (uniChar >= 0x2070 && uniChar <= 0x218F)
            || (uniChar >= 0x2C00 && uniChar <= 0x2FEF)
            || (uniChar >= 0x3001 && uniChar <= 0xD7FF)
            || (uniChar >= 0xF900 && uniChar <= 0xFDCF)
            || (uniChar >= 0xFDF0 && uniChar <= 0xFFFD)) {
            p += clen;
        } else {
            return 0;
        }
    }
    if (!dashseen) return 0;
    switch (str[0]) {
    case 'a': if (!strcmp(str,"annotation-xml")) {return 0;} break;
    case 'c': if (!strcmp(str,"color-profile")) {return 0;} break;
    case 'f': if (!strcmp(str,"font-face")        ||
                  !strcmp(str,"font-face-src")    ||
                  !strcmp(str,"font-face-uri")    ||
                  !strcmp(str,"font-face-format") ||
                  !strcmp(str,"font-face-name")) {return 0;} break;
    case 'm': if (!strcmp(str,"missing-glyph")) {return 0;} break;
    }
    return 1;
}

/*---------------------------------------------------------------------------
|   domClearString
|
\--------------------------------------------------------------------------*/
void 
domClearString (

int            domIsChar (const char *str);
void           domClearString (char *str, char *replacement, domLength repllen,
                               Tcl_DString *clearedstr, int *changed);
int            domIsBMPChar (const char *str);
int            domIsComment (const char *str);
int            domIsCDATA (const char *str);
int            domIsPIValue (const char *str);
int            domIsHTML5CustomName (const char *str);
void           domCopyTo (domNode *node, domNode *parent, int copyNS);
void           domCopyNS (domNode *from, domNode *to);
domAttrNode *  domCreateXMLNamespaceNode (domNode *parent);
void           domRenumberTree (domNode *node);
int            domPrecedes (domNode *node, domNode *other);
void           domNormalize (domNode *node, int forXPath, 
                             domFreeCallback freeCB, void *clientData);

    int            hasContent;
    domNode       *pnode;
    domNode       *node = NULL, *parent_node = parent;
    domTextNode   *tnode;
    domAttrNode   *attrnode, *lastAttr;
    int            ampersandSeen = 0;
    int            only_whites   = 0;
    int            hnew, autoclose, ignore, maybeCustomName, rc;
    char           tmp[250], *y = NULL;
    Tcl_HashEntry *h;
    domProcessingInstructionNode *pinode;

    x = &(html[*pos]);

    while ( (c=*x)!=0 ) {

            }


            /*----------------------------------------------------------------
            |   new tag/element
            |
            \---------------------------------------------------------------*/
            maybeCustomName = 0;
            while ((c=*x)!=0 && c!='/' && c!='>' && c!='<' && !SPACE(c) ) {
                if (!maybeCustomName && !isalnum(c)) maybeCustomName = 1;
                x++;
            }
            if (!maybeCustomName) {
                c = *x;
                *x = '\0'; /* temporarily terminate the string */
                x = start + 1;
                while (*x) {
                    *x = tolower(*x);
                    x++;
                }
                *x = c;
            } else {
                c = *x;
                *x = '\0'; /* temporarily terminate the string */
                rc = domIsHTML5CustomName (start+1);
                *x = c;
                if (!rc) {
                    goto readText;
                }
            }
            hasContent = 1;
            if (c==0) {
                RetError("Missing \">\"",(start-html) );
            }
            if ( (x-start)==1) {
                RetError("Null markup name",(start-html) );

    "    isComment string                                 \n"
    "    isCDATA string                                   \n"
    "    isPIValue string                                 \n"
    "    isName string                                    \n"
    "    isQName string                                   \n"
    "    isNCName string                                  \n"
    "    isPIName string                                  \n"
    "    isHTML5CustomName string                         \n"
    "    featureinfo feature                              \n"
;

static char doc_usage[] =
    "Usage domDoc <method> <args>, where method can be:\n"
    "    documentElement ?objVar?                \n"
    "    getElementsByTagName name               \n"

        "createDocument",  "createDocumentNS",   "createNodeCmd",
        "parse",                                 "setStoreLineColumn",
        "isCharData",      "isName",             "isPIName",
        "isQName",         "isComment",          "isCDATA",
        "isPIValue",       "isNCName",           "createDocumentNode",
        "setNameCheck",    "setTextCheck",       "setObjectCommands",
        "featureinfo",     "isBMPCharData",      "clearString",
        "isHTML5CustomName",
#ifdef TCL_THREADS
        "attachDocument",  "detachDocument",
#endif
        NULL
    };
    enum domMethod {
        m_createDocument,    m_createDocumentNS,   m_createNodeCmd,
        m_parse,                                   m_setStoreLineColumn,
        m_isCharData,        m_isName,             m_isPIName,
        m_isQName,           m_isComment,          m_isCDATA,
        m_isPIValue,         m_isNCName,           m_createDocumentNode,
        m_setNameCheck,      m_setTextCheck,       m_setObjectCommands,
        m_featureinfo,       m_isBMPCharData,      m_clearString,
        m_isHTML5CustomName
#ifdef TCL_THREADS
        ,m_attachDocument,   m_detachDocument
#endif
    };

    static const char *nodeModeValues[] = {
        "automatic", "command", "token", NULL

            return tcldom_featureinfo(clientData, interp, --objc, objv+1);

        case m_isBMPCharData:
            CheckArgs(3,3,2,"string");
            SetBooleanResult(domIsBMPChar(Tcl_GetString(objv[2])));
            return TCL_OK;

        case m_isHTML5CustomName:
            CheckArgs(3,3,2,"string");
            SetBooleanResult(domIsHTML5CustomName(Tcl_GetString(objv[2])));
            return TCL_OK;
        
        case m_clearString:
            CheckArgs(3,5,2,"?-replace ?replacement?? string");
            if (objc >= 4) {
                option = Tcl_GetString (objv[2]);
                if (option[0] == '-' && option[1] == 'r') {
                    if (Tcl_GetIndexFromObj (interp, objv[2],
                                             clearStringOptions, "option",

# Features covered: dom command
#
# This file contains a collection of tests for the dom command of
# tDOM.
#
#    dom-1.*:  createDocument, createDocumentNS
#    dom-2.*:  parse
#    dom-3.*:  is* methods, clearString
#    dom-4.*:  parse -useForeignDTD
#    dom-5.*:  external entities
#    dom-6.*:  use in slave interpreter
#    dom-7.*:  setNameCheck, setTextCheck
#    dom-8.*:  createDocumentNode, documentNodes
#    dom-9.*:  setObjectCommands
#    dom-10.*: createNodeCmd

        \u0004\u0005\u0001
    } {
        lappend result [dom clearString -replace some $str]
    }
    set result
} [list some asome someb asomeb asomesomeb asomecsomeb asomedsomesomeb asomedsomesomesomesome_foo_bar somesomesome_foo_bar_bazsome_didumsome somesomesome_foo_bar_bazsome_didum\uE000 somesomesome abc somesomesome]

test dom-3.46 {isHTML5CustomName} {
    set result [list]
    foreach str {
        abc
        ab-c
        ab-C
        -ab
        äb-c
        ab---c
        ab-
        ab-ᴨ
        aÄ-b
        aA-b
        aä-b
        0n-foo
        A-b
        font-face
        m\u00B7-.
        n-\uFDF0
        o-\u3000
    } {
        lappend result [dom isHTML5CustomName $str]
    }
    set result
} {0 1 0 0 0 1 1 1 1 0 1 0 0 0 1 1 0}

test dom-4.1 {-useForeignDTD 0} {
    set doc [dom parse -useForeignDTD 0 {<root/>}]
    $doc delete
} {}

test dom-4.2 {-useForeignDTD 1 with document with internal subset} {need_uri} {
    set baseURI [tdom::baseURL [file join [pwd] [file dir [info script]] dom.test]]

<head><title></title></head><body><form><select id="L" name="nls_language">
<option value="">--
        </option><option selected="selected" value="en_US">en_US
        </option><option value="de_DE">de_DE
        </option>
</select></form></body>
</html>}

test html-2.9 {HTML parsing} {knownBug} {
    set doc [dom parse -html {<HTML><MATH-field>x = 1 + 1</MATH-field></HTML>}]
    set result [$doc asHTML]
    $doc delete
    set result
} {<html>&lt;MATH-field&gt;x = 1 + 1&lt;/MATH-field&gt;</html&gt;}

test html-2.10 {HTML parsing} {
    set doc [dom parse -html {<HTML><mytag>foo</mytag></HTML>}]
    set result [$doc asHTML]
    $doc delete
    set result
} {<html><mytag>foo</mytag></html>}

test html-2.11 {HTML parsing} {
    set doc [dom parse -html {<HTML><math-field>x = 1 + 1</math-field></HTML>}]
    set result [$doc asHTML]
    $doc delete
    set result
} {<html><math-field>x = 1 + 1</math-field></html>}


test html-3.1 {Bad data} {
    set data {line 6 column 17 - Warning: <script> lacks "type" attribute
line 10 column 17 - Warning: <script> lacks "type" attribute
        line 11 column 17 - Warning: <table> lacks "summary" attribute}
    set doc [dom parse -html $data]
    set result [$doc asHTML]