View Javadoc
1   /*
2    * reserved comment block
3    * DO NOT REMOVE OR ALTER!
4    */
5   /*
6    * Copyright 2001-2004 The Apache Software Foundation.
7    *
8    * Licensed under the Apache License, Version 2.0 (the "License");
9    * you may not use this file except in compliance with the License.
10   * 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   * $Id: VariableBase.java,v 1.5 2005/09/28 13:48:18 pvedula Exp $
22   */
23  
24  package com.sun.org.apache.xalan.internal.xsltc.compiler;
25  
26  import java.util.Vector;
27  
28  import com.sun.org.apache.bcel.internal.generic.ConstantPoolGen;
29  import com.sun.org.apache.bcel.internal.generic.Instruction;
30  import com.sun.org.apache.bcel.internal.generic.InstructionList;
31  import com.sun.org.apache.bcel.internal.generic.INVOKESPECIAL;
32  import com.sun.org.apache.bcel.internal.generic.LocalVariableGen;
33  import com.sun.org.apache.bcel.internal.generic.NEW;
34  import com.sun.org.apache.bcel.internal.generic.PUSH;
35  import com.sun.org.apache.xalan.internal.xsltc.compiler.util.ClassGenerator;
36  import com.sun.org.apache.xalan.internal.xsltc.compiler.util.ErrorMsg;
37  import com.sun.org.apache.xalan.internal.xsltc.compiler.util.MethodGenerator;
38  import com.sun.org.apache.xalan.internal.xsltc.compiler.util.NodeSetType;
39  import com.sun.org.apache.xalan.internal.xsltc.compiler.util.Type;
40  import com.sun.org.apache.xalan.internal.xsltc.compiler.util.Util;
41  import com.sun.org.apache.xml.internal.utils.XML11Char;
42  
43  /**
44   * @author Jacek Ambroziak
45   * @author Santiago Pericas-Geertsen
46   * @author Morten Jorgensen
47   * @author Erwin Bolwidt <ejb@klomp.org>
48   * @author John Howard <JohnH@schemasoft.com>
49   */
50  class VariableBase extends TopLevelElement {
51  
52      protected QName       _name;            // The name of the variable.
53      protected String      _escapedName;        // The escaped qname of the variable.
54      protected Type        _type;            // The type of this variable.
55      protected boolean     _isLocal;         // True if the variable is local.
56      protected LocalVariableGen _local;      // Reference to JVM variable
57      protected Instruction _loadInstruction; // Instruction to load JVM variable
58      protected Instruction _storeInstruction; // Instruction to load JVM variable
59      protected Expression  _select;          // Reference to variable expression
60      protected String      select;           // Textual repr. of variable expr.
61  
62      // References to this variable (when local)
63      protected Vector      _refs = new Vector(2);
64  
65      // Dependencies to other variables/parameters (for globals only)
66      protected Vector      _dependencies = null;
67  
68      // Used to make sure parameter field is not added twice
69      protected boolean    _ignore = false;
70  
71      /**
72       * Disable this variable/parameter
73       */
74      public void disable() {
75          _ignore = true;
76      }
77  
78      /**
79       * Add a reference to this variable. Called by VariableRef when an
80       * expression contains a reference to this variable.
81       */
82      public void addReference(VariableRefBase vref) {
83          _refs.addElement(vref);
84      }
85  
86      /**
87       * When a variable is overriden by another, e.g. via xsl:import,
88       * its references need to be copied or otherwise it may be
89       * compiled away as dead code. This method can be used for that
90       * purpose.
91       */
92      public void copyReferences(VariableBase var) {
93          final int size = _refs.size();
94          for (int i = 0; i < size; i++) {
95              var.addReference((VariableRefBase) _refs.get(i));
96          }
97      }
98  
99      /**
100      * Map this variable to a register
101      */
102     public void mapRegister(MethodGenerator methodGen) {
103         if (_local == null) {
104             final InstructionList il = methodGen.getInstructionList();
105             final String name = getEscapedName(); // TODO: namespace ?
106             final com.sun.org.apache.bcel.internal.generic.Type varType = _type.toJCType();
107             _local = methodGen.addLocalVariable2(name, varType, il.getEnd());
108         }
109     }
110 
111     /**
112      * Remove the mapping of this variable to a register.
113      * Called when we leave the AST scope of the variable's declaration
114      */
115     public void unmapRegister(MethodGenerator methodGen) {
116         if (_local != null) {
117             _local.setEnd(methodGen.getInstructionList().getEnd());
118             methodGen.removeLocalVariable(_local);
119             _refs = null;
120             _local = null;
121         }
122     }
123 
124     /**
125      * Returns an instruction for loading the value of this variable onto
126      * the JVM stack.
127      */
128     public Instruction loadInstruction() {
129         final Instruction instr = _loadInstruction;
130         if (_loadInstruction == null) {
131             _loadInstruction = _type.LOAD(_local.getIndex());
132         }
133         return _loadInstruction;
134     }
135 
136     /**
137      * Returns an instruction for storing a value from the JVM stack
138      * into this variable.
139      */
140     public Instruction storeInstruction() {
141         final Instruction instr = _storeInstruction;
142         if (_storeInstruction == null) {
143             _storeInstruction = _type.STORE(_local.getIndex());
144         }
145         return _storeInstruction;
146     }
147 
148     /**
149      * Returns the expression from this variable's select attribute (if any)
150      */
151     public Expression getExpression() {
152         return(_select);
153     }
154 
155     /**
156      * Display variable as single string
157      */
158     public String toString() {
159         return("variable("+_name+")");
160     }
161 
162     /**
163      * Display variable in a full AST dump
164      */
165     public void display(int indent) {
166         indent(indent);
167         System.out.println("Variable " + _name);
168         if (_select != null) {
169             indent(indent + IndentIncrement);
170             System.out.println("select " + _select.toString());
171         }
172         displayContents(indent + IndentIncrement);
173     }
174 
175     /**
176      * Returns the type of the variable
177      */
178     public Type getType() {
179         return _type;
180     }
181 
182     /**
183      * Returns the name of the variable or parameter as it will occur in the
184      * compiled translet.
185      */
186     public QName getName() {
187         return _name;
188     }
189 
190     /**
191      * Returns the escaped qname of the variable or parameter
192      */
193     public String getEscapedName() {
194         return _escapedName;
195     }
196 
197     /**
198      * Set the name of the variable or paremeter. Escape all special chars.
199      */
200     public void setName(QName name) {
201         _name = name;
202         _escapedName = Util.escape(name.getStringRep());
203     }
204 
205     /**
206      * Returns the true if the variable is local
207      */
208     public boolean isLocal() {
209         return _isLocal;
210     }
211 
212     /**
213      * Parse the contents of the <xsl:decimal-format> element.
214      */
215     public void parseContents(Parser parser) {
216         // Get the 'name attribute
217         String name = getAttribute("name");
218 
219         if (name.length() > 0) {
220             if (!XML11Char.isXML11ValidQName(name)) {
221                 ErrorMsg err = new ErrorMsg(ErrorMsg.INVALID_QNAME_ERR, name, this);
222                 parser.reportError(Constants.ERROR, err);
223             }
224             setName(parser.getQNameIgnoreDefaultNs(name));
225         }
226         else
227             reportError(this, parser, ErrorMsg.REQUIRED_ATTR_ERR, "name");
228 
229         // Check whether variable/param of the same name is already in scope
230         VariableBase other = parser.lookupVariable(_name);
231         if ((other != null) && (other.getParent() == getParent())) {
232             reportError(this, parser, ErrorMsg.VARIABLE_REDEF_ERR, name);
233         }
234 
235         select = getAttribute("select");
236         if (select.length() > 0) {
237             _select = getParser().parseExpression(this, "select", null);
238             if (_select.isDummy()) {
239                 reportError(this, parser, ErrorMsg.REQUIRED_ATTR_ERR, "select");
240                 return;
241             }
242         }
243 
244         // Children must be parsed first -> static scoping
245         parseChildren(parser);
246     }
247 
248     /**
249      * Compile the value of the variable, which is either in an expression in
250      * a 'select' attribute, or in the variable elements body
251      */
252     public void translateValue(ClassGenerator classGen,
253                                MethodGenerator methodGen) {
254         // Compile expression is 'select' attribute if present
255         if (_select != null) {
256             _select.translate(classGen, methodGen);
257             // Create a CachedNodeListIterator for select expressions
258             // in a variable or parameter.
259             if (_select.getType() instanceof NodeSetType) {
260                 final ConstantPoolGen cpg = classGen.getConstantPool();
261                 final InstructionList il = methodGen.getInstructionList();
262 
263                 final int initCNI = cpg.addMethodref(CACHED_NODE_LIST_ITERATOR_CLASS,
264                                             "<init>",
265                                             "("
266                                             +NODE_ITERATOR_SIG
267                                             +")V");
268                 il.append(new NEW(cpg.addClass(CACHED_NODE_LIST_ITERATOR_CLASS)));
269                 il.append(DUP_X1);
270                 il.append(SWAP);
271 
272                 il.append(new INVOKESPECIAL(initCNI));
273             }
274             _select.startIterator(classGen, methodGen);
275         }
276         // If not, compile result tree from parameter body if present.
277         else if (hasContents()) {
278             compileResultTree(classGen, methodGen);
279         }
280         // If neither are present then store empty string in variable
281         else {
282             final ConstantPoolGen cpg = classGen.getConstantPool();
283             final InstructionList il = methodGen.getInstructionList();
284             il.append(new PUSH(cpg, Constants.EMPTYSTRING));
285         }
286     }
287 
288 }