text
stringlengths 9
39.2M
| dir
stringlengths 25
226
| lang
stringclasses 163
values | created_date
timestamp[s] | updated_date
timestamp[s] | repo_name
stringclasses 751
values | repo_full_name
stringclasses 752
values | star
int64 1.01k
183k
| len_tokens
int64 1
18.5M
|
|---|---|---|---|---|---|---|---|---|
```java
package com.github.jvmgo.clazz.constant;
import com.github.jvmgo.clazz.ClassReader;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class CONSTANT_Fieldref extends CONSTANT {
private int class_index;
private int name_and_type_index;
@Override
public int getTag() {
return 9;
}
@Override
public CONSTANT parse(ClassReader classReader) {
CONSTANT_Fieldref constant = new CONSTANT_Fieldref();
constant.setTag(getTag());
constant.setClass_index(classReader.readU2());
constant.setName_and_type_index(classReader.readU2());
return constant;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/clazz/constant/CONSTANT_Fieldref.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 135
|
```java
package com.github.jvmgo.clazz.constant;
import com.github.jvmgo.clazz.ClassReader;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class CONSTANT_Utf8_info extends CONSTANT {
private int length;
private byte[] bytes;
@Override
public int getTag() {
return 1;
}
@Override
public CONSTANT parse(ClassReader classReader) {
CONSTANT_Utf8_info constant = new CONSTANT_Utf8_info();
constant.setTag(getTag());
constant.setLength(classReader.readU2());
byte[] bs = new byte[constant.getLength()];
for (int i = 0; i < constant.getLength(); i++) {
bs[i] = classReader.readU1Byte();
}
constant.setBytes(bs);
return constant;
}
public String parseString() {
return new String(bytes);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/clazz/constant/CONSTANT_Utf8_info.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 188
|
```java
package com.github.jvmgo.clazz.constant;
import com.github.jvmgo.clazz.ClassReader;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class CONSTANT_MethodType_info extends CONSTANT {
private int descriptor_index;
@Override
public int getTag() {
return 16;
}
@Override
public CONSTANT parse(ClassReader classReader) {
CONSTANT_MethodType_info constant = new CONSTANT_MethodType_info();
constant.setTag(getTag());
constant.setDescriptor_index(classReader.readU2());
return constant;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/clazz/constant/CONSTANT_MethodType_info.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 118
|
```java
package com.github.jvmgo.clazz.constant;
import com.github.jvmgo.clazz.ClassReader;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class CONSTANT_InterfaceMethodref_info extends CONSTANT {
private int class_index;
private int name_and_type_index;
@Override
public int getTag() {
return 11;
}
@Override
public CONSTANT parse(ClassReader classReader) {
CONSTANT_InterfaceMethodref_info constant = new CONSTANT_InterfaceMethodref_info();
constant.setTag(getTag());
constant.setClass_index(classReader.readU2());
constant.setName_and_type_index(classReader.readU2());
return constant;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/clazz/constant/CONSTANT_InterfaceMethodref_info.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 141
|
```java
package com.github.jvmgo.clazz.constant;
import com.github.jvmgo.clazz.ClassReader;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class CONSTANT_InvokeDynamic_info extends CONSTANT {
private int bootstrap_method_attr_index;
private int name_and_type_index;
@Override
public int getTag() {
return 18;
}
@Override
public CONSTANT parse(ClassReader classReader) {
CONSTANT_InvokeDynamic_info constant = new CONSTANT_InvokeDynamic_info();
constant.setTag(getTag());
constant.setBootstrap_method_attr_index(classReader.readU2());
constant.setName_and_type_index(classReader.readU2());
return constant;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/clazz/constant/CONSTANT_InvokeDynamic_info.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 142
|
```java
package com.github.jvmgo.clazz.constant;
import com.github.jvmgo.clazz.ClassReader;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class CONSTANT_MethodHandle_info extends CONSTANT {
private int reference_kind;
private int reference_index;
@Override
public int getTag() {
return 15;
}
@Override
public CONSTANT parse(ClassReader classReader) {
CONSTANT_MethodHandle_info constant = new CONSTANT_MethodHandle_info();
constant.setTag(getTag());
constant.setReference_kind(classReader.readU1());
constant.setReference_index(classReader.readU2());
return constant;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/clazz/constant/CONSTANT_MethodHandle_info.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 135
|
```java
package com.github.jvmgo.clazz.attribute;
import com.github.jvmgo.clazz.ClassFile;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class StackMapTable extends Attribute_info {
private int number;
private Stack_map_frame[] entries;
@Override
public String getName() {
return "StackMapTable";
}
@Override
public Attribute_info parseAttribute(ClassFile classFile) {
setIndex(0);
setNumber(read(2));
Stack_map_frame[] stack_map_frames = new Stack_map_frame[getNumber()];
for (int i = 0; i < getNumber(); i++) {
}
setEntries(stack_map_frames);
return this;
}
class Stack_map_frame {
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/clazz/attribute/StackMapTable.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 162
|
```java
package com.github.jvmgo.clazz.attribute;
import com.github.jvmgo.clazz.ClassFile;
import com.github.jvmgo.clazz.ClassReader;
import com.github.jvmgo.clazz.constant.CONSTANT_Utf8_info;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class SourceFile extends Attribute_info {
private String source_file;
@Override
public String getName() {
return "SourceFile";
}
@Override
public SourceFile parseAttribute(ClassFile classFile) {
if (!getName().equals(this.getAttribute_name())) {
throw new RuntimeException("parse source file exception");
}
if (2 != this.getAttribute_length()) {
throw new RuntimeException("parse source file exception");
}
if (2 != this.getInfo().length) {
throw new RuntimeException("parse source file exception");
}
int index = ClassReader.bytesToInt(this.getInfo());
CONSTANT_Utf8_info constant_utf8_info = (CONSTANT_Utf8_info) classFile.getConstantPool()[index];
this.setSource_file(constant_utf8_info.parseString());
return this;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/clazz/attribute/SourceFile.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 236
|
```java
package com.github.jvmgo.clazz.attribute;
import com.github.jvmgo.clazz.ClassFile;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class SourceFileDebugExtension extends Attribute_info {
private String debug_extension;
@Override
public String getName() {
return "SourceFileDebugExtension";
}
@Override
public SourceFileDebugExtension parseAttribute(ClassFile classFile) {
if (!getName().equals(this.getAttribute_name())) {
throw new RuntimeException("parse source file exception");
}
setDebug_extension(new String(getInfo()));
return this;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/clazz/attribute/SourceFileDebugExtension.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 127
|
```java
package com.github.jvmgo.clazz.attribute;
import com.github.jvmgo.clazz.ClassFile;
import com.github.jvmgo.clazz.constant.CONSTANT_Utf8_info;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class Code extends Attribute_info {
//U2
private int max_stack;
//U2
private int max_locals;
//U4
private int code_length;
//U1[]
private byte[] code;
//U2
private int exception_table_length;
private Exception_table[] exception_table;
//U2
private int attributes_count;
private Attribute_info[] attributes;
@Override
public String getName() {
return "Code";
}
@Override
public Code parseAttribute(ClassFile classFile) {
setIndex(0);
if (!getName().equals(this.getAttribute_name())) {
throw new RuntimeException("parse source file exception");
}
max_stack = read(2);
max_locals = read(2);
code_length = read(4);
code = readBytes(code_length);
exception_table_length = read(2);
Exception_table[] exception_tables = new Exception_table[exception_table_length];
for (int i = 0; i < exception_table_length; i++) {
Exception_table exception_table = new Exception_table();
exception_table.setStart_pc(read(2));
exception_table.setEnd_pc(read(2));
exception_table.setHandler_pc(read(2));
exception_table.setCatch_type(read(2));
exception_tables[i] = exception_table;
}
this.setException_table(exception_tables);
attributes_count = read(2);
Attribute_info[] attribute_infos = new Attribute_info[attributes_count];
for (int i = 0; i < attributes_count; i++) {
int pool_index = read(2);
CONSTANT_Utf8_info attributeName = (CONSTANT_Utf8_info) classFile.getConstantPool()[pool_index];
Attribute_info attribute_info = Attribute_info.getInstance(attributeName.parseString());
attribute_info.setAttribute_name(attributeName.parseString());
int u4 = read(4);
attribute_info.setAttribute_length(u4);
attribute_info.setInfo(readBytes(u4));
attribute_infos[i] = attribute_info.parseAttribute(classFile);
}
setAttributes(attribute_infos);
return this;
}
@Getter
@Setter
class Exception_table {
private int start_pc;
private int end_pc;
private int handler_pc;
private int catch_type;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/clazz/attribute/Code.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 535
|
```java
package com.github.jvmgo.clazz.attribute;
import com.github.jvmgo.clazz.ClassFile;
import com.github.jvmgo.clazz.constant.CONSTANT_Class_info;
import lombok.Getter;
import lombok.Setter;
@Setter
@Getter
public class Exceptions extends Attribute_info {
private int number;
private CONSTANT_Class_info[] exceptions;
@Override
public String getName() {
return "Exceptions";
}
@Override
public Attribute_info parseAttribute(ClassFile classFile) {
if (!getName().equals(getAttribute_name())) {
throw new RuntimeException("parse source file exception");
}
setIndex(0);
setNumber(read(2));
CONSTANT_Class_info[] constant_class_infos = new CONSTANT_Class_info[getNumber()];
for (int i = 0; i < constant_class_infos.length; i++) {
CONSTANT_Class_info constant_class_info = (CONSTANT_Class_info) classFile.getConstantPool()[read(2)];
exceptions[i] = constant_class_info;
}
setExceptions(constant_class_infos);
return this;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/clazz/attribute/Exceptions.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 224
|
```java
package com.github.jvmgo.clazz.attribute;
import com.github.jvmgo.clazz.ClassFile;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class Synthetic extends Attribute_info {
@Override
public String getName() {
return "Synthetic";
}
@Override
public Attribute_info parseAttribute(ClassFile classFile) {
setIndex(0);
if (!getName().equals(getAttribute_name())) {
throw new RuntimeException("parse source file exception");
}
if (0 != getInfo().length || 0 != getAttribute_length()) {
throw new RuntimeException("parse source file exception");
}
return this;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/clazz/attribute/Synthetic.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 140
|
```java
package com.github.jvmgo.clazz.attribute;
import com.github.jvmgo.clazz.ClassFile;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class MethodParameters extends Attribute_info {
@Override
public String getName() {
return "MethodParameters";
}
@Override
public MethodParameters parseAttribute(ClassFile classFile) {
setIndex(0);
if (!getName().equals(this.getAttribute_name())) {
throw new RuntimeException("parse source file exception");
}
return this;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/clazz/attribute/MethodParameters.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 112
|
```java
package com.github.jvmgo.clazz.attribute;
import com.github.jvmgo.clazz.ClassFile;
import com.github.jvmgo.clazz.constant.CONSTANT_Utf8_info;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class RuntimeVisibleAnnotations extends Attribute_info {
private int num_annotations;
private Annotation[] annotations;
@Override
public String getName() {
return "RuntimeVisibleAnnotations";
}
@Override
public Attribute_info parseAttribute(ClassFile classFile) {
setIndex(0);
if (!getName().equals(getAttribute_name())) {
throw new RuntimeException("parse source file exception");
}
setNum_annotations(read(2));
Annotation[] annotations = new Annotation[getNum_annotations()];
for (int i = 0; i < getNum_annotations(); i++) {
Annotation annotation = new Annotation();
CONSTANT_Utf8_info constant_utf8_info = (CONSTANT_Utf8_info) classFile.getConstantPool()[read(2)];
annotation.setType(constant_utf8_info.parseString());
annotation.setNum(read(2));
Annotation_element[] annotation_elements = new Annotation_element[annotation.getNum()];
for (int j = 0; j < annotation_elements.length; j++) {
Annotation_element annotation_element = new Annotation_element();
CONSTANT_Utf8_info constant_utf8_info1 = (CONSTANT_Utf8_info) classFile.getConstantPool()[read(2)];
annotation_element.setElement_name(constant_utf8_info.parseString());
Element_value element_value = new Element_value();
//TODO
annotation_element.setElement_value(element_value);
annotation_elements[j] = annotation_element;
}
annotation.setElements(annotation_elements);
annotations[i] = annotation;
}
setAnnotations(annotations);
return this;
}
@Getter
@Setter
class Annotation {
private String type;
private int num;
private Annotation_element[] elements;
}
@Getter
@Setter
class Annotation_element {
private String element_name;
private Element_value element_value;
}
@Getter
@Setter
class Element_value {
private byte tag;
private Object value;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/clazz/attribute/RuntimeVisibleAnnotations.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 461
|
```java
package com.github.jvmgo.clazz.attribute;
import com.github.jvmgo.clazz.ClassFile;
import com.github.jvmgo.clazz.constant.CONSTANT_Utf8_info;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class Signature extends Attribute_info {
private String signature;
@Override
public String getName() {
return "Signature";
}
@Override
public Signature parseAttribute(ClassFile classFile) {
if (!getName().equals(this.getAttribute_name())) {
throw new RuntimeException("parse source file exception");
}
int index = read(2);
CONSTANT_Utf8_info constant_utf8_info = (CONSTANT_Utf8_info) classFile.getConstantPool()[index];
setSignature(constant_utf8_info.parseString());
return this;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/clazz/attribute/Signature.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 171
|
```java
package com.github.jvmgo.clazz.attribute;
import com.github.jvmgo.clazz.ClassFile;
import com.github.jvmgo.clazz.constant.CONSTANT_Utf8_info;
import lombok.Getter;
import lombok.Setter;
@Setter
@Getter
public class LocalVariableTypeTable extends Attribute_info {
private int local_variable_type_table_length;
private Local_variable_table[] local_variable_type_tables;
@Override
public String getName() {
return "LocalVariableTable";
}
@Override
public Attribute_info parseAttribute(ClassFile classFile) {
setIndex(0);
setLocal_variable_type_table_length(read(2));
Local_variable_table[] local_variable_tables = new Local_variable_table[getLocal_variable_type_table_length()];
for (int i = 0; i < getLocal_variable_type_table_length(); i++) {
Local_variable_table local_variable_table = new Local_variable_table();
local_variable_table.setStart_pc(read(2));
local_variable_table.setLength(read(2));
CONSTANT_Utf8_info constant = (CONSTANT_Utf8_info) classFile.getConstantPool()[read(2)];
local_variable_table.setName(constant.parseString());
CONSTANT_Utf8_info constant2 = (CONSTANT_Utf8_info) classFile.getConstantPool()[read(2)];
local_variable_table.setSignature(constant2.parseString());
local_variable_table.setIndex(read(2));
local_variable_tables[i] = local_variable_table;
}
setLocal_variable_type_tables(local_variable_tables);
return this;
}
@Setter
@Getter
class Local_variable_table {
private int start_pc;
private int length;
private String name;
private String signature;
private int index;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/clazz/attribute/LocalVariableTypeTable.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 366
|
```java
package com.github.jvmgo.clazz.attribute;
import com.github.jvmgo.clazz.ClassFile;
import com.github.jvmgo.clazz.constant.CONSTANT_Utf8_info;
import lombok.Getter;
import lombok.Setter;
@Setter
@Getter
public class LocalVariableTable extends Attribute_info {
private int local_variable_table_length;
private Local_variable_table[] local_variable_tables;
@Override
public String getName() {
return "LocalVariableTable";
}
@Override
public Attribute_info parseAttribute(ClassFile classFile) {
setIndex(0);
setLocal_variable_table_length(read(2));
Local_variable_table[] local_variable_tables = new Local_variable_table[local_variable_table_length];
for (int i = 0; i < local_variable_table_length; i++) {
Local_variable_table local_variable_table = new Local_variable_table();
local_variable_table.setStart_pc(read(2));
local_variable_table.setLength(read(2));
CONSTANT_Utf8_info constant = (CONSTANT_Utf8_info) classFile.getConstantPool()[read(2)];
local_variable_table.setName(constant.parseString());
CONSTANT_Utf8_info constant2 = (CONSTANT_Utf8_info) classFile.getConstantPool()[read(2)];
local_variable_table.setDescriptor(constant2.parseString());
local_variable_table.setIndex(read(2));
local_variable_tables[i] = local_variable_table;
}
setLocal_variable_tables(local_variable_tables);
return this;
}
@Setter
@Getter
class Local_variable_table {
private int start_pc;
private int length;
private String name;
private String descriptor;
private int index;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/clazz/attribute/LocalVariableTable.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 357
|
```java
package com.github.jvmgo.clazz.attribute;
import com.github.jvmgo.clazz.ClassFile;
import com.github.jvmgo.clazz.constant.CONSTANT_Class_info;
import com.github.jvmgo.clazz.constant.CONSTANT_NameAndType_info;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class EnclosingMethod extends Attribute_info {
private CONSTANT_Class_info clazz;
private CONSTANT_NameAndType_info method;
@Override
public String getName() {
return "EnclosingMethod";
}
@Override
public EnclosingMethod parseAttribute(ClassFile classFile) {
if (!getName().equals(this.getAttribute_name())) {
throw new RuntimeException("parse source file exception");
}
if (4 != this.getAttribute_length()) {
throw new RuntimeException("parse source file exception");
}
int clazz_index = read(2);
CONSTANT_Class_info constant_class_info = (CONSTANT_Class_info) classFile.getConstantPool()[clazz_index];
setClazz(constant_class_info);
int method_index = read(2);
if (method_index == 0) {
setMethod(null);
} else {
CONSTANT_NameAndType_info constant_nameAndType_info = (CONSTANT_NameAndType_info) classFile.getConstantPool()[method_index];
setMethod(constant_nameAndType_info);
}
return this;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/clazz/attribute/EnclosingMethod.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 288
|
```java
package com.github.jvmgo.clazz.attribute;
import com.github.jvmgo.clazz.ClassFile;
import com.github.jvmgo.clazz.constant.CONSTANT;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class ConstantValue extends Attribute_info {
private CONSTANT constant_value;
@Override
public String getName() {
return "ConstantValue";
}
@Override
public Attribute_info parseAttribute(ClassFile classFile) {
setIndex(0);
if (!getName().equals(getAttribute_name())) {
throw new RuntimeException("parse source file exception");
}
if (2 != getInfo().length || 2 != getAttribute_length()) {
throw new RuntimeException("parse source file exception");
}
int pool_index = read(2);
CONSTANT constant = classFile.getConstantPool()[pool_index];
setConstant_value(constant);
return this;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/clazz/attribute/ConstantValue.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 189
|
```java
package com.github.jvmgo.clazz.attribute;
import com.github.jvmgo.clazz.ClassFile;
import com.github.jvmgo.clazz.ClassReader;
import lombok.Getter;
import lombok.Setter;
import java.util.Arrays;
import java.util.HashMap;
@Getter
@Setter
public abstract class Attribute_info {
private String attribute_name;
private int attribute_length;
private byte[] info;
public abstract String getName();
public abstract Attribute_info parseAttribute(ClassFile classFile);
private static HashMap<String, Attribute_info> map = new HashMap<>();
static {
Code code = new Code();
ConstantValue constantValue = new ConstantValue();
Deprecated deprecated = new Deprecated();
EnclosingMethod enclosingMethod = new EnclosingMethod();
Exceptions exceptions = new Exceptions();
InnerClasses innerClasses = new InnerClasses();
LineNumberTable lineNumberTable = new LineNumberTable();
LocalVariableTable localVariableTable = new LocalVariableTable();
LocalVariableTypeTable localVariableTypeTable = new LocalVariableTypeTable();
MethodParameters methodParameters = new MethodParameters();
RuntimeVisibleAnnotations runtimeVisibleAnnotations = new RuntimeVisibleAnnotations();
Signature signature = new Signature();
SourceFile sourceFile = new SourceFile();
SourceFileDebugExtension sourceFileDebugExtension = new SourceFileDebugExtension();
StackMapTable stackMapTable = new StackMapTable();
Synthetic synthetic = new Synthetic();
map.put(code.getName(), code);
map.put(constantValue.getName(), constantValue);
map.put(deprecated.getName(), deprecated);
map.put(enclosingMethod.getName(), enclosingMethod);
map.put(exceptions.getName(), exceptions);
map.put(innerClasses.getName(), innerClasses);
map.put(lineNumberTable.getName(), lineNumberTable);
map.put(localVariableTable.getName(), localVariableTable);
map.put(localVariableTypeTable.getName(), localVariableTypeTable);
map.put(methodParameters.getName(), methodParameters);
map.put(runtimeVisibleAnnotations.getName(), runtimeVisibleAnnotations);
map.put(signature.getName(), signature);
map.put(sourceFile.getName(), sourceFile);
map.put(sourceFileDebugExtension.getName(), sourceFileDebugExtension);
map.put(stackMapTable.getName(), stackMapTable);
map.put(synthetic.getName(), synthetic);
}
public static Attribute_info getInstance(String attribute_name) {
return map.get(attribute_name);
}
private int index = 0;
protected int read(int i) {
int k = ClassReader.bytesToInt(Arrays.copyOfRange(getInfo(), index, index + i));
index += i;
return k;
}
protected byte[] readBytes(int length) {
byte[] bytes = Arrays.copyOfRange(this.getInfo(), index, index + length);
index += length;
return bytes;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/clazz/attribute/Attribute_info.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 563
|
```java
package com.github.jvmgo.clazz.attribute;
import com.github.jvmgo.clazz.ClassFile;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class LineNumberTable extends Attribute_info {
private int line_number_table_length;
private Line_number_table[] line_number_table;
@Override
public String getName() {
return "LineNumberTable";
}
@Override
public Attribute_info parseAttribute(ClassFile classFile) {
setIndex(0);
line_number_table_length = read(2);
Line_number_table[] line_number_tables = new Line_number_table[line_number_table_length];
for (int i = 0; i < line_number_table_length; i++) {
Line_number_table line_number_table = new Line_number_table();
line_number_table.setStart_pc(read(2));
line_number_table.setLine_number(read(2));
line_number_tables[i] = line_number_table;
}
this.setLine_number_table(line_number_tables);
return this;
}
@Getter
@Setter
class Line_number_table {
private int start_pc;
private int line_number;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/clazz/attribute/LineNumberTable.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 241
|
```java
package com.github.jvmgo.clazz.attribute;
import com.github.jvmgo.clazz.ClassFile;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class Deprecated extends Attribute_info {
@Override
public String getName() {
return "Deprecated";
}
@Override
public Attribute_info parseAttribute(ClassFile classFile) {
setIndex(0);
if (!getName().equals(getAttribute_name())) {
throw new RuntimeException("parse source file exception");
}
if (0 != getInfo().length || 0 != getAttribute_length()) {
throw new RuntimeException("parse source file exception");
}
return this;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/clazz/attribute/Deprecated.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 139
|
```java
package com.github.jvmgo;
import org.junit.Assert;
import org.junit.Test;
public class UnitTest {
@Test
public void test() {
Assert.assertTrue(true);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch10/src/test/java/com/github/jvmgo/UnitTest.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 41
|
```java
package com.github.jvmgo;
public class Main {
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch10/src/main/java/com/github/jvmgo/Main.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 34
|
```java
package com.github.jvmgo;
import org.junit.Test;
import java.util.Arrays;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
public class ArgsTest {
@Test
public void test() {
assertTrue(Args.parse(new String[]{"-?"}).helpFlag);
assertTrue(Args.parse(new String[]{"-help"}).helpFlag);
assertTrue(Args.parse(new String[]{"-version"}).versionFlag);
assertFalse(Args.parse(new String[]{"-cp"}).ok);
assertFalse(Args.parse(new String[]{"-classpath"}).ok);
assertEquals("foo.jar", Args.parse(new String[]{"-cp", "foo.jar"}).classpath);
assertEquals("foo.jar", Args.parse(new String[]{"-classpath", "foo.jar"}).classpath);
assertEquals("foo/bar", Args.parse(new String[]{"-Xjre", "foo/bar"}).jre);
assertEquals(Arrays.asList("Main", "foo"), Args.parse(new String[]{"Main", "foo"}).mainClassAndArgs);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch03/src/test/java/com/github/jvmgo/ArgsTest.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 221
|
```java
package com.github.jvmgo.clazz.attribute;
import com.github.jvmgo.clazz.ClassFile;
import com.github.jvmgo.clazz.ClassReader;
import com.github.jvmgo.clazz.constant.CONSTANT_Class_info;
import com.github.jvmgo.clazz.constant.CONSTANT_Utf8_info;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class InnerClasses extends Attribute_info {
private int number;
private Clazz[] classes;
@Override
public String getName() {
return "InnerClasses";
}
@Override
public Attribute_info parseAttribute(ClassFile classFile) {
if (!getName().equals(getAttribute_name())) {
throw new RuntimeException("parse source file exception");
}
setIndex(0);
setNumber(read(2));
Clazz[] clazzes = new Clazz[getNumber()];
for (int i = 0; i < clazzes.length; i++) {
Clazz clazz = new Clazz();
CONSTANT_Class_info inner = (CONSTANT_Class_info) classFile.getConstantPool()[read(2)];
clazz.setInner_class_info(inner);
CONSTANT_Class_info outer = (CONSTANT_Class_info) classFile.getConstantPool()[read(2)];
clazz.setOuter_class_info(outer);
int read = read(2);
if (read == 0)
clazz.setInner_name(null);
else {
CONSTANT_Utf8_info inner_name = (CONSTANT_Utf8_info) classFile.getConstantPool()[read];
clazz.setInner_name(inner_name);
}
byte[] bytes = readBytes(2);
String s = ClassReader.toHexString(bytes);
if (s.length() < 4) {
for (; 0 < 4 - s.length(); ) {
s = "0" + s;
}
}
clazz.setInner_class_access_flag(parseAccessFlag(s));
clazzes[i] = clazz;
}
setClasses(clazzes);
return this;
}
private String parseAccessFlag(String s) {
StringBuilder builder = new StringBuilder();
switch (s.charAt(3)) {
case '0':
break;
case '1':
builder.append("ACC_PUBLIC ");
break;
case '2':
builder.append("ACC_PRIVATE ");
break;
case '4':
builder.append("ACC_PROTECTED ");
break;
case '8':
builder.append("ACC_STATIC ");
break;
default:
throw new RuntimeException("can not parse access flag");
}
switch (s.charAt(2)) {
case '0':
break;
case '1':
builder.append("ACC_FINAL ");
break;
default:
throw new RuntimeException("can not parse access flag");
}
switch (s.charAt(1)) {
case '0':
break;
case '2':
builder.append("ACC_INTERFACE ");
break;
case '4':
builder.append("ACC_ABSTRACT ");
break;
default:
throw new RuntimeException("can not parse access flag");
}
switch (s.charAt(0)) {
case '0':
break;
case '1':
builder.append("ACC_SYNTHETIC ");
break;
case '2':
builder.append("ACC_ANNOTATION ");
break;
case '4':
builder.append("ACC_ENUM ");
break;
default:
throw new RuntimeException("can not parse access flag");
}
return builder.toString();
}
@Getter
@Setter
class Clazz {
private CONSTANT_Class_info inner_class_info;
private CONSTANT_Class_info outer_class_info;
private CONSTANT_Utf8_info inner_name;
private String inner_class_access_flag;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/clazz/attribute/InnerClasses.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 793
|
```java
package com.github.jvmgo.classpath;
import org.junit.Test;
import java.io.File;
import java.util.Arrays;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
public class EntryTest {
@Test
public void create() {
assertEquals(DirEntry.class, Entry.create(".").getClass());
assertEquals(CompositeEntry.class,
Entry.create("foo.jar" + File.pathSeparator + "bar.jar").getClass());
assertEquals(WildcardEntry.class, Entry.create("foo/bar/*").getClass());
}
@Test
public void dirEntry() throws Exception {
String className = EntryTest.class.getName().replace('.', '/') + ".class";
String classesDir = EntryTest.class.getResource("EntryTest.class")
.getPath().replace(className, "");
Entry entry = Entry.create(classesDir);
assertEquals(DirEntry.class, entry.getClass());
byte[] data = entry.readClass(className);
assertNotNull(data);
}
@Test
public void zipEntry() throws Exception {
String[] cp = System.getProperty("java.class.path").split(File.pathSeparator);
String rtJarPath = Arrays.stream(cp)
.filter(path -> path.endsWith("/junit-4.12.jar"))
.findFirst()
.get();
Entry entry = Entry.create(rtJarPath);
assertEquals(ZipEntry.class, entry.getClass());
byte[] data = entry.readClass("org/junit/Test.class");
assertNotNull(data);
}
@Test
public void compositeEntry() throws Exception {
String cp = System.getProperty("java.class.path");
Entry entry = Entry.create(cp);
assertEquals(CompositeEntry.class, entry.getClass());
byte[] data = entry.readClass("org/junit/Test.class");
assertNotNull(data);
}
@Test
public void wildcardEntry() throws Exception {
String[] cp = System.getProperty("java.class.path").split(File.pathSeparator);
String rtJarPath = Arrays.stream(cp)
.filter(path -> path.endsWith("/junit-4.12.jar"))
.findFirst()
.get()
.replace("/junit-4.12.jar", "/*");
Entry entry = Entry.create(rtJarPath);
assertEquals(WildcardEntry.class, entry.getClass());
byte[] data = entry.readClass("org/junit/Test.class");
assertNotNull(data);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch03/src/test/java/com/github/jvmgo/classpath/EntryTest.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 487
|
```java
package com.github.jvmgo;
import com.github.jvmgo.classfile.ClassFile;
import com.github.jvmgo.classfile.MemberInfo;
import com.github.jvmgo.classfile.constantpool.ConstantInfo;
import com.github.jvmgo.classfile.constantpool.ConstantPool;
import com.github.jvmgo.classpath.Classpath;
public class Main {
private ClassFile cf;
public static void main(String[] argv) {
Args args = Args.parse(argv);
if (!args.ok || args.helpFlag) {
System.out.println("Usage: <main class> [-options] class [args...]");
} else if (args.versionFlag) {
System.out.println("java version \"1.8.0\"");
} else {
startJVM(args);
}
}
private static void startJVM(Args args) {
Classpath cp = new Classpath(args.jre, args.classpath);
System.out.printf("classpath:%s class:%s args:%s\n",
cp, args.getMainClass(), args.getAppArgs());
String className = args.getMainClass().replace(".", "/");
try {
byte[] classData = cp.readClass(className);
ClassFile classFile = new ClassFile(classData);
printClassInfo(classFile);
} catch (Exception e) {
System.out.print(e.getMessage());
System.out.println("Could not find or load main class " + args.getMainClass());
}
}
private static void printClassInfo(ClassFile cf) {
System.out.println("version: "+ cf.getMajorVersion()+"."+cf.getMinorVersion());
ConstantPool constantPool = cf.getConstantPool();
ConstantInfo[] constantInfos = constantPool.getConstantInfos();
System.out.println("constants count: "+ constantPool.getConstantPoolSize());
for(int i = 1; i < constantPool.getConstantPoolSize() ; i++) {
if(constantInfos[i]!=null){
System.out.println(i+": "+constantInfos[i]);
}
}
System.out.format("access flags: 0x%x\n", cf.getAccessFlag());
System.out.println("this class: "+ constantPool.getUTF8(cf.getClassNameIndex()));
System.out.println("super class: "+ constantPool.getUTF8(cf.getSuperClassNameIndex()));
System.out.println("interfaces: "+cf.getInterfaceIndexes().length);
MemberInfo[] fields = cf.getFields();
System.out.println("fields count: "+ fields.length);
for (MemberInfo memberInfo : fields) {
System.out.format(" %s\n", constantPool.getUTF8(memberInfo.getNameIndex()));
}
MemberInfo[] methods = cf.getMethods();
System.out.println("methods count: "+ methods.length);
for (MemberInfo memberInfo : methods) {
System.out.format(" %s\n", constantPool.getUTF8(memberInfo.getNameIndex()));
}
}
public static void panic(String msg) {
System.out.println(msg);
System.exit(0);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch03/src/main/java/com/github/jvmgo/Main.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 627
|
```java
package com.github.jvmgo;
import com.beust.jcommander.JCommander;
import com.beust.jcommander.Parameter;
import com.beust.jcommander.ParameterException;
import java.util.List;
public class Args {
@Parameter(names = {"-?", "-help"}, description = "print help message", order = 3, help = true)
boolean helpFlag = false;
@Parameter(names = "-version", description = "print version and exit", order = 2)
boolean versionFlag = false;
@Parameter(names = { "-cp", "-classpath" }, description = "classpath", order = 1)
String classpath;
@Parameter(names = "-Xjre", description = "path to jre", order = 4)
String jre;
@Parameter(description = "main class and args")
List<String> mainClassAndArgs;
boolean ok;
String getMainClass() {
return mainClassAndArgs != null && !mainClassAndArgs.isEmpty()
? mainClassAndArgs.get(0)
: null;
}
List<String> getAppArgs() {
return mainClassAndArgs != null && mainClassAndArgs.size() >1
? mainClassAndArgs.subList(1, mainClassAndArgs.size())
: null;
}
static Args parse(String[] argv) {
Args args = new Args();
JCommander cmd = JCommander.newBuilder()
.addObject(args)
.build();
try {
cmd.parse(argv);
args.ok = true;
} catch (ParameterException ignored) {
}
return args;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch03/src/main/java/com/github/jvmgo/Args.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 346
|
```java
package com.github.jvmgo.classfile;
import com.github.jvmgo.classfile.attributes.AttributeInfo;
import com.github.jvmgo.classfile.constantpool.ConstantPool;
import lombok.Getter;
/*
field_info {
u2 access_flags;//
u2 name_index;//
u2 descriptor_index;//
//
u2 attributes_count;
attribute_info attributes[attributes_count];
}
*/
@Getter
public class MemberInfo {
private ConstantPool cp;
private int accessFlags;
private int nameIndex;
private int descriptorIndex;
private AttributeInfo[] attributes;
public MemberInfo(ConstantPool constantPool, ClassReader reader) {
cp = constantPool;
accessFlags = reader.nextU2ToInt();
nameIndex = reader.nextU2ToInt();
descriptorIndex = reader.nextU2ToInt();
attributes = AttributeInfo.readAttributes(reader, cp);
}
public static MemberInfo[] readMembers(ConstantPool constantPool, ClassReader reader) {
int fieldCount = reader.nextU2ToInt();
MemberInfo[] fields = new MemberInfo[fieldCount];
for (int i = 0; i < fieldCount; i++) {
fields[i] = new MemberInfo(constantPool, reader);
}
return fields;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch03/src/main/java/com/github/jvmgo/classFile/MemberInfo.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 265
|
```java
package com.github.jvmgo.classfile;
import com.github.jvmgo.util.Util;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.Arrays;
//
public class ClassReader {
private byte[] codes;
private int pos;
public ClassReader(byte[] aClassData) {
this.codes = aClassData;
this.pos = 0;
}
public int nextU1toInt() {
return Util.byteToInt(new byte[]{codes[pos++]});
}
public int nextU2ToInt() {
return Util.byteToInt(new byte[]{codes[pos++], codes[pos++]});
}
public int nextU4ToInt() {
return Util.byteToInt(new byte[]{codes[pos++], codes[pos++], codes[pos++], codes[pos++]});
}
public float nextU4ToFloat() {
byte[] bytes = nextBytes(4);
return ByteBuffer.wrap(bytes).order(ByteOrder.BIG_ENDIAN).getFloat();
}
public String nextU4ToHexString() {
return Util.byteToHexString((new byte[]{codes[pos++], codes[pos++], codes[pos++], codes[pos++]}));
}
public byte[] nextBytes(int len) {
if (pos + len >= codes.length) {
throw new ArrayIndexOutOfBoundsException();
}
byte[] data = Arrays.copyOfRange(codes, pos, pos + len);
pos += len;
return data;
}
public long next2U4ToLong() {
byte[] bytes = nextBytes(8);
return ByteBuffer.wrap(bytes).order(ByteOrder.BIG_ENDIAN).getLong();
}
public double next2U4Double() {
byte[] bytes = nextBytes(8);
return ByteBuffer.wrap(bytes).order(ByteOrder.BIG_ENDIAN).getDouble();
}
public int[] nextUint16s() {
int count = nextU2ToInt();
int[] result = new int[count];
for (int i = 0; i < count; i++) {
result[i] = nextU2ToInt();
}
return result;
}
public void back(int n) {
this.pos -= n;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch03/src/main/java/com/github/jvmgo/classFile/ClassReader.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 457
|
```java
package com.github.jvmgo.classfile.constantpool;
import com.github.jvmgo.classfile.ClassReader;
/**
* @Author: panda
* @Date: 2018/10/3 0003 12:41
*/
public class ConstantDoubleInfo implements ConstantInfo {
private Double value;
public ConstantDoubleInfo(ClassReader reader) {
value = reader.next2U4Double(); //u4
}
@Override
public String getValue() {
return value + "";
}
@Override
public String toString() {
return "Double:" + value;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch03/src/main/java/com/github/jvmgo/classFile/constantPool/ConstantDoubleInfo.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 128
|
```java
package com.github.jvmgo.classfile;
import com.github.jvmgo.classfile.constantpool.ConstantPool;
import lombok.Getter;
@Getter
public class ClassFile {
//private static Long CAFEBABE = new BigInteger("cafebabe",16).longValue();
//private static int ACC_PUBLIC =0x0021;
private int minorVersion;
private int majorVersion;
private ConstantPool constantPool;
private int accessFlag;
private int classNameIndex;
private int superClassNameIndex;
private int[] interfaceIndexes;
private MemberInfo[] fields;
private MemberInfo[] methods;
private ClassReader reader;
public ClassFile(byte[] classData) {
reader = new ClassReader(classData);
this.readAndCheckMagic();
this.readAndCheckVersion();
this.readConstantPool();
this.readAccessFlag();
this.readClassNameIndex();
this.readSuperClassNameIndex();
this.readInterfaceIndexes();
this.readFields();
this.readMethods();
}
//0xCAFEBABE
private void readAndCheckMagic() {
String magic = this.reader.nextU4ToHexString();
if (!"cafebabe".equals(magic)) {
throw new ClassFormatError("magic!");
}
}
private void readAndCheckVersion() {
this.minorVersion = this.reader.nextU2ToInt();
this.majorVersion = this.reader.nextU2ToInt();
if (this.majorVersion >= 46 && this.majorVersion <= 52 && this.minorVersion == 0) {
return;
}
throw new UnsupportedClassVersionError();
}
private void readConstantPool() {
this.constantPool = new ConstantPool(this.reader);
}
private void readAccessFlag() {
accessFlag = reader.nextU2ToInt();
}
private void readClassNameIndex() {
classNameIndex = reader.nextU2ToInt();
}
private void readSuperClassNameIndex() {
superClassNameIndex = reader.nextU2ToInt();
}
private void readInterfaceIndexes() {
interfaceIndexes = reader.nextUint16s();
}
private void readFields() {
fields = MemberInfo.readMembers(constantPool, reader);
}
private void readMethods() {
methods = MemberInfo.readMembers(constantPool, reader);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch03/src/main/java/com/github/jvmgo/classFile/ClassFile.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 490
|
```java
package com.github.jvmgo.classfile.constantpool;
import com.github.jvmgo.classfile.ClassReader;
/**
* @Author: panda
* @Date: 2018/10/3 0003 15:19
* <p>
* CONSTANT_XXXXref_info {
* u1 tag;
* u2 class_index;//CONSTANT_Class_info
* u2 name_and_type_index;//CONSTANT_NameAndType_info
* }
*/
public class ConstantMemberrefInfo implements ConstantInfo {
private ConstantPool constPool;
private int classIndex;
private int nameAndTypeIndex;
public ConstantMemberrefInfo(ConstantPool aConstPool, ClassReader reader) {
this.classIndex = reader.nextU2ToInt();
this.nameAndTypeIndex = reader.nextU2ToInt();
this.constPool = aConstPool;
}
@Override
public String getValue() {
return constPool.getUTF8(classIndex)
+ " " + constPool.getUTF8(nameAndTypeIndex);
}
@Override
public String toString() {
ConstantInfo[] constantInfos = constPool.getConstantInfos();
ConstantClassInfo constClassInfo = (ConstantClassInfo) constantInfos[classIndex];
ConstantNameAndTypeInfo nameAndTypeInfo = (ConstantNameAndTypeInfo) constantInfos[nameAndTypeIndex];
return "ConstantMemberrefInfo{" +
constClassInfo + " " +
nameAndTypeInfo +
'}';
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch03/src/main/java/com/github/jvmgo/classFile/constantPool/ConstantMemberrefInfo.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 305
|
```java
package com.github.jvmgo.classfile.constantpool;
import com.github.jvmgo.classfile.ClassReader;
import lombok.Getter;
@Getter
public class ConstantPool {
private final int constantPoolSize;
private ConstantInfo[] constantInfos;
public ConstantPool(ClassReader reader) {
constantPoolSize = reader.nextU2ToInt();
constantInfos = new ConstantInfo[constantPoolSize];
for (int i = 1; i < constantPoolSize; i++) {
int tag = reader.nextU1toInt();
ConstantInfo constInfo = ConstantInfo.createConstantInfo(tag, reader, this);
constantInfos[i] = constInfo;
if (tag == ConstantInfo.CONST_TAG_DOUBLE || tag == ConstantInfo.CONST_TAG_LONG) {
i++;
}
}
}
public String getUTF8(int index) {
ConstantInfo constInfo = this.constantInfos[index];
return constInfo == null ? "" : constInfo.toString();
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch03/src/main/java/com/github/jvmgo/classFile/constantPool/ConstantPool.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 204
|
```java
package com.github.jvmgo.classfile.constantpool;
import com.github.jvmgo.classfile.ClassReader;
/**
* @Author: panda
* @Date: 2018/10/3 0003 12:41
*/
public class ConstantLongInfo implements ConstantInfo {
private long value;
public ConstantLongInfo(ClassReader reader) {
value = reader.next2U4ToLong(); //u4
}
@Override
public String getValue() {
return value + "";
}
@Override
public String toString() {
return "Long: " + value;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch03/src/main/java/com/github/jvmgo/classFile/constantPool/ConstantLongInfo.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 130
|
```java
package com.github.jvmgo.classfile.constantpool;
import com.github.jvmgo.classfile.ClassReader;
/**
* @Author: panda
* @Date: 2018/10/3 0003 12:41
*/
public class ConstantIntegerInfo implements ConstantInfo {
private Integer value;
public ConstantIntegerInfo(ClassReader reader) {
value = reader.nextU4ToInt(); //u4
}
@Override
public String getValue() {
return value + "";
}
@Override
public String toString() {
return "Integer: " + value;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch03/src/main/java/com/github/jvmgo/classFile/constantPool/ConstantIntegerInfo.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 128
|
```java
package com.github.jvmgo.classfile.constantpool;
import com.github.jvmgo.classfile.ClassReader;
/**
* @Author: panda
* @Date: 2018/10/3 0003 12:41
*/
public class ConstantFloatInfo implements ConstantInfo {
private float value;
public ConstantFloatInfo(ClassReader reader) {
value = reader.nextU4ToFloat();//u4
}
@Override
public String getValue() {
return value + "";
}
@Override
public String toString() {
return "Float: " + value;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch03/src/main/java/com/github/jvmgo/classFile/constantPool/ConstantFloatInfo.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 128
|
```java
package com.github.jvmgo.classfile.constantpool;
import com.github.jvmgo.classfile.ClassReader;
public interface ConstantInfo {
int CONST_TAG_CLASS = 7;
int CONST_TAG_FIELD_REF = 9;
int CONST_TAG_METHOD_REF = 10;
int CONST_TAG_INTERFACE_MTTHOD_REF = 11;
int CONST_TAG_STRING = 8;
int CONST_TAG_INTEGER = 3;
int CONST_TAG_FLOAT = 4;
int CONST_TAG_LONG = 5;
int CONST_TAG_DOUBLE = 6;
int CONST_TAG_NAME_AND_TYPE = 12;
int CONST_TAG_UTF8 = 1;
int CONST_TAG_METHOD_HANDLE = 15;
int CONST_TAG_METHOD_TYPE = 16;
int CONST_TAG_INVOKE_DYNAMIC = 18;
String getValue();
//Factory method
static ConstantInfo createConstantInfo(int tag, ClassReader reader, ConstantPool constPool) {
switch (tag) {
//
case CONST_TAG_INTEGER:
return new ConstantIntegerInfo(reader);
case CONST_TAG_FLOAT:
return new ConstantFloatInfo(reader);
case CONST_TAG_LONG:
return new ConstantLongInfo(reader);
case CONST_TAG_DOUBLE:
return new ConstantDoubleInfo(reader);
case CONST_TAG_UTF8:
return new ConstantUft8Info(reader);
//3UTF8
case CONST_TAG_STRING:
return new ConstantStringInfo(constPool, reader);
case CONST_TAG_CLASS:
return new ConstantClassInfo(constPool, reader);
case CONST_TAG_NAME_AND_TYPE:
return new ConstantNameAndTypeInfo(constPool, reader);
//3CLASS+NAME_AND_TYPE
case CONST_TAG_FIELD_REF:
return new ConstantMemberrefInfo(constPool, reader);
case CONST_TAG_METHOD_REF:
return new ConstantMemberrefInfo(constPool, reader);
case CONST_TAG_INTERFACE_MTTHOD_REF:
return new ConstantMemberrefInfo(constPool, reader);
//Java SE 7classinvokedynamic
case CONST_TAG_METHOD_HANDLE:
return null;
case CONST_TAG_METHOD_TYPE:
return null;
case CONST_TAG_INVOKE_DYNAMIC:
return null;
default:
throw new ClassFormatError("constant pool tag!");
}
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch03/src/main/java/com/github/jvmgo/classFile/constantPool/ConstantInfo.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 470
|
```java
package com.github.jvmgo.classfile.constantpool;
import com.github.jvmgo.classfile.ClassReader;
import lombok.Getter;
/**
* @Author: panda
* @Date: 2018/10/3 0003 15:04
* CONSTANT_NameAndType_info {
* u1 tag;
* u2 name_index;//
* u2 descriptor_index;//
* }
*/
@Getter
public class ConstantNameAndTypeInfo implements ConstantInfo {
private ConstantPool constPool;
private int nameIndex;
private int descriptorIndex;
public ConstantNameAndTypeInfo(ConstantPool aConstPool, ClassReader reader) {
this.nameIndex = reader.nextU2ToInt();
this.descriptorIndex = reader.nextU2ToInt();
this.constPool = aConstPool;
}
@Override
public String getValue() {
return "";
}
@Override
public String toString() {
return this.constPool.getUTF8(this.nameIndex) + "&"
+ this.constPool.getUTF8(this.descriptorIndex);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch03/src/main/java/com/github/jvmgo/classFile/constantPool/ConstantNameAndTypeInfo.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 218
|
```java
package com.github.jvmgo.util;
public class Util {
public static int byteToInt(byte[] codes) {
String s1 = byteToHexString(codes);
return Integer.valueOf(s1, 16).intValue();
}
public static String byteToHexString(byte[] codes) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < codes.length; i++) {
byte b = codes[i];
int value = b & 0xFF;
String strHex = Integer.toHexString(value);
if (strHex.length() < 2) {
strHex = "0" + strHex;
}
sb.append(strHex);
}
return sb.toString();
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch03/src/main/java/com/github/jvmgo/util/Util.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 152
|
```java
package com.github.jvmgo.classfile.constantpool;
import com.github.jvmgo.classfile.ClassReader;
public class ConstantStringInfo implements ConstantInfo {
private ConstantPool constPool;
private int nameIndex;
public ConstantStringInfo(ConstantPool aConstPool, ClassReader reader) {
this.nameIndex = reader.nextU2ToInt();
this.constPool = aConstPool;
}
@Override
public String getValue() {
return this.constPool.getUTF8(this.nameIndex);
}
@Override
public String toString() {
return "ConstStringInfo{" +
"name=" + constPool.getUTF8(nameIndex) +
'}';
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch03/src/main/java/com/github/jvmgo/classfile/constantpool/ConstantStringInfo.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 144
|
```java
package com.github.jvmgo.classfile.constantpool;
import com.github.jvmgo.classfile.ClassReader;
public class ConstantUft8Info implements ConstantInfo {
private String value;
public ConstantUft8Info(ClassReader reader) {
int length = reader.nextU2ToInt();
byte[] bytes = reader.nextBytes(length);
this.value = new String(bytes);
}
@Override
public String getValue() {
return this.value;
}
@Override
public String toString() {
return value;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch03/src/main/java/com/github/jvmgo/classfile/constantpool/ConstantUft8Info.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 115
|
```java
package com.github.jvmgo.classfile.constantpool;
import com.github.jvmgo.classfile.ClassReader;
public class ConstantMethodInfo implements ConstantInfo {
private ConstantPool constPool;
private int classIndex;
private int nameAndTypeIndex;
public ConstantMethodInfo(ConstantPool aConstPool, ClassReader reader) {
this.classIndex = reader.nextU2ToInt();
this.nameAndTypeIndex = reader.nextU2ToInt();
}
@Override
public String getValue() {
return "";
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch03/src/main/java/com/github/jvmgo/classfile/constantpool/ConstantMethodInfo.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 109
|
```java
package com.github.jvmgo.classfile.constantpool;
import com.github.jvmgo.classfile.ClassReader;
import lombok.Getter;
/**
* {
* u1 tag;
* u2 name_index;
* }
*/
@Getter
public class ConstantClassInfo implements ConstantInfo {
private ConstantPool constPool;
private int nameIndex;
public ConstantClassInfo(ConstantPool aConstPool, ClassReader reader) {
this.nameIndex = reader.nextU2ToInt();
this.constPool = aConstPool;
}
@Override
public String getValue() {
return this.constPool.getUTF8(this.nameIndex);
}
@Override
public String toString() {
return constPool.getUTF8(nameIndex);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch03/src/main/java/com/github/jvmgo/classfile/constantpool/ConstantClassInfo.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 153
|
```java
package com.github.jvmgo.classfile.attributes;
import com.github.jvmgo.classfile.ClassReader;
/**
* @Author: panda
* @Date: 2018/10/3 0003 19:47
*/
public class DeprecatedAttribute implements AttributeInfo {
@Override
public void readInfo(ClassReader reader) {
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch03/src/main/java/com/github/jvmgo/classfile/attributes/DeprecatedAttribute.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 74
|
```java
package com.github.jvmgo.classfile.attributes;
import com.github.jvmgo.classfile.ClassReader;
/**
* @Author: panda
* @Date: 2018/10/3 0003 21:57
*/
public class LineNumberTableAttribute implements AttributeInfo {
private LineNumberTableEntry[] lineNumberTable;
@Override
public void readInfo(ClassReader reader) {
int length = reader.nextU2ToInt();
lineNumberTable = new LineNumberTableEntry[length];
for (int i = 0; i < length; i++) {
lineNumberTable[i] = new LineNumberTableEntry(reader);
}
}
private static class LineNumberTableEntry {
private final int startPc;
private final int lineNumber;
public LineNumberTableEntry(ClassReader reader) {
startPc = reader.nextU2ToInt();
lineNumber = reader.nextU2ToInt();
}
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch03/src/main/java/com/github/jvmgo/classfile/attributes/LineNumberTableAttribute.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 196
|
```java
package com.github.jvmgo.classfile.attributes;
import com.github.jvmgo.classfile.ClassReader;
import com.github.jvmgo.classfile.constantpool.ConstantPool;
/**
* ```
* SourceFile_attribute {
* u2 attribute_name_index;
* u4 attribute_length;//2
* u2 sourcefile_index;//CONSTANT_Utf8_info
* }
* ```
*/
public class SourceFileAttribute implements AttributeInfo {
private ConstantPool cp;
private String sourceFile;
public SourceFileAttribute(ConstantPool cp) {
this.cp = cp;
}
@Override
public void readInfo(ClassReader reader) {
int sourceFileIndex = reader.nextU2ToInt();
sourceFile = cp.getUTF8(sourceFileIndex);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch03/src/main/java/com/github/jvmgo/classfile/attributes/SourceFileAttribute.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 157
|
```java
package com.github.jvmgo.classfile.attributes;
import com.github.jvmgo.classfile.ClassReader;
/**
* @Author: panda
* @Date: 2018/10/3 0003 19:47
*/
public class SyntheticAttribute implements AttributeInfo {
@Override
public void readInfo(ClassReader reader) {
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch03/src/main/java/com/github/jvmgo/classfile/attributes/SyntheticAttribute.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 74
|
```java
package com.github.jvmgo.classfile.attributes;
import com.github.jvmgo.classfile.ClassReader;
public class LocalVariableTableAttribute implements AttributeInfo {
private LocalVariableTableEntry[] localVariableTable;
@Override
public void readInfo(ClassReader reader) {
int length = reader.nextU2ToInt();
localVariableTable = new LocalVariableTableEntry[length];
for (int i = 0; i < length; i++) {
localVariableTable[i] = new LocalVariableTableEntry(reader);
}
}
private static class LocalVariableTableEntry {
private final int startPc;
private final int length;
private final int nameIndex;
private final int descriptorIndex;
private final int index;
public LocalVariableTableEntry(ClassReader reader) {
startPc = reader.nextU2ToInt();
length = reader.nextU2ToInt();
nameIndex = reader.nextU2ToInt();
descriptorIndex = reader.nextU2ToInt();
index = reader.nextU2ToInt();
}
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch03/src/main/java/com/github/jvmgo/classfile/attributes/LocalVariableTableAttribute.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 221
|
```java
package com.github.jvmgo.classfile.attributes;
import com.github.jvmgo.classfile.ClassReader;
/**
* @Author: panda
* @Date: 2018/10/3 0003 21:37
*/
public class ExceptionsAttribute implements AttributeInfo {
private int[] exceptionIndexTable;
@Override
public void readInfo(ClassReader reader) {
exceptionIndexTable = reader.nextUint16s();
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch03/src/main/java/com/github/jvmgo/classfile/attributes/ExceptionsAttribute.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 93
|
```java
package com.github.jvmgo.classfile.attributes;
import com.github.jvmgo.classfile.ClassReader;
import com.github.jvmgo.classfile.constantpool.ConstantPool;
/*
attribute_info {
u2 attribute_name_index;
u4 attribute_length;
u1 info[attribute_length];
}
*/
public interface AttributeInfo {
void readInfo(ClassReader reader);
static AttributeInfo[] readAttributes(ClassReader reader, ConstantPool cp) {
int attributesCount = reader.nextU2ToInt();
AttributeInfo[] attributes = new AttributeInfo[attributesCount];
for (int i = 0; i < attributesCount; i++) {
attributes[i] = readAttribute(reader, cp);
}
return attributes;
}
static AttributeInfo readAttribute(ClassReader reader, ConstantPool cp) {
int attrNameIndex = reader.nextU2ToInt();
String attrName = cp.getUTF8(attrNameIndex);
long attrLen = reader.nextU4ToInt();
AttributeInfo attributeInfo = newAttributeInfo(attrName, attrLen, cp);
attributeInfo.readInfo(reader);
return attributeInfo;
}
//todo xml?
static AttributeInfo newAttributeInfo(String attrName, long attrLen, ConstantPool cp) {
switch (attrName) {
//method
case "Code"://
return new CodeAttribute(cp);
//field
case "ConstantValue"://
return new ConstantValueAttribute();
//method
case "Exceptions"://
return new ExceptionsAttribute();
//3 javacJavaclass
// methodCode
case "LineNumberTable"://
return new LineNumberTableAttribute();
// methodCode
case "LocalVariableTable"://
return new LocalVariableTableAttribute();
//class
case "SourceFile":// XXX.java
return new SourceFileAttribute(cp);
//
//ClassFilefield_infomethod_info
case "Synthetic"://
return new SyntheticAttribute();
case "Deprecated"://
return new DeprecatedAttribute();
//
default:
return new UnparsedAttribute(attrName, (int) attrLen);
}
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch03/src/main/java/com/github/jvmgo/classfile/attributes/AttributeInfo.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 455
|
```java
package com.github.jvmgo.classfile.attributes;
import com.github.jvmgo.classfile.ClassReader;
import com.github.jvmgo.classfile.constantpool.ConstantPool;
/**
* Code_attribute {
* <p>
* u2 attribute_name_index;
* u4 attribute_length;
* <p>
* u2 max_stack;//
* u2 max_locals;//
* <p>
* //
* u4 code_length;
* u1 code[code_length];
* <p>
* //
* u2 exception_table_length;
* {
* u2 start_pc;
* u2 end_pc;
* u2 handler_pc;
* u2 catch_type;
* }
* exception_table[exception_table_length];
* <p>
* //
* u2 attributes_count;
* attribute_info attributes[attributes_count];
* }
* ```
*/
public class CodeAttribute implements AttributeInfo {
private int maxStack;//
private int maxLocals;//
private byte[] code;//
private AttributeInfo[] attributes;//
private ConstantPool cp;
private ExceptionTableEntry[] exceptionTable; //
public CodeAttribute(ConstantPool cp) {
this.cp = cp;
}
@Override
public void readInfo(ClassReader reader) {
maxStack = reader.nextU2ToInt();
maxLocals = reader.nextU2ToInt();
//
int codeLength = reader.nextU4ToInt();
code = reader.nextBytes(codeLength);
//
exceptionTable = ExceptionTableEntry.readExceptionTable(reader);
attributes = AttributeInfo.readAttributes(reader, cp);
}
static class ExceptionTableEntry {
private int startPc;
private int endPc;
private int handlerPc;
private int catchType;
private ExceptionTableEntry(ClassReader reader) {
this.startPc = reader.nextU2ToInt();
this.endPc = reader.nextU2ToInt();
this.handlerPc = reader.nextU2ToInt();
this.catchType = reader.nextU2ToInt();
}
static ExceptionTableEntry[] readExceptionTable(ClassReader reader) {
int length = reader.nextU2ToInt();
ExceptionTableEntry[] exceptionTable = new ExceptionTableEntry[length];
for (int i = 0; i < length; i++) {
exceptionTable[i] = new ExceptionTableEntry(reader);
}
return exceptionTable;
}
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch03/src/main/java/com/github/jvmgo/classfile/attributes/CodeAttribute.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 494
|
```java
package com.github.jvmgo.classfile.attributes;
import com.github.jvmgo.classfile.ClassReader;
/**
* ConstantValue_attribute {
* u2 attribute_name_index;
* u4 attribute_length;//2
* u2 constantvalue_index;//
* }
*/
public class ConstantValueAttribute implements AttributeInfo {
//
private int constantValueIndex;
@Override
public void readInfo(ClassReader reader) {
constantValueIndex = reader.nextU2ToInt();
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch03/src/main/java/com/github/jvmgo/classfile/attributes/ConstantValueAttribute.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 100
|
```java
package com.github.jvmgo.classfile.attributes;
import com.github.jvmgo.classfile.ClassReader;
/**
* @Author: panda
* @Date: 2018/10/3 0003 19:18
*/
public class UnparsedAttribute implements AttributeInfo {
private String name;
private int length;
private byte[] info;
public UnparsedAttribute(String name, int length) {
this.name = name;
this.length = length;
}
@Override
public void readInfo(ClassReader reader) {
info = reader.nextBytes(length);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch03/src/main/java/com/github/jvmgo/classfile/attributes/UnparsedAttribute.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 125
|
```java
package com.github.jvmgo.classpath;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.stream.Collectors;
class WildcardEntry extends CompositeEntry {
WildcardEntry(String path) {
super(toPathList(path));
}
private static String toPathList(String wildcardPath) {
String baseDir = wildcardPath.replace("*", ""); // remove *
try {
return Files.walk(Paths.get(baseDir))
.filter(Files::isRegularFile)
.map(Path::toString)
.filter(p -> p.endsWith(".jar") || p.endsWith(".JAR"))
.collect(Collectors.joining(File.pathSeparator));
} catch (IOException e) {
//e.printStackTrace(System.err);
return "";
}
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch03/src/main/java/com/github/jvmgo/classpath/WildcardEntry.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 175
|
```java
package com.github.jvmgo.classpath;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
class DirEntry implements Entry {
private Path absPath;
DirEntry(String path) {
absPath = Paths.get(path).toAbsolutePath();
}
@Override
public byte[] readClass(String className) throws IOException {
return Files.readAllBytes(absPath.resolve(className));
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch03/src/main/java/com/github/jvmgo/classpath/DirEntry.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 95
|
```java
package com.github.jvmgo.classpath;
import java.io.File;
public interface Entry {
// className: fully/qualified/ClassName.class
byte[] readClass(String className) throws Exception;
// factory method
static Entry create(String path) {
if (path.contains(File.pathSeparator)) {
return new CompositeEntry(path);
} if (path.endsWith("*")) {
return new WildcardEntry(path);
} if (path.endsWith(".jar") || path.endsWith(".JAR") ||
path.endsWith(".zip") || path.endsWith(".ZIP")) {
return new ZipEntry(path);
} else {
return new DirEntry(path);
}
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch03/src/main/java/com/github/jvmgo/classpath/Entry.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 141
|
```java
package com.github.jvmgo.classpath;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.stream.Collectors;
public class Classpath {
private Entry bootClasspath;
private Entry extClasspath;
private Entry userClasspath;
public Classpath(String jreOption, String cpOption) {
parseBootAndExtClasspath(jreOption);
parseUserClasspath(cpOption);
}
private void parseBootAndExtClasspath(String jreOption) {
String jreDir = getJreDir(jreOption);
// jre/lib/*
String jreLibPath = Paths.get(jreDir, "lib") + File.separator + "*";
bootClasspath = new WildcardEntry(jreLibPath);
// jre/lib/ext/*
String jreExtPath = Paths.get(jreDir, "lib", "ext") + File.separator + "*";
extClasspath = new WildcardEntry(jreExtPath);
}
private static String getJreDir(String jreOption) {
if (jreOption != null && Files.exists(Paths.get(jreOption))) {
return jreOption;
}
if (Files.exists(Paths.get("./jre"))) {
return "./jre";
}
String jh = System.getenv("JAVA_HOME");
if (jh != null) {
return Paths.get(jh, "jre").toString();
}
throw new RuntimeException("Can not find JRE folder!");
}
private void parseUserClasspath(String cpOption) {
if (cpOption == null) {
cpOption = ".";
}
userClasspath = Entry.create(cpOption);
}
// className: fully/qualified/ClassName
public byte[] readClass(String className) throws Exception {
className = className + ".class";
try {
return bootClasspath.readClass(className);
} catch (Exception ignored) {
}
try {
return bootClasspath.readClass(className);
} catch (Exception ignored) {
}
return userClasspath.readClass(className);
}
public static String join(String... paths) {
return Arrays.stream(paths)
.collect(Collectors.joining(File.pathSeparator));
}
public static String[] split(String pathList) {
return pathList.split(File.pathSeparator);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch03/src/main/java/com/github/jvmgo/classpath/Classpath.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 504
|
```java
package com.github.jvmgo.classpath;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
class CompositeEntry implements Entry {
private final List<Entry> entries = new ArrayList<>();
CompositeEntry(String pathList) {
for (String path : pathList.split(File.pathSeparator)) {
entries.add(Entry.create(path));
}
}
@Override
public byte[] readClass(String className) throws Exception {
for (Entry entry : entries) {
try {
return entry.readClass(className);
} catch (Exception ignored) {
}
}
throw new Exception("class not found: " + className);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch03/src/main/java/com/github/jvmgo/classpath/CompositeEntry.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 139
|
```java
package com.github.jvmgo.classpath;
import java.nio.file.*;
class ZipEntry implements Entry {
private Path absPath;
ZipEntry(String path) {
absPath = Paths.get(path).toAbsolutePath();
}
@Override
public byte[] readClass(String className) throws Exception {
try (FileSystem zipFs = FileSystems.newFileSystem(absPath, null)) {
return Files.readAllBytes(zipFs.getPath(className));
}
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch03/src/main/java/com/github/jvmgo/classpath/ZipEntry.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 96
|
```java
package com.github.jvmgo;
import org.junit.Test;
import java.util.Arrays;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
public class ArgsTest {
@Test
public void test() {
assertTrue(Args.parse(new String[]{"-?"}).helpFlag);
assertTrue(Args.parse(new String[]{"-help"}).helpFlag);
assertTrue(Args.parse(new String[]{"-version"}).versionFlag);
assertFalse(Args.parse(new String[]{"-cp"}).ok);
assertFalse(Args.parse(new String[]{"-classpath"}).ok);
assertEquals("foo.jar", Args.parse(new String[]{"-cp", "foo.jar"}).classpath);
assertEquals("foo.jar", Args.parse(new String[]{"-classpath", "foo.jar"}).classpath);
assertEquals("foo/bar", Args.parse(new String[]{"-Xjre", "foo/bar"}).jre);
assertEquals(Arrays.asList("Main", "foo"), Args.parse(new String[]{"Main", "foo"}).mainClassAndArgs);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch02/src/test/java/com/github/jvmgo/ArgsTest.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 221
|
```java
package com.github.jvmgo.classpath;
import org.junit.Test;
import java.io.File;
import java.util.Arrays;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
public class EntryTest {
@Test
public void create() {
assertEquals(DirEntry.class, Entry.create(".").getClass());
assertEquals(CompositeEntry.class,
Entry.create("foo.jar" + File.pathSeparator + "bar.jar").getClass());
assertEquals(WildcardEntry.class, Entry.create("foo/bar/*").getClass());
}
@Test
public void dirEntry() throws Exception {
String className = EntryTest.class.getName().replace('.', '/') + ".class";
String classesDir = EntryTest.class.getResource("EntryTest.class")
.getPath().replace(className, "");
Entry entry = Entry.create(classesDir);
assertEquals(DirEntry.class, entry.getClass());
byte[] data = entry.readClass(className);
assertNotNull(data);
}
@Test
public void zipEntry() throws Exception {
String[] cp = System.getProperty("java.class.path").split(File.pathSeparator);
String rtJarPath = Arrays.stream(cp)
.filter(path -> path.endsWith("/junit-4.12.jar"))
.findFirst()
.get();
Entry entry = Entry.create(rtJarPath);
assertEquals(ZipEntry.class, entry.getClass());
byte[] data = entry.readClass("org/junit/Test.class");
assertNotNull(data);
}
@Test
public void compositeEntry() throws Exception {
String cp = System.getProperty("java.class.path");
Entry entry = Entry.create(cp);
assertEquals(CompositeEntry.class, entry.getClass());
byte[] data = entry.readClass("org/junit/Test.class");
assertNotNull(data);
}
@Test
public void wildcardEntry() throws Exception {
String[] cp = System.getProperty("java.class.path").split(File.pathSeparator);
String rtJarPath = Arrays.stream(cp)
.filter(path -> path.endsWith("/junit-4.12.jar"))
.findFirst()
.get()
.replace("/junit-4.12.jar", "/*");
Entry entry = Entry.create(rtJarPath);
assertEquals(WildcardEntry.class, entry.getClass());
byte[] data = entry.readClass("org/junit/Test.class");
assertNotNull(data);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch02/src/test/java/com/github/jvmgo/classpath/EntryTest.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 487
|
```java
package com.github.jvmgo;
import com.github.jvmgo.classpath.Classpath;
import java.util.Arrays;
public class Main {
public static void main(String[] argv) {
Args args = Args.parse(argv);
if (!args.ok || args.helpFlag) {
System.out.println("Usage: <main class> [-options] class [args...]");
} else if (args.versionFlag) {
System.out.println("java version \"1.8.0\"");
} else {
startJVM(args);
}
}
private static void startJVM(Args args) {
Classpath cp = new Classpath(args.jre, args.classpath);
System.out.printf("classpath:%s class:%s args:%s\n",
cp, args.getMainClass(), args.getAppArgs());
String className = args.getMainClass().replace(".", "/");
try {
byte[] classData = cp.readClass(className);
System.out.println("class data: " + Arrays.toString(classData));
} catch (Exception e) {
System.out.println("Could not find or load main class " + args.getMainClass());
}
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch02/src/main/java/com/github/jvmgo/Main.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 243
|
```java
package com.github.jvmgo.classpath;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.stream.Collectors;
class WildcardEntry extends CompositeEntry {
WildcardEntry(String path) {
super(toPathList(path));
}
private static String toPathList(String wildcardPath) {
String baseDir = wildcardPath.replace("*", ""); // remove *
try {
return Files.walk(Paths.get(baseDir))
.filter(Files::isRegularFile)
.map(Path::toString)
.filter(p -> p.endsWith(".jar") || p.endsWith(".JAR"))
.collect(Collectors.joining(File.pathSeparator));
} catch (IOException e) {
//e.printStackTrace(System.err);
return "";
}
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch02/src/main/java/com/github/jvmgo/classpath/WildcardEntry.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 175
|
```java
package com.github.jvmgo;
import com.beust.jcommander.JCommander;
import com.beust.jcommander.Parameter;
import com.beust.jcommander.ParameterException;
import java.util.List;
public class Args {
@Parameter(names = {"-?", "-help"}, description = "print help message", order = 3, help = true)
boolean helpFlag = false;
@Parameter(names = "-version", description = "print version and exit", order = 2)
boolean versionFlag = false;
@Parameter(names = { "-cp", "-classpath" }, description = "classpath", order = 1)
String classpath;
/**
* jre
*/
@Parameter(names = "-Xjre", description = "path to jre", order = 4)
String jre;
@Parameter(description = "main class and args")
List<String> mainClassAndArgs;
boolean ok;
String getMainClass() {
return mainClassAndArgs != null && !mainClassAndArgs.isEmpty()
? mainClassAndArgs.get(0)
: null;
}
List<String> getAppArgs() {
return mainClassAndArgs != null && mainClassAndArgs.size() >1
? mainClassAndArgs.subList(1, mainClassAndArgs.size())
: null;
}
static Args parse(String[] argv) {
Args args = new Args();
JCommander cmd = JCommander.newBuilder()
.addObject(args)
.build();
try {
cmd.parse(argv);
args.ok = true;
} catch (ParameterException ignored) {
}
return args;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch02/src/main/java/com/github/jvmgo/Args.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 355
|
```java
package com.github.jvmgo.classpath;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
class DirEntry implements Entry {
private Path absPath;
DirEntry(String path) {
absPath = Paths.get(path).toAbsolutePath();
}
@Override
public byte[] readClass(String className) throws IOException {
return Files.readAllBytes(absPath.resolve(className));
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch02/src/main/java/com/github/jvmgo/classpath/DirEntry.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 95
|
```java
package com.github.jvmgo.classpath;
import java.io.File;
public interface Entry {
// className: fully/qualified/ClassName.class
byte[] readClass(String className) throws Exception;
// factory method
static Entry create(String path) {
if (path.contains(File.pathSeparator)) {
return new CompositeEntry(path);
}
if (path.endsWith("*")) {
return new WildcardEntry(path);
}
if (path.endsWith(".jar") || path.endsWith(".JAR") ||
path.endsWith(".zip") || path.endsWith(".ZIP")) {
return new ZipEntry(path);
}
return new DirEntry(path);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch02/src/main/java/com/github/jvmgo/classpath/Entry.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 139
|
```java
package com.github.jvmgo.classpath;
import java.nio.file.*;
class ZipEntry implements Entry {
private Path absPath;
ZipEntry(String path) {
absPath = Paths.get(path).toAbsolutePath();
}
@Override
public byte[] readClass(String className) throws Exception {
try (FileSystem zipFs = FileSystems.newFileSystem(absPath, null)) {
return Files.readAllBytes(zipFs.getPath(className));
}
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch02/src/main/java/com/github/jvmgo/classpath/ZipEntry.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 96
|
```java
package com.github.jvmgo.classpath;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.stream.Collectors;
public class Classpath {
private Entry bootClasspath;
private Entry extClasspath;
private Entry userClasspath;
public Classpath(String jreOption, String cpOption) {
parseBootAndExtClasspath(jreOption);
parseUserClasspath(cpOption);
}
private void parseBootAndExtClasspath(String jreOption) {
String jreDir = getJreDir(jreOption);
// jre/lib/*
String jreLibPath = Paths.get(jreDir, "lib") + File.separator + "*";
bootClasspath = new WildcardEntry(jreLibPath);
// jre/lib/ext/*
String jreExtPath = Paths.get(jreDir, "lib", "ext") + File.separator + "*";
extClasspath = new WildcardEntry(jreExtPath);
}
private static String getJreDir(String jreOption) {
if (jreOption != null && Files.exists(Paths.get(jreOption))) {
return jreOption;
}
if (Files.exists(Paths.get("./jre"))) {
return "./jre";
}
String jh = System.getenv("JAVA_HOME");
if (jh != null) {
return Paths.get(jh, "jre").toString();
}
throw new RuntimeException("Can not find JRE folder!");
}
private void parseUserClasspath(String cpOption) {
if (cpOption == null) {
cpOption = ".";
}
userClasspath = Entry.create(cpOption);
}
// className: fully/qualified/ClassName
public byte[] readClass(String className) throws Exception {
className = className + ".class";
try {
return bootClasspath.readClass(className);
} catch (Exception ignored) {
}
try {
return bootClasspath.readClass(className);
} catch (Exception ignored) {
}
return userClasspath.readClass(className);
}
public static String join(String... paths) {
return Arrays.stream(paths)
.collect(Collectors.joining(File.pathSeparator));
}
public static String[] split(String pathList) {
return pathList.split(File.pathSeparator);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch02/src/main/java/com/github/jvmgo/classpath/Classpath.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 504
|
```java
package com.github.jvmgo;
import org.junit.Assert;
import org.junit.Test;
public class UnitTest {
@Test
public void test() {
Assert.assertTrue(true);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch08/src/test/java/com/github/jvmgo/UnitTest.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 41
|
```java
package com.github.jvmgo.classpath;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
class CompositeEntry implements Entry {
private final List<Entry> entries = new ArrayList<>();
CompositeEntry(String pathList) {
for (String path : pathList.split(File.pathSeparator)) {
entries.add(Entry.create(path));
}
}
@Override
public byte[] readClass(String className) throws Exception {
for (Entry entry : entries) {
try {
return entry.readClass(className);
} catch (Exception ignored) {
}
}
throw new Exception("class not found: " + className);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch02/src/main/java/com/github/jvmgo/classpath/CompositeEntry.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 139
|
```java
package com.github.jvmgo;
public class Main {
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch08/src/main/java/com/github/jvmgo/Main.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 34
|
```java
package com.github.jvmgo;
public class Main {
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch06/src/main/java/com/github/jvmgo/Main.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 34
|
```java
package com.github.jvmgo;
import org.junit.Assert;
import org.junit.Test;
public class UnitTest {
@Test
public void test() {
Assert.assertTrue(true);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch06/src/test/java/com/github/jvmgo/UnitTest.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 41
|
```ini
#Wed Sep 12 09:22:31 CST 2018
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-4.9-all.zip
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/gradle/wrapper/gradle-wrapper.properties
|
ini
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 71
|
```java
package com.github.jvmgo;
public class Main {
public static void main(String[] argv) {
Args args = Args.parse(argv);
if (!args.ok || args.helpFlag) {
System.out.println("Usage: <main class> [-options] class [args...]");
} else if (args.versionFlag) {
System.out.println("java version \"1.8.0\"");
} else {
startJVM(args);
}
}
private static void startJVM(Args args) {
//
System.out.printf("classpath:%s class:%s args:%s\n",
args.classpath, args.getMainClass(), args.getAppArgs());
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch01/src/main/java/com/github/jvmgo/Main.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 145
|
```java
package com.github.jvmgo;
import org.junit.Test;
import java.util.Arrays;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
public class ArgsTest {
@Test
public void test() {
assertTrue(Args.parse(new String[]{"-?"}).helpFlag);
assertTrue(Args.parse(new String[]{"-help"}).helpFlag);
assertTrue(Args.parse(new String[]{"-version"}).versionFlag);
assertFalse(Args.parse(new String[]{"-cp"}).ok);
assertFalse(Args.parse(new String[]{"-classpath"}).ok);
assertEquals("foo.jar", Args.parse(new String[]{"-cp", "foo.jar"}).classpath);
assertEquals("foo.jar", Args.parse(new String[]{"-classpath", "foo.jar"}).classpath);
assertEquals(Arrays.asList("Main", "foo"), Args.parse(new String[]{"Main", "foo"}).mainClassAndArgs);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch01/src/test/java/com/github/jvmgo/ArgsTest.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 197
|
```java
package com.github.jvmgo;
import org.junit.Assert;
import org.junit.Test;
public class UnitTest {
@Test
public void test() {
Assert.assertTrue(true);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch09/src/test/java/com/github/jvmgo/UnitTest.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 41
|
```java
package com.github.jvmgo;
public class Main {
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch09/src/main/java/com/github/jvmgo/Main.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 34
|
```java
package com.github.jvmgo;
import com.beust.jcommander.JCommander;
import com.beust.jcommander.Parameter;
import com.beust.jcommander.ParameterException;
import java.util.List;
public class Args {
@Parameter(names = {"-?", "-help"}, description = "print help message", order = 3, help = true)
boolean helpFlag = false;
@Parameter(names = "-version", description = "print version and exit", order = 2)
boolean versionFlag = false;
@Parameter(names = { "-cp", "-classpath" }, description = "classpath", order = 1)
String classpath;
@Parameter(description = "main class and args")//options
List<String> mainClassAndArgs;
boolean ok;
String getMainClass() {
return mainClassAndArgs != null && !mainClassAndArgs.isEmpty()
? mainClassAndArgs.get(0)
: null;
}
List<String> getAppArgs() {
return mainClassAndArgs != null && mainClassAndArgs.size() >1
? mainClassAndArgs.subList(1, mainClassAndArgs.size())
: null;
}
static Args parse(String[] argv) {
Args args = new Args();
JCommander cmd = JCommander.newBuilder()
.addObject(args)
.build();
try {
cmd.parse(argv);
args.ok = true;
} catch (ParameterException ignored) {
}
return args;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch01/src/main/java/com/github/jvmgo/Args.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 321
|
```java
package jvmgo.book.ch04;
public class Math {
public static void main(String[] args) {
System.out.println(circumference(1.6f));
}
public static float circumference(float r) {
float pi = 3.14f;
float c = 2 * pi * r;
return c;
}
}
```
|
/content/code_sandbox/v1/code/java/example/src/main/java/jvmgo/book/ch04/Math.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 76
|
```java
package jvmgo.book.ch07;
public class InvokeVirtualTest {
public static void main(String[] args) {
Vector2D v2 = new Vector2D(2.1, 2.2);
Vector2D v3 = new Vector3D(3.1, 3.2, 3.3);
v2.multiply(2);
v3.multiply(3);
System.out.println(v2.x);
System.out.println(v2.y);
System.out.println(v3.x);
System.out.println(v3.y);
System.out.println(((Vector3D)v3).z);
}
}
```
|
/content/code_sandbox/v1/code/java/example/src/main/java/jvmgo/book/ch07/InvokeVirtualTest.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 134
|
```java
package jvmgo.book.ch07;
public class AccSuperDemo {
// lib1.jar
public static class A {
public void foo() {
System.out.println("A.foo");
}
}
public static class B extends A {
// empty
}
// lib2.jar
public static class C extends B {
public void foo() {
super.foo();
}
}
public static void main(String[] args) {
new C().foo();
}
}
```
|
/content/code_sandbox/v1/code/java/example/src/main/java/jvmgo/book/ch07/AccSuperDemo.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 106
|
```java
package jvmgo.book.ch07;
public interface Vector {
public void multiply(double s);
}
```
|
/content/code_sandbox/v1/code/java/example/src/main/java/jvmgo/book/ch07/Vector.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 21
|
```java
package jvmgo.book.ch07;
public class Vector3D extends Vector2D {
protected double z;
public Vector3D() {
this(1, 1, 1);
}
public Vector3D(double x, double y, double z) {
super(x, y);
this.z = z;
}
@Override
public void multiply(double s) {
super.multiply(s);
this.z *= s;
}
}
```
|
/content/code_sandbox/v1/code/java/example/src/main/java/jvmgo/book/ch07/Vector3D.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 99
|
```java
package jvmgo.book.ch07;
public class ClinitTest {
public static final boolean Z = true;
public static final byte B = 1;
public static final short S = 2;
public static final int I = 3;
public static final long L = 4;
public static final char C = 'x';
public static final float F = 3.14f;
public static final double D = 2.71828;
public static final String STR = "abc";
public static boolean z = true;
public static byte b = 1;
public static short s = 2;
public static int i = 3;
public static long l = 4;
public static char c = 'x';
public static float f = 3.14f;
public static double d = 2.71828;
public static String str = "abc";
public static void main(String[] args) {
System.out.println(ClinitTest.I);
System.out.println(ClinitTest.i);
}
}
```
|
/content/code_sandbox/v1/code/java/example/src/main/java/jvmgo/book/ch07/ClinitTest.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 227
|
```java
package jvmgo.book.ch07;
public class InvokeDemo implements Runnable {
public static void main(String[] args) {
new InvokeDemo().test();
}
public void test() {
InvokeDemo.staticMethod(); // invokestatic
InvokeDemo demo = new InvokeDemo(); // invokespecial
demo.instanceMethod(); // invokespecial
super.equals(null); // invokespecial
this.run(); // invokevirtual
((Runnable) demo).run(); // invokeinterface
}
public static void staticMethod() {}
private void instanceMethod() {}
@Override public void run() {}
}
```
|
/content/code_sandbox/v1/code/java/example/src/main/java/jvmgo/book/ch07/InvokeDemo.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 132
|
```java
package jvmgo.book.ch07;
public class FibonacciTest {
public static void main(String[] args) {
long x = fibonacci(30);
System.out.println(x);
}
private static long fibonacci(long n) {
if (n <= 1) {
return n;
} else {
return fibonacci(n - 1) + fibonacci(n - 2);
}
}
}
```
|
/content/code_sandbox/v1/code/java/example/src/main/java/jvmgo/book/ch07/FibonacciTest.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 86
|
```java
package jvmgo.book.ch07;
public class InvokeSpecialTest {
public static void main(String[] args) {
Vector2D v2 = new Vector2D(2.1, 2.2);
System.out.println(v2.x);
System.out.println(v2.y);
Vector3D v3 = new Vector3D(3.1, 3.2, 3.3);
System.out.println(v3.x);
System.out.println(v3.y);
System.out.println(v3.z);
}
}
```
|
/content/code_sandbox/v1/code/java/example/src/main/java/jvmgo/book/ch07/InvokeSpecialTest.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 115
|
```java
package jvmgo.book.ch07;
public class Vector2D implements Vector {
protected double x;
protected double y;
public Vector2D() {
this(1, 1);
}
public Vector2D(double x, double y) {
this.x = x;
this.y = y;
}
@Override
public void multiply(double s) {
this.x *= s;
this.y *= s;
}
}
```
|
/content/code_sandbox/v1/code/java/example/src/main/java/jvmgo/book/ch07/Vector2D.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 97
|
```java
package jvmgo.book.ch07;
public class InvokeInterfaceTest {
public static void main(String[] args) {
Vector v = new Vector3D(3.1, 3.2, 3.3);
v.multiply(3);
Vector3D v3 = (Vector3D) v;
System.out.println(v3.x);
System.out.println(v3.y);
System.out.println(v3.z);
}
}
```
|
/content/code_sandbox/v1/code/java/example/src/main/java/jvmgo/book/ch07/InvokeInterfaceTest.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 95
|
```java
package jvmgo.book.ch07.test;
public class Assert {
public static void assertTrue(boolean condition) {
if (!condition) {
fail();
}
}
private static void fail() {
throw new AssertionError("failed!");
}
}
```
|
/content/code_sandbox/v1/code/java/example/src/main/java/jvmgo/book/ch07/test/Assert.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 53
|
```java
package jvmgo.book.ch07.test;
import jvmgo.book.ch07.test.instructions.MathTest;
import jvmgo.book.ch07.test.instructions.SwitchTest;
public class Test {
public static void main(String[] args) {
MathTest.main(args);
SwitchTest.main(args);
}
}
```
|
/content/code_sandbox/v1/code/java/example/src/main/java/jvmgo/book/ch07/test/Test.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 64
|
```java
package jvmgo.book.ch07.test.instructions;
import static jvmgo.book.ch07.test.Assert.*;
public class SwitchTest {
public static void main(String[] args) {
assertTrue(chooseNear(0) == 0);
assertTrue(chooseNear(1) == 1);
assertTrue(chooseNear(2) == 2);
assertTrue(chooseNear(3) == -1);
assertTrue(chooseFar(-100) == -1);
assertTrue(chooseFar(0) == 0);
assertTrue(chooseFar(100) == 1);
assertTrue(chooseFar(12) == -1);
}
// tableswitch
private static int chooseNear(int i) {
switch (i) {
case 0: return 0;
case 1: return 1;
case 2: return 2;
default: return -1;
}
}
// lookupswitch
private static int chooseFar(int i) {
switch (i) {
case -100: return -1;
case 0: return 0;
case 100: return 1;
default: return -1;
}
}
}
```
|
/content/code_sandbox/v1/code/java/example/src/main/java/jvmgo/book/ch07/test/instructions/SwitchTest.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 273
|
```java
package jvmgo.book.ch05;
public class GaussTest {
public static void main(String[] args) {
int sum = 0;
for (int i = 1; i <= 100; i++) {
sum += i;
}
System.out.println(sum);
}
}
```
|
/content/code_sandbox/v1/code/java/example/src/main/java/jvmgo/book/ch05/GaussTest.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 66
|
```java
package jvmgo.book.ch05;
public class ShTest {
public static void main(String[] args) {
int x = -1;
System.out.println(Integer.toBinaryString(x));
System.out.println(Integer.toBinaryString(x >> 8));
System.out.println(Integer.toBinaryString(x >>> 8));
}
}
```
|
/content/code_sandbox/v1/code/java/example/src/main/java/jvmgo/book/ch05/ShTest.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 70
|
```java
package jvmgo.book.ch10;
public class JvmsExample {
public static class TestExc extends RuntimeException {}
public static class TestExc1 extends RuntimeException {}
public static class TestExc2 extends RuntimeException {}
void cantBeZero(int i) {
if (i == 0) {
throw new TestExc();
}
}
void catchOne() {
try {
tryItOut();
} catch (TestExc e) {
handleExc(e);
}
}
void catchTwo() {
try {
tryItOut();
} catch (TestExc1 e) {
handleExc(e);
} catch (TestExc2 e) {
handleExc(e);
}
}
void nestedCatch() {
try {
try {
tryItOut();
} catch (TestExc1 e) {
handleExc1(e);
}
} catch (TestExc2 e) {
handleExc2(e);
}
}
void tryItOut() {
//throw new TestExc();
}
void handleExc(RuntimeException exc) {
}
void handleExc1(TestExc1 exc) {
}
void handleExc2(TestExc2 exc) {
}
public static void main(String[] args) {
JvmsExample example = new JvmsExample();
example.catchOne();
example.catchTwo();
example.nestedCatch();
}
}
```
|
/content/code_sandbox/v1/code/java/example/src/main/java/jvmgo/book/ch10/JvmsExample.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 303
|
```java
package jvmgo.book.ch07.test.instructions;
import static jvmgo.book.ch07.test.Assert.*;
public class MathTest {
public static void main(String[] args) {
add();
sub();
mul();
div();
rem();
neg();
sh();
and();
or();
xor();
iinc();
}
private static void add() {
assertTrue(iadd(1, 1) == 2);
assertTrue(ladd(1L, 1L) == 2L);
assertTrue(fadd(1.0f, 1.0f) == 2.0f);
assertTrue(dadd(1.0d, 1.0d) == 2.0d);
}
private static void sub() {
assertTrue(isub(1, 1) == 0);
assertTrue(lsub(1L, 1L) == 0L);
assertTrue(fsub(1.0f, 1.0f) == 0.0f);
assertTrue(dsub(1.0d, 1.0d) == 0.0d);
}
private static void mul() {
assertTrue(imul(2, 3) == 6);
assertTrue(lmul(2L, 3L) == 6L);
assertTrue(fmul(2.0f, 3.0f) == 6.0f);
assertTrue(dmul(2.0d, 3.0d) == 6.0d);
}
private static void div() {
assertTrue(idiv(3, 2) == 1);
assertTrue(ldiv(3L, 2L) == 1L);
assertTrue(fdiv(3.0f, 2.0f) == 1.5f);
assertTrue(ddiv(3.0d, 2.0d) == 1.5d);
}
private static void rem() {
assertTrue(irem(7, 3) == 1);
assertTrue(lrem(7L, 3L) == 1L);
assertTrue(frem(7.0f, 3.0f) == 1.0f);
assertTrue(drem(7.0d, 3.0d) == 1.0d);
}
private static void neg() {
assertTrue(ineg(1) == -1);
assertTrue(lneg(1L) == -1L);
assertTrue(fneg(1.0f) == -1.0f);
assertTrue(dneg(1.0d) == -1.0d);
}
private static void sh() {
assertTrue(ishl(0xFEDCBA98, 8) == 0xDCBA9800);
assertTrue(ishr(0xFEDCBA98, 8) == 0xFFFEDCBA);
assertTrue(iushr(0xFEDCBA98, 8) == 0x00FEDCBA);
assertTrue(lshl(0xFEDCBA9876543210L, 8) == 0xDCBA987654321000L);
assertTrue(lshr(0xFEDCBA9876543210L, 8) == 0xFFFEDCBA98765432L);
assertTrue(lushr(0xFEDCBA9876543210L, 8) == 0x00FEDCBA98765432L);
}
private static void and() {
assertTrue(iand(0b1010, 0b0110) == 0b0010);
assertTrue(land(0b1010, 0b0110) == 0b0010);
}
private static void or() {
assertTrue(ior(0b1010, 0b0110) == 0b1110);
assertTrue(lor(0b1010, 0b0110) == 0b1110);
}
private static void xor() {
assertTrue(ixor(0b1010, 0b0110) == 0b1100);
assertTrue(lxor(0b1010, 0b0110) == 0b1100);
}
private static void iinc() {
// TODO
}
private static int iadd (int a, int b) {return a + b; }
private static int isub (int a, int b) {return a - b; }
private static int imul (int a, int b) {return a * b; }
private static int idiv (int a, int b) {return a / b; }
private static int irem (int a, int b) {return a % b; }
private static int ineg (int a ) {return -a; }
private static int ishl (int a, int b) {return a << b; }
private static int ishr (int a, int b) {return a >> b; }
private static int iushr(int a, int b) {return a >>> b;}
private static int iand (int a, int b) {return a & b; }
private static int ior (int a, int b) {return a | b; }
private static int ixor (int a, int b) {return a ^ b; }
private static long ladd (long a, long b) {return a + b; }
private static long lsub (long a, long b) {return a - b; }
private static long lmul (long a, long b) {return a * b; }
private static long ldiv (long a, long b) {return a / b; }
private static long lrem (long a, long b) {return a % b; }
private static long lneg (long a ) {return -a; }
private static long lshl (long a, long b) {return a << b; }
private static long lshr (long a, long b) {return a >> b; }
private static long lushr(long a, long b) {return a >>> b;}
private static long land (long a, long b) {return a & b; }
private static long lor (long a, long b) {return a | b; }
private static long lxor (long a, long b) {return a ^ b; }
private static float fadd(float a, float b) {return a + b; }
private static float fsub(float a, float b) {return a - b; }
private static float fmul(float a, float b) {return a * b; }
private static float fdiv(float a, float b) {return a / b; }
private static float frem(float a, float b) {return a % b; }
private static float fneg(float a ) {return -a; }
private static double dadd(double a, double b) {return a + b; }
private static double dsub(double a, double b) {return a - b; }
private static double dmul(double a, double b) {return a * b; }
private static double ddiv(double a, double b) {return a / b; }
private static double drem(double a, double b) {return a % b; }
private static double dneg(double a ) {return -a; }
}
```
|
/content/code_sandbox/v1/code/java/example/src/main/java/jvmgo/book/ch07/test/instructions/MathTest.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 1,654
|
```java
package jvmgo.book.ch10;
public class ExceptionTest1 {
public static void main(String[] args) {
test(0);
test(1);
test(2);
test(3);
}
private static void test(int x) {
try {
if (x == 0) {
throw new IllegalArgumentException("0!");
}
if (x == 1) {
throw new RuntimeException("1!");
}
if (x == 2) {
throw new Exception("2!");
}
} catch (IllegalArgumentException e) {
System.out.println(e.getMessage());
} catch (RuntimeException e) {
System.out.println(e.getMessage());
} catch (Exception e) {
System.out.println(e.getMessage());
} finally {
System.out.println(x);
}
}
}
```
|
/content/code_sandbox/v1/code/java/example/src/main/java/jvmgo/book/ch10/ExceptionTest1.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 173
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.