1. /*

  2.  * Copyright 2001-2004 The Apache Software Foundation.

  3.  *

  4.  * Licensed under the Apache License, Version 2.0 (the "License");

  5.  * you may not use this file except in compliance with the License.

  6.  * You may obtain a copy of the License at

  7.  *

  8.  *     http://www.apache.org/licenses/LICENSE-2.0

  9.  *

  10.  * Unless required by applicable law or agreed to in writing, software

  11.  * distributed under the License is distributed on an "AS IS" BASIS,

  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  13.  * See the License for the specific language governing permissions and

  14.  * limitations under the License.

  15.  */

  16. /*

  17.  * $Id: Key.java,v 1.18 2004/02/24 03:55:47 zongaro Exp $

  18.  */

  19. 

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

  21. 

  22. import com.sun.org.apache.bcel.internal.generic.BranchHandle;

  23. import com.sun.org.apache.bcel.internal.generic.ConstantPoolGen;

  24. import com.sun.org.apache.bcel.internal.generic.GOTO;

  25. import com.sun.org.apache.bcel.internal.generic.IFEQ;

  26. import com.sun.org.apache.bcel.internal.generic.IFGE;

  27. import com.sun.org.apache.bcel.internal.generic.IFGT;

  28. import com.sun.org.apache.bcel.internal.generic.ILOAD;

  29. import com.sun.org.apache.bcel.internal.generic.INVOKEINTERFACE;

  30. import com.sun.org.apache.bcel.internal.generic.INVOKEVIRTUAL;

  31. import com.sun.org.apache.bcel.internal.generic.ISTORE;

  32. import com.sun.org.apache.bcel.internal.generic.InstructionHandle;

  33. import com.sun.org.apache.bcel.internal.generic.InstructionList;

  34. import com.sun.org.apache.bcel.internal.generic.LocalVariableGen;

  35. import com.sun.org.apache.bcel.internal.generic.PUSH;

  36. import com.sun.org.apache.xalan.internal.xsltc.compiler.util.ClassGenerator;

  37. import com.sun.org.apache.xalan.internal.xsltc.compiler.util.ErrorMsg;

  38. import com.sun.org.apache.xalan.internal.xsltc.compiler.util.MethodGenerator;

  39. import com.sun.org.apache.xalan.internal.xsltc.compiler.util.NodeSetType;

  40. import com.sun.org.apache.xalan.internal.xsltc.compiler.util.StringType;

  41. import com.sun.org.apache.xalan.internal.xsltc.compiler.util.Type;

  42. import com.sun.org.apache.xalan.internal.xsltc.compiler.util.TypeCheckError;

  43. import com.sun.org.apache.xalan.internal.xsltc.compiler.util.Util;

  44. import com.sun.org.apache.xalan.internal.xsltc.dom.Axis;

  45. import com.sun.org.apache.xml.internal.utils.XMLChar;

  46. 

  47. /**

  48.  * @author Morten Jorgensen

  49.  * @author Santiago Pericas-Geertsen

  50.  */

  51. final class Key extends TopLevelElement {

  52. 

  53.     /**

  54.      * The name of this key as defined in xsl:key.

  55.      */

  56.     private QName _name;

  57. 

  58.     /**

  59.      * The pattern to match starting at the root node.

  60.      */

  61.     private Pattern _match; 

  62. 

  63.     /**

  64.      * The expression that generates the values for this key.

  65.      */

  66.     private Expression _use;

  67. 

  68.     /**

  69.      * The type of the _use expression.

  70.      */

  71.     private Type _useType;

  72. 

  73.     /**

  74.      * Parse the <xsl:key> element and attributes

  75.      * @param parser A reference to the stylesheet parser

  76.      */

  77.     public void parseContents(Parser parser) {

  78. 

  79. 	// Get the required attributes and parser XPath expressions

  80.         final String name = getAttribute("name");

  81.         if (!XMLChar.isValidQName(name)){

  82.             ErrorMsg err = new ErrorMsg(ErrorMsg.INVALID_QNAME_ERR, name, this);

  83.             parser.reportError(Constants.ERROR, err);           

  84.         }

  85.         _name = parser.getQNameIgnoreDefaultNs(name);

  86. 	_match = parser.parsePattern(this, "match", null);

  87. 	_use = parser.parseExpression(this, "use", null);

  88. 

  89.         // Make sure required attribute(s) have been set

  90.         if (_name == null) {

  91. 	    reportError(this, parser, ErrorMsg.REQUIRED_ATTR_ERR, "name");

  92. 	    return;

  93.         }

  94.         if (_match.isDummy()) {

  95. 	    reportError(this, parser, ErrorMsg.REQUIRED_ATTR_ERR, "match");

  96. 	    return;

  97.         }

  98.         if (_use.isDummy()) {

  99. 	    reportError(this, parser, ErrorMsg.REQUIRED_ATTR_ERR, "use");

  100. 	    return;

  101.         }

  102.     }

  103. 

  104.     /**

  105.      * Returns a String-representation of this key's name

  106.      * @return The key's name (from the <xsl:key> elements 'name' attribute).

  107.      */

  108.     public String getName() {

  109. 	return _name.toString();

  110.     }

  111. 

  112.     public Type typeCheck(SymbolTable stable) throws TypeCheckError {

  113. 	// Type check match pattern

  114. 	_match.typeCheck(stable);

  115. 

  116. 	// Cast node values to string values (except for nodesets)

  117. 	_useType = _use.typeCheck(stable);

  118. 	if (_useType instanceof StringType == false &&

  119. 	    _useType instanceof NodeSetType == false) 

  120. 	{

  121. 	    _use = new CastExpr(_use, Type.String);

  122. 	}

  123. 

  124. 	return Type.Void;

  125.     }

  126. 

  127.     /**

  128.      * This method is called if the "use" attribute of the key contains a

  129.      * node set. In this case we must traverse all nodes in the set and

  130.      * create one entry in this key's index for each node in the set.

  131.      */

  132.     public void traverseNodeSet(ClassGenerator classGen,

  133. 				MethodGenerator methodGen,

  134. 				int buildKeyIndex) {

  135. 	final ConstantPoolGen cpg = classGen.getConstantPool();

  136. 	final InstructionList il = methodGen.getInstructionList();

  137. 

  138. 	// DOM.getStringValueX(nodeIndex) => String

  139. 	final int getNodeValue = cpg.addInterfaceMethodref(DOM_INTF,

  140. 							   GET_NODE_VALUE,

  141. 							   "(I)"+STRING_SIG);

  142. 							   

  143. 	final int getNodeIdent = cpg.addInterfaceMethodref(DOM_INTF,

  144. 							   "getNodeIdent",

  145. 							   "(I)"+NODE_SIG);	

  146. 							   

  147. 	// AbstractTranslet.SetKeyIndexDom(name, Dom) => void

  148. 	final int keyDom = cpg.addMethodref(TRANSLET_CLASS,

  149. 					 "setKeyIndexDom",

  150. 					 "("+STRING_SIG+DOM_INTF_SIG+")V");				 

  151. 						   					   

  152. 

  153. 	// This variable holds the id of the node we found with the "match"

  154. 	// attribute of xsl:key. This is the id we store, with the value we

  155. 	// get from the nodes we find here, in the index for this key.

  156. 	final LocalVariableGen parentNode =

  157. 	    methodGen.addLocalVariable("parentNode",

  158. 				       Util.getJCRefType("I"),

  159. 				       il.getEnd(), null);

  160. 

  161. 	// Get the 'parameter' from the stack and store it in a local var.

  162. 	il.append(new ISTORE(parentNode.getIndex()));	

  163. 	il.append(methodGen.loadDOM());

  164. 	il.append(new ILOAD(parentNode.getIndex()));	

  165. 	il.append(new INVOKEINTERFACE(getNodeIdent, 2));

  166. 	il.append(new ISTORE(parentNode.getIndex()));

  167. 

  168. 	// Save current node and current iterator on the stack

  169. 	il.append(methodGen.loadCurrentNode());

  170. 	il.append(methodGen.loadIterator());

  171. 

  172. 	// Overwrite current iterator with one that gives us only what we want

  173. 	_use.translate(classGen, methodGen);

  174. 	_use.startIterator(classGen, methodGen);

  175. 	il.append(methodGen.storeIterator());

  176. 

  177. 	final BranchHandle nextNode = il.append(new GOTO(null));

  178. 	final InstructionHandle loop = il.append(NOP);

  179. 

  180. 	// Prepare to call buildKeyIndex(String name, int node, String value);

  181. 	il.append(classGen.loadTranslet());

  182. 	il.append(new PUSH(cpg, _name.toString()));

  183. 	il.append(new ILOAD(parentNode.getIndex()));

  184. 

  185. 	// Now get the node value and feck it on the parameter stack

  186. 	il.append(methodGen.loadDOM());

  187. 	il.append(methodGen.loadCurrentNode());

  188. 	il.append(new INVOKEINTERFACE(getNodeValue, 2));		

  189. 

  190. 	// Finally do the call to add an entry in the index for this key.

  191. 	il.append(new INVOKEVIRTUAL(buildKeyIndex));

  192. 	

  193. 	il.append(classGen.loadTranslet());

  194. 	il.append(new PUSH(cpg, getName()));

  195. 	il.append(methodGen.loadDOM());

  196. 	il.append(new INVOKEVIRTUAL(keyDom));

  197. 

  198. 	nextNode.setTarget(il.append(methodGen.loadIterator()));

  199. 	il.append(methodGen.nextNode());	

  200. 

  201. 	il.append(DUP);

  202. 	il.append(methodGen.storeCurrentNode());

  203. 	il.append(new IFGE(loop)); // Go on to next matching node....

  204. 

  205. 	// Restore current node and current iterator from the stack

  206. 	il.append(methodGen.storeIterator());

  207. 	il.append(methodGen.storeCurrentNode());

  208.     }

  209. 

  210.     /**

  211.      * Gather all nodes that match the expression in the attribute "match"

  212.      * and add one (or more) entries in this key's index.

  213.      */

  214.     public void translate(ClassGenerator classGen, MethodGenerator methodGen) {

  215. 

  216. 	final ConstantPoolGen cpg = classGen.getConstantPool();

  217. 	final InstructionList il = methodGen.getInstructionList();

  218. 	final int current = methodGen.getLocalIndex("current");

  219. 

  220. 	// AbstractTranslet.buildKeyIndex(name,node_id,value) => void

  221. 	final int key = cpg.addMethodref(TRANSLET_CLASS,

  222. 					 "buildKeyIndex",

  223. 					 "("+STRING_SIG+"I"+OBJECT_SIG+")V");

  224. 					 

  225. 	// AbstractTranslet.SetKeyIndexDom(name, Dom) => void

  226. 	final int keyDom = cpg.addMethodref(TRANSLET_CLASS,

  227. 					 "setKeyIndexDom",

  228. 					 "("+STRING_SIG+DOM_INTF_SIG+")V");

  229. 					 

  230. 	final int getNodeIdent = cpg.addInterfaceMethodref(DOM_INTF,

  231. 							   "getNodeIdent",

  232. 							   "(I)"+NODE_SIG);					 				 

  233. 

  234. 	// DOM.getAxisIterator(root) => NodeIterator

  235. 	final int git = cpg.addInterfaceMethodref(DOM_INTF,

  236. 						  "getAxisIterator",

  237. 						  "(I)"+NODE_ITERATOR_SIG);

  238. 

  239. 	il.append(methodGen.loadCurrentNode());

  240. 	il.append(methodGen.loadIterator());

  241. 

  242. 	// Get an iterator for all nodes in the DOM

  243. 	il.append(methodGen.loadDOM());	

  244. 	il.append(new PUSH(cpg,Axis.DESCENDANT));

  245. 	il.append(new INVOKEINTERFACE(git, 2));

  246. 

  247. 	// Reset the iterator to start with the root node

  248. 	il.append(methodGen.loadCurrentNode());

  249. 	il.append(methodGen.setStartNode());

  250. 	il.append(methodGen.storeIterator());

  251. 

  252. 	// Loop for traversing all nodes in the DOM

  253. 	final BranchHandle nextNode = il.append(new GOTO(null));

  254. 	final InstructionHandle loop = il.append(NOP);

  255. 

  256. 	// Check if the current node matches the pattern in "match"

  257. 	il.append(methodGen.loadCurrentNode());

  258. 	_match.translate(classGen, methodGen);

  259. 	_match.synthesize(classGen, methodGen); // Leaves 0 or 1 on stack

  260. 	final BranchHandle skipNode = il.append(new IFEQ(null));

  261. 	

  262. 	// If this is a node-set we must go through each node in the set

  263. 	if (_useType instanceof NodeSetType) {

  264. 	    // Pass current node as parameter (we're indexing on that node)

  265. 	    il.append(methodGen.loadCurrentNode());

  266. 	    traverseNodeSet(classGen, methodGen, key);

  267. 	}

  268. 	else {

  269. 	    il.append(classGen.loadTranslet());

  270. 	    il.append(DUP);

  271. 	    il.append(new PUSH(cpg, _name.toString()));

  272. 	    il.append(DUP_X1);

  273. 	    il.append(methodGen.loadCurrentNode());

  274. 	    _use.translate(classGen, methodGen);

  275. 	    il.append(SWAP);

  276. 	    il.append(methodGen.loadDOM());

  277. 	    il.append(SWAP);

  278. 	    il.append(new INVOKEINTERFACE(getNodeIdent, 2));

  279. 	    il.append(SWAP);

  280. 	    il.append(new INVOKEVIRTUAL(key));

  281. 	    

  282. 	    il.append(methodGen.loadDOM());

  283. 	    il.append(new INVOKEVIRTUAL(keyDom));

  284. 	}

  285. 	

  286. 	// Get the next node from the iterator and do loop again...

  287. 	final InstructionHandle skip = il.append(NOP);

  288. 	

  289. 	il.append(methodGen.loadIterator());

  290. 	il.append(methodGen.nextNode());

  291. 	il.append(DUP);

  292. 	il.append(methodGen.storeCurrentNode());

  293. 	il.append(new IFGT(loop));

  294. 

  295. 	// Restore current node and current iterator from the stack

  296. 	il.append(methodGen.storeIterator());

  297. 	il.append(methodGen.storeCurrentNode());

  298. 	

  299. 	nextNode.setTarget(skip);

  300. 	skipNode.setTarget(skip);

  301.     }

  302. }