static void freeKeyConstraints (
    KeyConstraint *kc
    )
{
    KeyConstraint *knext;
    KeyStep *step, *snext;
    int i;
    
    while (kc) {
        knext = kc->next;
        if (kc->name) FREE (kc->name);
        step = kc->selector;
        while (step) {
            snext = step->next;
            FREE (step);
            step = snext;
        }
        for (i = 0; i < kc->nrFields; i++) {
            step = kc->fields[i];
            while (step) {
                snext = step->next;
                FREE (step);
                step = snext;
            }
        }
        FREE (kc->fields);
        FREE (kc);
        kc = knext;
    }
}

static void freeSchemaCP (
    SchemaCP *pattern

                REMEMBER_PATTERN (cp);
                Tcl_SetHashValue (h, cp);
            }
            step->name = Tcl_GetHashKey (&sdata->element, h);
            if (lastStep) {
                lastStep->next = step;
            } else {
                if (field) kc->fields[field-1] = step;
                else kc->selector = step;
            }
            lastStep = step;
            t = savedt;
            break;
        case AxisChild:
            nextType = SCHEMA_STEP_ELEMENT;
            break;

    ClientData clientData,
    Tcl_Interp *interp,
    int objc,
    Tcl_Obj *const objv[]
    )
{
    SchemaData *sdata = GETASI;
    ast t;
    char *errMsg = NULL;
    KeyConstraint *kc, *kc1;
    int i, nrFields;
    Tcl_Obj *elm;

    CHECK_SI
    CHECK_TOPLEVEL
    checkNrArgs (3,4,"Expected: <selector> <fieldlist> ?<name>?");
    if (sdata->cp->type != SCHEMA_CTYPE_NAME) {
        SetResult ("The unique schema definition command is only "
                   "allowed as direct child of an element.");
    }
    
    if (xpathParse (Tcl_GetString (objv[1]), NULL, XPATH_EXPR,
                    sdata->prefixns, NULL, &t, &errMsg) < 0) {
        SetResult3 ("Error in selector xpath: '", errMsg, "");
        FREE (errMsg);
        return TCL_ERROR;
    }

    if (Tcl_ListObjLength (interp, objv[2], &nrFields) != TCL_OK) {
        SetResult ("The <fieldlist> argument must be a valid tcl list");
        xpathFreeAst (t);
        return TCL_ERROR;
    }
    
    kc = TMALLOC (KeyConstraint);
    memset (kc, 0, sizeof (KeyConstraint));
    kc->fields = MALLOC (sizeof (KeyStep*) * nrFields);

    if (processSchemaXPath (interp, sdata, kc, NULL, SCHEMA_STEP_NONE, t, 0, 1)
        != TCL_OK) {
        xpathFreeAst (t);
        freeKeyConstraints (kc);
        return TCL_ERROR;
    }
    xpathFreeAst (t);

    for (i = 0; i < nrFields; i++) {
        Tcl_ListObjIndex (interp, objv[2], i, &elm);
        if (xpathParse (Tcl_GetString (elm), NULL, XPATH_EXPR,
                        sdata->prefixns, NULL, &t, &errMsg) < 0) {
            SetResult3 ("Error in field xpath: '", errMsg, "");
            FREE (errMsg);
            xpathFreeAst (t);
            freeKeyConstraints (kc);
            return TCL_ERROR;
        }
        if (processSchemaXPath (interp, sdata, kc, NULL, SCHEMA_STEP_NONE, t, i+1, 1)
            != TCL_OK) {
            xpathFreeAst (t);

            freeKeyConstraints (kc);
            return TCL_ERROR;
        }
        xpathFreeAst (t);
    }
    if (objc == 4) {
        kc->name = tdomstrdup (Tcl_GetString (objv[3]));
    }
    if (sdata->cp->localkeys) {
        kc1 = sdata->cp->localkeys;
        while (kc1->next) kc1 = kc1->next;
        kc1->next = kc;
    } else {
        sdata->cp->localkeys = kc;
    }

|   License for the specific language governing rights and limitations
|   under the License.
|
|   Contributor(s):
|
|
|   written by Rolf Ade
|   2018-2019
|
\---------------------------------------------------------------------------*/

#ifndef __SCHEMA_H__
#define __SCHEMA_H__

typedef enum {

    StepType type;
    char    *name;
    char    *ns;
    struct KeyStep *next;
} KeyStep;

typedef struct KeyConstraint {
    char     *name;
    KeyType   type;
    KeyStep  *selector;
    KeyStep  **fields;
    int       nrFields;
    struct KeyConstraint *next;
} KeyConstraint;

typedef struct SchemaCP
{
    Schema_CP_Type    type;
    char             *namespace;

        //a
        a/@ref
        a/b/c
        a//b/c
        (.//b|a)/c
        ns1:a
        a/.//b/c
        {}
        {    }
        "
                "
    } {
        tdom::schema s
        lappend result [catch {s define $schema} errMsg]
        #puts $errMsg
        s delete
    }
    set result
} {0 1 1 0 1 1 1 1 0 1 1 0 1 1 0 1 1 1 1}

test schema-19.3 {unique} {
    tdom::schema s
    s define {
        defelement doc {
            unique item @lang
            element item * {
                attribute lang
            }
        }
    }
    set result [list]
    foreach xml {
        {<doc><item lang="de"/><item lang="en"/><item lang="fr"/></doc>}
    } {
        lappend result [s validate $xml]
    }
    s delete
    set result
} {1}

test schema-19.4 {unique} {
    tdom::schema s
    s define {
        defelement doc {
            unique item {@lang @sub} "Combined field unique constraint"
            element item * {
                attribute lang
            }
        }
    }
    set result [list]
    foreach xml {
        {<doc><item lang="de"/><item lang="en"/><item lang="fr"/></doc>}
    } {
        lappend result [s validate $xml]
    }
    s delete
    set result
} {1}

}