/**
* Adds the specified namespace to the namespace array. If the prefix is already used for another
* URI, a new name is generated.
*
* @param pref prefix
* @param uri uri
* @param ns namespaces
* @return resulting prefix
*/
private static byte[] addNS(final byte[] pref, final byte[] uri, final Atts ns) {
final byte[] u = ns.string(pref);
if (u == null) {
// add undeclared namespace
ns.add(pref, uri);
} else if (!eq(u, uri)) {
// prefixes with different URIs exist; new one must be replaced
byte[] apref = null;
// check if one of the existing prefixes can be adopted
for (int c = 0; c < ns.size(); c++) {
if (eq(ns.string(c), uri)) apref = ns.name(c);
}
// if negative, generate a new one that is not used yet
if (apref == null) {
int i = 1;
do {
apref = concat(pref, new byte[] {'_'}, token(i++));
} while (ns.contains(apref));
ns.add(apref, uri);
}
return apref;
}
return null;
}
/**
* Adds namespaces to the namespace stack.
*
* @param ctx query context
* @return old stack position
*/
private int prepare(final QueryContext ctx) {
final int s = ctx.sc.ns.size();
for (int n = 0; n < nspaces.size(); n++) {
ctx.sc.ns.add(nspaces.name(n), nspaces.string(n));
}
return s;
}
/**
* Inherits namespaces.
*
* @param node to be modified
* @param nsp in-scope namespaces
*/
private static void inherit(final ANode node, final Atts nsp) {
final Atts ns = node.namespaces();
for (int a = nsp.size() - 1; a >= 0; a--) {
final byte[] pref = nsp.name(a);
if (!ns.contains(pref)) ns.add(pref, nsp.string(a));
}
}
@Override
public FElem item(final QueryContext ctx, final InputInfo ii) throws QueryException {
final int s = prepare(ctx);
try {
// adds in-scope namespaces
final Atts ns = new Atts();
for (int i = 0; i < nspaces.size(); ++i) {
ns.add(nspaces.name(i), nspaces.string(i));
}
// create and check QName
final QNm nm = qname(ctx, ii);
final byte[] cp = nm.prefix(), cu = nm.uri();
if (eq(cp, XML) ^ eq(cu, XMLURI)) CEXML.thrw(input, cu, cp);
if (eq(cu, XMLNSURI)) CEINV.thrw(input, cu);
if (eq(cp, XMLNS)) CEINV.thrw(input, cp);
// analyze element namespace unless it is "xml"
if (!eq(cp, XML)) {
// request namespace for the specified uri
final byte[] uri = ctx.sc.ns.uri(cp);
// check if element has a namespace
if (nm.hasURI()) {
// add to statically known namespaces
if (!comp && (uri == null || !eq(uri, cu))) ctx.sc.ns.add(cp, cu);
// add to in-scope namespaces
if (!ns.contains(cp)) ns.add(cp, cu);
} else {
// element has no namespace: assign default uri
nm.uri(uri);
}
}
// create child and attribute nodes
final Constr constr = new Constr(ii, ctx).add(expr);
if (constr.errAtt) NOATTALL.thrw(input);
if (constr.errNS) NONSALL.thrw(input);
if (constr.duplAtt != null) (comp ? CATTDUPL : ATTDUPL).thrw(input, constr.duplAtt);
if (constr.duplNS != null) DUPLNSCONS.thrw(input, constr.duplNS);
// create node
final FElem node = new FElem(nm, constr.children, constr.atts, ns);
// add namespaces from constructor
final Atts cns = constr.nspaces;
for (int a = 0; a < cns.size(); ++a) {
addNS(cns.name(a), cns.string(a), ns);
}
// update parent references of attributes and add namespaces
for (int a = 0; a < constr.atts.size(); ++a) {
constr.atts.get(a).parent(node);
final ANode att = constr.atts.get(a);
final QNm qnm = att.qname();
// skip attributes without prefixes or URIs
if (!qnm.hasPrefix() || !qnm.hasURI()) continue;
// skip XML namespace
final byte[] apref = qnm.prefix();
if (eq(apref, XML)) continue;
final byte[] auri = qnm.uri();
final byte[] npref = addNS(apref, auri, ns);
if (npref != null) {
constr.atts.item[a] =
new FAttr(new QNm(concat(npref, COLON, qnm.local()), auri), att.string());
}
}
// add inherited namespaces
final Atts stack = ctx.sc.ns.stack();
for (int a = stack.size() - 1; a >= 0; a--) {
final byte[] pref = stack.name(a);
if (!ns.contains(pref)) ns.add(pref, stack.string(a));
}
// update parent references of children
for (int c = 0; c < constr.children.size(); ++c) {
final ANode child = constr.children.get(c).parent(node);
// add inherited and remove unused namespaces
if (child.type == NodeType.ELM) {
if (ctx.sc.nsInherit) inherit(child, ns);
if (!ctx.sc.nsPreserve) noPreserve(child);
child.optimize();
}
}
// return generated and optimized node
return node.optimize();
} finally {
ctx.sc.ns.size(s);
}
}
/**
* Finds the prefix for the specified uri.
*
* @param uri namespace uri
* @return prefix, or empty string
*/
public static byte[] prefix(final byte[] uri) {
for (int s = NS.size() - 1; s >= 0; s--) {
if (eq(NS.string(s), uri)) return NS.name(s);
}
return EMPTY;
}
/**
* Finds the specified namespace uri.
*
* @param pref prefix of the namespace
* @return uri, or {@code null}
*/
public static byte[] uri(final byte[] pref) {
for (int s = NS.size() - 1; s >= 0; s--) {
if (eq(NS.name(s), pref)) return NS.string(s);
}
return null;
}
/**
* Checks if the specified uri is a reserved namespace.
*
* @param uri uri to be checked
* @return result of check
*/
public static boolean reserved(final byte[] uri) {
for (int s = RESERVED - 1; s >= 0; s--) {
if (eq(NS.string(s), uri)) return true;
}
return false;
}