• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Licensed to the Apache Software Foundation (ASF) under one
3  * or more contributor license agreements. See the NOTICE file
4  * distributed with this work for additional information
5  * regarding copyright ownership. The ASF licenses this file
6  * to you under the Apache License, Version 2.0 (the  "License");
7  * you may not use this file except in compliance with the License.
8  * You may obtain a copy of the License at
9  *
10  *     http://www.apache.org/licenses/LICENSE-2.0
11  *
12  * Unless required by applicable law or agreed to in writing, software
13  * distributed under the License is distributed on an "AS IS" BASIS,
14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15  * See the License for the specific language governing permissions and
16  * limitations under the License.
17  */
18 /*
19  * $Id: VariableStack.java 524812 2007-04-02 15:52:03Z zongaro $
20  */
21 package org.apache.xpath;
22 
23 import javax.xml.transform.TransformerException;
24 
25 import org.apache.xalan.res.XSLMessages;
26 import org.apache.xpath.objects.XObject;
27 import org.apache.xpath.res.XPATHErrorResources;
28 
29 /**
30  * Defines a class to keep track of a stack for
31  * template arguments and variables.
32  *
33  * <p>This has been changed from the previous incarnations of this
34  * class to be fairly low level.</p>
35  * @xsl.usage internal
36  */
37 public class VariableStack implements Cloneable
38 {
39   /**
40    * limitation for 1K
41    */
42   public static final int CLEARLIMITATION= 1024;
43 
44   /**
45    * Constructor for a variable stack.
46    */
VariableStack()47   public VariableStack()
48   {
49     reset();
50   }
51 
52   /**
53    * Constructor for a variable stack.
54    * @param initStackSize The initial stack size.  Must be at least one.  The
55    *                      stack can grow if needed.
56    */
VariableStack(int initStackSize)57   public VariableStack(int initStackSize)
58   {
59     // Allow for twice as many variables as stack link entries
60     reset(initStackSize, initStackSize*2);
61   }
62 
63   /**
64    * Returns a clone of this variable stack.
65    *
66    * @return  a clone of this variable stack.
67    *
68    * @throws CloneNotSupportedException
69    */
clone()70   public synchronized Object clone() throws CloneNotSupportedException
71   {
72 
73     VariableStack vs = (VariableStack) super.clone();
74 
75     // I *think* I can get away with a shallow clone here?
76     vs._stackFrames = (XObject[]) _stackFrames.clone();
77     vs._links = (int[]) _links.clone();
78 
79     return vs;
80   }
81 
82   /**
83    * The stack frame where all variables and params will be kept.
84    * @serial
85    */
86   XObject[] _stackFrames;
87 
88   /**
89    * The top of the stack frame (<code>_stackFrames</code>).
90    * @serial
91    */
92   int _frameTop;
93 
94   /**
95    * The bottom index of the current frame (relative to <code>_stackFrames</code>).
96    * @serial
97    */
98   private int _currentFrameBottom;
99 
100   /**
101    * The stack of frame positions.  I call 'em links because of distant
102    * <a href="http://math.millikin.edu/mprogers/Courses/currentCourses/CS481-ComputerArchitecture/cs481.Motorola68000.html">
103    * Motorola 68000 assembler</a> memories.  :-)
104    * @serial
105    */
106   int[] _links;
107 
108   /**
109    * The top of the links stack.
110    */
111   int _linksTop;
112 
113   /**
114    * Get the element at the given index, regardless of stackframe.
115    *
116    * @param i index from zero.
117    *
118    * @return The item at the given index.
119    */
elementAt(final int i)120   public XObject elementAt(final int i)
121   {
122     return _stackFrames[i];
123   }
124 
125   /**
126    * Get size of the stack.
127    *
128    * @return the total size of the execution stack.
129    */
size()130   public int size()
131   {
132     return _frameTop;
133   }
134 
135   /**
136    * Reset the stack to a start position.
137    */
reset()138   public void reset()
139   {
140     // If the stack was previously allocated, assume that about the same
141     // amount of stack space will be needed again; otherwise, use a very
142     // large stack size.
143     int linksSize = (_links == null) ? XPathContext.RECURSIONLIMIT
144                                      : _links.length;
145     int varArraySize = (_stackFrames == null) ? XPathContext.RECURSIONLIMIT * 2
146                                               : _stackFrames.length;
147     reset(linksSize, varArraySize);
148   }
149 
150   /**
151    * Reset the stack to a start position.
152    * @param linksSize Initial stack size to use
153    * @param varArraySize Initial variable array size to use
154    */
reset(int linksSize, int varArraySize)155   protected void reset(int linksSize, int varArraySize) {
156     _frameTop = 0;
157     _linksTop = 0;
158 
159     // Don't bother reallocating _links array if it exists already
160     if (_links == null) {
161       _links = new int[linksSize];
162     }
163 
164     // Adding one here to the stack of frame positions will allow us always
165     // to look one under without having to check if we're at zero.
166     // (As long as the caller doesn't screw up link/unlink.)
167     _links[_linksTop++] = 0;
168 
169     // Get a clean _stackFrames array and discard the old one.
170     _stackFrames = new XObject[varArraySize];
171   }
172 
173   /**
174    * Set the current stack frame.
175    *
176    * @param sf The new stack frame position.
177    */
setStackFrame(int sf)178   public void setStackFrame(int sf)
179   {
180     _currentFrameBottom = sf;
181   }
182 
183   /**
184    * Get the position from where the search should start,
185    * which is either the searchStart property, or the top
186    * of the stack if that value is -1.
187    *
188    * @return The current stack frame position.
189    */
getStackFrame()190   public int getStackFrame()
191   {
192     return _currentFrameBottom;
193   }
194 
195   /**
196    * Allocates memory (called a stackframe) on the stack; used to store
197    * local variables and parameter arguments.
198    *
199    * <p>I use the link/unlink concept because of distant
200    * <a href="http://math.millikin.edu/mprogers/Courses/currentCourses/CS481-ComputerArchitecture/cs481.Motorola68000.html">
201    * Motorola 68000 assembler</a> memories.</p>
202    *
203    * @param size The size of the stack frame allocation.  This ammount should
204    * normally be the maximum number of variables that you can have allocated
205    * at one time in the new stack frame.
206    *
207    * @return The bottom of the stack frame, from where local variable addressing
208    * should start from.
209    */
link(final int size)210   public int link(final int size)
211   {
212 
213     _currentFrameBottom = _frameTop;
214     _frameTop += size;
215 
216     if (_frameTop >= _stackFrames.length)
217     {
218       XObject newsf[] = new XObject[_stackFrames.length + XPathContext.RECURSIONLIMIT + size];
219 
220       System.arraycopy(_stackFrames, 0, newsf, 0, _stackFrames.length);
221 
222       _stackFrames = newsf;
223     }
224 
225     if (_linksTop + 1 >= _links.length)
226     {
227       int newlinks[] = new int[_links.length + (CLEARLIMITATION * 2)];
228 
229       System.arraycopy(_links, 0, newlinks, 0, _links.length);
230 
231       _links = newlinks;
232     }
233 
234     _links[_linksTop++] = _currentFrameBottom;
235 
236     return _currentFrameBottom;
237   }
238 
239   /**
240    * Free up the stack frame that was last allocated with
241    * {@link #link(int size)}.
242    */
unlink()243   public  void unlink()
244   {
245     _frameTop = _links[--_linksTop];
246     _currentFrameBottom = _links[_linksTop - 1];
247   }
248 
249   /**
250    * Free up the stack frame that was last allocated with
251    * {@link #link(int size)}.
252    * @param currentFrame The current frame to set to
253    * after the unlink.
254    */
unlink(int currentFrame)255   public  void unlink(int currentFrame)
256   {
257     _frameTop = _links[--_linksTop];
258     _currentFrameBottom = currentFrame;
259   }
260 
261   /**
262    * Set a local variable or parameter in the current stack frame.
263    *
264    *
265    * @param index Local variable index relative to the current stack
266    * frame bottom.
267    *
268    * @param val The value of the variable that is being set.
269    */
setLocalVariable(int index, XObject val)270   public void setLocalVariable(int index, XObject val)
271   {
272     _stackFrames[index + _currentFrameBottom] = val;
273   }
274 
275   /**
276    * Set a local variable or parameter in the specified stack frame.
277    *
278    *
279    * @param index Local variable index relative to the current stack
280    * frame bottom.
281    * NEEDSDOC @param stackFrame
282    *
283    * @param val The value of the variable that is being set.
284    */
setLocalVariable(int index, XObject val, int stackFrame)285   public void setLocalVariable(int index, XObject val, int stackFrame)
286   {
287     _stackFrames[index + stackFrame] = val;
288   }
289 
290   /**
291    * Get a local variable or parameter in the current stack frame.
292    *
293    *
294    * @param xctxt The XPath context, which must be passed in order to
295    * lazy evaluate variables.
296    *
297    * @param index Local variable index relative to the current stack
298    * frame bottom.
299    *
300    * @return The value of the variable.
301    *
302    * @throws TransformerException
303    */
getLocalVariable(XPathContext xctxt, int index)304   public XObject getLocalVariable(XPathContext xctxt, int index)
305           throws TransformerException
306   {
307 
308     index += _currentFrameBottom;
309 
310     XObject val = _stackFrames[index];
311 
312     if(null == val)
313       throw new TransformerException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_VARIABLE_ACCESSED_BEFORE_BIND, null),
314                      xctxt.getSAXLocator());
315       // "Variable accessed before it is bound!", xctxt.getSAXLocator());
316 
317     // Lazy execution of variables.
318     if (val.getType() == XObject.CLASS_UNRESOLVEDVARIABLE)
319       return (_stackFrames[index] = val.execute(xctxt));
320 
321     return val;
322   }
323 
324   /**
325    * Get a local variable or parameter in the current stack frame.
326    *
327    *
328    * @param index Local variable index relative to the given
329    * frame bottom.
330    * NEEDSDOC @param frame
331    *
332    * @return The value of the variable.
333    *
334    * @throws TransformerException
335    */
getLocalVariable(int index, int frame)336   public XObject getLocalVariable(int index, int frame)
337           throws TransformerException
338   {
339 
340     index += frame;
341 
342     XObject val = _stackFrames[index];
343 
344     return val;
345   }
346 
347   /**
348    * Get a local variable or parameter in the current stack frame.
349    *
350    *
351    * @param xctxt The XPath context, which must be passed in order to
352    * lazy evaluate variables.
353    *
354    * @param index Local variable index relative to the current stack
355    * frame bottom.
356    *
357    * @return The value of the variable.
358    *
359    * @throws TransformerException
360    */
getLocalVariable(XPathContext xctxt, int index, boolean destructiveOK)361   public XObject getLocalVariable(XPathContext xctxt, int index, boolean destructiveOK)
362           throws TransformerException
363   {
364 
365     index += _currentFrameBottom;
366 
367     XObject val = _stackFrames[index];
368 
369     if(null == val)
370       throw new TransformerException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_VARIABLE_ACCESSED_BEFORE_BIND, null),
371                      xctxt.getSAXLocator());
372       // "Variable accessed before it is bound!", xctxt.getSAXLocator());
373 
374     // Lazy execution of variables.
375     if (val.getType() == XObject.CLASS_UNRESOLVEDVARIABLE)
376       return (_stackFrames[index] = val.execute(xctxt));
377 
378     return destructiveOK ? val : val.getFresh();
379   }
380 
381   /**
382    * Tell if a local variable has been set or not.
383    *
384    * @param index Local variable index relative to the current stack
385    * frame bottom.
386    *
387    * @return true if the value at the index is not null.
388    *
389    * @throws TransformerException
390    */
isLocalSet(int index)391   public boolean isLocalSet(int index) throws TransformerException
392   {
393     return (_stackFrames[index + _currentFrameBottom] != null);
394   }
395 
396   /** NEEDSDOC Field m_nulls          */
397   private static XObject[] m_nulls = new XObject[CLEARLIMITATION];
398 
399   /**
400    * Use this to clear the variables in a section of the stack.  This is
401    * used to clear the parameter section of the stack, so that default param
402    * values can tell if they've already been set.  It is important to note that
403    * this function has a 1K limitation.
404    *
405    * @param start The start position, relative to the current local stack frame.
406    * @param len The number of slots to be cleared.
407    */
clearLocalSlots(int start, int len)408   public void clearLocalSlots(int start, int len)
409   {
410 
411     start += _currentFrameBottom;
412 
413     System.arraycopy(m_nulls, 0, _stackFrames, start, len);
414   }
415 
416   /**
417    * Set a global variable or parameter in the global stack frame.
418    *
419    *
420    * @param index Local variable index relative to the global stack frame
421    * bottom.
422    *
423    * @param val The value of the variable that is being set.
424    */
setGlobalVariable(final int index, final XObject val)425   public void setGlobalVariable(final int index, final XObject val)
426   {
427     _stackFrames[index] = val;
428   }
429 
430   /**
431    * Get a global variable or parameter from the global stack frame.
432    *
433    *
434    * @param xctxt The XPath context, which must be passed in order to
435    * lazy evaluate variables.
436    *
437    * @param index Global variable index relative to the global stack
438    * frame bottom.
439    *
440    * @return The value of the variable.
441    *
442    * @throws TransformerException
443    */
getGlobalVariable(XPathContext xctxt, final int index)444   public XObject getGlobalVariable(XPathContext xctxt, final int index)
445           throws TransformerException
446   {
447 
448     XObject val = _stackFrames[index];
449 
450     // Lazy execution of variables.
451     if (val.getType() == XObject.CLASS_UNRESOLVEDVARIABLE)
452       return (_stackFrames[index] = val.execute(xctxt));
453 
454     return val;
455   }
456 
457   /**
458    * Get a global variable or parameter from the global stack frame.
459    *
460    *
461    * @param xctxt The XPath context, which must be passed in order to
462    * lazy evaluate variables.
463    *
464    * @param index Global variable index relative to the global stack
465    * frame bottom.
466    *
467    * @return The value of the variable.
468    *
469    * @throws TransformerException
470    */
getGlobalVariable(XPathContext xctxt, final int index, boolean destructiveOK)471   public XObject getGlobalVariable(XPathContext xctxt, final int index, boolean destructiveOK)
472           throws TransformerException
473   {
474 
475     XObject val = _stackFrames[index];
476 
477     // Lazy execution of variables.
478     if (val.getType() == XObject.CLASS_UNRESOLVEDVARIABLE)
479       return (_stackFrames[index] = val.execute(xctxt));
480 
481     return destructiveOK ? val : val.getFresh();
482   }
483 
484   /**
485    * Get a variable based on it's qualified name.
486    * This is for external use only.
487    *
488    * @param xctxt The XPath context, which must be passed in order to
489    * lazy evaluate variables.
490    *
491    * @param qname The qualified name of the variable.
492    *
493    * @return The evaluated value of the variable.
494    *
495    * @throws javax.xml.transform.TransformerException
496    */
getVariableOrParam( XPathContext xctxt, org.apache.xml.utils.QName qname)497   public XObject getVariableOrParam(
498           XPathContext xctxt, org.apache.xml.utils.QName qname)
499             throws javax.xml.transform.TransformerException
500   {
501 
502     org.apache.xml.utils.PrefixResolver prefixResolver =
503       xctxt.getNamespaceContext();
504 
505     // Get the current ElemTemplateElement, which must be pushed in as the
506     // prefix resolver, and then walk backwards in document order, searching
507     // for an xsl:param element or xsl:variable element that matches our
508     // qname.  If we reach the top level, use the StylesheetRoot's composed
509     // list of top level variables and parameters.
510 
511     if (prefixResolver instanceof org.apache.xalan.templates.ElemTemplateElement)
512     {
513 
514       org.apache.xalan.templates.ElemVariable vvar;
515 
516       org.apache.xalan.templates.ElemTemplateElement prev =
517         (org.apache.xalan.templates.ElemTemplateElement) prefixResolver;
518 
519       if (!(prev instanceof org.apache.xalan.templates.Stylesheet))
520       {
521         while ( !(prev.getParentNode() instanceof org.apache.xalan.templates.Stylesheet) )
522         {
523           org.apache.xalan.templates.ElemTemplateElement savedprev = prev;
524 
525           while (null != (prev = prev.getPreviousSiblingElem()))
526           {
527             if (prev instanceof org.apache.xalan.templates.ElemVariable)
528             {
529               vvar = (org.apache.xalan.templates.ElemVariable) prev;
530 
531               if (vvar.getName().equals(qname))
532                 return getLocalVariable(xctxt, vvar.getIndex());
533             }
534           }
535           prev = savedprev.getParentElem();
536         }
537       }
538 
539       vvar = prev.getStylesheetRoot().getVariableOrParamComposed(qname);
540       if (null != vvar)
541         return getGlobalVariable(xctxt, vvar.getIndex());
542     }
543 
544     throw new javax.xml.transform.TransformerException(XSLMessages.createXPATHMessage(XPATHErrorResources.ER_VAR_NOT_RESOLVABLE, new Object[]{qname.toString()})); //"Variable not resolvable: " + qname);
545   }
546 }  // end VariableStack
547 
548