1#[cfg(feature = "moon_sharp-interpreter-execution-vm-bytecode-types")]
4mod __types {
5 #[allow(unused_imports)] use ::unity::prelude::*;
6
7 use super::*;
8 use crate::{
9 moon_sharp::interpreter::refidobject::{IRefIdObject, RefIdObject},
10 system::object::{IObject, Object},
11 };
12
13 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/moon_sharp/interpreter/execution/vm/bytecode/ByteCode.md"))]
14 #[::unity::class(namespace = "MoonSharp.Interpreter.Execution.VM", name = "ByteCode")]
15 #[parent(crate::moon_sharp::interpreter::refidobject::RefIdObject)]
16 pub struct ByteCode {
17 #[offset(24)]
18 #[rename(name = "Code")]
19 pub code: crate::system::collections::generic::list_1::List_1<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction>,
20 #[offset(40)]
21 #[rename(name = "m_SourceRefStack")]
22 pub m_source_ref_stack: crate::system::collections::generic::list_1::List_1<crate::moon_sharp::interpreter::debugging::sourceref::SourceRef>,
23 #[offset(48)]
24 #[rename(name = "m_CurrentSourceRef")]
25 pub m_current_source_ref: crate::moon_sharp::interpreter::debugging::sourceref::SourceRef,
26 #[offset(56)]
27 #[rename(name = "LoopTracker")]
28 pub loop_tracker: crate::moon_sharp::interpreter::execution::looptracker::LoopTracker,
29 }
30
31 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/moon_sharp/interpreter/execution/vm/bytecode/ByteCode_SourceCodeStackGuard.md"))]
32 #[::unity::class(namespace = "MoonSharp.Interpreter.Execution.VM", name = "ByteCode.SourceCodeStackGuard")]
33 #[parent(crate::system::object::Object)]
34 pub struct ByteCode_SourceCodeStackGuard {
35 #[offset(16)]
36 #[rename(name = "m_Bc")]
37 pub m_bc: crate::moon_sharp::interpreter::execution::vm::bytecode::ByteCode,
38 }
39}
40
41#[cfg(feature = "moon_sharp-interpreter-execution-vm-bytecode-types")]
42pub use __types::*;
43
44#[cfg(feature = "moon_sharp-interpreter-execution-vm-bytecode")]
45#[doc(hidden)]
46#[allow(non_snake_case, non_camel_case_types, clippy::too_many_arguments)]
47mod __ByteCode_unity_raw {
48 use super::*;
49 #[doc(hidden)]
50 #[allow(non_snake_case)]
51 pub mod __lookup_get_script {
52 use super::*;
53 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
54 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
55 ::unity::lookup::method_info_on_class_with_signature(<ByteCode as ::unity::ClassIdentity>::class(), "get_Script", 0, param_types, false)
56 });
57 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
58 match &*METHOD {
59 ::core::result::Result::Ok(mi) => *mi,
60 ::core::result::Result::Err(e) => {
61 panic!(
62 "method lookup failed: {}
63::{}
64: {}
65",
66 <ByteCode as ::unity::ClassIdentity>::NAME,
67 "get_Script",
68 e
69 )
70 },
71 }
72 }
73 }
74 #[doc(hidden)]
75 #[allow(non_snake_case)]
76 pub mod __lookup_set_script {
77 use super::*;
78 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
79 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
80 &[<crate::moon_sharp::interpreter::script::Script as ::unity::IlType>::il_type()];
81 ::unity::lookup::method_info_on_class_with_signature(<ByteCode as ::unity::ClassIdentity>::class(), "set_Script", 1, param_types, false)
82 });
83 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
84 match &*METHOD {
85 ::core::result::Result::Ok(mi) => *mi,
86 ::core::result::Result::Err(e) => {
87 panic!(
88 "method lookup failed: {}
89::{}
90: {}
91",
92 <ByteCode as ::unity::ClassIdentity>::NAME,
93 "set_Script",
94 e
95 )
96 },
97 }
98 }
99 }
100 #[doc(hidden)]
101 #[allow(non_snake_case)]
102 pub mod __lookup_ctor {
103 use super::*;
104 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
105 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
106 &[<crate::moon_sharp::interpreter::script::Script as ::unity::IlType>::il_type()];
107 ::unity::lookup::method_info_on_class_with_signature(<ByteCode as ::unity::ClassIdentity>::class(), ".ctor", 1, param_types, false)
108 });
109 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
110 match &*METHOD {
111 ::core::result::Result::Ok(mi) => *mi,
112 ::core::result::Result::Err(e) => {
113 panic!(
114 "method lookup failed: {}
115::{}
116: {}
117",
118 <ByteCode as ::unity::ClassIdentity>::NAME,
119 ".ctor",
120 e
121 )
122 },
123 }
124 }
125 }
126 #[doc(hidden)]
127 #[allow(non_snake_case)]
128 pub mod __lookup_push_source_ref {
129 use super::*;
130 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
131 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
132 &[<crate::moon_sharp::interpreter::debugging::sourceref::SourceRef as ::unity::IlType>::il_type()];
133 ::unity::lookup::method_info_on_class_with_signature(
134 <ByteCode as ::unity::ClassIdentity>::class(),
135 "PushSourceRef",
136 1,
137 param_types,
138 false,
139 )
140 });
141 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
142 match &*METHOD {
143 ::core::result::Result::Ok(mi) => *mi,
144 ::core::result::Result::Err(e) => {
145 panic!(
146 "method lookup failed: {}
147::{}
148: {}
149",
150 <ByteCode as ::unity::ClassIdentity>::NAME,
151 "PushSourceRef",
152 e
153 )
154 },
155 }
156 }
157 }
158 #[doc(hidden)]
159 #[allow(non_snake_case)]
160 pub mod __lookup_pop_source_ref {
161 use super::*;
162 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
163 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
164 ::unity::lookup::method_info_on_class_with_signature(<ByteCode as ::unity::ClassIdentity>::class(), "PopSourceRef", 0, param_types, false)
165 });
166 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
167 match &*METHOD {
168 ::core::result::Result::Ok(mi) => *mi,
169 ::core::result::Result::Err(e) => {
170 panic!(
171 "method lookup failed: {}
172::{}
173: {}
174",
175 <ByteCode as ::unity::ClassIdentity>::NAME,
176 "PopSourceRef",
177 e
178 )
179 },
180 }
181 }
182 }
183 #[doc(hidden)]
184 #[allow(non_snake_case)]
185 pub mod __lookup_dump {
186 use super::*;
187 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
188 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<::unity::Il2CppString as ::unity::IlType>::il_type()];
189 ::unity::lookup::method_info_on_class_with_signature(<ByteCode as ::unity::ClassIdentity>::class(), "Dump", 1, param_types, false)
190 });
191 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
192 match &*METHOD {
193 ::core::result::Result::Ok(mi) => *mi,
194 ::core::result::Result::Err(e) => {
195 panic!(
196 "method lookup failed: {}
197::{}
198: {}
199",
200 <ByteCode as ::unity::ClassIdentity>::NAME,
201 "Dump",
202 e
203 )
204 },
205 }
206 }
207 }
208 #[doc(hidden)]
209 #[allow(non_snake_case)]
210 pub mod __lookup_get_jump_point_for_next_instruction {
211 use super::*;
212 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
213 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
214 ::unity::lookup::method_info_on_class_with_signature(
215 <ByteCode as ::unity::ClassIdentity>::class(),
216 "GetJumpPointForNextInstruction",
217 0,
218 param_types,
219 false,
220 )
221 });
222 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
223 match &*METHOD {
224 ::core::result::Result::Ok(mi) => *mi,
225 ::core::result::Result::Err(e) => {
226 panic!(
227 "method lookup failed: {}
228::{}
229: {}
230",
231 <ByteCode as ::unity::ClassIdentity>::NAME,
232 "GetJumpPointForNextInstruction",
233 e
234 )
235 },
236 }
237 }
238 }
239 #[doc(hidden)]
240 #[allow(non_snake_case)]
241 pub mod __lookup_get_jump_point_for_last_instruction {
242 use super::*;
243 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
244 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
245 ::unity::lookup::method_info_on_class_with_signature(
246 <ByteCode as ::unity::ClassIdentity>::class(),
247 "GetJumpPointForLastInstruction",
248 0,
249 param_types,
250 false,
251 )
252 });
253 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
254 match &*METHOD {
255 ::core::result::Result::Ok(mi) => *mi,
256 ::core::result::Result::Err(e) => {
257 panic!(
258 "method lookup failed: {}
259::{}
260: {}
261",
262 <ByteCode as ::unity::ClassIdentity>::NAME,
263 "GetJumpPointForLastInstruction",
264 e
265 )
266 },
267 }
268 }
269 }
270 #[doc(hidden)]
271 #[allow(non_snake_case)]
272 pub mod __lookup_get_last_instruction {
273 use super::*;
274 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
275 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
276 ::unity::lookup::method_info_on_class_with_signature(
277 <ByteCode as ::unity::ClassIdentity>::class(),
278 "GetLastInstruction",
279 0,
280 param_types,
281 false,
282 )
283 });
284 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
285 match &*METHOD {
286 ::core::result::Result::Ok(mi) => *mi,
287 ::core::result::Result::Err(e) => {
288 panic!(
289 "method lookup failed: {}
290::{}
291: {}
292",
293 <ByteCode as ::unity::ClassIdentity>::NAME,
294 "GetLastInstruction",
295 e
296 )
297 },
298 }
299 }
300 }
301 #[doc(hidden)]
302 #[allow(non_snake_case)]
303 pub mod __lookup_append_instruction {
304 use super::*;
305 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
306 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
307 &[<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction as ::unity::IlType>::il_type()];
308 ::unity::lookup::method_info_on_class_with_signature(
309 <ByteCode as ::unity::ClassIdentity>::class(),
310 "AppendInstruction",
311 1,
312 param_types,
313 false,
314 )
315 });
316 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
317 match &*METHOD {
318 ::core::result::Result::Ok(mi) => *mi,
319 ::core::result::Result::Err(e) => {
320 panic!(
321 "method lookup failed: {}
322::{}
323: {}
324",
325 <ByteCode as ::unity::ClassIdentity>::NAME,
326 "AppendInstruction",
327 e
328 )
329 },
330 }
331 }
332 }
333 #[doc(hidden)]
334 #[allow(non_snake_case)]
335 pub mod __lookup_emit_nop {
336 use super::*;
337 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
338 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<::unity::Il2CppString as ::unity::IlType>::il_type()];
339 ::unity::lookup::method_info_on_class_with_signature(<ByteCode as ::unity::ClassIdentity>::class(), "Emit_Nop", 1, param_types, false)
340 });
341 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
342 match &*METHOD {
343 ::core::result::Result::Ok(mi) => *mi,
344 ::core::result::Result::Err(e) => {
345 panic!(
346 "method lookup failed: {}
347::{}
348: {}
349",
350 <ByteCode as ::unity::ClassIdentity>::NAME,
351 "Emit_Nop",
352 e
353 )
354 },
355 }
356 }
357 }
358 #[doc(hidden)]
359 #[allow(non_snake_case)]
360 pub mod __lookup_emit_invalid {
361 use super::*;
362 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
363 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<::unity::Il2CppString as ::unity::IlType>::il_type()];
364 ::unity::lookup::method_info_on_class_with_signature(<ByteCode as ::unity::ClassIdentity>::class(), "Emit_Invalid", 1, param_types, false)
365 });
366 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
367 match &*METHOD {
368 ::core::result::Result::Ok(mi) => *mi,
369 ::core::result::Result::Err(e) => {
370 panic!(
371 "method lookup failed: {}
372::{}
373: {}
374",
375 <ByteCode as ::unity::ClassIdentity>::NAME,
376 "Emit_Invalid",
377 e
378 )
379 },
380 }
381 }
382 }
383 #[doc(hidden)]
384 #[allow(non_snake_case)]
385 pub mod __lookup_emit_pop {
386 use super::*;
387 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
388 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<i32 as ::unity::IlType>::il_type()];
389 ::unity::lookup::method_info_on_class_with_signature(<ByteCode as ::unity::ClassIdentity>::class(), "Emit_Pop", 1, param_types, false)
390 });
391 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
392 match &*METHOD {
393 ::core::result::Result::Ok(mi) => *mi,
394 ::core::result::Result::Err(e) => {
395 panic!(
396 "method lookup failed: {}
397::{}
398: {}
399",
400 <ByteCode as ::unity::ClassIdentity>::NAME,
401 "Emit_Pop",
402 e
403 )
404 },
405 }
406 }
407 }
408 #[doc(hidden)]
409 #[allow(non_snake_case)]
410 pub mod __lookup_emit_call {
411 use super::*;
412 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
413 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
414 &[<i32 as ::unity::IlType>::il_type(), <::unity::Il2CppString as ::unity::IlType>::il_type()];
415 ::unity::lookup::method_info_on_class_with_signature(<ByteCode as ::unity::ClassIdentity>::class(), "Emit_Call", 2, param_types, false)
416 });
417 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
418 match &*METHOD {
419 ::core::result::Result::Ok(mi) => *mi,
420 ::core::result::Result::Err(e) => {
421 panic!(
422 "method lookup failed: {}
423::{}
424: {}
425",
426 <ByteCode as ::unity::ClassIdentity>::NAME,
427 "Emit_Call",
428 e
429 )
430 },
431 }
432 }
433 }
434 #[doc(hidden)]
435 #[allow(non_snake_case)]
436 pub mod __lookup_emit_this_call {
437 use super::*;
438 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
439 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
440 &[<i32 as ::unity::IlType>::il_type(), <::unity::Il2CppString as ::unity::IlType>::il_type()];
441 ::unity::lookup::method_info_on_class_with_signature(
442 <ByteCode as ::unity::ClassIdentity>::class(),
443 "Emit_ThisCall",
444 2,
445 param_types,
446 false,
447 )
448 });
449 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
450 match &*METHOD {
451 ::core::result::Result::Ok(mi) => *mi,
452 ::core::result::Result::Err(e) => {
453 panic!(
454 "method lookup failed: {}
455::{}
456: {}
457",
458 <ByteCode as ::unity::ClassIdentity>::NAME,
459 "Emit_ThisCall",
460 e
461 )
462 },
463 }
464 }
465 }
466 #[doc(hidden)]
467 #[allow(non_snake_case)]
468 pub mod __lookup_emit_literal {
469 use super::*;
470 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
471 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
472 &[<crate::moon_sharp::interpreter::dynvalue::DynValue as ::unity::IlType>::il_type()];
473 ::unity::lookup::method_info_on_class_with_signature(<ByteCode as ::unity::ClassIdentity>::class(), "Emit_Literal", 1, param_types, false)
474 });
475 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
476 match &*METHOD {
477 ::core::result::Result::Ok(mi) => *mi,
478 ::core::result::Result::Err(e) => {
479 panic!(
480 "method lookup failed: {}
481::{}
482: {}
483",
484 <ByteCode as ::unity::ClassIdentity>::NAME,
485 "Emit_Literal",
486 e
487 )
488 },
489 }
490 }
491 }
492 #[doc(hidden)]
493 #[allow(non_snake_case)]
494 pub mod __lookup_emit_jump {
495 use super::*;
496 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
497 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
498 <crate::moon_sharp::interpreter::execution::vm::opcode::OpCode as ::unity::IlType>::il_type(),
499 <i32 as ::unity::IlType>::il_type(),
500 <i32 as ::unity::IlType>::il_type(),
501 ];
502 ::unity::lookup::method_info_on_class_with_signature(<ByteCode as ::unity::ClassIdentity>::class(), "Emit_Jump", 3, param_types, false)
503 });
504 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
505 match &*METHOD {
506 ::core::result::Result::Ok(mi) => *mi,
507 ::core::result::Result::Err(e) => {
508 panic!(
509 "method lookup failed: {}
510::{}
511: {}
512",
513 <ByteCode as ::unity::ClassIdentity>::NAME,
514 "Emit_Jump",
515 e
516 )
517 },
518 }
519 }
520 }
521 #[doc(hidden)]
522 #[allow(non_snake_case)]
523 pub mod __lookup_emit_mk_tuple {
524 use super::*;
525 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
526 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<i32 as ::unity::IlType>::il_type()];
527 ::unity::lookup::method_info_on_class_with_signature(<ByteCode as ::unity::ClassIdentity>::class(), "Emit_MkTuple", 1, param_types, false)
528 });
529 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
530 match &*METHOD {
531 ::core::result::Result::Ok(mi) => *mi,
532 ::core::result::Result::Err(e) => {
533 panic!(
534 "method lookup failed: {}
535::{}
536: {}
537",
538 <ByteCode as ::unity::ClassIdentity>::NAME,
539 "Emit_MkTuple",
540 e
541 )
542 },
543 }
544 }
545 }
546 #[doc(hidden)]
547 #[allow(non_snake_case)]
548 pub mod __lookup_emit_operator {
549 use super::*;
550 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
551 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
552 &[<crate::moon_sharp::interpreter::execution::vm::opcode::OpCode as ::unity::IlType>::il_type()];
553 ::unity::lookup::method_info_on_class_with_signature(
554 <ByteCode as ::unity::ClassIdentity>::class(),
555 "Emit_Operator",
556 1,
557 param_types,
558 false,
559 )
560 });
561 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
562 match &*METHOD {
563 ::core::result::Result::Ok(mi) => *mi,
564 ::core::result::Result::Err(e) => {
565 panic!(
566 "method lookup failed: {}
567::{}
568: {}
569",
570 <ByteCode as ::unity::ClassIdentity>::NAME,
571 "Emit_Operator",
572 e
573 )
574 },
575 }
576 }
577 }
578 #[doc(hidden)]
579 #[allow(non_snake_case)]
580 pub mod __lookup_emit_debug {
581 use super::*;
582 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
583 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<::unity::Il2CppString as ::unity::IlType>::il_type()];
584 ::unity::lookup::method_info_on_class_with_signature(<ByteCode as ::unity::ClassIdentity>::class(), "Emit_Debug", 1, param_types, false)
585 });
586 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
587 match &*METHOD {
588 ::core::result::Result::Ok(mi) => *mi,
589 ::core::result::Result::Err(e) => {
590 panic!(
591 "method lookup failed: {}
592::{}
593: {}
594",
595 <ByteCode as ::unity::ClassIdentity>::NAME,
596 "Emit_Debug",
597 e
598 )
599 },
600 }
601 }
602 }
603 #[doc(hidden)]
604 #[allow(non_snake_case)]
605 pub mod __lookup_emit_enter {
606 use super::*;
607 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
608 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
609 &[<crate::moon_sharp::interpreter::execution::runtimescopeblock::RuntimeScopeBlock as ::unity::IlType>::il_type()];
610 ::unity::lookup::method_info_on_class_with_signature(<ByteCode as ::unity::ClassIdentity>::class(), "Emit_Enter", 1, param_types, false)
611 });
612 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
613 match &*METHOD {
614 ::core::result::Result::Ok(mi) => *mi,
615 ::core::result::Result::Err(e) => {
616 panic!(
617 "method lookup failed: {}
618::{}
619: {}
620",
621 <ByteCode as ::unity::ClassIdentity>::NAME,
622 "Emit_Enter",
623 e
624 )
625 },
626 }
627 }
628 }
629 #[doc(hidden)]
630 #[allow(non_snake_case)]
631 pub mod __lookup_emit_leave {
632 use super::*;
633 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
634 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
635 &[<crate::moon_sharp::interpreter::execution::runtimescopeblock::RuntimeScopeBlock as ::unity::IlType>::il_type()];
636 ::unity::lookup::method_info_on_class_with_signature(<ByteCode as ::unity::ClassIdentity>::class(), "Emit_Leave", 1, param_types, false)
637 });
638 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
639 match &*METHOD {
640 ::core::result::Result::Ok(mi) => *mi,
641 ::core::result::Result::Err(e) => {
642 panic!(
643 "method lookup failed: {}
644::{}
645: {}
646",
647 <ByteCode as ::unity::ClassIdentity>::NAME,
648 "Emit_Leave",
649 e
650 )
651 },
652 }
653 }
654 }
655 #[doc(hidden)]
656 #[allow(non_snake_case)]
657 pub mod __lookup_emit_exit {
658 use super::*;
659 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
660 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
661 &[<crate::moon_sharp::interpreter::execution::runtimescopeblock::RuntimeScopeBlock as ::unity::IlType>::il_type()];
662 ::unity::lookup::method_info_on_class_with_signature(<ByteCode as ::unity::ClassIdentity>::class(), "Emit_Exit", 1, param_types, false)
663 });
664 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
665 match &*METHOD {
666 ::core::result::Result::Ok(mi) => *mi,
667 ::core::result::Result::Err(e) => {
668 panic!(
669 "method lookup failed: {}
670::{}
671: {}
672",
673 <ByteCode as ::unity::ClassIdentity>::NAME,
674 "Emit_Exit",
675 e
676 )
677 },
678 }
679 }
680 }
681 #[doc(hidden)]
682 #[allow(non_snake_case)]
683 pub mod __lookup_emit_clean {
684 use super::*;
685 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
686 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
687 &[<crate::moon_sharp::interpreter::execution::runtimescopeblock::RuntimeScopeBlock as ::unity::IlType>::il_type()];
688 ::unity::lookup::method_info_on_class_with_signature(<ByteCode as ::unity::ClassIdentity>::class(), "Emit_Clean", 1, param_types, false)
689 });
690 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
691 match &*METHOD {
692 ::core::result::Result::Ok(mi) => *mi,
693 ::core::result::Result::Err(e) => {
694 panic!(
695 "method lookup failed: {}
696::{}
697: {}
698",
699 <ByteCode as ::unity::ClassIdentity>::NAME,
700 "Emit_Clean",
701 e
702 )
703 },
704 }
705 }
706 }
707 #[doc(hidden)]
708 #[allow(non_snake_case)]
709 pub mod __lookup_emit_closure {
710 use super::*;
711 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
712 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
713 <::unity::Array<crate::moon_sharp::interpreter::symbolref::SymbolRef> as ::unity::IlType>::il_type(),
714 <i32 as ::unity::IlType>::il_type(),
715 ];
716 ::unity::lookup::method_info_on_class_with_signature(<ByteCode as ::unity::ClassIdentity>::class(), "Emit_Closure", 2, param_types, false)
717 });
718 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
719 match &*METHOD {
720 ::core::result::Result::Ok(mi) => *mi,
721 ::core::result::Result::Err(e) => {
722 panic!(
723 "method lookup failed: {}
724::{}
725: {}
726",
727 <ByteCode as ::unity::ClassIdentity>::NAME,
728 "Emit_Closure",
729 e
730 )
731 },
732 }
733 }
734 }
735 #[doc(hidden)]
736 #[allow(non_snake_case)]
737 pub mod __lookup_emit_args {
738 use super::*;
739 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
740 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
741 &[<::unity::Array<crate::moon_sharp::interpreter::symbolref::SymbolRef> as ::unity::IlType>::il_type()];
742 ::unity::lookup::method_info_on_class_with_signature(<ByteCode as ::unity::ClassIdentity>::class(), "Emit_Args", 1, param_types, false)
743 });
744 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
745 match &*METHOD {
746 ::core::result::Result::Ok(mi) => *mi,
747 ::core::result::Result::Err(e) => {
748 panic!(
749 "method lookup failed: {}
750::{}
751: {}
752",
753 <ByteCode as ::unity::ClassIdentity>::NAME,
754 "Emit_Args",
755 e
756 )
757 },
758 }
759 }
760 }
761 #[doc(hidden)]
762 #[allow(non_snake_case)]
763 pub mod __lookup_emit_ret {
764 use super::*;
765 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
766 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<i32 as ::unity::IlType>::il_type()];
767 ::unity::lookup::method_info_on_class_with_signature(<ByteCode as ::unity::ClassIdentity>::class(), "Emit_Ret", 1, param_types, false)
768 });
769 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
770 match &*METHOD {
771 ::core::result::Result::Ok(mi) => *mi,
772 ::core::result::Result::Err(e) => {
773 panic!(
774 "method lookup failed: {}
775::{}
776: {}
777",
778 <ByteCode as ::unity::ClassIdentity>::NAME,
779 "Emit_Ret",
780 e
781 )
782 },
783 }
784 }
785 }
786 #[doc(hidden)]
787 #[allow(non_snake_case)]
788 pub mod __lookup_emit_to_num {
789 use super::*;
790 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
791 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<i32 as ::unity::IlType>::il_type()];
792 ::unity::lookup::method_info_on_class_with_signature(<ByteCode as ::unity::ClassIdentity>::class(), "Emit_ToNum", 1, param_types, false)
793 });
794 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
795 match &*METHOD {
796 ::core::result::Result::Ok(mi) => *mi,
797 ::core::result::Result::Err(e) => {
798 panic!(
799 "method lookup failed: {}
800::{}
801: {}
802",
803 <ByteCode as ::unity::ClassIdentity>::NAME,
804 "Emit_ToNum",
805 e
806 )
807 },
808 }
809 }
810 }
811 #[doc(hidden)]
812 #[allow(non_snake_case)]
813 pub mod __lookup_emit_incr {
814 use super::*;
815 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
816 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<i32 as ::unity::IlType>::il_type()];
817 ::unity::lookup::method_info_on_class_with_signature(<ByteCode as ::unity::ClassIdentity>::class(), "Emit_Incr", 1, param_types, false)
818 });
819 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
820 match &*METHOD {
821 ::core::result::Result::Ok(mi) => *mi,
822 ::core::result::Result::Err(e) => {
823 panic!(
824 "method lookup failed: {}
825::{}
826: {}
827",
828 <ByteCode as ::unity::ClassIdentity>::NAME,
829 "Emit_Incr",
830 e
831 )
832 },
833 }
834 }
835 }
836 #[doc(hidden)]
837 #[allow(non_snake_case)]
838 pub mod __lookup_emit_new_table {
839 use super::*;
840 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
841 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<bool as ::unity::IlType>::il_type()];
842 ::unity::lookup::method_info_on_class_with_signature(
843 <ByteCode as ::unity::ClassIdentity>::class(),
844 "Emit_NewTable",
845 1,
846 param_types,
847 false,
848 )
849 });
850 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
851 match &*METHOD {
852 ::core::result::Result::Ok(mi) => *mi,
853 ::core::result::Result::Err(e) => {
854 panic!(
855 "method lookup failed: {}
856::{}
857: {}
858",
859 <ByteCode as ::unity::ClassIdentity>::NAME,
860 "Emit_NewTable",
861 e
862 )
863 },
864 }
865 }
866 }
867 #[doc(hidden)]
868 #[allow(non_snake_case)]
869 pub mod __lookup_emit_iter_prep {
870 use super::*;
871 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
872 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
873 ::unity::lookup::method_info_on_class_with_signature(
874 <ByteCode as ::unity::ClassIdentity>::class(),
875 "Emit_IterPrep",
876 0,
877 param_types,
878 false,
879 )
880 });
881 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
882 match &*METHOD {
883 ::core::result::Result::Ok(mi) => *mi,
884 ::core::result::Result::Err(e) => {
885 panic!(
886 "method lookup failed: {}
887::{}
888: {}
889",
890 <ByteCode as ::unity::ClassIdentity>::NAME,
891 "Emit_IterPrep",
892 e
893 )
894 },
895 }
896 }
897 }
898 #[doc(hidden)]
899 #[allow(non_snake_case)]
900 pub mod __lookup_emit_exp_tuple {
901 use super::*;
902 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
903 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<i32 as ::unity::IlType>::il_type()];
904 ::unity::lookup::method_info_on_class_with_signature(
905 <ByteCode as ::unity::ClassIdentity>::class(),
906 "Emit_ExpTuple",
907 1,
908 param_types,
909 false,
910 )
911 });
912 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
913 match &*METHOD {
914 ::core::result::Result::Ok(mi) => *mi,
915 ::core::result::Result::Err(e) => {
916 panic!(
917 "method lookup failed: {}
918::{}
919: {}
920",
921 <ByteCode as ::unity::ClassIdentity>::NAME,
922 "Emit_ExpTuple",
923 e
924 )
925 },
926 }
927 }
928 }
929 #[doc(hidden)]
930 #[allow(non_snake_case)]
931 pub mod __lookup_emit_iter_upd {
932 use super::*;
933 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
934 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
935 ::unity::lookup::method_info_on_class_with_signature(<ByteCode as ::unity::ClassIdentity>::class(), "Emit_IterUpd", 0, param_types, false)
936 });
937 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
938 match &*METHOD {
939 ::core::result::Result::Ok(mi) => *mi,
940 ::core::result::Result::Err(e) => {
941 panic!(
942 "method lookup failed: {}
943::{}
944: {}
945",
946 <ByteCode as ::unity::ClassIdentity>::NAME,
947 "Emit_IterUpd",
948 e
949 )
950 },
951 }
952 }
953 }
954 #[doc(hidden)]
955 #[allow(non_snake_case)]
956 pub mod __lookup_emit_meta {
957 use super::*;
958 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
959 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
960 <::unity::Il2CppString as ::unity::IlType>::il_type(),
961 <crate::moon_sharp::interpreter::execution::vm::opcodemetadatatype::OpCodeMetadataType as ::unity::IlType>::il_type(),
962 <crate::moon_sharp::interpreter::dynvalue::DynValue as ::unity::IlType>::il_type(),
963 ];
964 ::unity::lookup::method_info_on_class_with_signature(<ByteCode as ::unity::ClassIdentity>::class(), "Emit_Meta", 3, param_types, false)
965 });
966 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
967 match &*METHOD {
968 ::core::result::Result::Ok(mi) => *mi,
969 ::core::result::Result::Err(e) => {
970 panic!(
971 "method lookup failed: {}
972::{}
973: {}
974",
975 <ByteCode as ::unity::ClassIdentity>::NAME,
976 "Emit_Meta",
977 e
978 )
979 },
980 }
981 }
982 }
983 #[doc(hidden)]
984 #[allow(non_snake_case)]
985 pub mod __lookup_emit_begin_fn {
986 use super::*;
987 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
988 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
989 &[<crate::moon_sharp::interpreter::execution::runtimescopeframe::RuntimeScopeFrame as ::unity::IlType>::il_type()];
990 ::unity::lookup::method_info_on_class_with_signature(<ByteCode as ::unity::ClassIdentity>::class(), "Emit_BeginFn", 1, param_types, false)
991 });
992 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
993 match &*METHOD {
994 ::core::result::Result::Ok(mi) => *mi,
995 ::core::result::Result::Err(e) => {
996 panic!(
997 "method lookup failed: {}
998::{}
999: {}
1000",
1001 <ByteCode as ::unity::ClassIdentity>::NAME,
1002 "Emit_BeginFn",
1003 e
1004 )
1005 },
1006 }
1007 }
1008 }
1009 #[doc(hidden)]
1010 #[allow(non_snake_case)]
1011 pub mod __lookup_emit_scalar {
1012 use super::*;
1013 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1014 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
1015 ::unity::lookup::method_info_on_class_with_signature(<ByteCode as ::unity::ClassIdentity>::class(), "Emit_Scalar", 0, param_types, false)
1016 });
1017 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1018 match &*METHOD {
1019 ::core::result::Result::Ok(mi) => *mi,
1020 ::core::result::Result::Err(e) => {
1021 panic!(
1022 "method lookup failed: {}
1023::{}
1024: {}
1025",
1026 <ByteCode as ::unity::ClassIdentity>::NAME,
1027 "Emit_Scalar",
1028 e
1029 )
1030 },
1031 }
1032 }
1033 }
1034 #[doc(hidden)]
1035 #[allow(non_snake_case)]
1036 pub mod __lookup_emit_load {
1037 use super::*;
1038 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1039 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
1040 &[<crate::moon_sharp::interpreter::symbolref::SymbolRef as ::unity::IlType>::il_type()];
1041 ::unity::lookup::method_info_on_class_with_signature(<ByteCode as ::unity::ClassIdentity>::class(), "Emit_Load", 1, param_types, false)
1042 });
1043 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1044 match &*METHOD {
1045 ::core::result::Result::Ok(mi) => *mi,
1046 ::core::result::Result::Err(e) => {
1047 panic!(
1048 "method lookup failed: {}
1049::{}
1050: {}
1051",
1052 <ByteCode as ::unity::ClassIdentity>::NAME,
1053 "Emit_Load",
1054 e
1055 )
1056 },
1057 }
1058 }
1059 }
1060 #[doc(hidden)]
1061 #[allow(non_snake_case)]
1062 pub mod __lookup_emit_store {
1063 use super::*;
1064 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1065 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
1066 <crate::moon_sharp::interpreter::symbolref::SymbolRef as ::unity::IlType>::il_type(),
1067 <i32 as ::unity::IlType>::il_type(),
1068 <i32 as ::unity::IlType>::il_type(),
1069 ];
1070 ::unity::lookup::method_info_on_class_with_signature(<ByteCode as ::unity::ClassIdentity>::class(), "Emit_Store", 3, param_types, false)
1071 });
1072 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1073 match &*METHOD {
1074 ::core::result::Result::Ok(mi) => *mi,
1075 ::core::result::Result::Err(e) => {
1076 panic!(
1077 "method lookup failed: {}
1078::{}
1079: {}
1080",
1081 <ByteCode as ::unity::ClassIdentity>::NAME,
1082 "Emit_Store",
1083 e
1084 )
1085 },
1086 }
1087 }
1088 }
1089 #[doc(hidden)]
1090 #[allow(non_snake_case)]
1091 pub mod __lookup_emit_tbl_init_n {
1092 use super::*;
1093 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1094 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
1095 ::unity::lookup::method_info_on_class_with_signature(
1096 <ByteCode as ::unity::ClassIdentity>::class(),
1097 "Emit_TblInitN",
1098 0,
1099 param_types,
1100 false,
1101 )
1102 });
1103 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1104 match &*METHOD {
1105 ::core::result::Result::Ok(mi) => *mi,
1106 ::core::result::Result::Err(e) => {
1107 panic!(
1108 "method lookup failed: {}
1109::{}
1110: {}
1111",
1112 <ByteCode as ::unity::ClassIdentity>::NAME,
1113 "Emit_TblInitN",
1114 e
1115 )
1116 },
1117 }
1118 }
1119 }
1120 #[doc(hidden)]
1121 #[allow(non_snake_case)]
1122 pub mod __lookup_emit_tbl_init_i {
1123 use super::*;
1124 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1125 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<bool as ::unity::IlType>::il_type()];
1126 ::unity::lookup::method_info_on_class_with_signature(
1127 <ByteCode as ::unity::ClassIdentity>::class(),
1128 "Emit_TblInitI",
1129 1,
1130 param_types,
1131 false,
1132 )
1133 });
1134 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1135 match &*METHOD {
1136 ::core::result::Result::Ok(mi) => *mi,
1137 ::core::result::Result::Err(e) => {
1138 panic!(
1139 "method lookup failed: {}
1140::{}
1141: {}
1142",
1143 <ByteCode as ::unity::ClassIdentity>::NAME,
1144 "Emit_TblInitI",
1145 e
1146 )
1147 },
1148 }
1149 }
1150 }
1151 #[doc(hidden)]
1152 #[allow(non_snake_case)]
1153 pub mod __lookup_emit_index {
1154 use super::*;
1155 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1156 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
1157 <crate::moon_sharp::interpreter::dynvalue::DynValue as ::unity::IlType>::il_type(),
1158 <bool as ::unity::IlType>::il_type(),
1159 <bool as ::unity::IlType>::il_type(),
1160 ];
1161 ::unity::lookup::method_info_on_class_with_signature(<ByteCode as ::unity::ClassIdentity>::class(), "Emit_Index", 3, param_types, false)
1162 });
1163 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1164 match &*METHOD {
1165 ::core::result::Result::Ok(mi) => *mi,
1166 ::core::result::Result::Err(e) => {
1167 panic!(
1168 "method lookup failed: {}
1169::{}
1170: {}
1171",
1172 <ByteCode as ::unity::ClassIdentity>::NAME,
1173 "Emit_Index",
1174 e
1175 )
1176 },
1177 }
1178 }
1179 }
1180 #[doc(hidden)]
1181 #[allow(non_snake_case)]
1182 pub mod __lookup_emit_index_set {
1183 use super::*;
1184 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1185 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
1186 <i32 as ::unity::IlType>::il_type(),
1187 <i32 as ::unity::IlType>::il_type(),
1188 <crate::moon_sharp::interpreter::dynvalue::DynValue as ::unity::IlType>::il_type(),
1189 <bool as ::unity::IlType>::il_type(),
1190 <bool as ::unity::IlType>::il_type(),
1191 ];
1192 ::unity::lookup::method_info_on_class_with_signature(
1193 <ByteCode as ::unity::ClassIdentity>::class(),
1194 "Emit_IndexSet",
1195 5,
1196 param_types,
1197 false,
1198 )
1199 });
1200 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1201 match &*METHOD {
1202 ::core::result::Result::Ok(mi) => *mi,
1203 ::core::result::Result::Err(e) => {
1204 panic!(
1205 "method lookup failed: {}
1206::{}
1207: {}
1208",
1209 <ByteCode as ::unity::ClassIdentity>::NAME,
1210 "Emit_IndexSet",
1211 e
1212 )
1213 },
1214 }
1215 }
1216 }
1217 #[doc(hidden)]
1218 #[allow(non_snake_case)]
1219 pub mod __lookup_emit_copy {
1220 use super::*;
1221 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1222 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<i32 as ::unity::IlType>::il_type()];
1223 ::unity::lookup::method_info_on_class_with_signature(<ByteCode as ::unity::ClassIdentity>::class(), "Emit_Copy", 1, param_types, false)
1224 });
1225 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1226 match &*METHOD {
1227 ::core::result::Result::Ok(mi) => *mi,
1228 ::core::result::Result::Err(e) => {
1229 panic!(
1230 "method lookup failed: {}
1231::{}
1232: {}
1233",
1234 <ByteCode as ::unity::ClassIdentity>::NAME,
1235 "Emit_Copy",
1236 e
1237 )
1238 },
1239 }
1240 }
1241 }
1242 #[doc(hidden)]
1243 #[allow(non_snake_case)]
1244 pub mod __lookup_emit_swap {
1245 use super::*;
1246 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1247 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<i32 as ::unity::IlType>::il_type(), <i32 as ::unity::IlType>::il_type()];
1248 ::unity::lookup::method_info_on_class_with_signature(<ByteCode as ::unity::ClassIdentity>::class(), "Emit_Swap", 2, param_types, false)
1249 });
1250 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1251 match &*METHOD {
1252 ::core::result::Result::Ok(mi) => *mi,
1253 ::core::result::Result::Err(e) => {
1254 panic!(
1255 "method lookup failed: {}
1256::{}
1257: {}
1258",
1259 <ByteCode as ::unity::ClassIdentity>::NAME,
1260 "Emit_Swap",
1261 e
1262 )
1263 },
1264 }
1265 }
1266 }
1267}
1268
1269#[cfg(feature = "moon_sharp-interpreter-execution-vm-bytecode")]
1270pub trait IByteCodeMethods: IByteCode {
1271 #[doc = "`get_Script()` overload"]
1272 fn get_script(self) -> crate::moon_sharp::interpreter::script::Script {
1273 unsafe {
1274 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1275 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_get_script::get_method_info().method_ptr,crate::moon_sharp::interpreter::script::Script;
1276(ByteCode)__receiver)
1277 }
1278 }
1279 #[doc = "`set_Script(crate::moon_sharp::interpreter::script::Script)` overload"]
1280 fn set_script(self, value: impl ::core::convert::Into<crate::moon_sharp::interpreter::script::Script>) -> () {
1281 unsafe {
1282 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1283 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_set_script::get_method_info().method_ptr,();
1284(ByteCode)__receiver,(crate::moon_sharp::interpreter::script::Script)::core::convert::Into::into(value))
1285 }
1286 }
1287 #[doc = "`.ctor(crate::moon_sharp::interpreter::script::Script)` overload"]
1288 fn ctor(self, script: impl ::core::convert::Into<crate::moon_sharp::interpreter::script::Script>) -> () {
1289 unsafe {
1290 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1291 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_ctor::get_method_info().method_ptr,();
1292(ByteCode)__receiver,(crate::moon_sharp::interpreter::script::Script)::core::convert::Into::into(script))
1293 }
1294 }
1295 #[doc = "`PushSourceRef(crate::moon_sharp::interpreter::debugging::sourceref::SourceRef)` overload"]
1296 fn push_source_ref(self, sref: impl ::core::convert::Into<crate::moon_sharp::interpreter::debugging::sourceref::SourceRef>) -> () {
1297 unsafe {
1298 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1299 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_push_source_ref::get_method_info().method_ptr,();
1300(ByteCode)__receiver,(crate::moon_sharp::interpreter::debugging::sourceref::SourceRef)::core::convert::Into::into(sref))
1301 }
1302 }
1303 #[doc = "`PopSourceRef()` overload"]
1304 fn pop_source_ref(self) -> () {
1305 unsafe {
1306 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1307 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_pop_source_ref::get_method_info().method_ptr,();
1308(ByteCode)__receiver)
1309 }
1310 }
1311 #[doc = "`Dump(::unity::Il2CppString)` overload"]
1312 fn dump(self, file: impl ::core::convert::Into<::unity::Il2CppString>) -> () {
1313 unsafe {
1314 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1315 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_dump::get_method_info().method_ptr,();
1316(ByteCode)__receiver,(::unity::Il2CppString)::core::convert::Into::into(file))
1317 }
1318 }
1319 #[doc = "`GetJumpPointForNextInstruction()` overload"]
1320 fn get_jump_point_for_next_instruction(self) -> i32 {
1321 unsafe {
1322 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1323 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_get_jump_point_for_next_instruction::get_method_info().method_ptr,i32;
1324(ByteCode)__receiver)
1325 }
1326 }
1327 #[doc = "`GetJumpPointForLastInstruction()` overload"]
1328 fn get_jump_point_for_last_instruction(self) -> i32 {
1329 unsafe {
1330 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1331 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_get_jump_point_for_last_instruction::get_method_info().method_ptr,i32;
1332(ByteCode)__receiver)
1333 }
1334 }
1335 #[doc = "`GetLastInstruction()` overload"]
1336 fn get_last_instruction(self) -> crate::moon_sharp::interpreter::execution::vm::instruction::Instruction {
1337 unsafe {
1338 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1339 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_get_last_instruction::get_method_info().method_ptr,crate::moon_sharp::interpreter::execution::vm::instruction::Instruction;
1340(ByteCode)__receiver)
1341 }
1342 }
1343 #[doc = "`AppendInstruction(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)` overload"]
1344 fn append_instruction(
1345 self,
1346 c: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction>,
1347 ) -> crate::moon_sharp::interpreter::execution::vm::instruction::Instruction {
1348 unsafe {
1349 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1350 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_append_instruction::get_method_info().method_ptr,crate::moon_sharp::interpreter::execution::vm::instruction::Instruction;
1351(ByteCode)__receiver,(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)::core::convert::Into::into(c))
1352 }
1353 }
1354 #[doc = "`Emit_Nop(::unity::Il2CppString)` overload"]
1355 fn emit_nop(
1356 self,
1357 comment: impl ::core::convert::Into<::unity::Il2CppString>,
1358 ) -> crate::moon_sharp::interpreter::execution::vm::instruction::Instruction {
1359 unsafe {
1360 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1361 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_emit_nop::get_method_info().method_ptr,crate::moon_sharp::interpreter::execution::vm::instruction::Instruction;
1362(ByteCode)__receiver,(::unity::Il2CppString)::core::convert::Into::into(comment))
1363 }
1364 }
1365 #[doc = "`Emit_Invalid(::unity::Il2CppString)` overload"]
1366 fn emit_invalid(
1367 self,
1368 r#type: impl ::core::convert::Into<::unity::Il2CppString>,
1369 ) -> crate::moon_sharp::interpreter::execution::vm::instruction::Instruction {
1370 unsafe {
1371 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1372 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_emit_invalid::get_method_info().method_ptr,crate::moon_sharp::interpreter::execution::vm::instruction::Instruction;
1373(ByteCode)__receiver,(::unity::Il2CppString)::core::convert::Into::into(r#type))
1374 }
1375 }
1376 #[doc = "`Emit_Pop(i32)` overload"]
1377 fn emit_pop(self, num: impl ::core::convert::Into<i32>) -> crate::moon_sharp::interpreter::execution::vm::instruction::Instruction {
1378 unsafe {
1379 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1380 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_emit_pop::get_method_info().method_ptr,crate::moon_sharp::interpreter::execution::vm::instruction::Instruction;
1381(ByteCode)__receiver,(i32)::core::convert::Into::into(num))
1382 }
1383 }
1384 #[doc = "`Emit_Call(i32, ::unity::Il2CppString)` overload"]
1385 fn emit_call(self, arg_count: impl ::core::convert::Into<i32>, debug_name: impl ::core::convert::Into<::unity::Il2CppString>) -> () {
1386 unsafe {
1387 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1388 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_emit_call::get_method_info().method_ptr,();
1389(ByteCode)__receiver,(i32)::core::convert::Into::into(arg_count),(::unity::Il2CppString)::core::convert::Into::into(debug_name))
1390 }
1391 }
1392 #[doc = "`Emit_ThisCall(i32, ::unity::Il2CppString)` overload"]
1393 fn emit_this_call(self, arg_count: impl ::core::convert::Into<i32>, debug_name: impl ::core::convert::Into<::unity::Il2CppString>) -> () {
1394 unsafe {
1395 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1396 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_emit_this_call::get_method_info().method_ptr,();
1397(ByteCode)__receiver,(i32)::core::convert::Into::into(arg_count),(::unity::Il2CppString)::core::convert::Into::into(debug_name))
1398 }
1399 }
1400 #[doc = "`Emit_Literal(crate::moon_sharp::interpreter::dynvalue::DynValue)` overload"]
1401 fn emit_literal(
1402 self,
1403 value: impl ::core::convert::Into<crate::moon_sharp::interpreter::dynvalue::DynValue>,
1404 ) -> crate::moon_sharp::interpreter::execution::vm::instruction::Instruction {
1405 unsafe {
1406 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1407 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_emit_literal::get_method_info().method_ptr,crate::moon_sharp::interpreter::execution::vm::instruction::Instruction;
1408(ByteCode)__receiver,(crate::moon_sharp::interpreter::dynvalue::DynValue)::core::convert::Into::into(value))
1409 }
1410 }
1411 #[doc = "`Emit_Jump(crate::moon_sharp::interpreter::execution::vm::opcode::OpCode, i32, i32)` overload"]
1412 fn emit_jump(
1413 self,
1414 jump_op_code: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::opcode::OpCode>,
1415 idx: impl ::core::convert::Into<i32>,
1416 opt_par: impl ::core::convert::Into<i32>,
1417 ) -> crate::moon_sharp::interpreter::execution::vm::instruction::Instruction {
1418 unsafe {
1419 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1420 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_emit_jump::get_method_info().method_ptr,crate::moon_sharp::interpreter::execution::vm::instruction::Instruction;
1421(ByteCode)__receiver,(crate::moon_sharp::interpreter::execution::vm::opcode::OpCode)::core::convert::Into::into(jump_op_code),(i32)::core::convert::Into::into(idx),(i32)::core::convert::Into::into(opt_par))
1422 }
1423 }
1424 #[doc = "`Emit_MkTuple(i32)` overload"]
1425 fn emit_mk_tuple(self, cnt: impl ::core::convert::Into<i32>) -> crate::moon_sharp::interpreter::execution::vm::instruction::Instruction {
1426 unsafe {
1427 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1428 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_emit_mk_tuple::get_method_info().method_ptr,crate::moon_sharp::interpreter::execution::vm::instruction::Instruction;
1429(ByteCode)__receiver,(i32)::core::convert::Into::into(cnt))
1430 }
1431 }
1432 #[doc = "`Emit_Operator(crate::moon_sharp::interpreter::execution::vm::opcode::OpCode)` overload"]
1433 fn emit_operator(
1434 self,
1435 opcode: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::opcode::OpCode>,
1436 ) -> crate::moon_sharp::interpreter::execution::vm::instruction::Instruction {
1437 unsafe {
1438 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1439 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_emit_operator::get_method_info().method_ptr,crate::moon_sharp::interpreter::execution::vm::instruction::Instruction;
1440(ByteCode)__receiver,(crate::moon_sharp::interpreter::execution::vm::opcode::OpCode)::core::convert::Into::into(opcode))
1441 }
1442 }
1443 #[doc = "`Emit_Debug(::unity::Il2CppString)` overload"]
1444 fn emit_debug(self, str: impl ::core::convert::Into<::unity::Il2CppString>) -> () {
1445 unsafe {
1446 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1447 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_emit_debug::get_method_info().method_ptr,();
1448(ByteCode)__receiver,(::unity::Il2CppString)::core::convert::Into::into(str))
1449 }
1450 }
1451 #[doc = "`Emit_Enter(crate::moon_sharp::interpreter::execution::runtimescopeblock::RuntimeScopeBlock)` overload"]
1452 fn emit_enter(
1453 self,
1454 runtime_scope_block: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::runtimescopeblock::RuntimeScopeBlock>,
1455 ) -> crate::moon_sharp::interpreter::execution::vm::instruction::Instruction {
1456 unsafe {
1457 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1458 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_emit_enter::get_method_info().method_ptr,crate::moon_sharp::interpreter::execution::vm::instruction::Instruction;
1459(ByteCode)__receiver,(crate::moon_sharp::interpreter::execution::runtimescopeblock::RuntimeScopeBlock)::core::convert::Into::into(runtime_scope_block))
1460 }
1461 }
1462 #[doc = "`Emit_Leave(crate::moon_sharp::interpreter::execution::runtimescopeblock::RuntimeScopeBlock)` overload"]
1463 fn emit_leave(
1464 self,
1465 runtime_scope_block: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::runtimescopeblock::RuntimeScopeBlock>,
1466 ) -> crate::moon_sharp::interpreter::execution::vm::instruction::Instruction {
1467 unsafe {
1468 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1469 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_emit_leave::get_method_info().method_ptr,crate::moon_sharp::interpreter::execution::vm::instruction::Instruction;
1470(ByteCode)__receiver,(crate::moon_sharp::interpreter::execution::runtimescopeblock::RuntimeScopeBlock)::core::convert::Into::into(runtime_scope_block))
1471 }
1472 }
1473 #[doc = "`Emit_Exit(crate::moon_sharp::interpreter::execution::runtimescopeblock::RuntimeScopeBlock)` overload"]
1474 fn emit_exit(
1475 self,
1476 runtime_scope_block: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::runtimescopeblock::RuntimeScopeBlock>,
1477 ) -> crate::moon_sharp::interpreter::execution::vm::instruction::Instruction {
1478 unsafe {
1479 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1480 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_emit_exit::get_method_info().method_ptr,crate::moon_sharp::interpreter::execution::vm::instruction::Instruction;
1481(ByteCode)__receiver,(crate::moon_sharp::interpreter::execution::runtimescopeblock::RuntimeScopeBlock)::core::convert::Into::into(runtime_scope_block))
1482 }
1483 }
1484 #[doc = "`Emit_Clean(crate::moon_sharp::interpreter::execution::runtimescopeblock::RuntimeScopeBlock)` overload"]
1485 fn emit_clean(
1486 self,
1487 runtime_scope_block: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::runtimescopeblock::RuntimeScopeBlock>,
1488 ) -> crate::moon_sharp::interpreter::execution::vm::instruction::Instruction {
1489 unsafe {
1490 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1491 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_emit_clean::get_method_info().method_ptr,crate::moon_sharp::interpreter::execution::vm::instruction::Instruction;
1492(ByteCode)__receiver,(crate::moon_sharp::interpreter::execution::runtimescopeblock::RuntimeScopeBlock)::core::convert::Into::into(runtime_scope_block))
1493 }
1494 }
1495 #[doc = "`Emit_Closure(::unity::Array<crate::moon_sharp::interpreter::symbolref::SymbolRef>, i32)` overload"]
1496 fn emit_closure(
1497 self,
1498 symbols: impl ::core::convert::Into<::unity::Array<crate::moon_sharp::interpreter::symbolref::SymbolRef>>,
1499 jmpnum: impl ::core::convert::Into<i32>,
1500 ) -> crate::moon_sharp::interpreter::execution::vm::instruction::Instruction {
1501 unsafe {
1502 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1503 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_emit_closure::get_method_info().method_ptr,crate::moon_sharp::interpreter::execution::vm::instruction::Instruction;
1504(ByteCode)__receiver,(::unity::Array<crate::moon_sharp::interpreter::symbolref::SymbolRef>)::core::convert::Into::into(symbols),(i32)::core::convert::Into::into(jmpnum))
1505 }
1506 }
1507 #[doc = "`Emit_Args(::unity::Array<crate::moon_sharp::interpreter::symbolref::SymbolRef>)` overload"]
1508 fn emit_args(
1509 self,
1510 symbols: impl ::core::convert::Into<::unity::Array<crate::moon_sharp::interpreter::symbolref::SymbolRef>>,
1511 ) -> crate::moon_sharp::interpreter::execution::vm::instruction::Instruction {
1512 unsafe {
1513 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1514 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_emit_args::get_method_info().method_ptr,crate::moon_sharp::interpreter::execution::vm::instruction::Instruction;
1515(ByteCode)__receiver,(::unity::Array<crate::moon_sharp::interpreter::symbolref::SymbolRef>)::core::convert::Into::into(symbols))
1516 }
1517 }
1518 #[doc = "`Emit_Ret(i32)` overload"]
1519 fn emit_ret(self, retvals: impl ::core::convert::Into<i32>) -> crate::moon_sharp::interpreter::execution::vm::instruction::Instruction {
1520 unsafe {
1521 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1522 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_emit_ret::get_method_info().method_ptr,crate::moon_sharp::interpreter::execution::vm::instruction::Instruction;
1523(ByteCode)__receiver,(i32)::core::convert::Into::into(retvals))
1524 }
1525 }
1526 #[doc = "`Emit_ToNum(i32)` overload"]
1527 fn emit_to_num(self, stage: impl ::core::convert::Into<i32>) -> crate::moon_sharp::interpreter::execution::vm::instruction::Instruction {
1528 unsafe {
1529 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1530 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_emit_to_num::get_method_info().method_ptr,crate::moon_sharp::interpreter::execution::vm::instruction::Instruction;
1531(ByteCode)__receiver,(i32)::core::convert::Into::into(stage))
1532 }
1533 }
1534 #[doc = "`Emit_Incr(i32)` overload"]
1535 fn emit_incr(self, i: impl ::core::convert::Into<i32>) -> crate::moon_sharp::interpreter::execution::vm::instruction::Instruction {
1536 unsafe {
1537 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1538 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_emit_incr::get_method_info().method_ptr,crate::moon_sharp::interpreter::execution::vm::instruction::Instruction;
1539(ByteCode)__receiver,(i32)::core::convert::Into::into(i))
1540 }
1541 }
1542 #[doc = "`Emit_NewTable(bool)` overload"]
1543 fn emit_new_table(self, shared: impl ::core::convert::Into<bool>) -> crate::moon_sharp::interpreter::execution::vm::instruction::Instruction {
1544 unsafe {
1545 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1546 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_emit_new_table::get_method_info().method_ptr,crate::moon_sharp::interpreter::execution::vm::instruction::Instruction;
1547(ByteCode)__receiver,(bool)::core::convert::Into::into(shared))
1548 }
1549 }
1550 #[doc = "`Emit_IterPrep()` overload"]
1551 fn emit_iter_prep(self) -> crate::moon_sharp::interpreter::execution::vm::instruction::Instruction {
1552 unsafe {
1553 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1554 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_emit_iter_prep::get_method_info().method_ptr,crate::moon_sharp::interpreter::execution::vm::instruction::Instruction;
1555(ByteCode)__receiver)
1556 }
1557 }
1558 #[doc = "`Emit_ExpTuple(i32)` overload"]
1559 fn emit_exp_tuple(
1560 self,
1561 stack_offset: impl ::core::convert::Into<i32>,
1562 ) -> crate::moon_sharp::interpreter::execution::vm::instruction::Instruction {
1563 unsafe {
1564 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1565 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_emit_exp_tuple::get_method_info().method_ptr,crate::moon_sharp::interpreter::execution::vm::instruction::Instruction;
1566(ByteCode)__receiver,(i32)::core::convert::Into::into(stack_offset))
1567 }
1568 }
1569 #[doc = "`Emit_IterUpd()` overload"]
1570 fn emit_iter_upd(self) -> crate::moon_sharp::interpreter::execution::vm::instruction::Instruction {
1571 unsafe {
1572 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1573 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_emit_iter_upd::get_method_info().method_ptr,crate::moon_sharp::interpreter::execution::vm::instruction::Instruction;
1574(ByteCode)__receiver)
1575 }
1576 }
1577 #[doc = "`Emit_Meta(::unity::Il2CppString, crate::moon_sharp::interpreter::execution::vm::opcodemetadatatype::OpCodeMetadataType, crate::moon_sharp::interpreter::dynvalue::DynValue)` overload"]
1578 fn emit_meta(
1579 self,
1580 func_name: impl ::core::convert::Into<::unity::Il2CppString>,
1581 meta_type: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::opcodemetadatatype::OpCodeMetadataType>,
1582 value: impl ::core::convert::Into<crate::moon_sharp::interpreter::dynvalue::DynValue>,
1583 ) -> crate::moon_sharp::interpreter::execution::vm::instruction::Instruction {
1584 unsafe {
1585 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1586 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_emit_meta::get_method_info().method_ptr,crate::moon_sharp::interpreter::execution::vm::instruction::Instruction;
1587(ByteCode)__receiver,(::unity::Il2CppString)::core::convert::Into::into(func_name),(crate::moon_sharp::interpreter::execution::vm::opcodemetadatatype::OpCodeMetadataType)::core::convert::Into::into(meta_type),(crate::moon_sharp::interpreter::dynvalue::DynValue)::core::convert::Into::into(value))
1588 }
1589 }
1590 #[doc = "`Emit_BeginFn(crate::moon_sharp::interpreter::execution::runtimescopeframe::RuntimeScopeFrame)` overload"]
1591 fn emit_begin_fn(
1592 self,
1593 stack_frame: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::runtimescopeframe::RuntimeScopeFrame>,
1594 ) -> crate::moon_sharp::interpreter::execution::vm::instruction::Instruction {
1595 unsafe {
1596 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1597 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_emit_begin_fn::get_method_info().method_ptr,crate::moon_sharp::interpreter::execution::vm::instruction::Instruction;
1598(ByteCode)__receiver,(crate::moon_sharp::interpreter::execution::runtimescopeframe::RuntimeScopeFrame)::core::convert::Into::into(stack_frame))
1599 }
1600 }
1601 #[doc = "`Emit_Scalar()` overload"]
1602 fn emit_scalar(self) -> crate::moon_sharp::interpreter::execution::vm::instruction::Instruction {
1603 unsafe {
1604 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1605 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_emit_scalar::get_method_info().method_ptr,crate::moon_sharp::interpreter::execution::vm::instruction::Instruction;
1606(ByteCode)__receiver)
1607 }
1608 }
1609 #[doc = "`Emit_Load(crate::moon_sharp::interpreter::symbolref::SymbolRef)` overload"]
1610 fn emit_load(self, sym: impl ::core::convert::Into<crate::moon_sharp::interpreter::symbolref::SymbolRef>) -> i32 {
1611 unsafe {
1612 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1613 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_emit_load::get_method_info().method_ptr,i32;
1614(ByteCode)__receiver,(crate::moon_sharp::interpreter::symbolref::SymbolRef)::core::convert::Into::into(sym))
1615 }
1616 }
1617 #[doc = "`Emit_Store(crate::moon_sharp::interpreter::symbolref::SymbolRef, i32, i32)` overload"]
1618 fn emit_store(
1619 self,
1620 sym: impl ::core::convert::Into<crate::moon_sharp::interpreter::symbolref::SymbolRef>,
1621 stackofs: impl ::core::convert::Into<i32>,
1622 tupleidx: impl ::core::convert::Into<i32>,
1623 ) -> i32 {
1624 unsafe {
1625 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1626 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_emit_store::get_method_info().method_ptr,i32;
1627(ByteCode)__receiver,(crate::moon_sharp::interpreter::symbolref::SymbolRef)::core::convert::Into::into(sym),(i32)::core::convert::Into::into(stackofs),(i32)::core::convert::Into::into(tupleidx))
1628 }
1629 }
1630 #[doc = "`Emit_TblInitN()` overload"]
1631 fn emit_tbl_init_n(self) -> crate::moon_sharp::interpreter::execution::vm::instruction::Instruction {
1632 unsafe {
1633 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1634 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_emit_tbl_init_n::get_method_info().method_ptr,crate::moon_sharp::interpreter::execution::vm::instruction::Instruction;
1635(ByteCode)__receiver)
1636 }
1637 }
1638 #[doc = "`Emit_TblInitI(bool)` overload"]
1639 fn emit_tbl_init_i(self, lastpos: impl ::core::convert::Into<bool>) -> crate::moon_sharp::interpreter::execution::vm::instruction::Instruction {
1640 unsafe {
1641 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1642 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_emit_tbl_init_i::get_method_info().method_ptr,crate::moon_sharp::interpreter::execution::vm::instruction::Instruction;
1643(ByteCode)__receiver,(bool)::core::convert::Into::into(lastpos))
1644 }
1645 }
1646 #[doc = "`Emit_Index(crate::moon_sharp::interpreter::dynvalue::DynValue, bool, bool)` overload"]
1647 fn emit_index(
1648 self,
1649 index: impl ::core::convert::Into<crate::moon_sharp::interpreter::dynvalue::DynValue>,
1650 is_name_index: impl ::core::convert::Into<bool>,
1651 is_exp_list: impl ::core::convert::Into<bool>,
1652 ) -> crate::moon_sharp::interpreter::execution::vm::instruction::Instruction {
1653 unsafe {
1654 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1655 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_emit_index::get_method_info().method_ptr,crate::moon_sharp::interpreter::execution::vm::instruction::Instruction;
1656(ByteCode)__receiver,(crate::moon_sharp::interpreter::dynvalue::DynValue)::core::convert::Into::into(index),(bool)::core::convert::Into::into(is_name_index),(bool)::core::convert::Into::into(is_exp_list))
1657 }
1658 }
1659 #[doc = "`Emit_IndexSet(i32, i32, crate::moon_sharp::interpreter::dynvalue::DynValue, bool, bool)` overload"]
1660 fn emit_index_set(
1661 self,
1662 stackofs: impl ::core::convert::Into<i32>,
1663 tupleidx: impl ::core::convert::Into<i32>,
1664 index: impl ::core::convert::Into<crate::moon_sharp::interpreter::dynvalue::DynValue>,
1665 is_name_index: impl ::core::convert::Into<bool>,
1666 is_exp_list: impl ::core::convert::Into<bool>,
1667 ) -> crate::moon_sharp::interpreter::execution::vm::instruction::Instruction {
1668 unsafe {
1669 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1670 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_emit_index_set::get_method_info().method_ptr,crate::moon_sharp::interpreter::execution::vm::instruction::Instruction;
1671(ByteCode)__receiver,(i32)::core::convert::Into::into(stackofs),(i32)::core::convert::Into::into(tupleidx),(crate::moon_sharp::interpreter::dynvalue::DynValue)::core::convert::Into::into(index),(bool)::core::convert::Into::into(is_name_index),(bool)::core::convert::Into::into(is_exp_list))
1672 }
1673 }
1674 #[doc = "`Emit_Copy(i32)` overload"]
1675 fn emit_copy(self, numval: impl ::core::convert::Into<i32>) -> crate::moon_sharp::interpreter::execution::vm::instruction::Instruction {
1676 unsafe {
1677 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1678 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_emit_copy::get_method_info().method_ptr,crate::moon_sharp::interpreter::execution::vm::instruction::Instruction;
1679(ByteCode)__receiver,(i32)::core::convert::Into::into(numval))
1680 }
1681 }
1682 #[doc = "`Emit_Swap(i32, i32)` overload"]
1683 fn emit_swap(
1684 self,
1685 p1: impl ::core::convert::Into<i32>,
1686 p2: impl ::core::convert::Into<i32>,
1687 ) -> crate::moon_sharp::interpreter::execution::vm::instruction::Instruction {
1688 unsafe {
1689 let __receiver = <ByteCode as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1690 ::unity::il2cpp_call!(__ByteCode_unity_raw::__lookup_emit_swap::get_method_info().method_ptr,crate::moon_sharp::interpreter::execution::vm::instruction::Instruction;
1691(ByteCode)__receiver,(i32)::core::convert::Into::into(p1),(i32)::core::convert::Into::into(p2))
1692 }
1693 }
1694}
1695
1696#[cfg(feature = "moon_sharp-interpreter-execution-vm-bytecode")]
1697impl<__T: IByteCode> IByteCodeMethods for __T {}
1698
1699#[cfg(feature = "moon_sharp-interpreter-execution-vm-bytecode")]
1700impl ByteCode {
1701 pub fn get_script_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1702 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1703 }
1704
1705 pub fn set_script_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1706 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1707 }
1708
1709 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1710 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
1711 }
1712
1713 pub fn push_source_ref_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1714 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
1715 }
1716
1717 pub fn pop_source_ref_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1718 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
1719 }
1720
1721 pub fn dump_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1722 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
1723 }
1724
1725 pub fn get_jump_point_for_next_instruction_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1726 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
1727 }
1728
1729 pub fn get_jump_point_for_last_instruction_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1730 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
1731 }
1732
1733 pub fn get_last_instruction_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1734 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
1735 }
1736
1737 pub fn append_instruction_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1738 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
1739 }
1740
1741 pub fn emit_nop_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1742 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
1743 }
1744
1745 pub fn emit_invalid_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1746 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
1747 }
1748
1749 pub fn emit_pop_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1750 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
1751 }
1752
1753 pub fn emit_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1754 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
1755 }
1756
1757 pub fn emit_this_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1758 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
1759 }
1760
1761 pub fn emit_literal_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1762 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[16]
1763 }
1764
1765 pub fn emit_jump_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1766 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[17]
1767 }
1768
1769 pub fn emit_mk_tuple_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1770 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[18]
1771 }
1772
1773 pub fn emit_operator_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1774 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[19]
1775 }
1776
1777 pub fn emit_debug_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1778 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[20]
1779 }
1780
1781 pub fn emit_enter_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1782 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[21]
1783 }
1784
1785 pub fn emit_leave_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1786 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[22]
1787 }
1788
1789 pub fn emit_exit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1790 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[23]
1791 }
1792
1793 pub fn emit_clean_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1794 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[24]
1795 }
1796
1797 pub fn emit_closure_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1798 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[25]
1799 }
1800
1801 pub fn emit_args_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1802 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[26]
1803 }
1804
1805 pub fn emit_ret_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1806 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[27]
1807 }
1808
1809 pub fn emit_to_num_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1810 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[28]
1811 }
1812
1813 pub fn emit_incr_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1814 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[29]
1815 }
1816
1817 pub fn emit_new_table_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1818 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[30]
1819 }
1820
1821 pub fn emit_iter_prep_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1822 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[31]
1823 }
1824
1825 pub fn emit_exp_tuple_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1826 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[32]
1827 }
1828
1829 pub fn emit_iter_upd_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1830 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[33]
1831 }
1832
1833 pub fn emit_meta_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1834 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[34]
1835 }
1836
1837 pub fn emit_begin_fn_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1838 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[35]
1839 }
1840
1841 pub fn emit_scalar_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1842 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[36]
1843 }
1844
1845 pub fn emit_load_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1846 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[37]
1847 }
1848
1849 pub fn emit_store_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1850 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[38]
1851 }
1852
1853 pub fn emit_tbl_init_n_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1854 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[39]
1855 }
1856
1857 pub fn emit_tbl_init_i_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1858 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[40]
1859 }
1860
1861 pub fn emit_index_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1862 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[41]
1863 }
1864
1865 pub fn emit_index_set_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1866 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[42]
1867 }
1868
1869 pub fn emit_copy_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1870 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[43]
1871 }
1872
1873 pub fn emit_swap_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1874 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[44]
1875 }
1876}
1877
1878#[cfg(feature = "moon_sharp-interpreter-execution-vm-bytecode")]
1879impl ByteCode {
1880 #[doc = "`.ctor(crate::moon_sharp::interpreter::script::Script)` — overload selector"]
1881 pub fn new(script: crate::moon_sharp::interpreter::script::Script) -> Self {
1882 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
1883 panic!(
1884 "{}
1885::{}
1886 failed to instantiate",
1887 ::core::stringify!(ByteCode),
1888 ::core::stringify!(new),
1889 )
1890 });
1891 <Self as IByteCodeMethods>::ctor(this, script);
1892 this
1893 }
1894}
1895
1896#[cfg(feature = "moon_sharp-interpreter-execution-vm-bytecode")]
1897#[doc(hidden)]
1898#[allow(non_snake_case, non_camel_case_types, clippy::too_many_arguments)]
1899mod __ByteCode_SourceCodeStackGuard_unity_raw {
1900 use super::*;
1901 #[doc(hidden)]
1902 #[allow(non_snake_case)]
1903 pub mod __lookup_ctor {
1904 use super::*;
1905 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1906 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
1907 <crate::moon_sharp::interpreter::debugging::sourceref::SourceRef as ::unity::IlType>::il_type(),
1908 <crate::moon_sharp::interpreter::execution::vm::bytecode::ByteCode as ::unity::IlType>::il_type(),
1909 ];
1910 ::unity::lookup::method_info_on_class_with_signature(
1911 <ByteCode_SourceCodeStackGuard as ::unity::ClassIdentity>::class(),
1912 ".ctor",
1913 2,
1914 param_types,
1915 false,
1916 )
1917 });
1918 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1919 match &*METHOD {
1920 ::core::result::Result::Ok(mi) => *mi,
1921 ::core::result::Result::Err(e) => {
1922 panic!(
1923 "method lookup failed: {}
1924::{}
1925: {}
1926",
1927 <ByteCode_SourceCodeStackGuard as ::unity::ClassIdentity>::NAME,
1928 ".ctor",
1929 e
1930 )
1931 },
1932 }
1933 }
1934 }
1935}
1936
1937#[cfg(feature = "moon_sharp-interpreter-execution-vm-bytecode")]
1938pub trait IByteCode_SourceCodeStackGuardMethods: IByteCode_SourceCodeStackGuard {
1939 #[doc = "`.ctor(crate::moon_sharp::interpreter::debugging::sourceref::SourceRef, crate::moon_sharp::interpreter::execution::vm::bytecode::ByteCode)` overload"]
1940 fn ctor(
1941 self,
1942 sref: impl ::core::convert::Into<crate::moon_sharp::interpreter::debugging::sourceref::SourceRef>,
1943 bc: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::bytecode::ByteCode>,
1944 ) -> () {
1945 unsafe {
1946 let __receiver =
1947 <ByteCode_SourceCodeStackGuard as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1948 ::unity::il2cpp_call!(__ByteCode_SourceCodeStackGuard_unity_raw::__lookup_ctor::get_method_info().method_ptr,();
1949(ByteCode_SourceCodeStackGuard)__receiver,(crate::moon_sharp::interpreter::debugging::sourceref::SourceRef)::core::convert::Into::into(sref),(crate::moon_sharp::interpreter::execution::vm::bytecode::ByteCode)::core::convert::Into::into(bc))
1950 }
1951 }
1952 #[doc = "`Dispose()` overload"]
1953 fn dispose(self) -> () {
1954 unsafe {
1955 let __receiver =
1956 <ByteCode_SourceCodeStackGuard as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
1957 {
1958 let __vt = ::unity::Cast::get_class(__receiver).raw().get_vtable();
1959 let __vi = *__vt.get(4usize).unwrap_or_else(|| {
1960 panic!(
1961 "unity: virtual slot {}
1962 out of range (vtable len {}
1963) on the runtime class behind {}
1964 (method `{}
1965`)",
1966 4usize,
1967 __vt.len(),
1968 <ByteCode_SourceCodeStackGuard as ::unity::ClassIdentity>::NAME,
1969 "Dispose",
1970 )
1971 });
1972 let __inner: extern "C" fn(ByteCode_SourceCodeStackGuard, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__vi.method_ptr);
1973 let __mi: ::unity::OptionalMethod = ::core::option::Option::Some(&*(__vi.method_info as *const ::unity::MethodInfo as *const ()));
1974 __inner(__receiver, __mi)
1975 }
1976 }
1977 }
1978}
1979
1980#[cfg(feature = "moon_sharp-interpreter-execution-vm-bytecode")]
1981impl<__T: IByteCode_SourceCodeStackGuard> IByteCode_SourceCodeStackGuardMethods for __T {}
1982
1983#[cfg(feature = "moon_sharp-interpreter-execution-vm-bytecode")]
1984impl ByteCode_SourceCodeStackGuard {
1985 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1986 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
1987 }
1988
1989 pub fn dispose_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1990 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
1991 }
1992}
1993
1994#[cfg(feature = "moon_sharp-interpreter-execution-vm-bytecode")]
1995impl ByteCode_SourceCodeStackGuard {
1996 #[doc = "Direct (non-virtual) call to `ByteCode_SourceCodeStackGuard`'s own `Dispose`. Bypasses the vtable, so it won't hit an override/patch — use it for base calls."]
1997 pub unsafe fn dispose(this: impl ::core::convert::Into<::unity::IlInstance>) -> () {
1998 let __mi = Self::dispose_method_info();
1999 let __inner: extern "C" fn(::unity::IlInstance, ::unity::OptionalMethod) -> () = ::core::mem::transmute(__mi.method_ptr);
2000 __inner(this.into(), ::core::option::Option::None)
2001 }
2002}
2003
2004#[cfg(feature = "moon_sharp-interpreter-execution-vm-bytecode")]
2005impl ByteCode_SourceCodeStackGuard {
2006 #[doc = "`.ctor(crate::moon_sharp::interpreter::debugging::sourceref::SourceRef, crate::moon_sharp::interpreter::execution::vm::bytecode::ByteCode)` — overload selector"]
2007 pub fn new(
2008 sref: crate::moon_sharp::interpreter::debugging::sourceref::SourceRef,
2009 bc: crate::moon_sharp::interpreter::execution::vm::bytecode::ByteCode,
2010 ) -> Self {
2011 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2012 panic!(
2013 "{}
2014::{}
2015 failed to instantiate",
2016 ::core::stringify!(ByteCode_SourceCodeStackGuard),
2017 ::core::stringify!(new),
2018 )
2019 });
2020 <Self as IByteCode_SourceCodeStackGuardMethods>::ctor(this, sref, bc);
2021 this
2022 }
2023}
2024
2025#[cfg(feature = "moon_sharp-interpreter-execution-vm-bytecode")]
2026#[doc(hidden)]
2027pub mod prelude {
2028 pub use super::{
2029 ByteCode, ByteCode_SourceCodeStackGuard, IByteCode, IByteCodeMethods, IByteCode_SourceCodeStackGuard, IByteCode_SourceCodeStackGuardMethods,
2030 };
2031 #[cfg(feature = "moon_sharp-interpreter-refidobject")]
2032 pub use crate::moon_sharp::interpreter::refidobject::IRefIdObjectMethods;
2033 #[cfg(feature = "system-object")]
2034 pub use crate::system::object::IObjectMethods;
2035 pub use crate::{moon_sharp::interpreter::refidobject::IRefIdObject, system::object::IObject};
2036}