jvm 0.3.0

Core abstractions and runtime services for embeddable JVM implementations
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

use alloc::{
    boxed::Box,
    string::{String, ToString},
    sync::Arc,
    vec::Vec,
};

use event_listener::Event;

use crate::{ClassInstance, JavaValue, class_loader::Class, monitor::MonitorWaitTimeout};

#[derive(Clone)]
pub(crate) enum ThreadInterruptWaiter {
    Monitor(MonitorWaitTimeout),
    Event(Arc<Event>),
}

impl ThreadInterruptWaiter {
    pub(crate) fn notify(self) {
        match self {
            Self::Monitor(waiter) => waiter.notify(),
            Self::Event(event) => {
                event.notify(1);
            }
        }
    }
}

pub enum StackFrame {
    Java(JavaStackFrame),
    Native(NativeStackFrame),
}

impl StackFrame {
    pub fn local_variables(&self) -> &[Box<dyn ClassInstance>] {
        match self {
            StackFrame::Java(java_frame) => &java_frame.local_variables,
            StackFrame::Native(native_frame) => &native_frame.local_variables,
        }
    }

    pub fn local_variables_mut(&mut self) -> &mut Vec<Box<dyn ClassInstance>> {
        match self {
            StackFrame::Java(java_frame) => &mut java_frame.local_variables,
            StackFrame::Native(native_frame) => &mut native_frame.local_variables,
        }
    }
}

pub struct JvmThread {
    stack: Vec<StackFrame>,
    java_thread: Option<Box<dyn ClassInstance>>,
    pub(crate) interrupted: bool,
    pub(crate) interrupt_waiter: Option<ThreadInterruptWaiter>,
}

impl JvmThread {
    pub fn new() -> Self {
        Self {
            stack: Vec::new(),
            java_thread: None,
            interrupted: false,
            interrupt_waiter: None,
        }
    }

    #[allow(clippy::borrowed_box)] // same as jvm.rs; callers pass it to &Box-taking apis
    pub fn java_thread(&self) -> Option<&Box<dyn ClassInstance>> {
        self.java_thread.as_ref()
    }

    pub fn set_java_thread(&mut self, java_thread: Box<dyn ClassInstance>) {
        self.java_thread = Some(java_thread);
    }

    pub fn push_java_frame(&mut self, class: &Class, class_instance: Option<Box<dyn ClassInstance>>, method: &str, args: &[JavaValue]) {
        self.stack.push(StackFrame::Java(JavaStackFrame {
            class: class.clone(),
            class_instance,
            method: method.to_string(),
            local_variables: args
                .iter()
                .filter_map(|arg| match arg {
                    JavaValue::Object(Some(instance)) => Some(instance.clone()),
                    _ => None,
                })
                .collect(),
        }));
    }

    pub fn push_native_frame(&mut self) {
        self.stack.push(StackFrame::Native(NativeStackFrame { local_variables: Vec::new() }));
    }

    pub fn pop_frame(&mut self) -> Option<StackFrame> {
        self.stack.pop()
    }

    pub fn top_frame_mut(&mut self) -> &mut StackFrame {
        self.stack.last_mut().unwrap()
    }

    pub fn top_java_frame(&self) -> Option<&JavaStackFrame> {
        self.stack.iter().rev().find_map(|frame| match frame {
            StackFrame::Java(java_frame) => Some(java_frame),
            _ => None,
        })
    }

    pub fn iter_java_frame(&self) -> impl DoubleEndedIterator<Item = &JavaStackFrame> {
        self.stack.iter().filter_map(|frame| match frame {
            StackFrame::Java(java_frame) => Some(java_frame),
            _ => None,
        })
    }

    pub fn iter_frame(&self) -> impl DoubleEndedIterator<Item = &StackFrame> {
        self.stack.iter()
    }
}

pub struct JavaStackFrame {
    pub class: Class,
    pub class_instance: Option<Box<dyn ClassInstance>>,
    pub method: String,
    pub local_variables: Vec<Box<dyn ClassInstance>>,
}

pub struct NativeStackFrame {
    pub local_variables: Vec<Box<dyn ClassInstance>>,
}