1 /*
   2  * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
   3  */
   4 /*
   5  * Copyright 2001-2004 The Apache Software Foundation.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *     http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  */
  19 
  20 package com.sun.org.apache.xalan.internal.xsltc.compiler;
  21 
  22 import com.sun.org.apache.bcel.internal.generic.ALOAD;
  23 import com.sun.org.apache.bcel.internal.generic.ASTORE;
  24 import com.sun.org.apache.bcel.internal.generic.CHECKCAST;
  25 import com.sun.org.apache.bcel.internal.generic.ConstantPoolGen;
  26 import com.sun.org.apache.bcel.internal.generic.INVOKEINTERFACE;
  27 import com.sun.org.apache.bcel.internal.generic.INVOKEVIRTUAL;
  28 import com.sun.org.apache.bcel.internal.generic.InstructionList;
  29 import com.sun.org.apache.bcel.internal.generic.LocalVariableGen;
  30 import com.sun.org.apache.bcel.internal.generic.PUSH;
  31 import com.sun.org.apache.xalan.internal.xsltc.compiler.util.ClassGenerator;
  32 import com.sun.org.apache.xalan.internal.xsltc.compiler.util.ErrorMsg;
  33 import com.sun.org.apache.xalan.internal.xsltc.compiler.util.MethodGenerator;
  34 import com.sun.org.apache.xalan.internal.xsltc.compiler.util.ReferenceType;
  35 import com.sun.org.apache.xalan.internal.xsltc.compiler.util.Type;
  36 import com.sun.org.apache.xalan.internal.xsltc.compiler.util.TypeCheckError;
  37 import com.sun.org.apache.xalan.internal.xsltc.compiler.util.Util;
  38 import com.sun.org.apache.xml.internal.utils.XML11Char;
  39 
  40 /**
  41  * @author Jacek Ambroziak
  42  * @author Santiago Pericas-Geertsen
  43  * @author Morten Jorgensen
  44  * @author John Howard <JohnH@schemasoft.com>
  45  */
  46 final class WithParam extends Instruction {
  47 
  48     /**
  49      * Parameter's name.
  50      */
  51     private QName _name;
  52 
  53     /**
  54      * The escaped qname of the with-param.
  55      */
  56     protected String _escapedName;
  57 
  58     /**
  59      * Parameter's default value.
  60      */
  61     private Expression _select;
  62 
  63     /**
  64      * Reference to JVM variable holding temporary result tree.
  65      */
  66     private LocalVariableGen _domAdapter;
  67 
  68     /**
  69      * %OPT% This is set to true when the WithParam is used in a CallTemplate
  70      * for a simple named template. If this is true, the parameters are
  71      * passed to the named template through method arguments rather than
  72      * using the expensive Translet.addParameter() call.
  73      */
  74     private boolean _doParameterOptimization = false;
  75 
  76     /**
  77      * Displays the contents of this element
  78      */
  79     public void display(int indent) {
  80         indent(indent);
  81         Util.println("with-param " + _name);
  82         if (_select != null) {
  83             indent(indent + IndentIncrement);
  84             Util.println("select " + _select.toString());
  85         }
  86         displayContents(indent + IndentIncrement);
  87     }
  88 
  89     /**
  90      * Returns the escaped qname of the parameter
  91      */
  92     public String getEscapedName() {
  93         return _escapedName;
  94     }
  95 
  96     /**
  97      * Return the name of this WithParam.
  98      */
  99     public QName getName() {
 100         return _name;
 101     }
 102 
 103     /**
 104      * Set the name of the variable or paremeter. Escape all special chars.
 105      */
 106     public void setName(QName name) {
 107         _name = name;
 108         _escapedName = Util.escape(name.getStringRep());
 109     }
 110 
 111     /**
 112      * Set the do parameter optimization flag
 113      */
 114     public void setDoParameterOptimization(boolean flag) {
 115         _doParameterOptimization = flag;
 116     }
 117 
 118     /**
 119      * The contents of a <xsl:with-param> elements are either in the element's
 120      * 'select' attribute (this has precedence) or in the element body.
 121      */
 122     public void parseContents(Parser parser) {
 123         final String name = getAttribute("name");
 124         if (name.length() > 0) {
 125             if (!XML11Char.isXML11ValidQName(name)) {
 126                 ErrorMsg err = new ErrorMsg(ErrorMsg.INVALID_QNAME_ERR, name,
 127                                             this);
 128                 parser.reportError(Constants.ERROR, err);
 129             }
 130             setName(parser.getQNameIgnoreDefaultNs(name));
 131         } else {
 132             reportError(this, parser, ErrorMsg.REQUIRED_ATTR_ERR, "name");
 133         }
 134 
 135         final String select = getAttribute("select");
 136         if (select.length() > 0) {
 137             _select = parser.parseExpression(this, "select", null);
 138         }
 139 
 140         parseChildren(parser);
 141     }
 142 
 143     /**
 144      * Type-check either the select attribute or the element body, depending
 145      * on which is in use.
 146      */
 147     public Type typeCheck(SymbolTable stable) throws TypeCheckError {
 148         if (_select != null) {
 149             final Type tselect = _select.typeCheck(stable);
 150             if (tselect instanceof ReferenceType == false) {
 151                 _select = new CastExpr(_select, Type.Reference);
 152             }
 153         } else {
 154             typeCheckContents(stable);
 155         }
 156         return Type.Void;
 157     }
 158 
 159     /**
 160      * Compile the value of the parameter, which is either in an expression in
 161      * a 'select' attribute, or in the with-param element's body
 162      */
 163     public void translateValue(ClassGenerator classGen,
 164                                MethodGenerator methodGen)
 165     {
 166         // Compile expression is 'select' attribute if present
 167         if (_select != null) {
 168             _select.translate(classGen, methodGen);
 169             _select.startIterator(classGen, methodGen);
 170         // If not, compile result tree from parameter body if present.
 171         // Store result tree into local variable for releasing it later
 172         } else if (hasContents()) {
 173             final InstructionList il = methodGen.getInstructionList();
 174             compileResultTree(classGen, methodGen);
 175             _domAdapter = methodGen.addLocalVariable2("@" + _escapedName,
 176                                                       Type.ResultTree.toJCType(),
 177                                                       il.getEnd());
 178             il.append(DUP);
 179             il.append(new ASTORE(_domAdapter.getIndex()));
 180         // If neither are present then store empty string in parameter slot
 181         } else {
 182             final ConstantPoolGen cpg = classGen.getConstantPool();
 183             final InstructionList il = methodGen.getInstructionList();
 184             il.append(new PUSH(cpg, Constants.EMPTYSTRING));
 185         }
 186     }
 187 
 188     /**
 189      * This code generates a sequence of bytecodes that call the
 190      * addParameter() method in AbstractTranslet. The method call will add
 191      * (or update) the parameter frame with the new parameter value.
 192      */
 193     public void translate(ClassGenerator classGen, MethodGenerator methodGen) {
 194         final ConstantPoolGen cpg = classGen.getConstantPool();
 195         final InstructionList il = methodGen.getInstructionList();
 196 
 197         // Translate the value and put it on the stack
 198         if (_doParameterOptimization) {
 199             translateValue(classGen, methodGen);
 200             return;
 201         }
 202 
 203         // Make name acceptable for use as field name in class
 204         String name = Util.escape(getEscapedName());
 205 
 206         // Load reference to the translet (method is in AbstractTranslet)
 207         il.append(classGen.loadTranslet());
 208 
 209         // Load the name of the parameter
 210         il.append(new PUSH(cpg, name)); // TODO: namespace ?
 211         // Generete the value of the parameter (use value in 'select' by def.)
 212         translateValue(classGen, methodGen);
 213         // Mark this parameter value is not being the default value
 214         il.append(new PUSH(cpg, false));
 215         // Pass the parameter to the template
 216         il.append(new INVOKEVIRTUAL(cpg.addMethodref(TRANSLET_CLASS,
 217                                                      ADD_PARAMETER,
 218                                                      ADD_PARAMETER_SIG)));
 219         il.append(POP); // cleanup stack
 220     }
 221 
 222     /**
 223      * Release the compiled result tree.
 224      */
 225     public void releaseResultTree(ClassGenerator classGen,
 226                                   MethodGenerator methodGen)
 227     {
 228         if (_domAdapter != null) {
 229             final ConstantPoolGen cpg = classGen.getConstantPool();
 230             final InstructionList il = methodGen.getInstructionList();
 231             if (classGen.getStylesheet().callsNodeset() &&
 232                 classGen.getDOMClass().equals(MULTI_DOM_CLASS))
 233             {
 234                 final int removeDA =
 235                     cpg.addMethodref(MULTI_DOM_CLASS, "removeDOMAdapter",
 236                                      "(" + DOM_ADAPTER_SIG + ")V");
 237                 il.append(methodGen.loadDOM());
 238                 il.append(new CHECKCAST(cpg.addClass(MULTI_DOM_CLASS)));
 239                 il.append(new ALOAD(_domAdapter.getIndex()));
 240                 il.append(new CHECKCAST(cpg.addClass(DOM_ADAPTER_CLASS)));
 241                 il.append(new INVOKEVIRTUAL(removeDA));
 242             }
 243             final int release =
 244                 cpg.addInterfaceMethodref(DOM_IMPL_CLASS, "release", "()V");
 245             il.append(new ALOAD(_domAdapter.getIndex()));
 246             il.append(new INVOKEINTERFACE(release, 1));
 247             _domAdapter.setEnd(il.getEnd());
 248             methodGen.removeLocalVariable(_domAdapter);
 249             _domAdapter = null;
 250         }
 251     }
 252 }