if (pattern->flags & FORWARD_PATTERN_DEF) {
            fprintf (stderr, "\tAnonymously defined NAME\n");
        }
        if (pattern->flags & PLACEHOLDER_PATTERN_DEF) {
            fprintf (stderr, "\tAs placeholder defined NAME\n");
        }
        if (pattern->flags & LOCAL_DEFINED_ELEMENT) {
            fprintf (stderr, "\tLocal defined NAME\n");
        }
        if (pattern->flags & ELEMENTTYPE_DEF) {
            fprintf (stderr, "\tElementtype '%s'\n", pattern->typeName);
        }
        /* Fall thru. */
    case SCHEMA_CTYPE_CHOICE:
    case SCHEMA_CTYPE_INTERLEAVE:
        fprintf (stderr, "\t%d childs\n", pattern->nc);
        break;
    case SCHEMA_CTYPE_ANY:

    sdata = TMALLOC (SchemaData);
    memset (sdata, 0, sizeof(SchemaData));
    name = Tcl_GetStringFromObj (cmdNameObj, &len);
    sdata->self = Tcl_NewStringObj (name, len);
    Tcl_IncrRefCount (sdata->self);
    Tcl_InitHashTable (&sdata->element, TCL_STRING_KEYS);
    Tcl_InitHashTable (&sdata->elementType, TCL_STRING_KEYS);
    Tcl_InitHashTable (&sdata->prefix, TCL_STRING_KEYS);
    Tcl_InitHashTable (&sdata->pattern, TCL_STRING_KEYS);
    Tcl_InitHashTable (&sdata->attrNames, TCL_STRING_KEYS);
    Tcl_InitHashTable (&sdata->namespace, TCL_STRING_KEYS);
    Tcl_InitHashTable (&sdata->textDef, TCL_STRING_KEYS);
    sdata->emptyNamespace = Tcl_CreateHashEntry (
        &sdata->namespace, "", &hnew);

            FREE (sdata->prefixns[i]);
            i++;
        }
        FREE (sdata->prefixns);
    }
    Tcl_DeleteHashTable (&sdata->namespace);
    Tcl_DeleteHashTable (&sdata->element);
    Tcl_DeleteHashTable (&sdata->elementType);
    Tcl_DeleteHashTable (&sdata->prefix);
    Tcl_DeleteHashTable (&sdata->pattern);
    Tcl_DeleteHashTable (&sdata->attrNames);
    Tcl_DeleteHashTable (&sdata->textDef);
    for (i = 0; i < sdata->numPatternList; i++) {
        freeSchemaCP (sdata->patternList[i]);
    }

static void
cleanupLastPattern (
    SchemaData *sdata,
    unsigned int from
    )
{
    unsigned int i;
    char *name;
    Tcl_HashTable *hashTable;
    Tcl_HashEntry *h;

    SchemaCP *this, *previous, *current;

    for (i = from; i < sdata->numPatternList; i++) {
        this = sdata->patternList[i];
        hashTable = NULL;
        if (this->type == SCHEMA_CTYPE_NAME) {
            if (this->flags & ELEMENTTYPE_DEF) {
                hashTable = &sdata->elementType;
                name = this->typeName;
            } else {
                hashTable = &sdata->element;
                name = this->name;
            }
        }
        if (this->type == SCHEMA_CTYPE_PATTERN) {
            hashTable = &sdata->pattern;
            name = this->name;
        }
        if (name && hashTable) {
            if (this->flags & FORWARD_PATTERN_DEF) {
                sdata->forwardPatternDefs--;
            }
            h = Tcl_FindHashEntry (hashTable, name);
            previous = NULL;
            current = Tcl_GetHashValue (h);
            while (current != NULL && current != this) {
                previous = current;
                current = current->next;
            }
            if (previous) {
                if (current->next) {
                    previous->next = current->next;
                } else {
                    previous->next = NULL;
                }
            } else {
                if (current && current->next) {
                    Tcl_SetHashValue (h, current->next);
                } else {
                    Tcl_DeleteHashEntry (h);
                }
            }
        }
        freeSchemaCP (sdata->patternList[i]);

schemaInstanceCmd (
    ClientData clientData,
    Tcl_Interp *interp,
    int objc,
    Tcl_Obj *const objv[]
    )
{
    int            methodIndex, keywordIndex, hnew, hnew1, patternIndex;
    int            result = TCL_OK, forwardDef = 0, i = 0, j;
    int            savedDefineToplevel, type, len;
    unsigned int   savedNumPatternList;
    SchemaData    *savedsdata = NULL, *sdata = (SchemaData *) clientData;
    Tcl_HashTable *hashTable;
    Tcl_HashEntry *h, *h1;
    SchemaCP      *pattern, *thiscp, *current = NULL;
    void          *namespacePtr, *savedNamespacePtr;
    char          *xmlstr, *errMsg;
    domDocument   *doc;
    domNode       *node;
    Tcl_Obj       *attData;

    static const char *schemaInstanceMethods[] = {

                    pattern->flags &= ~FORWARD_PATTERN_DEF;
                }
                pattern->flags &= ~PLACEHOLDER_PATTERN_DEF;
            }
            pattern->defScript = objv[patternIndex];
            Tcl_IncrRefCount (pattern->defScript);
        } else {
            if (forwardDef) {
                pattern->nc = 0;
            }
            cleanupLastPattern (sdata, savedNumPatternList);
        }
        sdata->defineToplevel = savedDefineToplevel;
        sdata->currentNamespace = savedNamespacePtr;
        if (!savedDefineToplevel) {
            SETASI(savedsdata);
        }

    case m_defelementtype:
        CHECK_RECURSIVE_CALL
        if (objc != 5-i && objc != 6-i) {
            Tcl_WrongNumArgs (interp, 1-i, objv, "<type_name> <name>"
                 " ?<namespace>? pattern");
            return TCL_ERROR;
        }
        savedNumPatternList = sdata->numPatternList;
        namespacePtr = NULL;
        patternIndex = 4-i;
        if (objc == 6-i) {
            patternIndex = 5-i;
            namespacePtr = getNamespacePtr (sdata, Tcl_GetString (objv[4-i]));
        }
        h = Tcl_CreateHashEntry (&sdata->elementType , Tcl_GetString (objv[2-i]),
                                 &hnew);
        pattern = NULL;
        if (!hnew) {
            pattern = (SchemaCP *) Tcl_GetHashValue (h);
            while (pattern) {
                if (pattern->namespace == namespacePtr) {
                    if (pattern->flags & FORWARD_PATTERN_DEF) {
                        forwardDef = 1;
                        break;
                    }
                    SetResult ("Element type already defined in this "
                               "namespace");
                    return TCL_ERROR;
                }
                pattern = pattern->next;
            }
        }
        h1 = Tcl_CreateHashEntry (&sdata->element , Tcl_GetString (objv[3-i]),
                                  &hnew1);
        if (hnew1) {
            thiscp = initSchemaCP (SCHEMA_CTYPE_NAME, namespacePtr,
                                   Tcl_GetString (objv[3-i]));
            REMEMBER_PATTERN (thiscp);
            thiscp->flags |= PLACEHOLDER_PATTERN_DEF;
            Tcl_SetHashValue (h1, thiscp);
        }
        if (pattern == NULL) {
            pattern = initSchemaCP (SCHEMA_CTYPE_NAME, namespacePtr,
                                    Tcl_GetHashKey (&sdata->element, h1));
            pattern->flags |= ELEMENTTYPE_DEF;
            pattern->typeName = Tcl_GetHashKey (&sdata->elementType, h);
            if (!hnew) {
                current = (SchemaCP *) Tcl_GetHashValue (h);
                pattern->next = current;
            }
            REMEMBER_PATTERN (pattern);
            Tcl_SetHashValue (h, pattern);
        }
        
        SETASI(sdata);
        savedDefineToplevel = sdata->defineToplevel;
        savedNamespacePtr = sdata->currentNamespace;
        sdata->defineToplevel = 0;
        sdata->currentNamespace = namespacePtr;
        sdata->cp = pattern;
        sdata->numAttr = 0;
        sdata->numReqAttr = 0;
        sdata->currentAttrs = NULL;
        sdata->contentSize = CONTENT_ARRAY_SIZE_INIT;
        sdata->evalStub[3] = objv[patternIndex];
        sdata->currentEvals++;
        result = Tcl_EvalObjv (interp, 4, sdata->evalStub, TCL_EVAL_GLOBAL);
        sdata->currentEvals--;
        sdata->currentNamespace = NULL;
        pattern->attrs = sdata->currentAttrs;
        pattern->numAttr = sdata->numAttr;
        pattern->numReqAttr = sdata->numReqAttr;
        if (result == TCL_OK) {
            if (forwardDef) {
                sdata->forwardPatternDefs--;
                pattern->name = Tcl_GetHashKey (&sdata->element, h1);
                pattern->flags &= ~FORWARD_PATTERN_DEF;
            }
            pattern->defScript = objv[patternIndex];
            Tcl_IncrRefCount (pattern->defScript);
        } else {
            if (forwardDef) {
                pattern->nc = 0;
            }
            cleanupLastPattern (sdata, savedNumPatternList);
        }
        sdata->defineToplevel = savedDefineToplevel;
        sdata->currentNamespace = savedNamespacePtr;
        if (!savedDefineToplevel) {
            SETASI(savedsdata);
        }
        break;
            
    default:
        Tcl_SetResult (interp, "unknown method", NULL);
        result = TCL_ERROR;
        break;

        addToContent (sdata, pattern, quant, n, m);
    } else {
        freeSchemaCP (pattern);
    }
    return result;
}

/* Implements the schema definition commands "element", "elementtype"
 * and "ref" */
static int
NamedPatternObjCmd (
    ClientData clientData,
    Tcl_Interp *interp,
    int objc,
    Tcl_Obj *const objv[]
    )
{
    SchemaData *sdata = GETASI;
    Schema_CP_Type patternType = (Schema_CP_Type) clientData;
    Tcl_HashTable *hashTable;
    Tcl_HashEntry *h;
    SchemaCP *pattern = NULL, *current;
    SchemaQuant quant;
    int hnew, n, m;

    CHECK_SI
    CHECK_TOPLEVEL
    if (clientData == 0) {
        checkNrArgs (2,4,"Expected: elementName ?quant? ?pattern?");
        patternType = SCHEMA_CTYPE_NAME;
        hashTable = &sdata->element;
    } else if (clientData == (ClientData) 1) {
        checkNrArgs (2,3,"Expected: elementtypeName ?quant?");
        patternType = SCHEMA_CTYPE_NAME;
        hashTable = &sdata->elementType;            
    } else {
        checkNrArgs (2,3,"Expected: patternName ?quant?");
        patternType = SCHEMA_CTYPE_PATTERN;
        hashTable = &sdata->pattern;
    }

    quant = getQuant (interp, sdata, objc == 2 ? NULL : objv[2], &n, &m);
    if (quant == SCHEMA_CQUANT_ERROR) {
        return TCL_ERROR;
    }
    h = Tcl_CreateHashEntry (hashTable, Tcl_GetString(objv[1]), &hnew);
    if (objc < 4) {
        /* Reference to an element, elementtype or pattern */
        if (!hnew) {
            pattern = (SchemaCP *) Tcl_GetHashValue (h);
            while (pattern) {
                if (pattern->namespace == sdata->currentNamespace) {
                    break;
                }
                pattern = pattern->next;
            }
        }
        if (!pattern) {
            pattern = initSchemaCP (
                patternType,
                sdata->currentNamespace,
                Tcl_GetHashKey (hashTable, h)
                );
            if (clientData == (ClientData) 1) {
                pattern->typeName = pattern->name;
                pattern->name = NULL;
                pattern->flags |= ELEMENTTYPE_DEF;
            }
            pattern->flags |= FORWARD_PATTERN_DEF;
            sdata->forwardPatternDefs++;
            if (!hnew) {
                current = (SchemaCP *) Tcl_GetHashValue (h);
                pattern->next = current;
            }
            REMEMBER_PATTERN (pattern);

    Tcl_CreateObjCommand (interp, "tdom::schema::prefixns",
                          schemaInstanceCmd, NULL, NULL);

    /* The "any" definition command. */
    Tcl_CreateObjCommand (interp, "tdom::schema::any",
                          AnyPatternObjCmd, NULL, NULL);

    /* The named pattern commands "element", "elementtype" and
     * "ref". */
    Tcl_CreateObjCommand (interp, "tdom::schema::element",
                          NamedPatternObjCmd, (ClientData) 0, NULL);
    Tcl_CreateObjCommand (interp, "tdom::schema::elementtype",
                          NamedPatternObjCmd, (ClientData) 1, NULL);
    Tcl_CreateObjCommand (interp, "tdom::schema::ref",
                          NamedPatternObjCmd, (ClientData) 2, NULL);


    /* The anonymous pattern commands "choise", "mixed", "interleave"
     * and "group". */
    Tcl_CreateObjCommand (interp, "tdom::schema::choice",
                          AnonPatternObjCmd, (ClientData) 0, NULL);
    Tcl_CreateObjCommand (interp, "tdom::schema::mixed",
                          AnonPatternObjCmd, (ClientData) 1, NULL);

/* The SchemaFlags flags */
#define FORWARD_PATTERN_DEF     1
#define PLACEHOLDER_PATTERN_DEF 2
#define AMBIGUOUS_PATTERN       4
#define LOCAL_DEFINED_ELEMENT   8
#define CONSTRAINT_TEXT_CHILD  16
#define MIXED_CONTENT          32
#define ELEMENTTYPE_DEF        64

typedef struct domKeyConstraint {
    char  *name;
    ast    selector;
    ast   *fields;
    int    nrFields;
    int    flags;

} SchemaKeySpace;

typedef struct SchemaCP
{
    Schema_CP_Type    type;
    char             *namespace;
    char             *name;
    char             *typeName;
    struct SchemaCP  *next;
    SchemaFlags       flags;
    struct SchemaCP **content;
    SchemaQuant      *quants;
    unsigned int      nc;
    SchemaAttr      **attrs;
    unsigned int      numAttr;

typedef struct SchemaData_
{
    Tcl_Obj *self;
    char *start;
    char *startNamespace;
    Tcl_HashTable element;
    Tcl_HashTable elementType;
    Tcl_HashTable namespace;
    Tcl_HashEntry *emptyNamespace;
    char **prefixns;
    Tcl_HashTable prefix;
    Tcl_HashTable pattern;
    Tcl_HashTable attrNames;
    Tcl_HashTable textDef;

#    schema-15.*: Constraint cmd tcl
#    schema-16.*: interleave
#    schema-17.*: info
#    schema-18.*: reportcmd
#    schema-19.*: keyspace
#    schema-20.*: domunique
#    schema-21.*: internal: buffers
#    schema-22.*: defelementtype, elementtype
#
# Copyright (c) 2018-2019 Rolf Ade.

source [file join [file dir [info script]] loadtdom.tcl]

if {[dom featureinfo schema]} {

            }
        }
    }]
    s delete
    set result
} 1
        
test schema-1.29 {defelement} {
    tdom::schema s
    catch {
        s defelement e {
            element a 
            element b
            error "some"
        }
    }
    s defelement e {
        element a 
        element b
    }
    set result [list]
    foreach xml {
        <e/>
        <e><a/></e>
        <e><a/><b/></e>
        <e><a/><b/><b/></e>
    } {
        lappend result [s validate $xml]
    }
    s delete
    set result
} {0 0 1 0}

test schema-2.1 {grammar definition: ref} {
    tdom::schema create grammar
    grammar defpattern thisPattern {
        element a
        element b
    }
    grammar defpattern thatPattern {

                     <doc>[string repeat <e/> 27]</doc>  \
                     <doc>[string repeat <e/> 37]</doc>] {
        lappend result [s validate $xml]
    }
    s delete
    set result
} {1 1 1 0}

test schema-22.1 {defelementtype} {
    tdom::schema s
    s defelementtype a_type a {
        element e1
    }
    s defelement doc {
        elementtype a_type
    }
    set result [list]
    foreach xml {
        <doc/>
        <doc><a/></doc>
        <doc><a><e1/></a></doc>
    } {
        lappend result [s validate $xml]
    }
    s delete
    set result
} {0 0 1}

test schema-22.2 {defelementtype} {
    tdom::schema s
    s defelement doc {
        elementtype a_type
    }
    s defelementtype a_type a {
        element e1
    }
    set result [list]
    foreach xml {
        <doc/>
        <doc><a/></doc>
        <doc><a><e1/></a></doc>
    } {
        lappend result [s validate $xml]
    }
    s delete
    set result
} {0 0 1}

test schema-22.3 {defelementtype} {
    tdom::schema s
    s defelement doc {
        elementtype a
        elementtype a2
    }
    s defelementtype a a {
        element e1
    }
    s defelementtype a2 a {
        element e2
    }
    set result [list]
    foreach xml {
        <doc/>
        <doc><a/></doc>
        <doc><a><e1/></a></doc>
        <doc><a><e1/></a><a><e2/></a></doc>
        <doc><a><e1/></a><a><e1/></a></doc>
        <doc><a><e2/></a><a><e1/></a></doc>
    } {
        lappend result [s validate $xml]
    }
    s delete
    set result
} {0 0 0 1 0 0}

test schema-22.4 {defelementtype} {
    tdom::schema s
    catch {s defelement doc {
        elementtype a
        elementtype a2
        error "my"
    }}
    s defelement doc {
        elementtype a
        elementtype a2
    }
    catch {s defelementtype a a {
        element e1
        error my
    }}
    s defelementtype a a {
        element e1
    }
    catch {s defelementtype a2 a {
        element e2
        error my
    }}
    s defelementtype a2 a {
        element e2
    }
    set result [list]
    foreach xml {
        <doc/>
        <doc><a/></doc>
        <doc><a><e1/></a></doc>
        <doc><a><e1/></a><a><e2/></a></doc>
        <doc><a><e1/></a><a><e1/></a></doc>
        <doc><a><e2/></a><a><e1/></a></doc>
    } {
        lappend result [s validate $xml]
    }
    s delete
    set result
} {0 0 0 1 0 0}

test schema-22.5 {defelementtype} {
    tdom::schema s
    s prefixns {ns http://my.foo}
    s defelement doc ns {
        elementtype a
        elementtype a2
    }
    s defelementtype a a ns {
        element e1
    }
    s defelementtype a2 a ns {
        element e2
    }
    set result [list]
    foreach xml {
        {<doc xmlns='http://my.foo'/>}
        {<doc xmlns='http://my.foo'><a/></doc>}
        {<doc xmlns='http://my.foo'><a><e1/></a></doc>}
        {<doc xmlns='http://my.foo'><a><e1/></a><a><e2/></a></doc>}
        {<doc xmlns='http://my.foo'><a><e1/></a><a><e1/></a></doc>}
        {<doc xmlns='http://my.foo'><a><e2/></a><a><e1/></a></doc>}
    } {
        lappend result [s validate $xml]
    }
    s delete
    set result
} {0 0 0 1 0 0}

}