Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
JDK 17 java.xml.jmod - XML Module
JDK 17 java.xml.jmod is the JMOD file for JDK 17 XML (eXtensible Markup Language) module.
JDK 17 XML module compiled class files are stored in \fyicenter\jdk-17.0.5\jmods\java.xml.jmod.
JDK 17 XML module compiled class files are also linked and stored in the \fyicenter\jdk-17.0.5\lib\modules JImage file.
JDK 17 XML module source code files are stored in \fyicenter\jdk-17.0.5\lib\src.zip\java.xml.
You can click and view the content of each source code file in the list below.
✍: FYIcenter
⏎ com/sun/org/apache/xalan/internal/xsltc/compiler/Step.java
/* * Copyright (c) 2017, 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 com.sun.org.apache.bcel.internal.generic.ALOAD; import com.sun.org.apache.bcel.internal.generic.ASTORE; 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.ICONST; import com.sun.org.apache.bcel.internal.generic.ILOAD; 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.ISTORE; import com.sun.org.apache.bcel.internal.generic.InstructionList; 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.DOM; import com.sun.org.apache.xalan.internal.xsltc.compiler.util.ClassGenerator; import com.sun.org.apache.xalan.internal.xsltc.compiler.util.MethodGenerator; import com.sun.org.apache.xalan.internal.xsltc.compiler.util.Type; import com.sun.org.apache.xalan.internal.xsltc.compiler.util.TypeCheckError; import com.sun.org.apache.xalan.internal.xsltc.compiler.util.Util; import com.sun.org.apache.xml.internal.dtm.Axis; import com.sun.org.apache.xml.internal.dtm.DTM; import java.util.List; /** * @author Jacek Ambroziak * @author Santiago Pericas-Geertsen * @author Morten Jorgensen * @LastModified: Oct 2017 */ final class Step extends RelativeLocationPath { /** * This step's axis as defined in class Axis. */ private int _axis; /** * A vector of predicates (filters) defined on this step - may be null */ private List<Predicate> _predicates; /** * Some simple predicates can be handled by this class (and not by the * Predicate class) and will be removed from the above vector as they are * handled. We use this boolean to remember if we did have any predicates. */ private boolean _hadPredicates = false; /** * Type of the node test. */ private int _nodeType; public Step(int axis, int nodeType, List<Predicate> predicates) { _axis = axis; _nodeType = nodeType; _predicates = predicates; } /** * Set the parser for this element and all child predicates */ public void setParser(Parser parser) { super.setParser(parser); if (_predicates != null) { final int n = _predicates.size(); for (int i = 0; i < n; i++) { final Predicate exp = _predicates.get(i); exp.setParser(parser); exp.setParent(this); } } } /** * Define the axis (defined in Axis class) for this step */ public int getAxis() { return _axis; } /** * Get the axis (defined in Axis class) for this step */ public void setAxis(int axis) { _axis = axis; } /** * Returns the node-type for this step */ public int getNodeType() { return _nodeType; } /** * Returns the vector containing all predicates for this step. */ public List<Predicate> getPredicates() { return _predicates; } /** * Returns the vector containing all predicates for this step. */ public void addPredicates(List<Predicate> predicates) { if (_predicates == null) { _predicates = predicates; } else { _predicates.addAll(predicates); } } /** * Returns 'true' if this step has a parent pattern. * This method will return 'false' if this step occurs on its own under * an element like <xsl:for-each> or <xsl:apply-templates>. */ private boolean hasParentPattern() { final SyntaxTreeNode parent = getParent(); return (parent instanceof ParentPattern || parent instanceof ParentLocationPath || parent instanceof UnionPathExpr || parent instanceof FilterParentPath); } /** * Returns 'true' if this step has a parent location path. */ private boolean hasParentLocationPath() { return getParent() instanceof ParentLocationPath; } /** * Returns 'true' if this step has any predicates */ private boolean hasPredicates() { return _predicates != null && _predicates.size() > 0; } /** * Returns 'true' if this step is used within a predicate */ private boolean isPredicate() { SyntaxTreeNode parent = this; while (parent != null) { parent = parent.getParent(); if (parent instanceof Predicate) return true; } return false; } /** * True if this step is the abbreviated step '.' */ public boolean isAbbreviatedDot() { return _nodeType == NodeTest.ANODE && _axis == Axis.SELF; } /** * True if this step is the abbreviated step '..' */ public boolean isAbbreviatedDDot() { return _nodeType == NodeTest.ANODE && _axis == Axis.PARENT; } /** * Type check this step. The abbreviated steps '.' and '@attr' are * assigned type node if they have no predicates. All other steps * have type node-set. */ public Type typeCheck(SymbolTable stable) throws TypeCheckError { // Save this value for later - important for testing for special // combinations of steps and patterns than can be optimised _hadPredicates = hasPredicates(); // Special case for '.' // in the case where '.' has a context such as book/. // or .[false()] we can not optimize the nodeset to a single node. if (isAbbreviatedDot()) { _type = (hasParentPattern() || hasPredicates() || hasParentLocationPath()) ? Type.NodeSet : Type.Node; } else { _type = Type.NodeSet; } // Type check all predicates (expressions applied to the step) if (_predicates != null) { for (Expression pred : _predicates) { pred.typeCheck(stable); } } // Return either Type.Node or Type.NodeSet return _type; } /** * Translate a step by pushing the appropriate iterator onto the stack. * The abbreviated steps '.' and '@attr' do not create new iterators * if they are not part of a LocationPath and have no filters. * In these cases a node index instead of an iterator is pushed * onto the stack. */ public void translate(ClassGenerator classGen, MethodGenerator methodGen) { translateStep(classGen, methodGen, hasPredicates() ? _predicates.size() - 1 : -1); } @SuppressWarnings("fallthrough") // at case NodeTest.ANODE and NodeTest.ELEMENT private void translateStep(ClassGenerator classGen, MethodGenerator methodGen, int predicateIndex) { final ConstantPoolGen cpg = classGen.getConstantPool(); final InstructionList il = methodGen.getInstructionList(); if (predicateIndex >= 0) { translatePredicates(classGen, methodGen, predicateIndex); } else { int star = 0; String name = null; final XSLTC xsltc = getParser().getXSLTC(); if (_nodeType >= DTM.NTYPES) { final List<String> ni = xsltc.getNamesIndex(); name = ni.get(_nodeType-DTM.NTYPES); star = name.lastIndexOf('*'); } // If it is an attribute, but not '@*', '@pre:*' or '@node()', // and has no parent if (_axis == Axis.ATTRIBUTE && _nodeType != NodeTest.ATTRIBUTE && _nodeType != NodeTest.ANODE && !hasParentPattern() && star == 0) { int iter = cpg.addInterfaceMethodref(DOM_INTF, "getTypedAxisIterator", "(II)"+NODE_ITERATOR_SIG); il.append(methodGen.loadDOM()); il.append(new PUSH(cpg, Axis.ATTRIBUTE)); il.append(new PUSH(cpg, _nodeType)); il.append(new INVOKEINTERFACE(iter, 3)); return; } SyntaxTreeNode parent = getParent(); // Special case for '.' if (isAbbreviatedDot()) { if (_type == Type.Node) { // Put context node on stack if using Type.Node il.append(methodGen.loadContextNode()); } else { if (parent instanceof ParentLocationPath){ // Wrap the context node in a singleton iterator if not. int init = cpg.addMethodref(SINGLETON_ITERATOR, "<init>", "("+NODE_SIG+")V"); il.append(new NEW(cpg.addClass(SINGLETON_ITERATOR))); il.append(DUP); il.append(methodGen.loadContextNode()); il.append(new INVOKESPECIAL(init)); } else { // DOM.getAxisIterator(int axis); int git = cpg.addInterfaceMethodref(DOM_INTF, "getAxisIterator", "(I)"+NODE_ITERATOR_SIG); il.append(methodGen.loadDOM()); il.append(new PUSH(cpg, _axis)); il.append(new INVOKEINTERFACE(git, 2)); } } return; } // Special case for /foo/*/bar if ((parent instanceof ParentLocationPath) && (parent.getParent() instanceof ParentLocationPath)) { if ((_nodeType == NodeTest.ELEMENT) && (!_hadPredicates)) { _nodeType = NodeTest.ANODE; } } // "ELEMENT" or "*" or "@*" or ".." or "@attr" with a parent. switch (_nodeType) { case NodeTest.ATTRIBUTE: _axis = Axis.ATTRIBUTE; case NodeTest.ANODE: // DOM.getAxisIterator(int axis); int git = cpg.addInterfaceMethodref(DOM_INTF, "getAxisIterator", "(I)"+NODE_ITERATOR_SIG); il.append(methodGen.loadDOM()); il.append(new PUSH(cpg, _axis)); il.append(new INVOKEINTERFACE(git, 2)); break; default: if (star > 1) { final String namespace; if (_axis == Axis.ATTRIBUTE) namespace = name.substring(0,star-2); else namespace = name.substring(0,star-1); final int nsType = xsltc.registerNamespace(namespace); final int ns = cpg.addInterfaceMethodref(DOM_INTF, "getNamespaceAxisIterator", "(II)"+NODE_ITERATOR_SIG); il.append(methodGen.loadDOM()); il.append(new PUSH(cpg, _axis)); il.append(new PUSH(cpg, nsType)); il.append(new INVOKEINTERFACE(ns, 3)); break; } case NodeTest.ELEMENT: // DOM.getTypedAxisIterator(int axis, int type); final int ty = cpg.addInterfaceMethodref(DOM_INTF, "getTypedAxisIterator", "(II)"+NODE_ITERATOR_SIG); // Get the typed iterator we're after il.append(methodGen.loadDOM()); il.append(new PUSH(cpg, _axis)); il.append(new PUSH(cpg, _nodeType)); il.append(new INVOKEINTERFACE(ty, 3)); break; } } } /** * Translate a sequence of predicates. Each predicate is translated * by constructing an instance of <code>CurrentNodeListIterator</code> * which is initialized from another iterator (recursive call), * a filter and a closure (call to translate on the predicate) and "this". */ public void translatePredicates(ClassGenerator classGen, MethodGenerator methodGen, int predicateIndex) { final ConstantPoolGen cpg = classGen.getConstantPool(); final InstructionList il = methodGen.getInstructionList(); int idx = 0; if (predicateIndex < 0) { translateStep(classGen, methodGen, predicateIndex); } else { final Predicate predicate = _predicates.get(predicateIndex--); // Special case for predicates that can use the NodeValueIterator // instead of an auxiliary class. Certain path/predicates pairs // are translated into a base path, on top of which we place a // node value iterator that tests for the desired value: // foo[@attr = 'str'] -> foo/@attr + test(value='str') // foo[bar = 'str'] -> foo/bar + test(value='str') // foo/bar[. = 'str'] -> foo/bar + test(value='str') if (predicate.isNodeValueTest()) { Step step = predicate.getStep(); il.append(methodGen.loadDOM()); // If the predicate's Step is simply '.' we translate this Step // and place the node test on top of the resulting iterator if (step.isAbbreviatedDot()) { translateStep(classGen, methodGen, predicateIndex); il.append(new ICONST(DOM.RETURN_CURRENT)); } // Otherwise we create a parent location path with this Step and // the predicates Step, and place the node test on top of that else { ParentLocationPath path = new ParentLocationPath(this, step); _parent = step._parent = path; // Force re-parenting try { path.typeCheck(getParser().getSymbolTable()); } catch (TypeCheckError e) { } translateStep(classGen, methodGen, predicateIndex); path.translateStep(classGen, methodGen); il.append(new ICONST(DOM.RETURN_PARENT)); } predicate.translate(classGen, methodGen); idx = cpg.addInterfaceMethodref(DOM_INTF, GET_NODE_VALUE_ITERATOR, GET_NODE_VALUE_ITERATOR_SIG); il.append(new INVOKEINTERFACE(idx, 5)); } // Handle '//*[n]' expression else if (predicate.isNthDescendant()) { il.append(methodGen.loadDOM()); // il.append(new ICONST(NodeTest.ELEMENT)); il.append(new PUSH(cpg, predicate.getPosType())); predicate.translate(classGen, methodGen); il.append(new ICONST(0)); idx = cpg.addInterfaceMethodref(DOM_INTF, "getNthDescendant", "(IIZ)"+NODE_ITERATOR_SIG); il.append(new INVOKEINTERFACE(idx, 4)); } // Handle 'elem[n]' expression else if (predicate.isNthPositionFilter()) { idx = cpg.addMethodref(NTH_ITERATOR_CLASS, "<init>", "("+NODE_ITERATOR_SIG+"I)V"); // Backwards branches are prohibited if an uninitialized object // is on the stack by section 4.9.4 of the JVM Specification, // 2nd Ed. We don't know whether this code might contain // backwards branches, so we mustn't create the new object until // after we've created the suspect arguments to its constructor. // Instead we calculate the values of the arguments to the // constructor first, store them in temporary variables, create // the object and reload the arguments from the temporaries to // avoid the problem. translatePredicates(classGen, methodGen, predicateIndex); // recursive call LocalVariableGen iteratorTemp = methodGen.addLocalVariable("step_tmp1", Util.getJCRefType(NODE_ITERATOR_SIG), null, null); iteratorTemp.setStart( il.append(new ASTORE(iteratorTemp.getIndex()))); predicate.translate(classGen, methodGen); LocalVariableGen predicateValueTemp = methodGen.addLocalVariable("step_tmp2", Util.getJCRefType("I"), null, null); predicateValueTemp.setStart( il.append(new ISTORE(predicateValueTemp.getIndex()))); il.append(new NEW(cpg.addClass(NTH_ITERATOR_CLASS))); il.append(DUP); iteratorTemp.setEnd( il.append(new ALOAD(iteratorTemp.getIndex()))); predicateValueTemp.setEnd( il.append(new ILOAD(predicateValueTemp.getIndex()))); il.append(new INVOKESPECIAL(idx)); } else { idx = cpg.addMethodref(CURRENT_NODE_LIST_ITERATOR, "<init>", "(" + NODE_ITERATOR_SIG + CURRENT_NODE_LIST_FILTER_SIG + NODE_SIG + TRANSLET_SIG + ")V"); // Backwards branches are prohibited if an uninitialized object // is on the stack by section 4.9.4 of the JVM Specification, // 2nd Ed. We don't know whether this code might contain // backwards branches, so we mustn't create the new object until // after we've created the suspect arguments to its constructor. // Instead we calculate the values of the arguments to the // constructor first, store them in temporary variables, create // the object and reload the arguments from the temporaries to // avoid the problem. translatePredicates(classGen, methodGen, predicateIndex); // recursive call LocalVariableGen iteratorTemp = methodGen.addLocalVariable("step_tmp1", Util.getJCRefType(NODE_ITERATOR_SIG), null, null); iteratorTemp.setStart( il.append(new ASTORE(iteratorTemp.getIndex()))); predicate.translateFilter(classGen, methodGen); LocalVariableGen filterTemp = methodGen.addLocalVariable("step_tmp2", Util.getJCRefType(CURRENT_NODE_LIST_FILTER_SIG), null, null); filterTemp.setStart( il.append(new ASTORE(filterTemp.getIndex()))); // create new CurrentNodeListIterator il.append(new NEW(cpg.addClass(CURRENT_NODE_LIST_ITERATOR))); il.append(DUP); iteratorTemp.setEnd( il.append(new ALOAD(iteratorTemp.getIndex()))); filterTemp.setEnd(il.append(new ALOAD(filterTemp.getIndex()))); il.append(methodGen.loadCurrentNode()); il.append(classGen.loadTranslet()); if (classGen.isExternal()) { final String className = classGen.getClassName(); il.append(new CHECKCAST(cpg.addClass(className))); } il.append(new INVOKESPECIAL(idx)); } } } /** * Returns a string representation of this step. */ public String toString() { final StringBuffer buffer = new StringBuffer("step(\""); buffer.append(Axis.getNames(_axis)).append("\", ").append(_nodeType); if (_predicates != null) { for (Expression pred : _predicates) { buffer.append(", ").append(pred.toString()); } } return buffer.append(')').toString(); } }
⏎ com/sun/org/apache/xalan/internal/xsltc/compiler/Step.java
Or download all of them as a single archive file:
File name: java.xml-17.0.5-src.zip File size: 5047495 bytes Release date: 2022-09-13 Download
⇒ JDK 17 java.xml.crypto.jmod - XML Crypto Module
2023-07-17, 50873👍, 1💬
Popular Posts:
maven-core-3.8.6.jar is the JAR file for Apache Maven 3.8.6 Core module. Apache Maven is a software ...
JDK 17 jdk.compiler.jmod is the JMOD file for JDK 17 Compiler tool, which can be invoked by the "jav...
commons-collections4-4.4 -sources.jaris the source JAR file for Apache Commons Collections 4.2, whic...
What Is HttpComponents httpclient-4.2.2.jar? HttpComponents httpclient-4.2.2.jar is the JAR file for...
JRE 8 rt.jar is the JAR file for JRE 8 RT (Runtime) libraries. JRE (Java Runtime) 8 is the runtime e...