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/AttributeValueTemplate.java
/*
* Copyright (c) 2015, 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.
*/
/*
* $Id: AttributeValueTemplate.java,v 1.2.4.1 2005/09/01 10:26:57 pvedula Exp $
*/
package com.sun.org.apache.xalan.internal.xsltc.compiler;
import com.sun.org.apache.bcel.internal.generic.ConstantPoolGen;
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.Instruction;
import com.sun.org.apache.bcel.internal.generic.InstructionList;
import com.sun.org.apache.bcel.internal.generic.NEW;
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.Type;
import com.sun.org.apache.xalan.internal.xsltc.compiler.util.TypeCheckError;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.StringTokenizer;
/**
* @author Jacek Ambroziak
* @author Santiago Pericas-Geertsen
* @LastModified: Oct 2017
*/
final class AttributeValueTemplate extends AttributeValue {
final static int OUT_EXPR = 0;
final static int IN_EXPR = 1;
final static int IN_EXPR_SQUOTES = 2;
final static int IN_EXPR_DQUOTES = 3;
final static String DELIMITER = "\uFFFE"; // A Unicode nonchar
public AttributeValueTemplate(String value, Parser parser,
SyntaxTreeNode parent)
{
setParent(parent);
setParser(parser);
try {
parseAVTemplate(value, parser);
}
catch (NoSuchElementException e) {
reportError(parent, parser,
ErrorMsg.ATTR_VAL_TEMPLATE_ERR, value);
}
}
/**
* Two-pass parsing of ATVs. In the first pass, double curly braces are
* replaced by one, and expressions are delimited using DELIMITER. The
* second pass splits up the resulting buffer into literal and non-literal
* expressions. Errors are reported during the first pass.
*/
private void parseAVTemplate(String text, Parser parser) {
StringTokenizer tokenizer =
new StringTokenizer(text, "{}\"\'", true);
/*
* First pass: replace double curly braces and delimit expressions
* Simple automaton to parse ATVs, delimit expressions and report
* errors.
*/
String t = null;
String lookahead = null;
StringBuilder buffer = new StringBuilder();
int state = OUT_EXPR;
while (tokenizer.hasMoreTokens()) {
// Use lookahead if available
if (lookahead != null) {
t = lookahead;
lookahead = null;
}
else {
t = tokenizer.nextToken();
}
if (t.length() == 1) {
switch (t.charAt(0)) {
case '{':
switch (state) {
case OUT_EXPR:
lookahead = tokenizer.nextToken();
if (lookahead.equals("{")) {
buffer.append(lookahead); // replace {{ by {
lookahead = null;
}
else {
buffer.append(DELIMITER);
state = IN_EXPR;
}
break;
case IN_EXPR:
case IN_EXPR_SQUOTES:
case IN_EXPR_DQUOTES:
reportError(getParent(), parser,
ErrorMsg.ATTR_VAL_TEMPLATE_ERR, text);
break;
}
break;
case '}':
switch (state) {
case OUT_EXPR:
lookahead = tokenizer.nextToken();
if (lookahead.equals("}")) {
buffer.append(lookahead); // replace }} by }
lookahead = null;
}
else {
reportError(getParent(), parser,
ErrorMsg.ATTR_VAL_TEMPLATE_ERR, text);
}
break;
case IN_EXPR:
buffer.append(DELIMITER);
state = OUT_EXPR;
break;
case IN_EXPR_SQUOTES:
case IN_EXPR_DQUOTES:
buffer.append(t);
break;
}
break;
case '\'':
switch (state) {
case IN_EXPR:
state = IN_EXPR_SQUOTES;
break;
case IN_EXPR_SQUOTES:
state = IN_EXPR;
break;
case OUT_EXPR:
case IN_EXPR_DQUOTES:
break;
}
buffer.append(t);
break;
case '\"':
switch (state) {
case IN_EXPR:
state = IN_EXPR_DQUOTES;
break;
case IN_EXPR_DQUOTES:
state = IN_EXPR;
break;
case OUT_EXPR:
case IN_EXPR_SQUOTES:
break;
}
buffer.append(t);
break;
default:
buffer.append(t);
break;
}
}
else {
buffer.append(t);
}
}
// Must be in OUT_EXPR at the end of parsing
if (state != OUT_EXPR) {
reportError(getParent(), parser,
ErrorMsg.ATTR_VAL_TEMPLATE_ERR, text);
}
/*
* Second pass: split up buffer into literal and non-literal expressions.
*/
tokenizer = new StringTokenizer(buffer.toString(), DELIMITER, true);
while (tokenizer.hasMoreTokens()) {
t = tokenizer.nextToken();
if (t.equals(DELIMITER)) {
addElement(parser.parseExpression(this, tokenizer.nextToken()));
tokenizer.nextToken(); // consume other delimiter
}
else {
addElement(new LiteralExpr(t));
}
}
}
public Type typeCheck(SymbolTable stable) throws TypeCheckError {
final List<SyntaxTreeNode> contents = getContents();
final int n = contents.size();
for (int i = 0; i < n; i++) {
final Expression exp = (Expression)contents.get(i);
if (!exp.typeCheck(stable).identicalTo(Type.String)) {
contents.set(i, new CastExpr(exp, Type.String));
}
}
return _type = Type.String;
}
public String toString() {
final StringBuilder buffer = new StringBuilder("AVT:[");
final int count = elementCount();
for (int i = 0; i < count; i++) {
buffer.append(elementAt(i).toString());
if (i < count - 1)
buffer.append(' ');
}
return buffer.append(']').toString();
}
public void translate(ClassGenerator classGen, MethodGenerator methodGen) {
if (elementCount() == 1) {
final Expression exp = (Expression)elementAt(0);
exp.translate(classGen, methodGen);
}
else {
final ConstantPoolGen cpg = classGen.getConstantPool();
final InstructionList il = methodGen.getInstructionList();
final int initBuffer = cpg.addMethodref(STRING_BUFFER_CLASS,
"<init>", "()V");
final Instruction append =
new INVOKEVIRTUAL(cpg.addMethodref(STRING_BUFFER_CLASS,
"append",
"(" + STRING_SIG + ")"
+ STRING_BUFFER_SIG));
final int toString = cpg.addMethodref(STRING_BUFFER_CLASS,
"toString",
"()"+STRING_SIG);
il.append(new NEW(cpg.addClass(STRING_BUFFER_CLASS)));
il.append(DUP);
il.append(new INVOKESPECIAL(initBuffer));
// StringBuilder is on the stack
final Iterator<SyntaxTreeNode> elements = elements();
while (elements.hasNext()) {
final Expression exp = (Expression)elements.next();
exp.translate(classGen, methodGen);
il.append(append);
}
il.append(new INVOKEVIRTUAL(toString));
}
}
}
⏎ com/sun/org/apache/xalan/internal/xsltc/compiler/AttributeValueTemplate.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, ≈428🔥, 1💬
Related Topics: