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
|
|---|---|---|---|---|---|---|---|---|
```go
package heap
import "fmt"
import "jvmgo/ch09/classfile"
import "jvmgo/ch09/classpath"
/*
class names:
- primitive types: boolean, byte, int ...
- primitive arrays: [Z, [B, [I ...
- non-array classes: java/lang/Object ...
- array classes: [Ljava/lang/Object; ...
*/
type ClassLoader struct {
cp *classpath.Classpath
verboseFlag bool
classMap map[string]*Class // loaded classes
}
func NewClassLoader(cp *classpath.Classpath, verboseFlag bool) *ClassLoader {
loader := &ClassLoader{
cp: cp,
verboseFlag: verboseFlag,
classMap: make(map[string]*Class),
}
loader.loadBasicClasses()
loader.loadPrimitiveClasses()
return loader
}
func (self *ClassLoader) loadBasicClasses() {
jlClassClass := self.LoadClass("java/lang/Class")
for _, class := range self.classMap {
if class.jClass == nil {
class.jClass = jlClassClass.NewObject()
class.jClass.extra = class
}
}
}
func (self *ClassLoader) loadPrimitiveClasses() {
for primitiveType, _ := range primitiveTypes {
self.loadPrimitiveClass(primitiveType)
}
}
func (self *ClassLoader) loadPrimitiveClass(className string) {
class := &Class{
accessFlags: ACC_PUBLIC, // todo
name: className,
loader: self,
initStarted: true,
}
class.jClass = self.classMap["java/lang/Class"].NewObject()
class.jClass.extra = class
self.classMap[className] = class
}
func (self *ClassLoader) LoadClass(name string) *Class {
if class, ok := self.classMap[name]; ok {
// already loaded
return class
}
var class *Class
if name[0] == '[' { // array class
class = self.loadArrayClass(name)
} else {
class = self.loadNonArrayClass(name)
}
if jlClassClass, ok := self.classMap["java/lang/Class"]; ok {
class.jClass = jlClassClass.NewObject()
class.jClass.extra = class
}
return class
}
func (self *ClassLoader) loadArrayClass(name string) *Class {
class := &Class{
accessFlags: ACC_PUBLIC, // todo
name: name,
loader: self,
initStarted: true,
superClass: self.LoadClass("java/lang/Object"),
interfaces: []*Class{
self.LoadClass("java/lang/Cloneable"),
self.LoadClass("java/io/Serializable"),
},
}
self.classMap[name] = class
return class
}
func (self *ClassLoader) loadNonArrayClass(name string) *Class {
data, entry := self.readClass(name)
class := self.defineClass(data)
link(class)
if self.verboseFlag {
fmt.Printf("[Loaded %s from %s]\n", name, entry)
}
return class
}
func (self *ClassLoader) readClass(name string) ([]byte, classpath.Entry) {
data, entry, err := self.cp.ReadClass(name)
if err != nil {
panic("java.lang.ClassNotFoundException: " + name)
}
return data, entry
}
// jvms 5.3.5
func (self *ClassLoader) defineClass(data []byte) *Class {
class := parseClass(data)
class.loader = self
resolveSuperClass(class)
resolveInterfaces(class)
self.classMap[class.name] = class
return class
}
func parseClass(data []byte) *Class {
cf, err := classfile.Parse(data)
if err != nil {
//panic("java.lang.ClassFormatError")
panic(err)
}
return newClass(cf)
}
// jvms 5.4.3.1
func resolveSuperClass(class *Class) {
if class.name != "java/lang/Object" {
class.superClass = class.loader.LoadClass(class.superClassName)
}
}
func resolveInterfaces(class *Class) {
interfaceCount := len(class.interfaceNames)
if interfaceCount > 0 {
class.interfaces = make([]*Class, interfaceCount)
for i, interfaceName := range class.interfaceNames {
class.interfaces[i] = class.loader.LoadClass(interfaceName)
}
}
}
func link(class *Class) {
verify(class)
prepare(class)
}
func verify(class *Class) {
// todo
}
// jvms 5.4.2
func prepare(class *Class) {
calcInstanceFieldSlotIds(class)
calcStaticFieldSlotIds(class)
allocAndInitStaticVars(class)
}
func calcInstanceFieldSlotIds(class *Class) {
slotId := uint(0)
if class.superClass != nil {
slotId = class.superClass.instanceSlotCount
}
for _, field := range class.fields {
if !field.IsStatic() {
field.slotId = slotId
slotId++
if field.isLongOrDouble() {
slotId++
}
}
}
class.instanceSlotCount = slotId
}
func calcStaticFieldSlotIds(class *Class) {
slotId := uint(0)
for _, field := range class.fields {
if field.IsStatic() {
field.slotId = slotId
slotId++
if field.isLongOrDouble() {
slotId++
}
}
}
class.staticSlotCount = slotId
}
func allocAndInitStaticVars(class *Class) {
class.staticVars = newSlots(class.staticSlotCount)
for _, field := range class.fields {
if field.IsStatic() && field.IsFinal() {
initStaticFinalVar(class, field)
}
}
}
func initStaticFinalVar(class *Class, field *Field) {
vars := class.staticVars
cp := class.constantPool
cpIndex := field.ConstValueIndex()
slotId := field.SlotId()
if cpIndex > 0 {
switch field.Descriptor() {
case "Z", "B", "C", "S", "I":
val := cp.GetConstant(cpIndex).(int32)
vars.SetInt(slotId, val)
case "J":
val := cp.GetConstant(cpIndex).(int64)
vars.SetLong(slotId, val)
case "F":
val := cp.GetConstant(cpIndex).(float32)
vars.SetFloat(slotId, val)
case "D":
val := cp.GetConstant(cpIndex).(float64)
vars.SetDouble(slotId, val)
case "Ljava/lang/String;":
goStr := cp.GetConstant(cpIndex).(string)
jStr := JString(class.Loader(), goStr)
vars.SetRef(slotId, jStr)
}
}
}
```
|
/content/code_sandbox/v1/code/go/src/jvmgo/ch09/rtda/heap/class_loader.go
|
go
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 1,449
|
```go
package heap
import "jvmgo/ch09/classfile"
type InterfaceMethodRef struct {
MemberRef
method *Method
}
func newInterfaceMethodRef(cp *ConstantPool, refInfo *classfile.ConstantInterfaceMethodrefInfo) *InterfaceMethodRef {
ref := &InterfaceMethodRef{}
ref.cp = cp
ref.copyMemberRefInfo(&refInfo.ConstantMemberrefInfo)
return ref
}
func (self *InterfaceMethodRef) ResolvedInterfaceMethod() *Method {
if self.method == nil {
self.resolveInterfaceMethodRef()
}
return self.method
}
// jvms8 5.4.3.4
func (self *InterfaceMethodRef) resolveInterfaceMethodRef() {
d := self.cp.class
c := self.ResolvedClass()
if !c.IsInterface() {
panic("java.lang.IncompatibleClassChangeError")
}
method := lookupInterfaceMethod(c, self.name, self.descriptor)
if method == nil {
panic("java.lang.NoSuchMethodError")
}
if !method.isAccessibleTo(d) {
panic("java.lang.IllegalAccessError")
}
self.method = method
}
// todo
func lookupInterfaceMethod(iface *Class, name, descriptor string) *Method {
for _, method := range iface.methods {
if method.name == name && method.descriptor == descriptor {
return method
}
}
return lookupMethodInInterfaces(iface.interfaces, name, descriptor)
}
```
|
/content/code_sandbox/v1/code/go/src/jvmgo/ch09/rtda/heap/cp_interface_methodref.go
|
go
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 300
|
```go
package heap
import "math"
type Slot struct {
num int32
ref *Object
}
type Slots []Slot
func newSlots(slotCount uint) Slots {
if slotCount > 0 {
return make([]Slot, slotCount)
}
return nil
}
func (self Slots) SetInt(index uint, val int32) {
self[index].num = val
}
func (self Slots) GetInt(index uint) int32 {
return self[index].num
}
func (self Slots) SetFloat(index uint, val float32) {
bits := math.Float32bits(val)
self[index].num = int32(bits)
}
func (self Slots) GetFloat(index uint) float32 {
bits := uint32(self[index].num)
return math.Float32frombits(bits)
}
// long consumes two slots
func (self Slots) SetLong(index uint, val int64) {
self[index].num = int32(val)
self[index+1].num = int32(val >> 32)
}
func (self Slots) GetLong(index uint) int64 {
low := uint32(self[index].num)
high := uint32(self[index+1].num)
return int64(high)<<32 | int64(low)
}
// double consumes two slots
func (self Slots) SetDouble(index uint, val float64) {
bits := math.Float64bits(val)
self.SetLong(index, int64(bits))
}
func (self Slots) GetDouble(index uint) float64 {
bits := uint64(self.GetLong(index))
return math.Float64frombits(bits)
}
func (self Slots) SetRef(index uint, ref *Object) {
self[index].ref = ref
}
func (self Slots) GetRef(index uint) *Object {
return self[index].ref
}
```
|
/content/code_sandbox/v1/code/go/src/jvmgo/ch09/rtda/heap/slots.go
|
go
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 373
|
```go
package heap
func (self *Object) Bytes() []int8 {
return self.data.([]int8)
}
func (self *Object) Shorts() []int16 {
return self.data.([]int16)
}
func (self *Object) Ints() []int32 {
return self.data.([]int32)
}
func (self *Object) Longs() []int64 {
return self.data.([]int64)
}
func (self *Object) Chars() []uint16 {
return self.data.([]uint16)
}
func (self *Object) Floats() []float32 {
return self.data.([]float32)
}
func (self *Object) Doubles() []float64 {
return self.data.([]float64)
}
func (self *Object) Refs() []*Object {
return self.data.([]*Object)
}
func (self *Object) ArrayLength() int32 {
switch self.data.(type) {
case []int8:
return int32(len(self.data.([]int8)))
case []int16:
return int32(len(self.data.([]int16)))
case []int32:
return int32(len(self.data.([]int32)))
case []int64:
return int32(len(self.data.([]int64)))
case []uint16:
return int32(len(self.data.([]uint16)))
case []float32:
return int32(len(self.data.([]float32)))
case []float64:
return int32(len(self.data.([]float64)))
case []*Object:
return int32(len(self.data.([]*Object)))
default:
panic("Not array!")
}
}
func ArrayCopy(src, dst *Object, srcPos, dstPos, length int32) {
switch src.data.(type) {
case []int8:
_src := src.data.([]int8)[srcPos : srcPos+length]
_dst := dst.data.([]int8)[dstPos : dstPos+length]
copy(_dst, _src)
case []int16:
_src := src.data.([]int16)[srcPos : srcPos+length]
_dst := dst.data.([]int16)[dstPos : dstPos+length]
copy(_dst, _src)
case []int32:
_src := src.data.([]int32)[srcPos : srcPos+length]
_dst := dst.data.([]int32)[dstPos : dstPos+length]
copy(_dst, _src)
case []int64:
_src := src.data.([]int64)[srcPos : srcPos+length]
_dst := dst.data.([]int64)[dstPos : dstPos+length]
copy(_dst, _src)
case []uint16:
_src := src.data.([]uint16)[srcPos : srcPos+length]
_dst := dst.data.([]uint16)[dstPos : dstPos+length]
copy(_dst, _src)
case []float32:
_src := src.data.([]float32)[srcPos : srcPos+length]
_dst := dst.data.([]float32)[dstPos : dstPos+length]
copy(_dst, _src)
case []float64:
_src := src.data.([]float64)[srcPos : srcPos+length]
_dst := dst.data.([]float64)[dstPos : dstPos+length]
copy(_dst, _src)
case []*Object:
_src := src.data.([]*Object)[srcPos : srcPos+length]
_dst := dst.data.([]*Object)[dstPos : dstPos+length]
copy(_dst, _src)
default:
panic("Not array!")
}
}
```
|
/content/code_sandbox/v1/code/go/src/jvmgo/ch09/rtda/heap/array_object.go
|
go
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 783
|
```go
package heap
import "jvmgo/ch09/classfile"
type Field struct {
ClassMember
constValueIndex uint
slotId uint
}
func newFields(class *Class, cfFields []*classfile.MemberInfo) []*Field {
fields := make([]*Field, len(cfFields))
for i, cfField := range cfFields {
fields[i] = &Field{}
fields[i].class = class
fields[i].copyMemberInfo(cfField)
fields[i].copyAttributes(cfField)
}
return fields
}
func (self *Field) copyAttributes(cfField *classfile.MemberInfo) {
if valAttr := cfField.ConstantValueAttribute(); valAttr != nil {
self.constValueIndex = uint(valAttr.ConstantValueIndex())
}
}
func (self *Field) IsVolatile() bool {
return 0 != self.accessFlags&ACC_VOLATILE
}
func (self *Field) IsTransient() bool {
return 0 != self.accessFlags&ACC_TRANSIENT
}
func (self *Field) IsEnum() bool {
return 0 != self.accessFlags&ACC_ENUM
}
func (self *Field) ConstValueIndex() uint {
return self.constValueIndex
}
func (self *Field) SlotId() uint {
return self.slotId
}
func (self *Field) isLongOrDouble() bool {
return self.descriptor == "J" || self.descriptor == "D"
}
```
|
/content/code_sandbox/v1/code/go/src/jvmgo/ch09/rtda/heap/field.go
|
go
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 296
|
```go
package heap
func (self *Class) IsArray() bool {
return self.name[0] == '['
}
func (self *Class) ComponentClass() *Class {
componentClassName := getComponentClassName(self.name)
return self.loader.LoadClass(componentClassName)
}
func (self *Class) NewArray(count uint) *Object {
if !self.IsArray() {
panic("Not array class: " + self.name)
}
switch self.Name() {
case "[Z":
return &Object{self, make([]int8, count), nil}
case "[B":
return &Object{self, make([]int8, count), nil}
case "[C":
return &Object{self, make([]uint16, count), nil}
case "[S":
return &Object{self, make([]int16, count), nil}
case "[I":
return &Object{self, make([]int32, count), nil}
case "[J":
return &Object{self, make([]int64, count), nil}
case "[F":
return &Object{self, make([]float32, count), nil}
case "[D":
return &Object{self, make([]float64, count), nil}
default:
return &Object{self, make([]*Object, count), nil}
}
}
```
|
/content/code_sandbox/v1/code/go/src/jvmgo/ch09/rtda/heap/array_class.go
|
go
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 275
|
```go
package heap
func (self *Object) Clone() *Object {
return &Object{
class: self.class,
data: self.cloneData(),
}
}
func (self *Object) cloneData() interface{} {
switch self.data.(type) {
case []int8:
elements := self.data.([]int8)
elements2 := make([]int8, len(elements))
copy(elements2, elements)
return elements2
case []int16:
elements := self.data.([]int16)
elements2 := make([]int16, len(elements))
copy(elements2, elements)
return elements2
case []uint16:
elements := self.data.([]uint16)
elements2 := make([]uint16, len(elements))
copy(elements2, elements)
return elements2
case []int32:
elements := self.data.([]int32)
elements2 := make([]int32, len(elements))
copy(elements2, elements)
return elements2
case []int64:
elements := self.data.([]int64)
elements2 := make([]int64, len(elements))
copy(elements2, elements)
return elements2
case []float32:
elements := self.data.([]float32)
elements2 := make([]float32, len(elements))
copy(elements2, elements)
return elements2
case []float64:
elements := self.data.([]float64)
elements2 := make([]float64, len(elements))
copy(elements2, elements)
return elements2
case []*Object:
elements := self.data.([]*Object)
elements2 := make([]*Object, len(elements))
copy(elements2, elements)
return elements2
default: // []Slot
slots := self.data.(Slots)
slots2 := newSlots(uint(len(slots)))
copy(slots2, slots)
return slots2
}
}
```
|
/content/code_sandbox/v1/code/go/src/jvmgo/ch09/rtda/heap/object_clone.go
|
go
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 423
|
```go
package classpath
import "os"
import "path/filepath"
type Classpath struct {
bootClasspath Entry
extClasspath Entry
userClasspath Entry
}
func Parse(jreOption, cpOption string) *Classpath {
cp := &Classpath{}
cp.parseBootAndExtClasspath(jreOption)
cp.parseUserClasspath(cpOption)
return cp
}
func (self *Classpath) parseBootAndExtClasspath(jreOption string) {
jreDir := getJreDir(jreOption)
// jre/lib/*
jreLibPath := filepath.Join(jreDir, "lib", "*")
self.bootClasspath = newWildcardEntry(jreLibPath)
// jre/lib/ext/*
jreExtPath := filepath.Join(jreDir, "lib", "ext", "*")
self.extClasspath = newWildcardEntry(jreExtPath)
}
func getJreDir(jreOption string) string {
if jreOption != "" && exists(jreOption) {
return jreOption
}
if exists("./jre") {
return "./jre"
}
if jh := os.Getenv("JAVA_HOME"); jh != "" {
return filepath.Join(jh, "jre")
}
panic("Can not find jre folder!")
}
func exists(path string) bool {
if _, err := os.Stat(path); err != nil {
if os.IsNotExist(err) {
return false
}
}
return true
}
func (self *Classpath) parseUserClasspath(cpOption string) {
if cpOption == "" {
cpOption = "."
}
self.userClasspath = newEntry(cpOption)
}
// className: fully/qualified/ClassName
func (self *Classpath) ReadClass(className string) ([]byte, Entry, error) {
className = className + ".class"
if data, entry, err := self.bootClasspath.readClass(className); err == nil {
return data, entry, err
}
if data, entry, err := self.extClasspath.readClass(className); err == nil {
return data, entry, err
}
return self.userClasspath.readClass(className)
}
func (self *Classpath) String() string {
return self.userClasspath.String()
}
```
|
/content/code_sandbox/v1/code/go/src/jvmgo/ch09/classpath/classpath.go
|
go
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 476
|
```go
package classpath
import "os"
import "strings"
// :(linux/unix) or ;(windows)
const pathListSeparator = string(os.PathListSeparator)
type Entry interface {
// className: fully/qualified/ClassName.class
readClass(className string) ([]byte, Entry, error)
String() string
}
func newEntry(path string) Entry {
if strings.Contains(path, pathListSeparator) {
return newCompositeEntry(path)
}
if strings.HasSuffix(path, "*") {
return newWildcardEntry(path)
}
if strings.HasSuffix(path, ".jar") || strings.HasSuffix(path, ".JAR") ||
strings.HasSuffix(path, ".zip") || strings.HasSuffix(path, ".ZIP") {
return newZipEntry(path)
}
return newDirEntry(path)
}
```
|
/content/code_sandbox/v1/code/go/src/jvmgo/ch09/classpath/entry.go
|
go
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 168
|
```go
package classpath
import "errors"
import "strings"
type CompositeEntry []Entry
func newCompositeEntry(pathList string) CompositeEntry {
compositeEntry := []Entry{}
for _, path := range strings.Split(pathList, pathListSeparator) {
entry := newEntry(path)
compositeEntry = append(compositeEntry, entry)
}
return compositeEntry
}
func (self CompositeEntry) readClass(className string) ([]byte, Entry, error) {
for _, entry := range self {
data, from, err := entry.readClass(className)
if err == nil {
return data, from, nil
}
}
return nil, nil, errors.New("class not found: " + className)
}
func (self CompositeEntry) String() string {
strs := make([]string, len(self))
for i, entry := range self {
strs[i] = entry.String()
}
return strings.Join(strs, pathListSeparator)
}
```
|
/content/code_sandbox/v1/code/go/src/jvmgo/ch09/classpath/entry_composite.go
|
go
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 202
|
```go
package classpath
import "os"
import "path/filepath"
import "strings"
func newWildcardEntry(path string) CompositeEntry {
baseDir := path[:len(path)-1] // remove *
compositeEntry := []Entry{}
walkFn := func(path string, info os.FileInfo, err error) error {
if err != nil {
return err
}
if info.IsDir() && path != baseDir {
return filepath.SkipDir
}
if strings.HasSuffix(path, ".jar") || strings.HasSuffix(path, ".JAR") {
jarEntry := newZipEntry(path)
compositeEntry = append(compositeEntry, jarEntry)
}
return nil
}
filepath.Walk(baseDir, walkFn)
return compositeEntry
}
```
|
/content/code_sandbox/v1/code/go/src/jvmgo/ch09/classpath/entry_wildcard.go
|
go
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 168
|
```go
package classpath
import "archive/zip"
import "errors"
import "io/ioutil"
import "path/filepath"
type ZipEntry struct {
absPath string
zipRC *zip.ReadCloser
}
func newZipEntry(path string) *ZipEntry {
absPath, err := filepath.Abs(path)
if err != nil {
panic(err)
}
return &ZipEntry{absPath, nil}
}
func (self *ZipEntry) readClass(className string) ([]byte, Entry, error) {
if self.zipRC == nil {
err := self.openJar()
if err != nil {
return nil, nil, err
}
}
classFile := self.findClass(className)
if classFile == nil {
return nil, nil, errors.New("class not found: " + className)
}
data, err := readClass(classFile)
return data, self, err
}
// todo: close zip
func (self *ZipEntry) openJar() error {
r, err := zip.OpenReader(self.absPath)
if err == nil {
self.zipRC = r
}
return err
}
func (self *ZipEntry) findClass(className string) *zip.File {
for _, f := range self.zipRC.File {
if f.Name == className {
return f
}
}
return nil
}
func readClass(classFile *zip.File) ([]byte, error) {
rc, err := classFile.Open()
if err != nil {
return nil, err
}
// read class data
data, err := ioutil.ReadAll(rc)
rc.Close()
if err != nil {
return nil, err
}
return data, nil
}
func (self *ZipEntry) String() string {
return self.absPath
}
```
|
/content/code_sandbox/v1/code/go/src/jvmgo/ch09/classpath/entry_zip.go
|
go
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 374
|
```go
package classpath
import "io/ioutil"
import "path/filepath"
type DirEntry struct {
absDir string
}
func newDirEntry(path string) *DirEntry {
absDir, err := filepath.Abs(path)
if err != nil {
panic(err)
}
return &DirEntry{absDir}
}
func (self *DirEntry) readClass(className string) ([]byte, Entry, error) {
fileName := filepath.Join(self.absDir, className)
data, err := ioutil.ReadFile(fileName)
return data, self, err
}
func (self *DirEntry) String() string {
return self.absDir
}
```
|
/content/code_sandbox/v1/code/go/src/jvmgo/ch09/classpath/entry_dir.go
|
go
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 131
|
```batchfile
@if "%DEBUG%" == "" @echo off
@rem ##########################################################################
@rem
@rem Gradle startup script for Windows
@rem
@rem ##########################################################################
@rem Set local scope for the variables with windows NT shell
if "%OS%"=="Windows_NT" setlocal
set DIRNAME=%~dp0
if "%DIRNAME%" == "" set DIRNAME=.
set APP_BASE_NAME=%~n0
set APP_HOME=%DIRNAME%
@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
set DEFAULT_JVM_OPTS=
@rem Find java.exe
if defined JAVA_HOME goto findJavaFromJavaHome
set JAVA_EXE=java.exe
%JAVA_EXE% -version >NUL 2>&1
if "%ERRORLEVEL%" == "0" goto init
echo.
echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
echo.
echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation.
goto fail
:findJavaFromJavaHome
set JAVA_HOME=%JAVA_HOME:"=%
set JAVA_EXE=%JAVA_HOME%/bin/java.exe
if exist "%JAVA_EXE%" goto init
echo.
echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
echo.
echo Please set the JAVA_HOME variable in your environment to match the
echo location of your Java installation.
goto fail
:init
@rem Get command-line arguments, handling Windows variants
if not "%OS%" == "Windows_NT" goto win9xME_args
:win9xME_args
@rem Slurp the command line arguments.
set CMD_LINE_ARGS=
set _SKIP=2
:win9xME_args_slurp
if "x%~1" == "x" goto execute
set CMD_LINE_ARGS=%*
:execute
@rem Setup the command line
set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
@rem Execute Gradle
"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
:end
@rem End local scope for the variables with windows NT shell
if "%ERRORLEVEL%"=="0" goto mainEnd
:fail
rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
rem the _cmd.exe /c_ return code!
if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
exit /b 1
:mainEnd
if "%OS%"=="Windows_NT" endlocal
:omega
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/gradlew.bat
|
batchfile
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 584
|
```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/ch11/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/ch11/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/ch04/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
|
```unknown
#!/usr/bin/env sh
##############################################################################
##
## Gradle start up script for UN*X
##
##############################################################################
# Attempt to set APP_HOME
# Resolve links: $0 may be a link
PRG="$0"
# Need this for relative symlinks.
while [ -h "$PRG" ] ; do
ls=`ls -ld "$PRG"`
link=`expr "$ls" : '.*-> \(.*\)$'`
if expr "$link" : '/.*' > /dev/null; then
PRG="$link"
else
PRG=`dirname "$PRG"`"/$link"
fi
done
SAVED="`pwd`"
cd "`dirname \"$PRG\"`/" >/dev/null
APP_HOME="`pwd -P`"
cd "$SAVED" >/dev/null
APP_NAME="Gradle"
APP_BASE_NAME=`basename "$0"`
# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
DEFAULT_JVM_OPTS=""
# Use the maximum available, or set MAX_FD != -1 to use that value.
MAX_FD="maximum"
warn () {
echo "$*"
}
die () {
echo
echo "$*"
echo
exit 1
}
# OS specific support (must be 'true' or 'false').
cygwin=false
msys=false
darwin=false
nonstop=false
case "`uname`" in
CYGWIN* )
cygwin=true
;;
Darwin* )
darwin=true
;;
MINGW* )
msys=true
;;
NONSTOP* )
nonstop=true
;;
esac
CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
# Determine the Java command to use to start the JVM.
if [ -n "$JAVA_HOME" ] ; then
if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
# IBM's JDK on AIX uses strange locations for the executables
JAVACMD="$JAVA_HOME/jre/sh/java"
else
JAVACMD="$JAVA_HOME/bin/java"
fi
if [ ! -x "$JAVACMD" ] ; then
die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
fi
else
JAVACMD="java"
which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
Please set the JAVA_HOME variable in your environment to match the
location of your Java installation."
fi
# Increase the maximum file descriptors if we can.
if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
MAX_FD_LIMIT=`ulimit -H -n`
if [ $? -eq 0 ] ; then
if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
MAX_FD="$MAX_FD_LIMIT"
fi
ulimit -n $MAX_FD
if [ $? -ne 0 ] ; then
warn "Could not set maximum file descriptor limit: $MAX_FD"
fi
else
warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
fi
fi
# For Darwin, add options to specify how the application appears in the dock
if $darwin; then
GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
fi
# For Cygwin, switch paths to Windows format before running java
if $cygwin ; then
APP_HOME=`cygpath --path --mixed "$APP_HOME"`
CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
JAVACMD=`cygpath --unix "$JAVACMD"`
# We build the pattern for arguments to be converted via cygpath
ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
SEP=""
for dir in $ROOTDIRSRAW ; do
ROOTDIRS="$ROOTDIRS$SEP$dir"
SEP="|"
done
OURCYGPATTERN="(^($ROOTDIRS))"
# Add a user-defined pattern to the cygpath arguments
if [ "$GRADLE_CYGPATTERN" != "" ] ; then
OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
fi
# Now convert the arguments - kludge to limit ourselves to /bin/sh
i=0
for arg in "$@" ; do
CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option
if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition
eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
else
eval `echo args$i`="\"$arg\""
fi
i=$((i+1))
done
case $i in
(0) set -- ;;
(1) set -- "$args0" ;;
(2) set -- "$args0" "$args1" ;;
(3) set -- "$args0" "$args1" "$args2" ;;
(4) set -- "$args0" "$args1" "$args2" "$args3" ;;
(5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
(6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
(7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
(8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
(9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
esac
fi
# Escape application args
save () {
for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
echo " "
}
APP_ARGS=$(save "$@")
# Collect all arguments for the java command, following the shell quoting and substitution rules
eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
cd "$(dirname "$0")"
fi
exec "$JAVACMD" "$@"
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/gradlew
|
unknown
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 1,633
|
```java
package com.github.jvmgo;
import com.github.jvmgo.classpath.Classpath;
import com.github.jvmgo.clazz.ClassFile;
import com.github.jvmgo.clazz.ClassReader;
import java.util.Arrays;
/**
* @author liang
* main ,
*
*/
public class Main {
public static void main(String[] args) {
Args argv = Args.parse(args);
if (argv.isHelpFlag()) {
System.out.println("Usage: <main class> [-options] class [args...]");
} else if (argv.isVersionFlag()) {
System.out.println("java version \"1.8.0\"");
} else {
startJVM(argv);
}
}
private static void startJVM(Args args) {
Classpath cp = new Classpath(args.getJre(), args.getClasspath());
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);
ClassReader reader = new ClassReader(classData);
ClassFile classFile = reader.parseClassFile();
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/ch04/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
| 299
|
```java
package com.github.jvmgo;
import org.junit.Assert;
import org.junit.Test;
import com.github.jvmgo.rtda.LocalVars;
import com.github.jvmgo.rtda.OperandStack;
import java.lang.ref.Reference;
import java.lang.ref.WeakReference;
public class RtdaTest {
@Test
public void testLocalVars() {
LocalVars localVars = new LocalVars(1024);
localVars.setInt(0, Integer.MAX_VALUE);
localVars.setInt(1, Integer.MIN_VALUE);
localVars.setFloat(2, Float.MAX_VALUE);
localVars.setFloat(3, Float.MIN_VALUE);
localVars.setLong(4, Long.MAX_VALUE);
localVars.setLong(6, Long.MIN_VALUE);
localVars.setDouble(8, Double.MAX_VALUE);
localVars.setDouble(10, Double.MIN_VALUE);
Object object = new Object();
Reference reference = new WeakReference(object);
localVars.setRef(12, reference);
Assert.assertEquals(Integer.MAX_VALUE, localVars.getInt(0));
Assert.assertEquals(Integer.MIN_VALUE, localVars.getInt(1));
Assert.assertEquals(Float.MAX_VALUE, localVars.getFloat(2), 0);
Assert.assertEquals(Float.MIN_VALUE, localVars.getFloat(3), 0);
Assert.assertEquals(Long.MAX_VALUE, localVars.getLong(4), 0);
Assert.assertEquals(Long.MIN_VALUE, localVars.getLong(6), 0);
Assert.assertEquals(Double.MAX_VALUE, localVars.getDouble(8), 0);
Assert.assertEquals(Double.MIN_VALUE, localVars.getDouble(10), 0);
Assert.assertEquals(object, localVars.getRef(12).get());
}
@Test
public void testOperandStack() throws Exception {
OperandStack operandStack = new OperandStack(1024);
operandStack.pushInt(Integer.MAX_VALUE);
operandStack.pushInt(Integer.MIN_VALUE);
operandStack.pushFloat(Float.MAX_VALUE);
operandStack.pushFloat(Float.MIN_VALUE);
operandStack.pushLong(Long.MAX_VALUE);
operandStack.pushLong(Long.MIN_VALUE);
operandStack.pushDouble(Double.MAX_VALUE);
operandStack.pushDouble(Double.MIN_VALUE);
Object object = new Object();
Reference reference = new WeakReference(object);
operandStack.pushRef(reference);
Assert.assertEquals(object, operandStack.popRef().get());
Assert.assertEquals(Double.MIN_VALUE, operandStack.popDouble(), 0);
Assert.assertEquals(Double.MAX_VALUE, operandStack.popDouble(), 0);
Assert.assertEquals(Long.MIN_VALUE, operandStack.popLong(), 0);
Assert.assertEquals(Long.MAX_VALUE, operandStack.popLong(), 0);
Assert.assertEquals(Float.MIN_VALUE, operandStack.popFloat(), 0);
Assert.assertEquals(Float.MAX_VALUE, operandStack.popFloat(), 0);
Assert.assertEquals(Integer.MIN_VALUE, operandStack.popInt());
Assert.assertEquals(Integer.MAX_VALUE, operandStack.popInt());
}
@Test
public void t0() {
long a = Long.MAX_VALUE;
String s = addZero(Long.toBinaryString(a), 64);
String high = s.substring(0, 32);
String low = s.substring(32);
long b = Long.parseLong(high + low, 2);
Assert.assertEquals(a, b);
}
@Test
public void t2() {
long a = Long.MIN_VALUE;
String s = addZero(translate(Long.toBinaryString(a)), 64);
String high = s.substring(0, 32);
String low = s.substring(32);
long b = Long.parseLong(high + low, 2) * -1 - 1;
Assert.assertEquals(a, b);
}
public String addZero(String s, int length) {
if (s.length() >= length) {
return s;
}
StringBuilder builder = new StringBuilder();
for (int i = 0; i < length - s.length(); i++) {
builder.append("0");
}
return builder.append(s).toString();
}
public String translate(String s) {
StringBuilder builder = new StringBuilder();
for (char c : s.toCharArray()) {
if (c == '0') {
builder.append("1");
} else {
builder.append("0");
}
}
return builder.toString();
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch04/src/test/java/com/github/jvmgo/RtdaTest.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 894
|
```java
package com.github.jvmgo.rtda;
public class Objcet {
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch04/src/main/java/com/github/jvmgo/rtda/Objcet.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 18
|
```java
package com.github.jvmgo;
import com.beust.jcommander.JCommander;
import com.beust.jcommander.Parameter;
import com.beust.jcommander.ParameterException;
import lombok.Getter;
import lombok.Setter;
import java.util.List;
@Getter
@Setter
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/ch04/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
| 358
|
```java
package com.github.jvmgo.rtda;
/**
*
*
* run time data area
*
*
**/
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch04/src/main/java/com/github/jvmgo/rtda/package-info.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 24
|
```java
package com.github.jvmgo.rtda;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
@Setter
@Getter
@ToString
public class Thread {
private int pc;
private Stack stack;
public Thread(int maxStack) {
this.stack = new Stack(maxStack);
}
public void pushFrame(Frame frame) {
this.stack.push(frame);
}
public Frame popFrame() {
return this.stack.pop();
}
public Frame currentFrame() {
return this.stack.current();
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch04/src/main/java/com/github/jvmgo/rtda/Thread.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 111
|
```java
package com.github.jvmgo.rtda;
public class Util {
public static Slot setInt(int val) {
boolean flag = true;
String s = addZero(Integer.toBinaryString(val), 32);
if (val < 0) {
flag = false;
s = addZero(translate(Integer.toBinaryString(val)), 32);
}
Slot slot = new Slot();
slot.setFlag(flag);
slot.setNum(s);
return slot;
}
public static int getInt(Slot slot) {
if (slot.isFlag()) {
return slot.getNumInt();
} else {
return slot.getNumInt() * -1 - 1;
}
}
public static Slot[] setLong(long val) {
Slot[] slots = new Slot[2];
boolean flag = true;
String s = Util.addZero(Long.toBinaryString(val), 64);
if (val < 0) {
flag = false;
s = Util.addZero(Util.translate(Long.toBinaryString(val)), 64);
}
String high = s.substring(0, 32);
String low = s.substring(32);
Slot slot = new Slot();
slot.setNum(high);
slot.setFlag(flag);
slots[0] = slot;
Slot slot2 = new Slot();
slot2.setNum(low);
slot.setFlag(flag);
slots[1] = slot2;
return slots;
}
public static long getLong(Slot[] slots) {
Slot high = slots[0];
Slot low = slots[1];
if (high.isFlag()) {
return Long.parseLong(high.getNum() + low.getNum(), 2);
} else {
return Long.parseLong(high.getNum() + low.getNum(), 2) * -1 - 1;
}
}
public static String addZero(String s, int length) {
if (s.length() >= length) {
return s;
}
StringBuilder builder = new StringBuilder();
for (int i = 0; i < length - s.length(); i++) {
builder.append("0");
}
return builder.append(s).toString();
}
public static String translate(String s) {
StringBuilder builder = new StringBuilder();
for (char c : s.toCharArray()) {
if (c == '0') {
builder.append("1");
} else {
builder.append("0");
}
}
return builder.toString();
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch04/src/main/java/com/github/jvmgo/rtda/Util.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 523
|
```java
package com.github.jvmgo.rtda;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class Stack {
private int maxSize;
private int size;
private java.util.Stack<Frame> stacks;
public Stack(int maxSize) {
this.maxSize = maxSize;
stacks = new java.util.Stack<>();
}
public void push(Frame frame) {
if (this.size >= maxSize) {
System.out.println("java.lang.StackOverflowError");
System.exit(1);
}
stacks.push(frame);
size++;
}
public Frame pop() {
Frame pop = stacks.pop();
if (pop == null) {
System.out.println("java stack is empty");
System.exit(2);
}
size--;
return pop;
}
public Frame current() {
Frame peek = stacks.peek();
if (peek == null) {
System.out.println("java stack is empty");
System.exit(2);
}
return peek;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch04/src/main/java/com/github/jvmgo/rtda/Stack.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 211
|
```java
package com.github.jvmgo.rtda;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
import java.lang.ref.Reference;
import java.util.Stack;
@Getter
@Setter
@ToString
public class OperandStack {
private java.util.Stack<Slot> stacks;
private int maxStack;
public OperandStack(int maxStack) {
this.maxStack = maxStack;
if (maxStack > 0) {
stacks = new Stack<>();
} else
System.exit(-1);
}
public void pushSlot(Slot slot) throws Exception {
if (stacks.size() >= maxStack) {
throw new Exception("");
}
stacks.push(slot);
}
public Slot popSlot() throws Exception {
if (stacks.size() <= 0) {
throw new Exception("");
}
return stacks.pop();
}
public void pushInt(int val) throws Exception {
pushSlot(Util.setInt(val));
}
public int popInt() {
return Util.getInt(stacks.pop());
}
public void pushFloat(float val) throws Exception {
int a = Float.floatToIntBits(val);
pushInt(a);
}
public float popFloat() {
return Float.intBitsToFloat(popInt());
}
public void pushLong(long val) throws Exception {
Slot[] slots = Util.setLong(val);
pushSlot(slots[0]);
pushSlot(slots[1]);
}
public long popLong() throws Exception {
Slot low = popSlot();
Slot high = popSlot();
return Util.getLong(new Slot[]{high, low});
}
public void pushDouble(double val) throws Exception {
pushLong(Double.doubleToLongBits(val));
}
public double popDouble() throws Exception {
return Double.longBitsToDouble(popLong());
}
public void pushRef(Reference ref) throws Exception {
Slot slot = new Slot();
slot.setRef(ref);
pushSlot(slot);
}
public Reference popRef() throws Exception {
Reference reference = popSlot().getRef();
return reference;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch04/src/main/java/com/github/jvmgo/rtda/OperandStack.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 441
|
```java
package com.github.jvmgo.rtda;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
@Setter
@Getter
@ToString
public class Frame {
private Frame lower;
private LocalVars localVars;
private OperandStack operandStack;
private Thread thread;
private int nextPc;
public Frame(Thread thread, int maxLocals, int maxStack) {
this.thread = thread;
this.localVars = new LocalVars(maxLocals);
this.operandStack = new OperandStack(maxStack);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch04/src/main/java/com/github/jvmgo/rtda/Frame.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 114
|
```java
package com.github.jvmgo.rtda;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
import java.lang.ref.Reference;
/**
*
*/
@Setter
@Getter
@ToString
public class LocalVars {
private Slot[] localVars;
public LocalVars(int maxLocals) {
if (maxLocals > 0)
localVars = new Slot[maxLocals];
else
System.exit(-1);
}
public void setInt(int index, int val) {
localVars[index] = Util.setInt(val);
}
public int getInt(int index) {
Slot slot = localVars[index];
return Util.getInt(slot);
}
public void setFloat(int index, float val) {
int a = Float.floatToIntBits(val);
setInt(index, a);
}
public float getFloat(int index) {
int a = getInt(index);
return Float.intBitsToFloat(a);
}
public void setLong(int index, long val) {
Slot[] slots = Util.setLong(val);
localVars[index] = slots[0];
localVars[index + 1] = slots[1];
}
public long getLong(int index) {
Slot high = localVars[index];
Slot low = localVars[index + 1];
return Util.getLong(new Slot[]{high, low});
}
public void setDouble(int index, double val) {
long v = Double.doubleToLongBits(val);
setLong(index, v);
}
public double getDouble(int index) {
long v = getLong(index);
return Double.longBitsToDouble(v);
}
public void setRef(int index, Reference ref) {
Slot slot = new Slot();
slot.setRef(ref);
localVars[index] = slot;
}
public Reference getRef(int index) {
return localVars[index].getRef();
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch04/src/main/java/com/github/jvmgo/rtda/LocalVars.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 403
|
```java
package com.github.jvmgo.rtda;
import lombok.Getter;
import lombok.Setter;
import java.lang.ref.Reference;
public class Slot {
private String num;
/**
* >0 true <0 false
*/
@Getter
@Setter
private boolean flag;
@Getter
@Setter
private Reference ref;
@Override
public String toString() {
return getNumInt() + "";
}
public int getNumInt() {
return Integer.parseInt(num, 2);
}
public String getNum() {
return num;
}
public void setNum(int num) {
this.num = Integer.toBinaryString(num);
}
public void setNum(String num) {
this.num = num;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch04/src/main/java/com/github/jvmgo/rtda/Slot.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 166
|
```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/ch04/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/ch04/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;
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/ch04/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;
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/ch04/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.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/ch04/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/ch04/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.clazz;
import com.github.jvmgo.clazz.attribute.Attribute_info;
import com.github.jvmgo.clazz.constant.CONSTANT;
import com.github.jvmgo.clazz.constant.CONSTANT_Utf8_info;
import com.github.jvmgo.clazz.field.Field_info;
import com.github.jvmgo.clazz.method.Method_info;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class ClassFile {
private String magic;
private int minorVersion;
private int majorVersion;
private int constantPoolCount;
private CONSTANT[] constantPool;
private String accessFlags;
private String thisClass;
private String superClass;
private int interfacesCount;
private CONSTANT_Utf8_info[] interfaces;
private int fieldsCount;
private Field_info[] fields;
private int methodsCount;
private Method_info[] methods;
private int attributesCount;
private Attribute_info[] attributes;
public Method_info getMainMethod() {
for (Method_info m : methods) {
if ("main".equals(m.getName()) && "([Ljava/lang/String;)V".equals(m.getDescriptor())) {
return m;
}
}
return null;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch04/src/main/java/com/github/jvmgo/clazz/ClassFile.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 254
|
```java
package com.github.jvmgo.clazz.field;
import com.github.jvmgo.clazz.attribute.Attribute_info;
import com.github.jvmgo.clazz.attribute.Code;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class Field_info {
//U2
private String access_flag;
//U2
private String name;
//U2
private String descriptor;
private int attributes_count;
private Attribute_info[] attributes;
public String accessFlagsToString(String s) {
StringBuilder builder = new StringBuilder();
switch (s.charAt(3)) {
case '0':
break;
case '1':
builder.append("ACC_PUBLIC").append(" ");
break;
case '2':
builder.append("ACC_PRIVATE").append(" ");
break;
case '4':
builder.append("ACC_PROTECTED").append(" ");
break;
case '8':
builder.append("ACC_STATIC").append(" ");
break;
default:
throw new RuntimeException("can not parse access flag");
}
switch (s.charAt(2)) {
case '0':
break;
case '1':
builder.append("ACC_FINAL").append(" ");
break;
case '4':
builder.append("ACC_VOLATILE").append(" ");
break;
case '8':
builder.append("ACC_TRANSIENT").append(" ");
break;
default:
throw new RuntimeException("can not parse access flag");
}
switch (s.charAt(1)) {
case '0':
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 '4':
builder.append("ACC_ENUM");
break;
default:
throw new RuntimeException("can not parse access flag");
}
return builder.toString();
}
public Code getCodeAttribute() {
for (Attribute_info attribute_info : attributes) {
if (attribute_info instanceof Code) {
return (Code) attribute_info;
}
}
return null;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch04/src/main/java/com/github/jvmgo/clazz/field/Field_info.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 467
|
```java
package com.github.jvmgo.clazz.method;
import com.github.jvmgo.clazz.attribute.Attribute_info;
import com.github.jvmgo.clazz.attribute.Code;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class Method_info {
private String access_flag;
private String name;
private String descriptor;
private int attributes_count;
private Attribute_info[] attributes;
public String accessFlagsToString(String s) {
StringBuilder builder = new StringBuilder();
switch (s.charAt(3)) {
case '0':
break;
case '1':
builder.append("ACC_PUBLIC").append(" ");
break;
case '2':
builder.append("ACC_PRIVATE").append(" ");
break;
case '4':
builder.append("ACC_PROTECTED").append(" ");
break;
case '8':
builder.append("ACC_STATIC").append(" ");
break;
case '9':
break;
default:
throw new RuntimeException("can not parse access flag");
}
switch (s.charAt(2)) {
case '0':
break;
case '1':
builder.append("ACC_FINAL").append(" ");
break;
case '2':
builder.append("ACC_SYNCHRONIZED").append(" ");
break;
case '4':
builder.append("ACC_BRIDGE").append(" ");
break;
case '8':
builder.append("ACC_VARARGS").append(" ");
break;
default:
throw new RuntimeException("can not parse access flag");
}
switch (s.charAt(1)) {
case '0':
break;
case '1':
builder.append("ACC_NATIVE");
break;
case '4':
builder.append("ACC_ABSTRACT");
break;
case '8':
builder.append("ACC_STRICT");
break;
default:
throw new RuntimeException("can not parse access flag");
}
switch (s.charAt(0)) {
case '0':
break;
case '1':
builder.append("ACC_SYNTHETIC");
break;
default:
throw new RuntimeException("can not parse access flag");
}
return builder.toString();
}
public Code getCodeAttribute() {
for (Attribute_info attribute_info : attributes) {
if (attribute_info instanceof Code) {
return (Code) attribute_info;
}
}
return null;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch04/src/main/java/com/github/jvmgo/clazz/method/Method_info.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 513
|
```java
package com.github.jvmgo.clazz.constant;
import com.github.jvmgo.clazz.ClassReader;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class CONSTANT_Double_info extends CONSTANT {
private int high_bytes;
private int low_bytes;
@Override
public int getTag() {
return 6;
}
@Override
public CONSTANT parse(ClassReader classReader) {
CONSTANT_Double_info constant = new CONSTANT_Double_info();
constant.setTag(getTag());
constant.setHigh_bytes(classReader.readU4Int());
constant.setLow_bytes(classReader.readU4Int());
return constant;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch04/src/main/java/com/github/jvmgo/clazz/constant/CONSTANT_Double_info.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 134
|
```java
package com.github.jvmgo.clazz.constant;
import com.github.jvmgo.clazz.ClassReader;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class CONSTANT_Methodref_info extends CONSTANT {
private int class_index;
private int name_and_type_index;
@Override
public int getTag() {
return 10;
}
@Override
public CONSTANT parse(ClassReader classReader) {
CONSTANT_Methodref_info constant = new CONSTANT_Methodref_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/ch04/src/main/java/com/github/jvmgo/clazz/constant/CONSTANT_Methodref_info.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 138
|
```java
package com.github.jvmgo.clazz.constant;
import com.github.jvmgo.clazz.ClassReader;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class CONSTANT_Long_info extends CONSTANT {
private int high_bytes;
private int low_bytes;
@Override
public int getTag() {
return 5;
}
@Override
public CONSTANT parse(ClassReader classReader) {
CONSTANT_Long_info constant = new CONSTANT_Long_info();
constant.setTag(getTag());
constant.setHigh_bytes(classReader.readU4Int());
constant.setLow_bytes(classReader.readU4Int());
return constant;
}
public long toLong() {
return ((long) high_bytes << 32) + low_bytes;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch04/src/main/java/com/github/jvmgo/clazz/constant/CONSTANT_Long_info.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 158
|
```java
package com.github.jvmgo.clazz.constant;
import com.github.jvmgo.clazz.ClassReader;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class CONSTANT_Float_info extends CONSTANT {
private int value;
@Override
public int getTag() {
return 4;
}
@Override
public CONSTANT parse(ClassReader classReader) {
CONSTANT_Float_info constant = new CONSTANT_Float_info();
constant.setTag(getTag());
constant.setValue(classReader.readU4Int());
return constant;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch04/src/main/java/com/github/jvmgo/clazz/constant/CONSTANT_Float_info.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 113
|
```java
package com.github.jvmgo.clazz;
import com.github.jvmgo.clazz.attribute.Attribute_info;
import com.github.jvmgo.clazz.constant.CONSTANT;
import com.github.jvmgo.clazz.constant.CONSTANT_Class_info;
import com.github.jvmgo.clazz.constant.CONSTANT_Utf8_info;
import com.github.jvmgo.clazz.field.Field_info;
import com.github.jvmgo.clazz.method.Method_info;
import java.util.Arrays;
public class ClassReader {
private int pos;
private byte[] bytes;
public ClassReader(byte[] bytes) {
this.bytes = bytes;
pos = 0;
}
public ClassFile parseClassFile() {
ClassFile classFile = new ClassFile();
parseMagic(classFile);
parseMinOrVersion(classFile);
parseMajorVersion(classFile);
parseConstantPoolCount(classFile);
parseConstantPool(classFile);
parseAccessFlags(classFile);
parseThisClass(classFile);
parseSuperClass(classFile);
parseInterfacesCount(classFile);
parseInterfaces(classFile);
parseFieldsCount(classFile);
parseFields(classFile);
parseMethodCount(classFile);
parseMethods(classFile);
parseAttributesCount(classFile);
parseAttributes(classFile);
return classFile;
}
private void parseAttributes(ClassFile classFile) {
Attribute_info[] attribute_infos = new Attribute_info[classFile.getAttributesCount()];
for (int i = 0; i < attribute_infos.length; i++) {
CONSTANT_Utf8_info attributeName = (CONSTANT_Utf8_info) classFile.getConstantPool()[readU2()];
Attribute_info attribute_info = Attribute_info.getInstance(attributeName.parseString());
attribute_info.setAttribute_name(attributeName.parseString());
int u4 = readU4Int();
attribute_info.setAttribute_length(u4);
attribute_info.setInfo(readBytes(u4));
attribute_infos[i] = attribute_info.parseAttribute(classFile);
}
classFile.setAttributes(attribute_infos);
}
private void parseAttributesCount(ClassFile classFile) {
classFile.setAttributesCount(readU2());
}
private void parseMethods(ClassFile classFile) {
Method_info[] method_infos = new Method_info[classFile.getMethodsCount()];
for (int i = 0; i < method_infos.length; i++) {
Method_info method_info = new Method_info();
String s = toHexString(readU2Byte());
if (s.length() < 4) {
for (; 0 < 4 - s.length(); ) {
s = "0" + s;
}
}
method_info.setAccess_flag(method_info.accessFlagsToString(s));
CONSTANT_Utf8_info constant_utf8_info =
(CONSTANT_Utf8_info) classFile.getConstantPool()[readU2()];
method_info.setName(constant_utf8_info.parseString());
CONSTANT_Utf8_info constant_utf8_info2 =
(CONSTANT_Utf8_info) classFile.getConstantPool()[readU2()];
method_info.setDescriptor(constant_utf8_info2.parseString());
int attribute_count = readU2();
method_info.setAttributes_count(attribute_count);
Attribute_info[] attribute_infos = new Attribute_info[attribute_count];
for (int j = 0; j < attribute_count; j++) {
CONSTANT_Utf8_info attributeName = (CONSTANT_Utf8_info) classFile.getConstantPool()[readU2()];
Attribute_info attribute_info = Attribute_info.getInstance(attributeName.parseString());
attribute_info.setAttribute_name(attributeName.parseString());
int u4 = readU4Int();
attribute_info.setAttribute_length(u4);
attribute_info.setInfo(readBytes(u4));
attribute_infos[j] = attribute_info.parseAttribute(classFile);
}
method_info.setAttributes(attribute_infos);
method_infos[i] = method_info;
}
classFile.setMethods(method_infos);
}
private void parseMethodCount(ClassFile classFile) {
classFile.setMethodsCount(readU2());
}
private void parseFields(ClassFile classFile) {
Field_info[] field_infos = new Field_info[classFile.getFieldsCount()];
for (int i = 0; i < field_infos.length; i++) {
Field_info field_info = new Field_info();
String s = toHexString(readU2Byte());
if (s.length() < 4) {
for (; 0 < 4 - s.length(); ) {
s = "0" + s;
}
}
field_info.setAccess_flag(field_info.accessFlagsToString(s));
CONSTANT_Utf8_info constant_utf8_info =
(CONSTANT_Utf8_info) classFile.getConstantPool()[readU2()];
field_info.setName(constant_utf8_info.parseString());
CONSTANT_Utf8_info constant_utf8_info2 =
(CONSTANT_Utf8_info) classFile.getConstantPool()[readU2()];
field_info.setDescriptor(constant_utf8_info2.parseString());
int attribute_count = readU2();
field_info.setAttributes_count(attribute_count);
Attribute_info[] attribute_infos = new Attribute_info[attribute_count];
for (int j = 0; j < attribute_count; j++) {
CONSTANT_Utf8_info attributeName = (CONSTANT_Utf8_info) classFile.getConstantPool()[readU2()];
Attribute_info attribute_info = Attribute_info.getInstance(attributeName.parseString());
attribute_info.setAttribute_name(attributeName.parseString());
int u4 = readU4Int();
attribute_info.setAttribute_length(u4);
attribute_info.setInfo(readBytes(u4));
attribute_infos[j] = attribute_info.parseAttribute(classFile);
}
field_info.setAttributes(attribute_infos);
field_infos[i] = field_info;
}
classFile.setFields(field_infos);
}
private void parseFieldsCount(ClassFile classFile) {
classFile.setFieldsCount(readU2());
}
private void parseInterfaces(ClassFile classFile) {
CONSTANT_Utf8_info[] infos = new CONSTANT_Utf8_info[classFile.getInterfacesCount()];
for (int i = 0; i < classFile.getInterfacesCount(); i++) {
CONSTANT_Class_info constant_class_info =
(CONSTANT_Class_info) classFile.getConstantPool()[readU2()];
CONSTANT_Utf8_info constant_utf8_info =
(CONSTANT_Utf8_info) classFile.getConstantPool()[constant_class_info.getName_index()];
infos[i] = constant_utf8_info;
}
classFile.setInterfaces(infos);
}
private void parseInterfacesCount(ClassFile classFile) {
classFile.setInterfacesCount(readU2());
}
private void parseThisClass(ClassFile classFile) {
CONSTANT_Class_info constant_class_info =
(CONSTANT_Class_info) classFile.getConstantPool()[readU2()];
CONSTANT_Utf8_info constant_utf8_info =
(CONSTANT_Utf8_info) classFile.getConstantPool()[constant_class_info.getName_index()];
classFile.setThisClass(constant_utf8_info.parseString());
}
private void parseSuperClass(ClassFile classFile) {
int index = readU2();
if (index == 0) {
classFile.setSuperClass("Object");
return;
}
CONSTANT_Class_info constant_class_info =
(CONSTANT_Class_info) classFile.getConstantPool()[index];
CONSTANT_Utf8_info constant_utf8_info =
(CONSTANT_Utf8_info) classFile.getConstantPool()[constant_class_info.getName_index()];
classFile.setSuperClass(constant_utf8_info.parseString());
}
private void parseAccessFlags(ClassFile classFile) {
String s = toHexString(readU2Byte());
if (s.length() < 4) {
for (; 0 < 4 - s.length(); ) {
s = "0" + s;
}
}
classFile.setAccessFlags(accessFlagsToString(s));
}
private String accessFlagsToString(String s) {
StringBuilder builder = new StringBuilder();
switch (s.charAt(3)) {
case '0':
break;
case '1':
builder.append("ACC_PUBLIC").append(" ");
break;
default:
throw new RuntimeException("can not parse access flag");
}
switch (s.charAt(2)) {
case '0':
break;
case '1':
builder.append("ACC_FINAL").append(" ");
break;
case '2':
builder.append("ACC_SUPER").append(" ");
break;
default:
throw new RuntimeException("can not parse access flag");
}
switch (s.charAt(1)) {
case '0':
break;
case '2':
builder.append("ACC_INTERFACE").append(" ");
break;
case '4':
builder.append("ACC_ABSTRACT").append(" ");
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();
}
private void parseConstantPool(ClassFile classFile) {
int count = classFile.getConstantPoolCount();
CONSTANT[] cpInfos = new CONSTANT[count];
cpInfos[0] = null;
for (int i = 1; i < count; i++) {
int tag = readU1();
cpInfos[i] = CONSTANT.parseConstant(tag, this);
}
classFile.setConstantPool(cpInfos);
}
private void parseConstantPoolCount(ClassFile classFile) {
classFile.setConstantPoolCount(readU2());
}
private void parseMajorVersion(ClassFile classFile) {
classFile.setMajorVersion(readU2());
}
private void parseMinOrVersion(ClassFile classFile) {
classFile.setMinorVersion(readU2());
}
private void parseMagic(ClassFile classFile) {
classFile.setMagic(readU4());
}
public int readU1() {
byte[] bytes = Arrays.copyOfRange(this.bytes, pos, pos + 1);
pos += 1;
return bytesToInt(bytes);
}
public byte[] readBytes(int length) {
byte[] bytes = Arrays.copyOfRange(this.bytes, pos, pos + length);
pos += length;
return bytes;
}
public byte readU1Byte() {
byte b = this.bytes[pos];
pos += 1;
return b;
}
public int readU2() {
byte[] bytes = Arrays.copyOfRange(this.bytes, pos, pos + 2);
pos += 2;
return bytesToInt(bytes);
}
public byte[] readU2Byte() {
byte[] bytes = Arrays.copyOfRange(this.bytes, pos, pos + 2);
pos += 2;
return bytes;
}
public String readU4() {
byte[] bytes = Arrays.copyOfRange(this.bytes, pos, pos + 4);
pos += 4;
return bytesToString(bytes);
}
public int readU4Int() {
byte[] bytes = Arrays.copyOfRange(this.bytes, pos, pos + 4);
pos += 4;
return bytesToInt(bytes);
}
public static String bytesToString(byte[] bytes) {
return toHexString(bytes);
}
public static int bytesToInt(byte[] bytes) {
return Integer.valueOf(toHexString(bytes), 16);
}
public static String toHexString(byte[] bytes) {
StringBuilder builder = new StringBuilder();
for (byte b : bytes) {
builder.append(Integer.toHexString(b & 0xFF));
}
return builder.toString();
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch04/src/main/java/com/github/jvmgo/clazz/ClassReader.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 2,518
|
```java
package com.github.jvmgo.clazz.constant;
import com.github.jvmgo.clazz.ClassReader;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class CONSTANT_Class_info extends CONSTANT {
private int name_index;
@Override
public int getTag() {
return 7;
}
@Override
public CONSTANT parse(ClassReader classReader) {
CONSTANT_Class_info constant_class = new CONSTANT_Class_info();
constant_class.setTag(getTag());
constant_class.setName_index(classReader.readU2());
return constant_class;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch04/src/main/java/com/github/jvmgo/clazz/constant/CONSTANT_Class_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_Inter_info extends CONSTANT {
private int value;
@Override
public int getTag() {
return 3;
}
@Override
public CONSTANT parse(ClassReader classReader) {
CONSTANT_Inter_info constant = new CONSTANT_Inter_info();
constant.setTag(getTag());
constant.setValue(classReader.readU4Int());
return constant;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch04/src/main/java/com/github/jvmgo/clazz/constant/CONSTANT_Inter_info.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 113
|
```java
package com.github.jvmgo.clazz.constant;
import com.github.jvmgo.clazz.ClassReader;
import lombok.Getter;
import lombok.Setter;
@Getter
@Setter
public class CONSTANT_String_info extends CONSTANT {
private int string_index;
@Override
public int getTag() {
return 8;
}
@Override
public CONSTANT parse(ClassReader classReader) {
CONSTANT_String_info constant = new CONSTANT_String_info();
constant.setTag(getTag());
constant.setString_index(classReader.readU2());
return constant;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch04/src/main/java/com/github/jvmgo/clazz/constant/CONSTANT_String_info.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 114
|
```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/ch04/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_NameAndType_info extends CONSTANT {
private int name_index;
private int descriptor_index;
@Override
public int getTag() {
return 12;
}
@Override
public CONSTANT parse(ClassReader classReader) {
CONSTANT_NameAndType_info constant = new CONSTANT_NameAndType_info();
constant.setTag(getTag());
constant.setName_index(classReader.readU2());
constant.setDescriptor_index(classReader.readU2());
return constant;
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch04/src/main/java/com/github/jvmgo/clazz/constant/CONSTANT_NameAndType_info.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 137
|
```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/ch04/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/ch04/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;
import java.util.HashMap;
@Getter
@Setter
public abstract class CONSTANT {
private int tag;
public abstract int getTag();
protected abstract CONSTANT parse(ClassReader classReader);
private static HashMap<Integer, CONSTANT> map = new HashMap<>();
public static CONSTANT parseConstant(int tag, ClassReader classReader) {
CONSTANT constant = map.get(tag);
return constant.parse(classReader);
}
static {
CONSTANT_Class_info constant_class = new CONSTANT_Class_info();
map.put(constant_class.getTag(), constant_class);
CONSTANT_Double_info constant_double_info = new CONSTANT_Double_info();
map.put(constant_double_info.getTag(), constant_double_info);
CONSTANT_Fieldref constant_fieldref = new CONSTANT_Fieldref();
map.put(constant_fieldref.getTag(), constant_fieldref);
CONSTANT_Float_info constant_float_info = new CONSTANT_Float_info();
map.put(constant_float_info.getTag(), constant_float_info);
CONSTANT_Inter_info constant_inter_info = new CONSTANT_Inter_info();
map.put(constant_inter_info.getTag(), constant_inter_info);
CONSTANT_InterfaceMethodref_info constant_interfaceMethodref_info =
new CONSTANT_InterfaceMethodref_info();
map.put(constant_interfaceMethodref_info.getTag(), constant_interfaceMethodref_info);
CONSTANT_InvokeDynamic_info constant_invokeDynamic_info = new CONSTANT_InvokeDynamic_info();
map.put(constant_invokeDynamic_info.getTag(), constant_invokeDynamic_info);
CONSTANT_Long_info constant_long_info = new CONSTANT_Long_info();
map.put(constant_long_info.getTag(), constant_long_info);
CONSTANT_MethodHandle_info constant_methodHandle_info = new CONSTANT_MethodHandle_info();
map.put(constant_methodHandle_info.getTag(), constant_methodHandle_info);
CONSTANT_Methodref_info constant_methodref_info = new CONSTANT_Methodref_info();
map.put(constant_methodref_info.getTag(), constant_methodref_info);
CONSTANT_MethodType_info constant_methodType_info = new CONSTANT_MethodType_info();
map.put(constant_methodType_info.getTag(), constant_methodType_info);
CONSTANT_NameAndType_info constant_nameAndType_info = new CONSTANT_NameAndType_info();
map.put(constant_nameAndType_info.getTag(), constant_nameAndType_info);
CONSTANT_String_info constant_string_info = new CONSTANT_String_info();
map.put(constant_string_info.getTag(), constant_string_info);
CONSTANT_Utf8_info constant_utf8_info = new CONSTANT_Utf8_info();
map.put(constant_utf8_info.getTag(), constant_utf8_info);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch04/src/main/java/com/github/jvmgo/clazz/constant/CONSTANT.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 526
|
```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/ch04/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/ch04/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_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/ch04/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 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/ch04/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 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/ch04/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 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/ch04/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_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/ch04/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 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/ch04/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 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/ch04/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 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/ch04/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 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/ch04/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 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/ch04/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/ch04/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/ch04/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/ch04/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/ch04/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/ch04/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/ch04/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/ch04/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/ch07/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/ch07/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 MainTest {
public static void main(String[] args) {
int sum = 0;
for (int i = 1; i <= 100; i++) {
sum += i;
}
int b = sum + 1;
System.out.println(b);
// int a = 1;
// int b = 2;
// int c = a + b;//3
// int d = c + a;//4
// int f = a + b + c + d;//10
// int e = f + 1;//11
// System.out.println(f);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/test/java/com/github/jvmgo/MainTest.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;
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/ch05/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.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/ch04/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;
import com.github.jvmgo.clazz.ClassFile;
import com.github.jvmgo.clazz.ClassReader;
import com.github.jvmgo.clazz.method.Method_info;
import org.junit.Test;
import java.nio.file.Files;
import java.nio.file.Paths;
public class InstructionsTest {
/**
* MainTest class
*
* @throws Exception
*/
@Test
public void t1() throws Exception {
String path = "D:\\github\\jvmgo-book\\v1\\code\\java\\jvmgo_java\\ch05\\build\\classes\\java\\test\\com\\github\\jvmgo\\MainTest.class";
byte[] bytes = Files.readAllBytes(Paths.get(path));
ClassReader classReader = new ClassReader(bytes);
ClassFile classFile = classReader.parseClassFile();
Method_info mainMethod = classFile.getMainMethod();
Interpreter.execute(mainMethod.getCodeAttribute());
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/test/java/com/github/jvmgo/InstructionsTest.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;
import com.github.jvmgo.classpath.Classpath;
import com.github.jvmgo.clazz.ClassFile;
import com.github.jvmgo.clazz.ClassReader;
import com.github.jvmgo.clazz.method.Method_info;
import java.util.Arrays;
/**
* @author liang
*/
public class Main {
public static void main(String[] args) {
Args argv = Args.parse(args);
if (argv.isHelpFlag()) {
System.out.println("Usage: <main class> [-options] class [args...]");
} else if (argv.isVersionFlag()) {
System.out.println("java version \"1.8.0\"");
} else {
startJVM(argv);
}
}
private static void startJVM(Args args) {
Classpath cp = new Classpath(args.getJre(), args.getClasspath());
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);
ClassReader reader = new ClassReader(classData);
ClassFile classFile = reader.parseClassFile();
Method_info mainMethod = classFile.getMainMethod();
Interpreter.execute(mainMethod.getCodeAttribute());
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/ch05/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
| 326
|
```java
package com.github.jvmgo;
import com.github.jvmgo.clazz.attribute.Code;
import com.github.jvmgo.instructions.base.BytecodeReader;
import com.github.jvmgo.instructions.base.Instruction;
import com.github.jvmgo.instructions.base.InstructionFactory;
import com.github.jvmgo.rtda.Frame;
import com.github.jvmgo.rtda.Thread;
/**
*/
public class Interpreter {
public static void execute(Code code) throws Exception {
int max_stack = code.getMax_stack();
int max_locals = code.getMax_locals();
byte[] byteCode = code.getCode();
Thread thread = new Thread(max_stack);
Frame frame = new Frame(thread, max_locals, max_stack);
thread.pushFrame(frame);
loop(thread, byteCode);
}
public static void loop(Thread thread, byte[] byteCode) throws Exception {
Frame frame = thread.popFrame();
BytecodeReader reader = new BytecodeReader(byteCode, frame.getNextPc());
int opcode;
do {
int pc = frame.getNextPc();
thread.setPc(pc);
System.out.print("pc:" + reader.getPc());
reader.reset(byteCode, pc);
opcode = reader.read8();
System.out.print(" opcode:" + opcode);
Instruction instruction = InstructionFactory.getByOpcode(opcode);
instruction.fetchOperands(reader);
frame.setNextPc(reader.getPc());
instruction.execute(frame);
System.out.print(" op:" + instruction.getReName());
System.out.println(" localVars:" + frame.getLocalVars());
} while (opcode != 0xb1);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/Interpreter.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 335
|
```java
package com.github.jvmgo.instructions.math;
import com.github.jvmgo.instructions.base.NoOperandsInstruction;
import com.github.jvmgo.rtda.Frame;
import com.github.jvmgo.rtda.OperandStack;
public class iand extends NoOperandsInstruction {
@Override
public int getOpCode() {
return 0x7e;
}
@Override
public void execute(Frame frame) throws Exception {
OperandStack operandStack = frame.getOperandStack();
int v2 = operandStack.popInt();
int v1 = operandStack.popInt();
operandStack.pushInt(v1 & v2);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/instructions/math/iand.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 138
|
```java
package com.github.jvmgo;
import com.beust.jcommander.JCommander;
import com.beust.jcommander.Parameter;
import com.beust.jcommander.ParameterException;
import lombok.Getter;
import lombok.Setter;
import java.util.List;
@Getter
@Setter
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/ch05/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
| 358
|
```java
package com.github.jvmgo.instructions.math;
import com.github.jvmgo.instructions.base.NoOperandsInstruction;
import com.github.jvmgo.rtda.Frame;
import com.github.jvmgo.rtda.OperandStack;
/**
*/
public class ishr extends NoOperandsInstruction {
@Override
public int getOpCode() {
return 0x7a;
}
@Override
public void execute(Frame frame) throws Exception {
OperandStack operandStack = frame.getOperandStack();
int v2 = operandStack.popInt();
int v1 = operandStack.popInt();
int s = v2 & 0x1f;
operandStack.pushInt(v1 >> s);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/instructions/math/ishr.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.instructions.math;
import com.github.jvmgo.instructions.base.NoOperandsInstruction;
import com.github.jvmgo.rtda.Frame;
import com.github.jvmgo.rtda.OperandStack;
public class ldiv extends NoOperandsInstruction {
@Override
public int getOpCode() {
return 0x6d;
}
@Override
public void execute(Frame frame) throws Exception {
OperandStack operandStack = frame.getOperandStack();
long v2 = operandStack.popLong();
long v1 = operandStack.popLong();
if (v2 == 0) {
throw new ArithmeticException("java.lang.ArithmeticException: / by zero");
}
operandStack.pushLong(v1 / v2);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/instructions/math/ldiv.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 166
|
```java
package com.github.jvmgo.instructions.math;
import com.github.jvmgo.instructions.base.NoOperandsInstruction;
import com.github.jvmgo.rtda.Frame;
import com.github.jvmgo.rtda.OperandStack;
/**
*/
public class lshr extends NoOperandsInstruction {
@Override
public int getOpCode() {
return 0x7b;
}
@Override
public void execute(Frame frame) throws Exception {
OperandStack operandStack = frame.getOperandStack();
long v2 = operandStack.popLong();
long v1 = operandStack.popLong();
long s = v2 & 0x3f;
operandStack.pushLong(v1 >> s);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/instructions/math/lshr.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.instructions.math;
import com.github.jvmgo.instructions.base.NoOperandsInstruction;
import com.github.jvmgo.rtda.Frame;
import com.github.jvmgo.rtda.OperandStack;
public class fdiv extends NoOperandsInstruction {
@Override
public int getOpCode() {
return 0x6e;
}
@Override
public void execute(Frame frame) throws Exception {
OperandStack operandStack = frame.getOperandStack();
float v2 = operandStack.popFloat();
float v1 = operandStack.popFloat();
if (v2 == 0) {
throw new ArithmeticException("java.lang.ArithmeticException: / by zero");
}
operandStack.pushFloat(v1 / v2);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/instructions/math/fdiv.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 166
|
```java
package com.github.jvmgo.instructions.math;
import com.github.jvmgo.instructions.base.NoOperandsInstruction;
import com.github.jvmgo.rtda.Frame;
import com.github.jvmgo.rtda.OperandStack;
public class dadd extends NoOperandsInstruction {
@Override
public int getOpCode() {
return 0x63;
}
@Override
public void execute(Frame frame) throws Exception {
OperandStack operandStack = frame.getOperandStack();
double v2 = operandStack.popDouble();
double v1 = operandStack.popDouble();
operandStack.pushDouble(v1 + v2);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/instructions/math/dadd.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 137
|
```java
package com.github.jvmgo.instructions.math;
import com.github.jvmgo.instructions.base.NoOperandsInstruction;
import com.github.jvmgo.rtda.Frame;
import com.github.jvmgo.rtda.OperandStack;
/**
*/
public class ishl extends NoOperandsInstruction {
@Override
public int getOpCode() {
return 0x78;
}
@Override
public void execute(Frame frame) throws Exception {
OperandStack operandStack = frame.getOperandStack();
int v2 = operandStack.popInt();
int v1 = operandStack.popInt();
int s = v2 & 0x1f;
operandStack.pushInt(v1 << s);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/instructions/math/ishl.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 151
|
```java
package com.github.jvmgo.instructions.math;
import com.github.jvmgo.instructions.base.NoOperandsInstruction;
import com.github.jvmgo.rtda.Frame;
import com.github.jvmgo.rtda.OperandStack;
/**
*/
public class iushr extends NoOperandsInstruction {
@Override
public int getOpCode() {
return 0x7c;
}
@Override
public void execute(Frame frame) throws Exception {
OperandStack operandStack = frame.getOperandStack();
int v2 = operandStack.popInt();
int v1 = operandStack.popInt();
int s = v2 & 0x1f;
operandStack.pushInt(v1 >>> s);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/instructions/math/iushr.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.instructions.math;
import com.github.jvmgo.instructions.base.NoOperandsInstruction;
import com.github.jvmgo.rtda.Frame;
import com.github.jvmgo.rtda.OperandStack;
public class idiv extends NoOperandsInstruction {
@Override
public int getOpCode() {
return 0x6c;
}
@Override
public void execute(Frame frame) throws Exception {
OperandStack operandStack = frame.getOperandStack();
int v2 = operandStack.popInt();
int v1 = operandStack.popInt();
if (v2 == 0) {
throw new ArithmeticException("java.lang.ArithmeticException: / by zero");
}
operandStack.pushInt(v1 / v2);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/instructions/math/idiv.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 166
|
```java
package com.github.jvmgo.instructions.math;
import com.github.jvmgo.instructions.base.NoOperandsInstruction;
import com.github.jvmgo.rtda.Frame;
import com.github.jvmgo.rtda.OperandStack;
public class fadd extends NoOperandsInstruction {
@Override
public int getOpCode() {
return 0x62;
}
@Override
public void execute(Frame frame) throws Exception {
OperandStack operandStack = frame.getOperandStack();
float v2 = operandStack.popFloat();
float v1 = operandStack.popFloat();
operandStack.pushFloat(v1 + v2);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/instructions/math/fadd.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 137
|
```java
package com.github.jvmgo.instructions.math;
import com.github.jvmgo.instructions.base.NoOperandsInstruction;
import com.github.jvmgo.rtda.Frame;
import com.github.jvmgo.rtda.OperandStack;
public class lneg extends NoOperandsInstruction {
@Override
public int getOpCode() {
return 0x75;
}
@Override
public void execute(Frame frame) throws Exception {
OperandStack operandStack = frame.getOperandStack();
operandStack.pushLong(operandStack.popLong() * -1);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/instructions/math/lneg.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 121
|
```java
package com.github.jvmgo.instructions.math;
import com.github.jvmgo.instructions.base.NoOperandsInstruction;
import com.github.jvmgo.rtda.Frame;
import com.github.jvmgo.rtda.OperandStack;
public class drem extends NoOperandsInstruction {
@Override
public int getOpCode() {
return 0x73;
}
@Override
public void execute(Frame frame) throws Exception {
OperandStack operandStack = frame.getOperandStack();
double v2 = operandStack.popDouble();
double v1 = operandStack.popDouble();
if (v2 == 0) {
throw new ArithmeticException("java.lang.ArithmeticException: / by zero");
}
operandStack.pushDouble(v1 % v2);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/instructions/math/drem.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 165
|
```java
package com.github.jvmgo.instructions.math;
import com.github.jvmgo.instructions.base.NoOperandsInstruction;
import com.github.jvmgo.rtda.Frame;
import com.github.jvmgo.rtda.OperandStack;
public class iadd extends NoOperandsInstruction {
@Override
public int getOpCode() {
return 0x60;
}
@Override
public void execute(Frame frame) throws Exception {
OperandStack operandStack = frame.getOperandStack();
int v2 = operandStack.popInt();
int v1 = operandStack.popInt();
operandStack.pushInt(v1 + v2);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/instructions/math/iadd.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 137
|
```java
package com.github.jvmgo.instructions.math;
import com.github.jvmgo.instructions.base.BytecodeReader;
import com.github.jvmgo.instructions.base.Index8Instruction;
import lombok.Setter;
import com.github.jvmgo.rtda.Frame;
import com.github.jvmgo.rtda.LocalVars;
public class iinc extends Index8Instruction {
@Setter
private int constVal;
@Override
public int getOpCode() {
return 0x84;
}
@Override
public void fetchOperands(BytecodeReader reader) {
this.index = reader.read8();
this.constVal = reader.read8();
}
@Override
public void execute(Frame frame) throws Exception {
LocalVars localVars = frame.getLocalVars();
int val = localVars.getInt(index);
val += constVal;
localVars.setInt(index, val);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/instructions/math/iinc.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 186
|
```java
package com.github.jvmgo.instructions.math;
import com.github.jvmgo.instructions.base.NoOperandsInstruction;
import com.github.jvmgo.rtda.Frame;
import com.github.jvmgo.rtda.OperandStack;
public class lxor extends NoOperandsInstruction {
@Override
public int getOpCode() {
return 0x83;
}
@Override
public void execute(Frame frame) throws Exception {
OperandStack operandStack = frame.getOperandStack();
long v2 = operandStack.popLong();
long v1 = operandStack.popLong();
operandStack.pushLong(v1 ^ v2);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/instructions/math/lxor.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 137
|
```java
package com.github.jvmgo.instructions.math;
import com.github.jvmgo.instructions.base.NoOperandsInstruction;
import com.github.jvmgo.rtda.Frame;
import com.github.jvmgo.rtda.OperandStack;
public class frem extends NoOperandsInstruction {
@Override
public int getOpCode() {
return 0x72;
}
@Override
public void execute(Frame frame) throws Exception {
OperandStack operandStack = frame.getOperandStack();
float v2 = operandStack.popFloat();
float v1 = operandStack.popFloat();
if (v2 == 0) {
throw new ArithmeticException("java.lang.ArithmeticException: / by zero");
}
operandStack.pushFloat(v1 % v2);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/instructions/math/frem.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 164
|
```java
package com.github.jvmgo.instructions.math;
import com.github.jvmgo.instructions.base.NoOperandsInstruction;
import com.github.jvmgo.rtda.Frame;
import com.github.jvmgo.rtda.OperandStack;
public class lmul extends NoOperandsInstruction {
@Override
public int getOpCode() {
return 0x69;
}
@Override
public void execute(Frame frame) throws Exception {
OperandStack operandStack = frame.getOperandStack();
long v2 = operandStack.popLong();
long v1 = operandStack.popLong();
operandStack.pushLong(v1 * v2);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/instructions/math/lmul.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 137
|
```java
package com.github.jvmgo.instructions.math;
import com.github.jvmgo.instructions.base.NoOperandsInstruction;
import com.github.jvmgo.rtda.Frame;
import com.github.jvmgo.rtda.OperandStack;
public class dsub extends NoOperandsInstruction {
@Override
public int getOpCode() {
return 0x67;
}
@Override
public void execute(Frame frame) throws Exception {
OperandStack operandStack = frame.getOperandStack();
double v2 = operandStack.popDouble();
double v1 = operandStack.popDouble();
operandStack.pushDouble(v1 - v2);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/instructions/math/dsub.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 137
|
```java
package com.github.jvmgo.instructions.math;
import com.github.jvmgo.instructions.base.NoOperandsInstruction;
import com.github.jvmgo.rtda.Frame;
import com.github.jvmgo.rtda.OperandStack;
public class ixor extends NoOperandsInstruction {
@Override
public int getOpCode() {
return 0x82;
}
@Override
public void execute(Frame frame) throws Exception {
OperandStack operandStack = frame.getOperandStack();
int v2 = operandStack.popInt();
int v1 = operandStack.popInt();
operandStack.pushInt(v1 ^ v2);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/instructions/math/ixor.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 137
|
```java
package com.github.jvmgo.instructions.math;
import com.github.jvmgo.instructions.base.NoOperandsInstruction;
import com.github.jvmgo.rtda.Frame;
import com.github.jvmgo.rtda.OperandStack;
public class imul extends NoOperandsInstruction {
@Override
public int getOpCode() {
return 0x68;
}
@Override
public void execute(Frame frame) throws Exception {
OperandStack operandStack = frame.getOperandStack();
int v2 = operandStack.popInt();
int v1 = operandStack.popInt();
operandStack.pushInt(v1 * v2);
}
}
```
|
/content/code_sandbox/v1/code/java/jvmgo_java/ch05/src/main/java/com/github/jvmgo/instructions/math/imul.java
|
java
| 2016-01-06T13:13:45
| 2024-08-16T13:42:58
|
jvmgo-book
|
zxh0/jvmgo-book
| 1,605
| 137
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.