JDK14/Java14源码在线阅读
/*
* Copyright (c) 2015, 2019, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package jdk.jshell;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import static java.util.stream.Collectors.joining;
import static jdk.jshell.Util.DOIT_METHOD_NAME;
/**
* Wrapping of source into Java methods, fields, etc. All but outer layer
* wrapping with imports and class.
*/
abstract class Wrap implements GeneralWrap {
private static Wrap methodWrap(String prefix, String source, String suffix) {
Wrap wunit = new NoWrap(source);
return new DoitMethodWrap(new CompoundWrap(prefix, wunit, suffix));
}
public static Wrap methodWrap(String source) {
return methodWrap("", source, semi(source) + " return null;\n");
}
public static Wrap methodReturnWrap(String source) {
return methodWrap("return ", source, semi(source));
}
public static Wrap methodUnreachableSemiWrap(String source) {
return methodWrap("", source, semi(source));
}
public static Wrap methodUnreachableWrap(String source) {
return methodWrap("", source, "");
}
private static String indent(int n) {
return " ".substring(0, n * 4);
}
private static String nlindent(int n) {
return "\n" + indent(n);
}
/**Create a stub of a compilable representation of a variable snippet.
* The variable is always represented by a field. If the variable
* in the snippet has an initializer, the field is initialized by
* calling the DOIT_METHOD_NAME method.
*
* In some cases, the real inferred type of the variable may be non-denotable
* (e.g. intersection types). The declared type of the field must always
* be denotable (i.e. such that it can be written into the classfile), but
* if the real type is potentially non-denotable, the {@code enhanced} parameter
* must be true.
*
* @param source the snippet's masked source code
* @param wtype variable's denotable type suitable for field declaration
* @param brackets any [] that should be appended to the type
* @param rname range in source that denotes the name of the
* @param winit Initializer or null
* @param enhanced if the real inferred type of the variable is potentially
* non-denotable, this must be true
* @return a Wrap that declares the given variable, potentially with
* an initialization method
*/
public static Wrap varWrap(String source, Wrap wtype, String brackets,
Range rname, Wrap winit, boolean enhanced,
Wrap anonDeclareWrap) {
RangeWrap wname = new RangeWrap(source, rname);
List<Object> components = new ArrayList<>();
components.add(new VarDeclareWrap(wtype, brackets, wname));
Wrap wmeth;
if (winit == null) {
wmeth = new CompoundWrap(new NoWrap(" "), " return null;\n");
} else {
// int x = y
if (enhanced) {
// private static <Z> Z do_itAux() {
// wtype x_ = y;
// @SuppressWarnings("unchecked")
// Z x__ = (Z) x_;
// return x__;
// }
// in do_it method:
//return do_itAux();
Wrap waux = new CompoundWrap(
" private static <Z> Z ", DOIT_METHOD_NAME + "Aux", "() throws Throwable {\n",
wtype, brackets + " ", wname, "_ =\n ", winit, semi(winit),
" @SuppressWarnings(\"unchecked\") Z ", wname, "__ = (Z)", wname, "_;\n",
" return ", wname, "__;\n",
"}"
);
components.add(waux);
wmeth = new CompoundWrap(
" return ", wname, " = ", DOIT_METHOD_NAME + "Aux", "();\n"
);
} else {
// int x_ = y; return x = x_;
// decl + "_ = " + init ; + "return " + name + "= " + name + "_ ;"
wmeth = new CompoundWrap(
wtype, brackets + " ", wname, "_ =\n ", winit, semi(winit),
" return ", wname, " = ", wname, "_;\n"
);
}
}
components.add(new DoitMethodWrap(wmeth));
if (anonDeclareWrap != null) {
components.add(anonDeclareWrap);
}
return new CompoundWrap(components.toArray());
}
public static Wrap tempVarWrap(String source, String typename, String name, Wrap anonDeclareWrap) {
RangeWrap winit = new NoWrap(source);
// y
// return $1 = y;
// "return " + $1 + "=" + init ;
Wrap wmeth = new CompoundWrap("return " + name + " =\n ", winit, semi(winit));
Wrap wInitMeth = new DoitMethodWrap(wmeth);
String varDecl = " public static\n " + typename + " " + name + ";\n";
return anonDeclareWrap != null ? new CompoundWrap(varDecl, wInitMeth, anonDeclareWrap)
: new CompoundWrap(varDecl, wInitMeth);
}
public static Wrap simpleWrap(String source) {
return new NoWrap(source);
}
public static Wrap identityWrap(String source) {
return new NoWrap(source);
}
public static Wrap rangeWrap(String source, Range range) {
return new RangeWrap(source, range);
}
public static Wrap classMemberWrap(String source) {
Wrap w = new NoWrap(source);
return new CompoundWrap(" public static\n ", w);
}
private static int countLines(String s) {
return countLines(s, 0, s.length());
}
private static int countLines(String s, int from, int toEx) {
int cnt = 0;
int idx = from;
while ((idx = s.indexOf('\n', idx)) > 0) {
if (idx >= toEx) break;
++cnt;
++idx;
}
return cnt;
}
public static final class Range {
final int begin;
final int end; // exclusive
Range(int begin, int end) {
this.begin = begin;
this.end = end;
}
Range(String s) {
this.begin = 0;
this.end = s.length();
}
String part(String s) {
return s.substring(begin, end);
}
int length() {
return end - begin;
}
boolean isEmpty() {
return end == begin;
}
void verify(String s) {
if (begin < 0 || end <= begin || end > s.length()) {
throw new InternalError("Bad Range: " + s + "[" + begin + "," + end + "]");
}
}
@Override
public String toString() {
return "Range[" + begin + "," + end + ")";
}
}
public static class CompoundWrap extends Wrap {
final Object[] os;
final String wrapped;
final int snidxFirst;
final int snidxLast;
final int snlineFirst;
final int snlineLast;
CompoundWrap(Object... os) {
this.os = os;
int sniFirst = Integer.MAX_VALUE;
int sniLast = Integer.MIN_VALUE;
int snlnFirst = Integer.MAX_VALUE;
int snlnLast = Integer.MIN_VALUE;
StringBuilder sb = new StringBuilder();
for (Object o : os) {
if (o instanceof String) {
String s = (String) o;
sb.append(s);
} else if (o instanceof Wrap) {
Wrap w = (Wrap) o;
if (w.firstSnippetIndex() < sniFirst) {
sniFirst = w.firstSnippetIndex();
}
if (w.lastSnippetIndex() > sniLast) {
sniLast = w.lastSnippetIndex();
}
if (w.firstSnippetLine() < snlnFirst) {
snlnFirst = w.firstSnippetLine();
}
if (w.lastSnippetLine() > snlnLast) {
snlnLast = w.lastSnippetLine();
}
sb.append(w.wrapped());
} else {
throw new InternalError("Bad object in CommoundWrap: " + o);
}
}
this.wrapped = sb.toString();
this.snidxFirst = sniFirst;
this.snidxLast = sniLast;
this.snlineFirst = snlnFirst;
this.snlineLast = snlnLast;
}
@Override
public String wrapped() {
return wrapped;
}
@Override
public int snippetIndexToWrapIndex(int sni) {
int before = 0;
for (Object o : os) {
if (o instanceof String) {
String s = (String) o;
before += s.length();
} else if (o instanceof Wrap) {
Wrap w = (Wrap) o;
if (sni >= w.firstSnippetIndex() && sni < w.lastSnippetIndex()) {
int wwi = w.snippetIndexToWrapIndex(sni);
debugWrap("\nCommoundWrap.snippetIndexToWrapIndex: SnippetIndex(%d) -> WrapIndex(%d + %d = %d)"
+ "\n === %s",
sni, wwi, before, wwi + before, wrapped());
return wwi + before;
}
before += w.wrapped().length();
}
}
return 0;
}
Wrap wrapIndexToWrap(long wi) {
int before = 0;
Wrap w = null;
for (Object o : os) {
if (o instanceof String) {
String s = (String) o;
before += s.length();
} else if (o instanceof Wrap) {
w = (Wrap) o;
int len = w.wrapped().length();
if ((wi - before) <= len) {
debugWrap("CommoundWrap.wrapIndexToWrap: Defer to wrap %s - wi: %d. before; %d >>> %s\n",
w, wi, before, w.wrapped());
return w;
}
before += len;
}
}
return w;
}
@Override
public int wrapIndexToSnippetIndex(int wi) {
int before = 0;
for (Object o : os) {
if (o instanceof String) {
String s = (String) o;
before += s.length();
} else if (o instanceof Wrap) {
Wrap w = (Wrap) o;
int len = w.wrapped().length();
if ((wi - before) <= len) {
int si = w.wrapIndexToSnippetIndex(wi - before);
debugWrap("\nCommoundWrap.wrapIndexToSnippetIndex: WrapIndex(%d) -> SnippetIndex(%d)\n",
wi, si);
return si;
}
before += len;
}
}
return lastSnippetIndex();
}
@Override
public int firstSnippetIndex() {
return snidxFirst;
}
@Override
public int lastSnippetIndex() {
return snidxLast;
}
@Override
public int snippetLineToWrapLine(int snline) {
int before = 0;
for (Object o : os) {
if (o instanceof String) {
String s = (String) o;
before += countLines(s);
} else if (o instanceof Wrap) {
Wrap w = (Wrap) o;
if (snline >= w.firstSnippetLine() && snline <= w.lastSnippetLine()) {
return w.snippetLineToWrapLine(snline) + before;
}
before += countLines(w.wrapped());
}
}
return 0;
}
Wrap wrapLineToWrap(int wline) {
int before = 0;
Wrap w = null;
for (Object o : os) {
if (o instanceof String) {
String s = (String) o;
before += countLines(s);
} else if (o instanceof Wrap) {
w = (Wrap) o;
int lns = countLines(w.wrapped());
if ((wline - before) <= lns) {
return w;
}
before += lns;
}
}
return w;
}
@Override
public int wrapLineToSnippetLine(int wline) {
int before = 0;
for (Object o : os) {
if (o instanceof String) {
String s = (String) o;
before += countLines(s);
} else if (o instanceof Wrap) {
Wrap w = (Wrap) o;
int lns = countLines(w.wrapped());
if ((wline - before) <= lns) {
return w.wrapLineToSnippetLine(wline - before);
}
before += lns;
}
}
return 0;
}
@Override
public int firstSnippetLine() {
return snlineFirst;
}
@Override
public int lastSnippetLine() {
return snlineLast;
}
@Override
public String toString() {
return "CompoundWrap(" + Arrays.stream(os)
.map(o -> (o instanceof String)
? "\"" + o + "\""
: o.toString())
.collect(joining(","))
+ ")";
}
}
static class RangeWrap extends Wrap {
final Range range;
final String wrapped; // The snippet portion of the source
final int firstSnline; // Line count to start of snippet portion
final int lastSnline; // Line count to end of snippet portion
RangeWrap(String snippetSource, Range usedWithinSnippet) {
this.range = usedWithinSnippet;
this.wrapped = usedWithinSnippet.part(snippetSource);
usedWithinSnippet.verify(snippetSource);
this.firstSnline = countLines(snippetSource, 0, range.begin);
this.lastSnline = firstSnline + countLines(snippetSource, range.begin, range.end);
}
@Override
public String wrapped() {
return wrapped;
}
@Override
public int snippetIndexToWrapIndex(int sni) {
if (sni < range.begin) {
debugWrap("\nRangeWrap.snippetIndexToWrapIndex: ERR before SnippetIndex(%d) -> WrapIndex(%d + %d = %d)\n",
sni, 0);
return 0;
}
if (sni > range.end) {
debugWrap("\nRangeWrap.snippetIndexToWrapIndex: ERR after SnippetIndex(%d) -> WrapIndex(%d + %d = %d)\n",
sni, range.length());
return range.length();
}
int wi = sni - range.begin;
debugWrap("\nRangeWrap.snippetIndexToWrapIndex: SnippetIndex(%d) -> WrapIndex(%d + %d = %d)"
+ "\n === %s",
sni, sni, range.begin, sni - range.begin, wrapped());
return wi;
}
@Override
public int wrapIndexToSnippetIndex(int wi) {
if (wi < 0) {
debugWrap("\nRangeWrap.wrapIndexToSnippetIndex: ERR before WrapIndex(%d) -> SnippetIndex(%d)\n",
wi, 0);
return 0; // bad index
}
int max = range.length();
if (wi > max) {
debugWrap("\nRangeWrap.wrapIndexToSnippetIndex: ERR after WrapIndex(%d) -> SnippetIndex(%d)\n",
wi, max + range.begin);
return max + range.begin;
}
int sni = wi + range.begin;
debugWrap("\nRangeWrap.wrapIndexToSnippetIndex: WrapIndex(%d) -> SnippetIndex(%d)\n",
wi, sni);
return sni;
}
@Override
public int firstSnippetIndex() {
return range.begin;
}
@Override
public int lastSnippetIndex() {
return range.end;
}
@Override
/**代码未完, 请加载全部代码(NowJava.com).**/
关注时代Java
关注时代Java