while (prefixMappings[i]) {
            if (strcmp (prefix, prefixMappings[i]) == 0) {
                return prefixMappings[i+1];
            }
            i += 2;
        }
    }
    if (node) {
        ns = domLookupPrefix (node, prefix);
        if (ns) return ns->uri;
    }
    return NULL;
}

/*---------------------------------------------------------------------------
|   domLookupPrefix
|
\--------------------------------------------------------------------------*/
domNS *

|
\---------------------------------------------------------------------------*/

#ifndef TDOM_NO_SCHEMA

#include <tdom.h>
#include <tcldom.h>
#include <domxpath.h>
#include <schema.h>

/* #define DEBUG */
/* #define DDEBUG */
/*----------------------------------------------------------------------------
|   Debug Macros
|

        pattern->content[i-1] = (SchemaCP *) objv[i];
        Tcl_IncrRefCount (objv[i]);
    }
    pattern->nc = objc;
    addToContent (sdata, pattern, SCHEMA_CQUANT_ONE, 0, 0);
    return TCL_OK;
}

extern void printAst (int depth, ast t);
static int
processSchemaXPath (
    Tcl_Interp *interp,
    ast t,
    int field
    )
{
    while (t) {
        switch (t->type) {
        case IsElement:
        case IsFQElement:
        case IsNSElement:
        case EvalSteps:
        case CombineSets:
            /* Only on top level? */
        case AxisAttribute:
        case AxisChild:
        case AxisDescendant:
        case GetContextNode:
        case AxisSelf:
        case IsNSAttr:
        case IsAttr:
            break;
        default:
            SetResult ("Not a reduced XPath expression.");
            printAst (0, t);
            return TCL_ERROR;
        }
        if (!field && (t->type == IsAttr || t->type == IsNSAttr)) {
            SetResult ("Attribute selection is only possible in reduced "
                       "XPath expression for field selectors.");
            return TCL_ERROR;
        }
        if (t->child) {
            if (processSchemaXPath (interp, t->child, field) != TCL_OK) {
                return TCL_ERROR;
            }
        }
        t = t->next;
    }
    return TCL_OK;
    
}

static int
uniquePatternCmd (
    ClientData clientData,
    Tcl_Interp *interp,
    int objc,
    Tcl_Obj *const objv[]
    )
{
    SchemaData *sdata = GETASI;
    ast s, f;
    char *errMsg = NULL;

    CHECK_SI
    CHECK_TOPLEVEL
    checkNrArgs (3,3,"Expected: <selector> <fieldlist>");

    if (xpathParse (Tcl_GetString (objv[1]), NULL, XPATH_EXPR,
                    NULL, NULL, &s, &errMsg) < 0) {
        SetResult3 ("Error in selector xpath: '", errMsg, "");
        FREE (errMsg);
        return TCL_ERROR;
    }
    if (processSchemaXPath (interp, s, 0) != TCL_OK) {
        xpathFreeAst (s);
        return TCL_ERROR;
    }
    printAst (0, s);
    
    return TCL_OK;
}

static int
integerImpl (
    Tcl_Interp *interp,
    void *constraintData,
    char *text
    )

                          NamespacePatternObjCmd, NULL, NULL);
    Tcl_CreateObjCommand (interp, "tdom::schema::text",
                          TextPatternObjCmd, NULL, NULL);

    /* The 'virtual' "tcl" definition command */
    Tcl_CreateObjCommand (interp, "tdom::schema::tcl",
                          VirtualPatternObjCmd, NULL, NULL);

    /* Identity definition commands */
    Tcl_CreateObjCommand (interp,"tdom::schema::unique",
                          uniquePatternCmd, NULL, NULL);

    /* The text constraint commands */
    Tcl_CreateObjCommand (interp,"tdom::schema::text::integer",
                          integerTCObjCmd, NULL, NULL);
    Tcl_CreateObjCommand (interp, "tdom::schema::text::tcl",
                          tclTCObjCmd, NULL, NULL);
    Tcl_CreateObjCommand (interp, "tdom::schema::text::fixed",
                          fixedTCObjCmd, NULL, NULL);

proc postValidation {g xml} {
    set doc [dom parse $xml]
    set rc [$g domvalidate $doc errMsg]
    $doc delete
    return $rc
}

test schema-19.1 {unique} {
    tdom::schema s
    s define {
        defelement doc {
            element a *
            element b *
            unique a @ref
        }
        defelement a {
            attribute ref
        }
        defelement b {
            attribute ref ?
        }
    }
    set result [list]
    foreach xml {
        <doc/>
        <doc><b/></doc>
        <doc><a/></doc>
        {<doc><a ref="1"/><a ref="foo"/></doc>}
    } {
        lappend result [s validate $xml errMsg]
        puts $errMsg
    }
    s delete
    set result
} {1 1 0 1}


test schema-19.2 {unique} {
    set schema {
        defelement doc {
            unique {${::schema-19.2}} @ref
        }
    }
    set result [list]
    foreach selector {
        a
        ./../a
        /foo
        a/b
        {a | b}
        a|b
        .//a
    } {
        set ::schema-19.2 $selector
        tdom::schema s
        lappend result [catch {s define [subst $schema]} errMsg]
        puts $errMsg
        s delete
    }
    set result
} {0 1 1 0 0 0}

}