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

package com.sun.org.apache.xalan.internal.xsltc.compiler;

import java.util.Vector;

import com.sun.org.apache.bcel.internal.generic.CHECKCAST;
import com.sun.org.apache.bcel.internal.generic.ConstantPoolGen;
import com.sun.org.apache.bcel.internal.generic.Instruction;
import com.sun.org.apache.bcel.internal.generic.InstructionList;
import com.sun.org.apache.bcel.internal.generic.INVOKEINTERFACE;
import com.sun.org.apache.bcel.internal.generic.INVOKESPECIAL;
import com.sun.org.apache.bcel.internal.generic.INVOKEVIRTUAL;
import com.sun.org.apache.bcel.internal.generic.LocalVariableGen;
import com.sun.org.apache.bcel.internal.generic.NEW;
import com.sun.org.apache.bcel.internal.generic.PUSH;
import com.sun.org.apache.xalan.internal.xsltc.compiler.util.ClassGenerator;
import com.sun.org.apache.xalan.internal.xsltc.compiler.util.ErrorMsg;
import com.sun.org.apache.xalan.internal.xsltc.compiler.util.MethodGenerator;
import com.sun.org.apache.xalan.internal.xsltc.compiler.util.NodeSetType;
import com.sun.org.apache.xalan.internal.xsltc.compiler.util.ResultTreeType;
import com.sun.org.apache.xalan.internal.xsltc.compiler.util.Type;
import com.sun.org.apache.xalan.internal.xsltc.compiler.util.Util;
import com.sun.org.apache.xml.internal.utils.XML11Char;

Author:Jacek Ambroziak, Santiago Pericas-Geertsen, Morten Jorgensen, Erwin Bolwidt , John Howard
/** * @author Jacek Ambroziak * @author Santiago Pericas-Geertsen * @author Morten Jorgensen * @author Erwin Bolwidt <ejb@klomp.org> * @author John Howard <JohnH@schemasoft.com> */
class VariableBase extends TopLevelElement { protected QName _name; // The name of the variable. protected String _escapedName; // The escaped qname of the variable. protected Type _type; // The type of this variable. protected boolean _isLocal; // True if the variable is local. protected LocalVariableGen _local; // Reference to JVM variable protected Instruction _loadInstruction; // Instruction to load JVM variable protected Instruction _storeInstruction; // Instruction to load JVM variable protected Expression _select; // Reference to variable expression protected String select; // Textual repr. of variable expr. // References to this variable (when local) protected Vector<VariableRefBase> _refs = new Vector<>(2); // Used to make sure parameter field is not added twice protected boolean _ignore = false;
Disable this variable/parameter
/** * Disable this variable/parameter */
public void disable() { _ignore = true; }
Add a reference to this variable. Called by VariableRef when an expression contains a reference to this variable.
/** * Add a reference to this variable. Called by VariableRef when an * expression contains a reference to this variable. */
public void addReference(VariableRefBase vref) { _refs.addElement(vref); }
When a variable is overriden by another, e.g. via xsl:import, its references need to be copied or otherwise it may be compiled away as dead code. This method can be used for that purpose.
/** * When a variable is overriden by another, e.g. via xsl:import, * its references need to be copied or otherwise it may be * compiled away as dead code. This method can be used for that * purpose. */
public void copyReferences(VariableBase var) { final int size = _refs.size(); for (int i = 0; i < size; i++) { var.addReference(_refs.get(i)); } }
Map this variable to a register
/** * Map this variable to a register */
public void mapRegister(MethodGenerator methodGen) { if (_local == null) { final InstructionList il = methodGen.getInstructionList(); final String name = getEscapedName(); // TODO: namespace ? final com.sun.org.apache.bcel.internal.generic.Type varType = _type.toJCType(); _local = methodGen.addLocalVariable2(name, varType, il.getEnd()); } }
Remove the mapping of this variable to a register. Called when we leave the AST scope of the variable's declaration
/** * Remove the mapping of this variable to a register. * Called when we leave the AST scope of the variable's declaration */
public void unmapRegister(ClassGenerator classGen, MethodGenerator methodGen) { if (_local != null) { if (_type instanceof ResultTreeType) { final ConstantPoolGen cpg = classGen.getConstantPool(); final InstructionList il = methodGen.getInstructionList(); if (classGen.getStylesheet().callsNodeset() && classGen.getDOMClass().equals(MULTI_DOM_CLASS)) { final int removeDA = cpg.addMethodref(MULTI_DOM_CLASS, "removeDOMAdapter", "(" + DOM_ADAPTER_SIG + ")V"); il.append(methodGen.loadDOM()); il.append(new CHECKCAST(cpg.addClass(MULTI_DOM_CLASS))); il.append(loadInstruction()); il.append(new CHECKCAST(cpg.addClass(DOM_ADAPTER_CLASS))); il.append(new INVOKEVIRTUAL(removeDA)); } final int release = cpg.addInterfaceMethodref(DOM_IMPL_CLASS, "release", "()V"); il.append(loadInstruction()); il.append(new INVOKEINTERFACE(release, 1)); } _local.setEnd(methodGen.getInstructionList().getEnd()); methodGen.removeLocalVariable(_local); _refs = null; _local = null; } }
Returns an instruction for loading the value of this variable onto the JVM stack.
/** * Returns an instruction for loading the value of this variable onto * the JVM stack. */
public Instruction loadInstruction() { if (_loadInstruction == null) { _loadInstruction = _type.LOAD(_local.getIndex()); } return _loadInstruction; }
Returns an instruction for storing a value from the JVM stack into this variable.
/** * Returns an instruction for storing a value from the JVM stack * into this variable. */
public Instruction storeInstruction() { if (_storeInstruction == null) { _storeInstruction = _type.STORE(_local.getIndex()); } return _storeInstruction; }
Returns the expression from this variable's select attribute (if any)
/** * Returns the expression from this variable's select attribute (if any) */
public Expression getExpression() { return(_select); }
Display variable as single string
/** * Display variable as single string */
public String toString() { return("variable("+_name+")"); }
Display variable in a full AST dump
/** * Display variable in a full AST dump */
public void display(int indent) { indent(indent); System.out.println("Variable " + _name); if (_select != null) { indent(indent + IndentIncrement); System.out.println("select " + _select.toString()); } displayContents(indent + IndentIncrement); }
Returns the type of the variable
/** * Returns the type of the variable */
public Type getType() { return _type; }
Returns the name of the variable or parameter as it will occur in the compiled translet.
/** * Returns the name of the variable or parameter as it will occur in the * compiled translet. */
public QName getName() { return _name; }
Returns the escaped qname of the variable or parameter
/** * Returns the escaped qname of the variable or parameter */
public String getEscapedName() { return _escapedName; }
Set the name of the variable or paremeter. Escape all special chars.
/** * Set the name of the variable or paremeter. Escape all special chars. */
public void setName(QName name) { _name = name; _escapedName = Util.escape(name.getStringRep()); }
Returns the true if the variable is local
/** * Returns the true if the variable is local */
public boolean isLocal() { return _isLocal; }
Parse the contents of the element.
/** * Parse the contents of the <xsl:decimal-format> element. */
public void parseContents(Parser parser) { // Get the 'name attribute String name = getAttribute("name"); if (name.length() > 0) { if (!XML11Char.isXML11ValidQName(name)) { ErrorMsg err = new ErrorMsg(ErrorMsg.INVALID_QNAME_ERR, name, this); parser.reportError(Constants.ERROR, err); } setName(parser.getQNameIgnoreDefaultNs(name)); } else reportError(this, parser, ErrorMsg.REQUIRED_ATTR_ERR, "name"); // Check whether variable/param of the same name is already in scope VariableBase other = parser.lookupVariable(_name); if ((other != null) && (other.getParent() == getParent())) { reportError(this, parser, ErrorMsg.VARIABLE_REDEF_ERR, name); } select = getAttribute("select"); if (select.length() > 0) { _select = getParser().parseExpression(this, "select", null); if (_select.isDummy()) { reportError(this, parser, ErrorMsg.REQUIRED_ATTR_ERR, "select"); return; } } // Children must be parsed first -> static scoping parseChildren(parser); }
Compile the value of the variable, which is either in an expression in a 'select' attribute, or in the variable elements body
/** * Compile the value of the variable, which is either in an expression in * a 'select' attribute, or in the variable elements body */
public void translateValue(ClassGenerator classGen, MethodGenerator methodGen) { // Compile expression is 'select' attribute if present if (_select != null) { _select.translate(classGen, methodGen); // Create a CachedNodeListIterator for select expressions // in a variable or parameter. if (_select.getType() instanceof NodeSetType) { final ConstantPoolGen cpg = classGen.getConstantPool(); final InstructionList il = methodGen.getInstructionList(); final int initCNI = cpg.addMethodref(CACHED_NODE_LIST_ITERATOR_CLASS, "<init>", "(" +NODE_ITERATOR_SIG +")V"); il.append(new NEW(cpg.addClass(CACHED_NODE_LIST_ITERATOR_CLASS))); il.append(DUP_X1); il.append(SWAP); il.append(new INVOKESPECIAL(initCNI)); } _select.startIterator(classGen, methodGen); } // If not, compile result tree from parameter body if present. else if (hasContents()) { compileResultTree(classGen, methodGen); } // If neither are present then store empty string in variable else { final ConstantPoolGen cpg = classGen.getConstantPool(); final InstructionList il = methodGen.getInstructionList(); il.append(new PUSH(cpg, Constants.EMPTYSTRING)); } } }