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
21pub 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}