literalelement.java

java1.6众多例子参考

		addAttribute(attr);
		attr.setParent(this);
		attr.parseContents(parser);
	    }
	}

	// Register all namespaces that are in scope, except for those that
	// are listed in the xsl:stylesheet element's *-prefixes attributes
	final Enumeration include = getNamespaceScope(this);
	while (include.hasMoreElements()) {
	    final String prefix = (String)include.nextElement();
	    if (!prefix.equals("xml")) {
		final String uri = lookupNamespace(prefix);
		if (uri != null && !stable.isExcludedNamespace(uri)) {
		    registerNamespace(prefix, uri, stable, true);
		}
	    }
	}

	parseChildren(parser);

	// Process all attributes and register all namespaces they use
	for (int i = 0; i < count; i++) {
	    final QName qname = parser.getQName(_attributes.getQName(i));
	    final String val = _attributes.getValue(i);

	    // Handle xsl:extension-element-prefixes
	    if (qname == parser.getExtensionElementPrefixes()) {
		stable.unExcludeNamespaces(val);
	    }
	    // Handle xsl:exclude-result-prefixes
	    else if (qname == parser.getExcludeResultPrefixes()) {
		stable.unExcludeNamespaces(val);
	    }
	}
    }

    protected boolean contextDependent() {
	return dependentContents();
    }

    /**
     * Compiles code that emits the literal element to the output handler,
     * first the start tag, then namespace declaration, then attributes,
     * then the element contents, and then the element end tag. Since the
     * value of an attribute may depend on a variable, variables must be
     * compiled first.
     */
    public void translate(ClassGenerator classGen, MethodGenerator methodGen) {

	final ConstantPoolGen cpg = classGen.getConstantPool();
	final InstructionList il = methodGen.getInstructionList();

        // Check whether all attributes are unique.
        _allAttributesUnique = checkAttributesUnique();

	// Compile code to emit element start tag
	il.append(methodGen.loadHandler());
	
	il.append(new PUSH(cpg, _name));
	il.append(DUP2); 		// duplicate these 2 args for endElement
	il.append(methodGen.startElement());

	// The value of an attribute may depend on a (sibling) variable
    int j=0;
    while (j < elementCount())
    {
        final SyntaxTreeNode item = (SyntaxTreeNode) elementAt(j);
        if (item instanceof Variable) {
            item.translate(classGen, methodGen);
            removeElement(item);	// avoid translating it twice
            /* When removing an element we do not increment j
             * but the removal will reduce the value of elementCount()
             * so this loop WILL end. The next iteration will process
             * elementAt(j), but with the old element removed
             * we are actually processing the next element.
             */
	    }
        else
            j++;
	}

	// Compile code to emit namespace attributes
	if (_accessedPrefixes != null) {
	    boolean declaresDefaultNS = false;
	    Enumeration e = _accessedPrefixes.keys();

	    while (e.hasMoreElements()) {
		final String prefix = (String)e.nextElement();
		final String uri = (String)_accessedPrefixes.get(prefix);

		if (uri != Constants.EMPTYSTRING || 
			prefix != Constants.EMPTYSTRING) 
		{
		    if (prefix == Constants.EMPTYSTRING) {
			declaresDefaultNS = true;
		    }
		    il.append(methodGen.loadHandler());
		    il.append(new PUSH(cpg,prefix));
		    il.append(new PUSH(cpg,uri));
		    il.append(methodGen.namespace());
		}
	    }

	    /* 
	     * If our XslElement parent redeclares the default NS, and this
	     * element doesn't, it must be redeclared one more time.
	     */
	    if (!declaresDefaultNS && (_parent instanceof XslElement)
		    && ((XslElement) _parent).declaresDefaultNS()) 
	    {
		il.append(methodGen.loadHandler());
		il.append(new PUSH(cpg, Constants.EMPTYSTRING));
		il.append(new PUSH(cpg, Constants.EMPTYSTRING));
		il.append(methodGen.namespace());
	    }
	}

	// Output all attributes
	if (_attributeElements != null) {
	    final int count = _attributeElements.size();
	    for (int i = 0; i < count; i++) {
		SyntaxTreeNode node = 
		    (SyntaxTreeNode)_attributeElements.elementAt(i);
		if (!(node instanceof XslAttribute)) {
		    node.translate(classGen, methodGen);
	        }
	    }
	}
	
	// Compile code to emit attributes and child elements
	translateContents(classGen, methodGen);

	// Compile code to emit element end tag
	il.append(methodGen.endElement());
    }

    /**
     * Return true if the output method is html.
     */
    private boolean isHTMLOutput() {
        return getStylesheet().getOutputMethod() == Stylesheet.HTML_OUTPUT;
    }
    
    /**
     * Return the ElemDesc object for an HTML element.
     * Return null if the output method is not HTML or this is not a 
     * valid HTML element.
     */
    public ElemDesc getElemDesc() {
    	if (isHTMLOutput()) {
    	    return ToHTMLStream.getElemDesc(_name);
    	}
    	else
    	    return null;
    }
    
    /**
     * Return true if all attributes of this LRE have unique names.
     */
    public boolean allAttributesUnique() {
    	return _allAttributesUnique;
    }
    
    /**
     * Check whether all attributes are unique.
     */
    private boolean checkAttributesUnique() {
    	 boolean hasHiddenXslAttribute = canProduceAttributeNodes(this, true);
    	 if (hasHiddenXslAttribute)
    	     return false;
    	 
    	 if (_attributeElements != null) {
    	     int numAttrs = _attributeElements.size();
    	     Hashtable attrsTable = null;
    	     for (int i = 0; i < numAttrs; i++) {
    	         SyntaxTreeNode node = (SyntaxTreeNode)_attributeElements.elementAt(i);
    	         
    	         if (node instanceof UseAttributeSets) {
    	             return false;
    	         }
    	         else if (node instanceof XslAttribute) {   	             
    	             if (attrsTable == null) {
    	             	attrsTable = new Hashtable();
    	                 for (int k = 0; k < i; k++) {
    	                     SyntaxTreeNode n = (SyntaxTreeNode)_attributeElements.elementAt(k);
    	                     if (n instanceof LiteralAttribute) {
    	                         LiteralAttribute literalAttr = (LiteralAttribute)n;
    	                         attrsTable.put(literalAttr.getName(), literalAttr);
    	                     }
    	                 }
    	             }
    	             
    	             XslAttribute xslAttr = (XslAttribute)node;
    	             AttributeValue attrName = xslAttr.getName();
    	             if (attrName instanceof AttributeValueTemplate) {
    	                 return false;
    	             }
    	             else if (attrName instanceof SimpleAttributeValue) {
    	                 SimpleAttributeValue simpleAttr = (SimpleAttributeValue)attrName;
    	                 String name = simpleAttr.toString();
    	                 if (name != null && attrsTable.get(name) != null)
    	                     return false;
    	                 else if (name != null) {
    	                     attrsTable.put(name, xslAttr);
    	                 }    	                 
    	             }
    	         }
    	     }
    	 }
    	 return true;
    }
    
    /**
     * Return true if the instructions under the given SyntaxTreeNode can produce attribute nodes
     * to an element. Only return false when we are sure that no attribute node is produced. 
     * Return true if we are not sure. If the flag ignoreXslAttribute is true, the direct 
     * <xsl:attribute> children of the current node are not included in the check.
     */
    private boolean canProduceAttributeNodes(SyntaxTreeNode node, boolean ignoreXslAttribute) {
    	Vector contents = node.getContents();
    	int size = contents.size();
    	for (int i = 0; i < size; i++) {
    	    SyntaxTreeNode child = (SyntaxTreeNode)contents.elementAt(i);
    	    if (child instanceof Text) {
    	    	Text text = (Text)child;
    	    	if (text.isIgnore())
    	    	    continue;
    	    	else
    	    	    return false;
    	    }
    	    // Cannot add an attribute to an element after children have been added to it.
    	    // We can safely return false when the instruction can produce an output node.
   	    else if (child instanceof LiteralElement
   	        || child instanceof ValueOf
   	        || child instanceof XslElement
   	        || child instanceof Comment
   	        || child instanceof Number
   	        || child instanceof ProcessingInstruction)
    	        return false;
    	    else if (child instanceof XslAttribute) {
    	    	if (ignoreXslAttribute)
    	    	    continue;
    	    	else
    	    	    return true;
    	    }
    	    // In general, there is no way to check whether <xsl:call-template> or 
    	    // <xsl:apply-templates> can produce attribute nodes. <xsl:copy> and
    	    // <xsl:copy-of> can also copy attribute nodes to an element. Return
    	    // true in those cases to be safe.
    	    else if (child instanceof CallTemplate
    	        || child instanceof ApplyTemplates
    	        || child instanceof Copy
    	        || child instanceof CopyOf)
    	        return true;
    	    else if ((child instanceof If
    	               || child instanceof ForEach)
    	             && canProduceAttributeNodes(child, false)) {
     	    	return true;
    	    }
    	    else if (child instanceof Choose) {
    	    	Vector chooseContents = child.getContents();
    	    	int num = chooseContents.size();
    	    	for (int k = 0; k < num; k++) {
    	    	    SyntaxTreeNode chooseChild = (SyntaxTreeNode)chooseContents.elementAt(k);
    	    	    if (chooseChild instanceof When || chooseChild instanceof Otherwise) {
    	    	    	if (canProduceAttributeNodes(chooseChild, false))
    	    	    	    return true;
    	    	    }
    	    	}
    	    }
    	}
    	return false;
    }
    
}