Skip to main content

rustjava_runtime/classes/java/io/
buffered_reader.rs

1use core::{cmp::min, future::Future};
2
3use alloc::{vec, vec::Vec};
4
5use jvm::{Array, ClassInstanceRef, JavaChar, Jvm, Result, runtime::JavaLangString};
6use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
7use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
8
9use crate::{
10    RuntimeClassProto, RuntimeContext,
11    classes::java::{
12        io::Reader,
13        lang::{Object, String},
14    },
15};
16
17const DEFAULT_BUFFER_SIZE: usize = 8192;
18const INVALIDATED: i32 = -2;
19const UNMARKED: i32 = -1;
20
21// class java.io.BufferedReader
22pub struct BufferedReader;
23
24impl BufferedReader {
25    pub fn as_proto() -> RuntimeClassProto {
26        RuntimeClassProto {
27            name: "java/io/BufferedReader",
28            parent_class: Some("java/io/Reader"),
29            interfaces: vec![],
30            methods: vec![
31                JavaMethodProto::new("<init>", "(Ljava/io/Reader;)V", Self::init, MethodAccessFlags::PUBLIC),
32                JavaMethodProto::new("<init>", "(Ljava/io/Reader;I)V", Self::init_with_size, MethodAccessFlags::PUBLIC),
33                JavaMethodProto::new("read", "()I", Self::read_char, MethodAccessFlags::PUBLIC),
34                JavaMethodProto::new("read", "([CII)I", Self::read, MethodAccessFlags::PUBLIC),
35                JavaMethodProto::new("readLine", "()Ljava/lang/String;", Self::read_line, MethodAccessFlags::PUBLIC),
36                JavaMethodProto::new("skip", "(J)J", Self::skip, MethodAccessFlags::PUBLIC),
37                JavaMethodProto::new("ready", "()Z", Self::ready, MethodAccessFlags::PUBLIC),
38                JavaMethodProto::new("markSupported", "()Z", Self::mark_supported, MethodAccessFlags::PUBLIC),
39                JavaMethodProto::new("mark", "(I)V", Self::mark, MethodAccessFlags::PUBLIC),
40                JavaMethodProto::new("reset", "()V", Self::reset, MethodAccessFlags::PUBLIC),
41                JavaMethodProto::new("close", "()V", Self::close, MethodAccessFlags::PUBLIC),
42            ],
43            fields: vec![
44                JavaFieldProto::new("in", "Ljava/io/Reader;", FieldAccessFlags::PRIVATE),
45                JavaFieldProto::new("cb", "[C", FieldAccessFlags::PRIVATE),
46                JavaFieldProto::new("nChars", "I", FieldAccessFlags::PRIVATE),
47                JavaFieldProto::new("nextChar", "I", FieldAccessFlags::PRIVATE),
48                JavaFieldProto::new("markedChar", "I", FieldAccessFlags::PRIVATE),
49                JavaFieldProto::new("readAheadLimit", "I", FieldAccessFlags::PRIVATE),
50                JavaFieldProto::new("skipLF", "Z", FieldAccessFlags::PRIVATE),
51                JavaFieldProto::new("markedSkipLF", "Z", FieldAccessFlags::PRIVATE),
52            ],
53            access_flags: ClassAccessFlags::PUBLIC,
54        }
55    }
56
57    async fn init(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, r#in: ClassInstanceRef<Reader>) -> Result<()> {
58        tracing::debug!("java.io.BufferedReader::<init>({this:?}, {in:?})", in = &r#in);
59
60        jvm.invoke_special(
61            &this,
62            "java/io/BufferedReader",
63            "<init>",
64            "(Ljava/io/Reader;I)V",
65            (r#in, DEFAULT_BUFFER_SIZE as i32),
66        )
67        .await
68    }
69
70    async fn init_with_size(
71        jvm: &Jvm,
72        _: &mut RuntimeContext,
73        mut this: ClassInstanceRef<Self>,
74        r#in: ClassInstanceRef<Reader>,
75        size: i32,
76    ) -> Result<()> {
77        tracing::debug!("java.io.BufferedReader::<init>({this:?}, {in:?}, {size})", in = &r#in);
78
79        if r#in.is_null() {
80            return Err(jvm.exception("java/lang/NullPointerException", "reader is null").await);
81        }
82        if size <= 0 {
83            return Err(jvm.exception("java/lang/IllegalArgumentException", "buffer size is not positive").await);
84        }
85
86        let _: () = jvm
87            .invoke_special(&this, "java/io/Reader", "<init>", "(Ljava/lang/Object;)V", (r#in.clone(),))
88            .await?;
89
90        let cb = jvm.instantiate_array("C", size as usize).await?;
91        jvm.put_field(&mut this, "java/io/BufferedReader", "in", "Ljava/io/Reader;", r#in).await?;
92        jvm.put_field(&mut this, "java/io/BufferedReader", "cb", "[C", cb).await?;
93        jvm.put_field(&mut this, "java/io/BufferedReader", "nChars", "I", 0).await?;
94        jvm.put_field(&mut this, "java/io/BufferedReader", "nextChar", "I", 0).await?;
95        jvm.put_field(&mut this, "java/io/BufferedReader", "markedChar", "I", UNMARKED).await?;
96        jvm.put_field(&mut this, "java/io/BufferedReader", "readAheadLimit", "I", 0).await?;
97        jvm.put_field(&mut this, "java/io/BufferedReader", "skipLF", "Z", false).await?;
98        jvm.put_field(&mut this, "java/io/BufferedReader", "markedSkipLF", "Z", false).await?;
99        Ok(())
100    }
101
102    async fn with_lock<T, F>(jvm: &Jvm, lock: &ClassInstanceRef<Object>, operation: F) -> Result<T>
103    where
104        F: Future<Output = Result<T>>,
105    {
106        jvm.monitor_enter(lock).await?;
107        match operation.await {
108            Ok(value) => {
109                jvm.monitor_exit(lock).await?;
110                Ok(value)
111            }
112            Err(error) => {
113                if let Err(exit_error) = jvm.monitor_exit(lock).await {
114                    tracing::error!(?exit_error, "failed to release BufferedReader lock");
115                }
116                Err(error)
117            }
118        }
119    }
120
121    async fn fill(jvm: &Jvm, this: &mut ClassInstanceRef<Self>) -> Result<i32> {
122        let r#in: ClassInstanceRef<Reader> = jvm.get_field(this, "java/io/BufferedReader", "in", "Ljava/io/Reader;").await?;
123        if r#in.is_null() {
124            return Err(jvm.exception("java/io/IOException", "stream is closed").await);
125        }
126
127        let mut cb: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(this, "java/io/BufferedReader", "cb", "[C").await?;
128        let mut destination = 0;
129        let marked_char: i32 = jvm.get_field(this, "java/io/BufferedReader", "markedChar", "I").await?;
130        if marked_char >= 0 {
131            let next_char: i32 = jvm.get_field(this, "java/io/BufferedReader", "nextChar", "I").await?;
132            let delta = next_char - marked_char;
133            let read_ahead_limit: i32 = jvm.get_field(this, "java/io/BufferedReader", "readAheadLimit", "I").await?;
134            if delta >= read_ahead_limit {
135                jvm.put_field(this, "java/io/BufferedReader", "markedChar", "I", INVALIDATED).await?;
136                jvm.put_field(this, "java/io/BufferedReader", "readAheadLimit", "I", 0).await?;
137            } else {
138                let capacity = jvm.array_length(&cb).await?;
139                if read_ahead_limit as usize > capacity {
140                    let expanded_capacity = min(capacity.saturating_mul(2), read_ahead_limit as usize);
141                    let expanded = jvm.instantiate_array("C", expanded_capacity).await?;
142                    let _: () = jvm
143                        .invoke_static(
144                            "java/lang/System",
145                            "arraycopy",
146                            "(Ljava/lang/Object;ILjava/lang/Object;II)V",
147                            (cb, marked_char, expanded.clone(), 0, delta),
148                        )
149                        .await?;
150                    cb = expanded.into();
151                    jvm.put_field(this, "java/io/BufferedReader", "cb", "[C", cb.clone()).await?;
152                } else if delta > 0 {
153                    let _: () = jvm
154                        .invoke_static(
155                            "java/lang/System",
156                            "arraycopy",
157                            "(Ljava/lang/Object;ILjava/lang/Object;II)V",
158                            (cb.clone(), marked_char, cb.clone(), 0, delta),
159                        )
160                        .await?;
161                }
162
163                jvm.put_field(this, "java/io/BufferedReader", "markedChar", "I", 0).await?;
164                destination = delta;
165            }
166        }
167
168        jvm.put_field(this, "java/io/BufferedReader", "nextChar", "I", destination).await?;
169        jvm.put_field(this, "java/io/BufferedReader", "nChars", "I", destination).await?;
170
171        let capacity = jvm.array_length(&cb).await? as i32;
172        let mut read;
173        loop {
174            read = jvm
175                .invoke_virtual(
176                    &r#in,
177                    "java/io/Reader",
178                    "read",
179                    "([CII)I",
180                    (cb.clone(), destination, capacity - destination),
181                )
182                .await?;
183            if read != 0 {
184                break;
185            }
186        }
187        if read > 0 {
188            jvm.put_field(this, "java/io/BufferedReader", "nChars", "I", destination + read).await?;
189            jvm.put_field(this, "java/io/BufferedReader", "nextChar", "I", destination).await?;
190        }
191
192        Ok(read)
193    }
194
195    async fn read_char(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<i32> {
196        let lock: ClassInstanceRef<Object> = jvm.get_field(&this, "java/io/BufferedReader", "lock", "Ljava/lang/Object;").await?;
197        Self::with_lock(jvm, &lock, Self::read_char_locked(jvm, this)).await
198    }
199
200    async fn read_char_locked(jvm: &Jvm, mut this: ClassInstanceRef<Self>) -> Result<i32> {
201        tracing::debug!("java.io.BufferedReader::read({this:?})");
202
203        let r#in: ClassInstanceRef<Reader> = jvm.get_field(&this, "java/io/BufferedReader", "in", "Ljava/io/Reader;").await?;
204        if r#in.is_null() {
205            return Err(jvm.exception("java/io/IOException", "stream is closed").await);
206        }
207
208        loop {
209            let mut next_char: i32 = jvm.get_field(&this, "java/io/BufferedReader", "nextChar", "I").await?;
210            let mut n_chars: i32 = jvm.get_field(&this, "java/io/BufferedReader", "nChars", "I").await?;
211            if next_char >= n_chars {
212                if Self::fill(jvm, &mut this).await? <= 0 {
213                    return Ok(-1);
214                }
215                next_char = jvm.get_field(&this, "java/io/BufferedReader", "nextChar", "I").await?;
216                n_chars = jvm.get_field(&this, "java/io/BufferedReader", "nChars", "I").await?;
217            }
218
219            if jvm.get_field::<bool>(&this, "java/io/BufferedReader", "skipLF", "Z").await? {
220                jvm.put_field(&mut this, "java/io/BufferedReader", "skipLF", "Z", false).await?;
221                let cb: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "java/io/BufferedReader", "cb", "[C").await?;
222                if jvm.load_array::<JavaChar>(&cb, next_char as usize, 1).await?[0] == '\n' as JavaChar {
223                    next_char += 1;
224                    jvm.put_field(&mut this, "java/io/BufferedReader", "nextChar", "I", next_char).await?;
225                    if next_char >= n_chars {
226                        continue;
227                    }
228                }
229            }
230
231            let cb: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "java/io/BufferedReader", "cb", "[C").await?;
232            let value = jvm.load_array::<JavaChar>(&cb, next_char as usize, 1).await?[0];
233            jvm.put_field(&mut this, "java/io/BufferedReader", "nextChar", "I", next_char + 1).await?;
234            return Ok(value as i32);
235        }
236    }
237
238    async fn read(
239        jvm: &Jvm,
240        _: &mut RuntimeContext,
241        this: ClassInstanceRef<Self>,
242        target: ClassInstanceRef<Array<JavaChar>>,
243        offset: i32,
244        length: i32,
245    ) -> Result<i32> {
246        let lock: ClassInstanceRef<Object> = jvm.get_field(&this, "java/io/BufferedReader", "lock", "Ljava/lang/Object;").await?;
247        Self::with_lock(jvm, &lock, Self::read_locked(jvm, this, target, offset, length)).await
248    }
249
250    async fn read_locked(
251        jvm: &Jvm,
252        mut this: ClassInstanceRef<Self>,
253        target: ClassInstanceRef<Array<JavaChar>>,
254        offset: i32,
255        length: i32,
256    ) -> Result<i32> {
257        tracing::debug!("java.io.BufferedReader::read({this:?}, {target:?}, {offset}, {length})");
258
259        let r#in: ClassInstanceRef<Reader> = jvm.get_field(&this, "java/io/BufferedReader", "in", "Ljava/io/Reader;").await?;
260        if r#in.is_null() {
261            return Err(jvm.exception("java/io/IOException", "stream is closed").await);
262        }
263        if target.is_null() {
264            return Err(jvm.exception("java/lang/NullPointerException", "target is null").await);
265        }
266
267        let target_length = jvm.array_length(&target).await? as i32;
268        if offset < 0 || length < 0 || offset > target_length || length > target_length - offset {
269            return Err(jvm.exception("java/lang/IndexOutOfBoundsException", "invalid offset or length").await);
270        }
271        if length == 0 {
272            return Ok(0);
273        }
274
275        let mut total = 0;
276        while total < length {
277            let mut next_char: i32 = jvm.get_field(&this, "java/io/BufferedReader", "nextChar", "I").await?;
278            let mut n_chars: i32 = jvm.get_field(&this, "java/io/BufferedReader", "nChars", "I").await?;
279            if next_char >= n_chars {
280                if total > 0 && !jvm.invoke_virtual::<_, bool>(&r#in, "java/io/Reader", "ready", "()Z", ()).await? {
281                    break;
282                }
283                if Self::fill(jvm, &mut this).await? <= 0 {
284                    break;
285                }
286                next_char = jvm.get_field(&this, "java/io/BufferedReader", "nextChar", "I").await?;
287                n_chars = jvm.get_field(&this, "java/io/BufferedReader", "nChars", "I").await?;
288            }
289
290            if jvm.get_field::<bool>(&this, "java/io/BufferedReader", "skipLF", "Z").await? {
291                jvm.put_field(&mut this, "java/io/BufferedReader", "skipLF", "Z", false).await?;
292                let cb: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "java/io/BufferedReader", "cb", "[C").await?;
293                if jvm.load_array::<JavaChar>(&cb, next_char as usize, 1).await?[0] == '\n' as JavaChar {
294                    next_char += 1;
295                    jvm.put_field(&mut this, "java/io/BufferedReader", "nextChar", "I", next_char).await?;
296                    if next_char >= n_chars {
297                        continue;
298                    }
299                }
300            }
301
302            let count = min(length - total, n_chars - next_char);
303            let cb: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "java/io/BufferedReader", "cb", "[C").await?;
304            let _: () = jvm
305                .invoke_static(
306                    "java/lang/System",
307                    "arraycopy",
308                    "(Ljava/lang/Object;ILjava/lang/Object;II)V",
309                    (cb, next_char, target.clone(), offset + total, count),
310                )
311                .await?;
312            total += count;
313            jvm.put_field(&mut this, "java/io/BufferedReader", "nextChar", "I", next_char + count)
314                .await?;
315        }
316
317        if total == 0 { Ok(-1) } else { Ok(total) }
318    }
319
320    async fn read_line(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
321        let lock: ClassInstanceRef<Object> = jvm.get_field(&this, "java/io/BufferedReader", "lock", "Ljava/lang/Object;").await?;
322        Self::with_lock(jvm, &lock, Self::read_line_locked(jvm, this)).await
323    }
324
325    async fn read_line_locked(jvm: &Jvm, mut this: ClassInstanceRef<Self>) -> Result<ClassInstanceRef<String>> {
326        tracing::debug!("java.io.BufferedReader::readLine({this:?})");
327
328        let r#in: ClassInstanceRef<Reader> = jvm.get_field(&this, "java/io/BufferedReader", "in", "Ljava/io/Reader;").await?;
329        if r#in.is_null() {
330            return Err(jvm.exception("java/io/IOException", "stream is closed").await);
331        }
332
333        let mut omit_lf: bool = jvm.get_field(&this, "java/io/BufferedReader", "skipLF", "Z").await?;
334        jvm.put_field(&mut this, "java/io/BufferedReader", "skipLF", "Z", false).await?;
335        let mut line = Vec::new();
336
337        loop {
338            let mut next_char: i32 = jvm.get_field(&this, "java/io/BufferedReader", "nextChar", "I").await?;
339            let mut n_chars: i32 = jvm.get_field(&this, "java/io/BufferedReader", "nChars", "I").await?;
340            if next_char >= n_chars {
341                if Self::fill(jvm, &mut this).await? <= 0 {
342                    if line.is_empty() {
343                        return Ok(None.into());
344                    }
345
346                    return Ok(JavaLangString::from_utf16(jvm, line).await?.into());
347                }
348                next_char = jvm.get_field(&this, "java/io/BufferedReader", "nextChar", "I").await?;
349                n_chars = jvm.get_field(&this, "java/io/BufferedReader", "nChars", "I").await?;
350            }
351
352            let cb: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "java/io/BufferedReader", "cb", "[C").await?;
353            if omit_lf {
354                omit_lf = false;
355                if jvm.load_array::<JavaChar>(&cb, next_char as usize, 1).await?[0] == '\n' as JavaChar {
356                    next_char += 1;
357                    jvm.put_field(&mut this, "java/io/BufferedReader", "nextChar", "I", next_char).await?;
358                    if next_char >= n_chars {
359                        continue;
360                    }
361                }
362            }
363
364            let buffered: Vec<JavaChar> = jvm.load_array(&cb, next_char as usize, (n_chars - next_char) as usize).await?;
365            if let Some(index) = buffered.iter().position(|value| *value == '\n' as JavaChar || *value == '\r' as JavaChar) {
366                line.extend_from_slice(&buffered[..index]);
367                let terminator = buffered[index];
368                jvm.put_field(&mut this, "java/io/BufferedReader", "nextChar", "I", next_char + index as i32 + 1)
369                    .await?;
370                if terminator == '\r' as JavaChar {
371                    jvm.put_field(&mut this, "java/io/BufferedReader", "skipLF", "Z", true).await?;
372                }
373
374                return Ok(JavaLangString::from_utf16(jvm, line).await?.into());
375            }
376
377            line.extend(buffered);
378            jvm.put_field(&mut this, "java/io/BufferedReader", "nextChar", "I", n_chars).await?;
379        }
380    }
381
382    async fn skip(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, count: i64) -> Result<i64> {
383        let lock: ClassInstanceRef<Object> = jvm.get_field(&this, "java/io/BufferedReader", "lock", "Ljava/lang/Object;").await?;
384        Self::with_lock(jvm, &lock, Self::skip_locked(jvm, this, count)).await
385    }
386
387    async fn skip_locked(jvm: &Jvm, mut this: ClassInstanceRef<Self>, count: i64) -> Result<i64> {
388        tracing::debug!("java.io.BufferedReader::skip({this:?}, {count})");
389
390        let r#in: ClassInstanceRef<Reader> = jvm.get_field(&this, "java/io/BufferedReader", "in", "Ljava/io/Reader;").await?;
391        if r#in.is_null() {
392            return Err(jvm.exception("java/io/IOException", "stream is closed").await);
393        }
394        if count < 0 {
395            return Err(jvm.exception("java/lang/IllegalArgumentException", "skip value is negative").await);
396        }
397
398        let mut remaining = count;
399        while remaining > 0 {
400            let mut next_char: i32 = jvm.get_field(&this, "java/io/BufferedReader", "nextChar", "I").await?;
401            let mut n_chars: i32 = jvm.get_field(&this, "java/io/BufferedReader", "nChars", "I").await?;
402            if next_char >= n_chars {
403                if Self::fill(jvm, &mut this).await? <= 0 {
404                    break;
405                }
406                next_char = jvm.get_field(&this, "java/io/BufferedReader", "nextChar", "I").await?;
407                n_chars = jvm.get_field(&this, "java/io/BufferedReader", "nChars", "I").await?;
408            }
409
410            if jvm.get_field::<bool>(&this, "java/io/BufferedReader", "skipLF", "Z").await? {
411                jvm.put_field(&mut this, "java/io/BufferedReader", "skipLF", "Z", false).await?;
412                let cb: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "java/io/BufferedReader", "cb", "[C").await?;
413                if jvm.load_array::<JavaChar>(&cb, next_char as usize, 1).await?[0] == '\n' as JavaChar {
414                    next_char += 1;
415                    jvm.put_field(&mut this, "java/io/BufferedReader", "nextChar", "I", next_char).await?;
416                    if next_char >= n_chars {
417                        continue;
418                    }
419                }
420            }
421
422            let skipped = min(remaining, (n_chars - next_char) as i64);
423            remaining -= skipped;
424            jvm.put_field(&mut this, "java/io/BufferedReader", "nextChar", "I", next_char + skipped as i32)
425                .await?;
426        }
427
428        Ok(count - remaining)
429    }
430
431    async fn ready(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
432        let lock: ClassInstanceRef<Object> = jvm.get_field(&this, "java/io/BufferedReader", "lock", "Ljava/lang/Object;").await?;
433        Self::with_lock(jvm, &lock, Self::ready_locked(jvm, this)).await
434    }
435
436    async fn ready_locked(jvm: &Jvm, mut this: ClassInstanceRef<Self>) -> Result<bool> {
437        tracing::debug!("java.io.BufferedReader::ready({this:?})");
438
439        let r#in: ClassInstanceRef<Reader> = jvm.get_field(&this, "java/io/BufferedReader", "in", "Ljava/io/Reader;").await?;
440        if r#in.is_null() {
441            return Err(jvm.exception("java/io/IOException", "stream is closed").await);
442        }
443
444        let mut next_char: i32 = jvm.get_field(&this, "java/io/BufferedReader", "nextChar", "I").await?;
445        let mut n_chars: i32 = jvm.get_field(&this, "java/io/BufferedReader", "nChars", "I").await?;
446        if jvm.get_field::<bool>(&this, "java/io/BufferedReader", "skipLF", "Z").await? {
447            if next_char >= n_chars && jvm.invoke_virtual::<_, bool>(&r#in, "java/io/Reader", "ready", "()Z", ()).await? {
448                let _ = Self::fill(jvm, &mut this).await?;
449                next_char = jvm.get_field(&this, "java/io/BufferedReader", "nextChar", "I").await?;
450                n_chars = jvm.get_field(&this, "java/io/BufferedReader", "nChars", "I").await?;
451            }
452
453            if next_char < n_chars {
454                let cb: ClassInstanceRef<Array<JavaChar>> = jvm.get_field(&this, "java/io/BufferedReader", "cb", "[C").await?;
455                if jvm.load_array::<JavaChar>(&cb, next_char as usize, 1).await?[0] == '\n' as JavaChar {
456                    next_char += 1;
457                    jvm.put_field(&mut this, "java/io/BufferedReader", "nextChar", "I", next_char).await?;
458                }
459                jvm.put_field(&mut this, "java/io/BufferedReader", "skipLF", "Z", false).await?;
460            }
461        }
462
463        if next_char < n_chars {
464            return Ok(true);
465        }
466        jvm.invoke_virtual(&r#in, "java/io/Reader", "ready", "()Z", ()).await
467    }
468
469    async fn mark_supported(_: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<bool> {
470        tracing::debug!("java.io.BufferedReader::markSupported({this:?})");
471        Ok(true)
472    }
473
474    async fn mark(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, read_ahead_limit: i32) -> Result<()> {
475        let lock: ClassInstanceRef<Object> = jvm.get_field(&this, "java/io/BufferedReader", "lock", "Ljava/lang/Object;").await?;
476        Self::with_lock(jvm, &lock, Self::mark_locked(jvm, this, read_ahead_limit)).await
477    }
478
479    async fn mark_locked(jvm: &Jvm, mut this: ClassInstanceRef<Self>, read_ahead_limit: i32) -> Result<()> {
480        tracing::debug!("java.io.BufferedReader::mark({this:?}, {read_ahead_limit})");
481
482        let r#in: ClassInstanceRef<Reader> = jvm.get_field(&this, "java/io/BufferedReader", "in", "Ljava/io/Reader;").await?;
483        if r#in.is_null() {
484            return Err(jvm.exception("java/io/IOException", "stream is closed").await);
485        }
486        if read_ahead_limit < 0 {
487            return Err(jvm.exception("java/lang/IllegalArgumentException", "read-ahead limit is negative").await);
488        }
489
490        let next_char: i32 = jvm.get_field(&this, "java/io/BufferedReader", "nextChar", "I").await?;
491        let skip_lf: bool = jvm.get_field(&this, "java/io/BufferedReader", "skipLF", "Z").await?;
492        jvm.put_field(&mut this, "java/io/BufferedReader", "readAheadLimit", "I", read_ahead_limit)
493            .await?;
494        jvm.put_field(&mut this, "java/io/BufferedReader", "markedChar", "I", next_char).await?;
495        jvm.put_field(&mut this, "java/io/BufferedReader", "markedSkipLF", "Z", skip_lf).await?;
496        Ok(())
497    }
498
499    async fn reset(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
500        let lock: ClassInstanceRef<Object> = jvm.get_field(&this, "java/io/BufferedReader", "lock", "Ljava/lang/Object;").await?;
501        Self::with_lock(jvm, &lock, Self::reset_locked(jvm, this)).await
502    }
503
504    async fn reset_locked(jvm: &Jvm, mut this: ClassInstanceRef<Self>) -> Result<()> {
505        tracing::debug!("java.io.BufferedReader::reset({this:?})");
506
507        let r#in: ClassInstanceRef<Reader> = jvm.get_field(&this, "java/io/BufferedReader", "in", "Ljava/io/Reader;").await?;
508        if r#in.is_null() {
509            return Err(jvm.exception("java/io/IOException", "stream is closed").await);
510        }
511
512        let marked_char: i32 = jvm.get_field(&this, "java/io/BufferedReader", "markedChar", "I").await?;
513        if marked_char < 0 {
514            let message = if marked_char == INVALIDATED {
515                "mark invalid"
516            } else {
517                "stream not marked"
518            };
519            return Err(jvm.exception("java/io/IOException", message).await);
520        }
521
522        let marked_skip_lf: bool = jvm.get_field(&this, "java/io/BufferedReader", "markedSkipLF", "Z").await?;
523        jvm.put_field(&mut this, "java/io/BufferedReader", "nextChar", "I", marked_char).await?;
524        jvm.put_field(&mut this, "java/io/BufferedReader", "skipLF", "Z", marked_skip_lf).await?;
525        Ok(())
526    }
527
528    async fn close(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>) -> Result<()> {
529        let lock: ClassInstanceRef<Object> = jvm.get_field(&this, "java/io/BufferedReader", "lock", "Ljava/lang/Object;").await?;
530        Self::with_lock(jvm, &lock, Self::close_locked(jvm, this)).await
531    }
532
533    async fn close_locked(jvm: &Jvm, mut this: ClassInstanceRef<Self>) -> Result<()> {
534        tracing::debug!("java.io.BufferedReader::close({this:?})");
535
536        let r#in: ClassInstanceRef<Reader> = jvm.get_field(&this, "java/io/BufferedReader", "in", "Ljava/io/Reader;").await?;
537        if r#in.is_null() {
538            return Ok(());
539        }
540
541        let result = jvm.invoke_virtual(&r#in, "java/io/Reader", "close", "()V", ()).await;
542        let closed: ClassInstanceRef<Reader> = None.into();
543        jvm.put_field(&mut this, "java/io/BufferedReader", "in", "Ljava/io/Reader;", closed)
544            .await?;
545        let released: ClassInstanceRef<Array<JavaChar>> = None.into();
546        jvm.put_field(&mut this, "java/io/BufferedReader", "cb", "[C", released).await?;
547        result
548    }
549}