rev 959 : 8162598: XSLTC transformer swallows empty namespace declaration which is needed to undeclare default namespace

   1 /*
   2  * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.
   3  */
   4 /*
   5  * Licensed to the Apache Software Foundation (ASF) under one or more
   6  * contributor license agreements.  See the NOTICE file distributed with
   7  * this work for additional information regarding copyright ownership.
   8  * The ASF licenses this file to You under the Apache License, Version 2.0
   9  * (the "License"); you may not use this file except in compliance with
  10  * the License.  You may obtain a copy of the License at
  11  *
  12  *     http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  */



  20 
  21 package com.sun.org.apache.xalan.internal.xsltc.compiler;
  22 
  23 import com.sun.org.apache.bcel.internal.generic.ALOAD;
  24 import com.sun.org.apache.bcel.internal.generic.ASTORE;
  25 import com.sun.org.apache.bcel.internal.generic.ConstantPoolGen;

  26 import com.sun.org.apache.bcel.internal.generic.INVOKESTATIC;
  27 import com.sun.org.apache.bcel.internal.generic.InstructionList;
  28 import com.sun.org.apache.bcel.internal.generic.LocalVariableGen;
  29 import com.sun.org.apache.bcel.internal.generic.PUSH;
  30 import com.sun.org.apache.xalan.internal.xsltc.compiler.util.ClassGenerator;
  31 import com.sun.org.apache.xalan.internal.xsltc.compiler.util.ErrorMsg;
  32 import com.sun.org.apache.xalan.internal.xsltc.compiler.util.MethodGenerator;
  33 import com.sun.org.apache.xalan.internal.xsltc.compiler.util.Type;
  34 import com.sun.org.apache.xalan.internal.xsltc.compiler.util.TypeCheckError;
  35 import com.sun.org.apache.xalan.internal.xsltc.compiler.util.Util;
  36 import com.sun.org.apache.xml.internal.utils.XML11Char;
  37 
  38 /**
  39  * @author Jacek Ambroziak
  40  * @author Santiago Pericas-Geertsen
  41  * @author Morten Jorgensen
  42  */
  43 final class XslElement extends Instruction {
  44 
  45     private String  _prefix;
  46     private boolean _ignore = false;
  47     private boolean _isLiteralName = true;
  48     private AttributeValueTemplate _name;
  49     private AttributeValueTemplate _namespace;
  50 
  51     /**
  52      * Displays the contents of the element
  53      */
  54     public void display(int indent) {
  55         indent(indent);
  56         Util.println("Element " + _name);
  57         displayContents(indent + IndentIncrement);
  58     }
  59 








  60     public void parseContents(Parser parser) {
  61         final SymbolTable stable = parser.getSymbolTable();
  62 
  63         // Handle the 'name' attribute
  64         String name = getAttribute("name");
  65         if (name == EMPTYSTRING) {
  66             ErrorMsg msg = new ErrorMsg(ErrorMsg.ILLEGAL_ELEM_NAME_ERR,
  67                                         name, this);
  68             parser.reportError(WARNING, msg);
  69             parseChildren(parser);
  70             _ignore = true;     // Ignore the element if the QName is invalid
  71             return;
  72         }
  73 
  74         // Get namespace attribute
  75         String namespace = getAttribute("namespace");
  76 
  77         // Optimize compilation when name is known at compile time
  78         _isLiteralName = Util.isLiteral(name);
  79         if (_isLiteralName) {
  80             if (!XML11Char.isXML11ValidQName(name)) {
  81                 ErrorMsg msg = new ErrorMsg(ErrorMsg.ILLEGAL_ELEM_NAME_ERR,
  82                                             name, this);
  83                 parser.reportError(WARNING, msg);
  84                 parseChildren(parser);
  85                 _ignore = true;         // Ignore the element if the QName is invalid
  86                 return;
  87             }
  88 
  89             final QName qname = parser.getQNameSafe(name);
  90             String prefix = qname.getPrefix();
  91             String local = qname.getLocalPart();
  92 
  93             if (prefix == null) {
  94                 prefix = EMPTYSTRING;
  95             }
  96 
  97             if (!hasAttribute("namespace")) {
  98                 namespace = lookupNamespace(prefix);
  99                 if (namespace == null) {
 100                     ErrorMsg err = new ErrorMsg(ErrorMsg.NAMESPACE_UNDEF_ERR,
 101                                                 prefix, this);
 102                     parser.reportError(WARNING, err);
 103                     parseChildren(parser);
 104                     _ignore = true;     // Ignore the element if prefix is undeclared
 105                     return;
 106                 }
 107                 _prefix = prefix;
 108                 _namespace = new AttributeValueTemplate(namespace, parser, this);
 109             }
 110             else {
 111                 if (prefix == EMPTYSTRING) {
 112                     if (Util.isLiteral(namespace)) {
 113                         prefix = lookupPrefix(namespace);
 114                         if (prefix == null) {
 115                             prefix = stable.generateNamespacePrefix();
 116                         }
 117                     }
 118 
 119                     // Prepend prefix to local name
 120                     final StringBuffer newName = new StringBuffer(prefix);
 121                     if (prefix != EMPTYSTRING) {
 122                         newName.append(':');
 123                     }
 124                     name = newName.append(local).toString();
 125                 }
 126                 _prefix = prefix;
 127                 _namespace = new AttributeValueTemplate(namespace, parser, this);
 128             }
 129         }
 130         else {
 131             _namespace = (namespace == EMPTYSTRING) ? null :
 132                          new AttributeValueTemplate(namespace, parser, this);
 133         }
 134 
 135         _name = new AttributeValueTemplate(name, parser, this);
 136 
 137         final String useSets = getAttribute("use-attribute-sets");
 138         if (useSets.length() > 0) {
 139             if (!Util.isValidQNames(useSets)) {
 140                 ErrorMsg err = new ErrorMsg(ErrorMsg.INVALID_QNAME_ERR, useSets, this);
 141                 parser.reportError(Constants.ERROR, err);
 142             }
 143             setFirstElement(new UseAttributeSets(useSets, parser));
 144         }
 145 
 146         parseChildren(parser);
 147     }
 148 
 149     /**
 150      * Run type check on element name & contents
 151      */
 152     public Type typeCheck(SymbolTable stable) throws TypeCheckError {
 153         if (!_ignore) {
 154             _name.typeCheck(stable);
 155             if (_namespace != null) {
 156                 _namespace.typeCheck(stable);
 157             }
 158         }
 159         typeCheckContents(stable);
 160         return Type.Void;
 161     }
 162 
 163     /**
 164      * This method is called when the name of the element is known at compile time.
 165      * In this case, there is no need to inspect the element name at runtime to
 166      * determine if a prefix exists, needs to be generated, etc.
 167      */
 168     public void translateLiteral(ClassGenerator classGen, MethodGenerator methodGen) {
 169         final ConstantPoolGen cpg = classGen.getConstantPool();
 170         final InstructionList il = methodGen.getInstructionList();
 171 
 172         if (!_ignore) {
 173             il.append(methodGen.loadHandler());
 174             _name.translate(classGen, methodGen);
 175             il.append(DUP2);
 176             il.append(methodGen.startElement());
 177 
 178             if (_namespace != null) {
 179                 il.append(methodGen.loadHandler());
 180                 il.append(new PUSH(cpg, _prefix));
 181                 _namespace.translate(classGen,methodGen);
 182                 il.append(methodGen.namespace());
 183             }
 184         }
 185 
 186         translateContents(classGen, methodGen);
 187 
 188         if (!_ignore) {
 189             il.append(methodGen.endElement());
 190         }
 191     }
 192 
 193     /**
 194      * At runtime the compilation of xsl:element results in code that: (i)
 195      * evaluates the avt for the name, (ii) checks for a prefix in the name
 196      * (iii) generates a new prefix and create a new qname when necessary
 197      * (iv) calls startElement() on the handler (v) looks up a uri in the XML
 198      * when the prefix is not known at compile time (vi) calls namespace()
 199      * on the handler (vii) evaluates the contents (viii) calls endElement().
 200      */
 201     public void translate(ClassGenerator classGen, MethodGenerator methodGen) {

 202         final ConstantPoolGen cpg = classGen.getConstantPool();
 203         final InstructionList il = methodGen.getInstructionList();
 204 
 205         // Optimize translation if element name is a literal
 206         if (_isLiteralName) {
 207             translateLiteral(classGen, methodGen);
 208             return;
 209         }
 210 
 211         if (!_ignore) {
 212 
 213             // if the qname is an AVT, then the qname has to be checked at runtime if it is a valid qname
 214             LocalVariableGen nameValue =
 215                     methodGen.addLocalVariable2("nameValue",
 216                                                 Util.getJCRefType(STRING_SIG),
 217                                                 null);
 218 
 219             // store the name into a variable first so _name.translate only needs to be called once
 220             _name.translate(classGen, methodGen);
 221             nameValue.setStart(il.append(new ASTORE(nameValue.getIndex())));
 222             il.append(new ALOAD(nameValue.getIndex()));
 223 
 224             // call checkQName if the name is an AVT
 225             final int check = cpg.addMethodref(BASIS_LIBRARY_CLASS, "checkQName",
 226                             "("
 227                             +STRING_SIG
 228                             +")V");
 229             il.append(new INVOKESTATIC(check));
 230 
 231             // Push handler for call to endElement()
 232             il.append(methodGen.loadHandler());
 233 
 234             // load name value again
 235             nameValue.setEnd(il.append(new ALOAD(nameValue.getIndex())));
 236 
 237             if (_namespace != null) {
 238                 _namespace.translate(classGen, methodGen);
 239             }
 240             else {
 241                 il.append(ACONST_NULL);
 242             }
 243 
 244             // Push additional arguments
 245             il.append(methodGen.loadHandler());
 246             il.append(methodGen.loadDOM());
 247             il.append(methodGen.loadCurrentNode());
 248 
 249             // Invoke BasisLibrary.startXslElemCheckQName()
 250             il.append(new INVOKESTATIC(
 251             cpg.addMethodref(BASIS_LIBRARY_CLASS, "startXslElement",
 252                     "(" + STRING_SIG
 253                     + STRING_SIG
 254                     + TRANSLET_OUTPUT_SIG
 255                     + DOM_INTF_SIG + "I)" + STRING_SIG)));
 256 
 257 
 258         }
 259 
 260         translateContents(classGen, methodGen);
 261 
 262         if (!_ignore) {
 263             il.append(methodGen.endElement());
 264         }
 265     }
 266 
 267     /**
 268      * Override this method to make sure that xsl:attributes are not
 269      * copied to output if this xsl:element is to be ignored
 270      */
 271     public void translateContents(ClassGenerator classGen,
 272                                   MethodGenerator methodGen) {
 273         final int n = elementCount();
 274         for (int i = 0; i < n; i++) {
 275             final SyntaxTreeNode item = getContents().get(i);
 276             if (_ignore && item instanceof XslAttribute) continue;
 277             item.translate(classGen, methodGen);
 278         }
 279     }
 280 
 281 }
--- EOF ---