1#[cfg(feature = "moon_sharp-interpreter-execution-vm-processor-types")]
4mod __types {
5 #[allow(unused_imports)] use ::unity::prelude::*;
6
7 use super::*;
8 use crate::system::object::{IObject, Object};
9
10 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/moon_sharp/interpreter/execution/vm/processor/Processor.md"))]
11 #[::unity::class(namespace = "MoonSharp.Interpreter.Execution.VM", name = "Processor")]
12 #[parent(crate::system::object::Object)]
13 pub struct Processor {
14 #[offset(16)]
15 #[rename(name = "m_RootChunk")]
16 pub m_root_chunk: crate::moon_sharp::interpreter::execution::vm::bytecode::ByteCode,
17 #[offset(24)]
18 #[rename(name = "m_ValueStack")]
19 pub m_value_stack: crate::moon_sharp::interpreter::data_structs::faststack_1::FastStack_1<crate::moon_sharp::interpreter::dynvalue::DynValue>,
20 #[offset(32)]
21 #[rename(name = "m_ExecutionStack")]
22 pub m_execution_stack: crate::moon_sharp::interpreter::data_structs::faststack_1::FastStack_1<
23 crate::moon_sharp::interpreter::execution::vm::callstackitem::CallStackItem,
24 >,
25 #[offset(40)]
26 #[rename(name = "m_CoroutinesStack")]
27 pub m_coroutines_stack:
28 crate::system::collections::generic::list_1::List_1<crate::moon_sharp::interpreter::execution::vm::processor::Processor>,
29 #[offset(48)]
30 #[rename(name = "m_GlobalTable")]
31 pub m_global_table: crate::moon_sharp::interpreter::table::Table,
32 #[offset(56)]
33 #[rename(name = "m_Script")]
34 pub m_script: crate::moon_sharp::interpreter::script::Script,
35 #[offset(64)]
36 #[rename(name = "m_Parent")]
37 pub m_parent: crate::moon_sharp::interpreter::execution::vm::processor::Processor,
38 #[offset(72)]
39 #[rename(name = "m_State")]
40 pub m_state: crate::moon_sharp::interpreter::coroutinestate::CoroutineState,
41 #[offset(76)]
42 #[rename(name = "m_CanYield")]
43 pub m_can_yield: bool,
44 #[offset(80)]
45 #[rename(name = "m_SavedInstructionPtr")]
46 pub m_saved_instruction_ptr: i32,
47 #[offset(88)]
48 #[rename(name = "m_Debug")]
49 pub m_debug: crate::moon_sharp::interpreter::execution::vm::processor::Processor_DebugContext,
50 #[offset(96)]
51 #[rename(name = "m_OwningThreadID")]
52 pub m_owning_thread_id: i32,
53 #[offset(100)]
54 #[rename(name = "m_ExecutionNesting")]
55 pub m_execution_nesting: i32,
56 #[static_field]
57 #[rename(name = "DUMP_CHUNK_MAGIC")]
58 pub dump_chunk_magic: u64,
59 #[static_field]
60 #[rename(name = "DUMP_CHUNK_VERSION")]
61 pub dump_chunk_version: i32,
62 #[static_field]
63 #[rename(name = "YIELD_SPECIAL_TRAP")]
64 pub yield_special_trap: i32,
65 #[offset(112)]
66 #[rename(name = "AutoYieldCounter")]
67 pub auto_yield_counter: i64,
68 }
69
70 #[doc=include_str!(concat!(env!("CARGO_MANIFEST_DIR"),"/","docs/moon_sharp/interpreter/execution/vm/processor/Processor_DebugContext.md"))]
71 #[::unity::class(namespace = "MoonSharp.Interpreter.Execution.VM", name = "Processor.DebugContext")]
72 #[parent(crate::system::object::Object)]
73 pub struct Processor_DebugContext {
74 #[offset(16)]
75 #[rename(name = "DebuggerEnabled")]
76 pub debugger_enabled: bool,
77 #[offset(24)]
78 #[rename(name = "DebuggerAttached")]
79 pub debugger_attached: crate::moon_sharp::interpreter::debugging::idebugger::IDebugger,
80 #[offset(32)]
81 #[rename(name = "DebuggerCurrentAction")]
82 pub debugger_current_action: crate::moon_sharp::interpreter::debugging::debuggeraction::DebuggerAction_ActionType,
83 #[offset(36)]
84 #[rename(name = "DebuggerCurrentActionTarget")]
85 pub debugger_current_action_target: i32,
86 #[offset(40)]
87 #[rename(name = "LastHlRef")]
88 pub last_hl_ref: crate::moon_sharp::interpreter::debugging::sourceref::SourceRef,
89 #[offset(48)]
90 #[rename(name = "ExStackDepthAtStep")]
91 pub ex_stack_depth_at_step: i32,
92 #[offset(56)]
93 #[rename(name = "BreakPoints")]
94 pub break_points: crate::system::collections::generic::list_1::List_1<crate::moon_sharp::interpreter::debugging::sourceref::SourceRef>,
95 #[offset(64)]
96 #[rename(name = "LineBasedBreakPoints")]
97 pub line_based_break_points: bool,
98 }
99}
100
101#[cfg(feature = "moon_sharp-interpreter-execution-vm-processor-types")]
102pub use __types::*;
103
104#[cfg(feature = "moon_sharp-interpreter-execution-vm-processor")]
105#[doc(hidden)]
106#[allow(non_snake_case, non_camel_case_types, clippy::too_many_arguments)]
107mod __Processor_unity_raw {
108 use super::*;
109 #[doc(hidden)]
110 #[allow(non_snake_case)]
111 pub mod __lookup_ctor {
112 use super::*;
113 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
114 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
115 <crate::moon_sharp::interpreter::script::Script as ::unity::IlType>::il_type(),
116 <crate::moon_sharp::interpreter::table::Table as ::unity::IlType>::il_type(),
117 <crate::moon_sharp::interpreter::execution::vm::bytecode::ByteCode as ::unity::IlType>::il_type(),
118 ];
119 ::unity::lookup::method_info_on_class_with_signature(<Processor as ::unity::ClassIdentity>::class(), ".ctor", 3, param_types, false)
120 });
121 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
122 match &*METHOD {
123 ::core::result::Result::Ok(mi) => *mi,
124 ::core::result::Result::Err(e) => {
125 panic!(
126 "method lookup failed: {}
127::{}
128: {}
129",
130 <Processor as ::unity::ClassIdentity>::NAME,
131 ".ctor",
132 e
133 )
134 },
135 }
136 }
137 }
138 #[doc(hidden)]
139 #[allow(non_snake_case)]
140 pub mod __lookup_ctor_2 {
141 use super::*;
142 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
143 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
144 &[<crate::moon_sharp::interpreter::execution::vm::processor::Processor as ::unity::IlType>::il_type()];
145 ::unity::lookup::method_info_on_class_with_signature(<Processor as ::unity::ClassIdentity>::class(), ".ctor", 1, param_types, false)
146 });
147 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
148 match &*METHOD {
149 ::core::result::Result::Ok(mi) => *mi,
150 ::core::result::Result::Err(e) => {
151 panic!(
152 "method lookup failed: {}
153::{}
154: {}
155",
156 <Processor as ::unity::ClassIdentity>::NAME,
157 ".ctor",
158 e
159 )
160 },
161 }
162 }
163 }
164 #[doc(hidden)]
165 #[allow(non_snake_case)]
166 pub mod __lookup_call {
167 use super::*;
168 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
169 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
170 <crate::moon_sharp::interpreter::dynvalue::DynValue as ::unity::IlType>::il_type(),
171 <::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue> as ::unity::IlType>::il_type(),
172 ];
173 ::unity::lookup::method_info_on_class_with_signature(<Processor as ::unity::ClassIdentity>::class(), "Call", 2, param_types, false)
174 });
175 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
176 match &*METHOD {
177 ::core::result::Result::Ok(mi) => *mi,
178 ::core::result::Result::Err(e) => {
179 panic!(
180 "method lookup failed: {}
181::{}
182: {}
183",
184 <Processor as ::unity::ClassIdentity>::NAME,
185 "Call",
186 e
187 )
188 },
189 }
190 }
191 }
192 #[doc(hidden)]
193 #[allow(non_snake_case)]
194 pub mod __lookup_push_clr_to_script_stack_frame {
195 use super::*;
196 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
197 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
198 <crate::moon_sharp::interpreter::execution::vm::callstackitemflags::CallStackItemFlags as ::unity::IlType>::il_type(),
199 <crate::moon_sharp::interpreter::dynvalue::DynValue as ::unity::IlType>::il_type(),
200 <::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue> as ::unity::IlType>::il_type(),
201 ];
202 ::unity::lookup::method_info_on_class_with_signature(
203 <Processor as ::unity::ClassIdentity>::class(),
204 "PushClrToScriptStackFrame",
205 3,
206 param_types,
207 false,
208 )
209 });
210 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
211 match &*METHOD {
212 ::core::result::Result::Ok(mi) => *mi,
213 ::core::result::Result::Err(e) => {
214 panic!(
215 "method lookup failed: {}
216::{}
217: {}
218",
219 <Processor as ::unity::ClassIdentity>::NAME,
220 "PushClrToScriptStackFrame",
221 e
222 )
223 },
224 }
225 }
226 }
227 #[doc(hidden)]
228 #[allow(non_snake_case)]
229 pub mod __lookup_leave_processor {
230 use super::*;
231 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
232 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
233 ::unity::lookup::method_info_on_class_with_signature(
234 <Processor as ::unity::ClassIdentity>::class(),
235 "LeaveProcessor",
236 0,
237 param_types,
238 false,
239 )
240 });
241 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
242 match &*METHOD {
243 ::core::result::Result::Ok(mi) => *mi,
244 ::core::result::Result::Err(e) => {
245 panic!(
246 "method lookup failed: {}
247::{}
248: {}
249",
250 <Processor as ::unity::ClassIdentity>::NAME,
251 "LeaveProcessor",
252 e
253 )
254 },
255 }
256 }
257 }
258 #[doc(hidden)]
259 #[allow(non_snake_case)]
260 pub mod __lookup_get_thread_id {
261 use super::*;
262 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
263 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
264 ::unity::lookup::method_info_on_class_with_signature(<Processor as ::unity::ClassIdentity>::class(), "GetThreadId", 0, param_types, false)
265 });
266 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
267 match &*METHOD {
268 ::core::result::Result::Ok(mi) => *mi,
269 ::core::result::Result::Err(e) => {
270 panic!(
271 "method lookup failed: {}
272::{}
273: {}
274",
275 <Processor as ::unity::ClassIdentity>::NAME,
276 "GetThreadId",
277 e
278 )
279 },
280 }
281 }
282 }
283 #[doc(hidden)]
284 #[allow(non_snake_case)]
285 pub mod __lookup_enter_processor {
286 use super::*;
287 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
288 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
289 ::unity::lookup::method_info_on_class_with_signature(
290 <Processor as ::unity::ClassIdentity>::class(),
291 "EnterProcessor",
292 0,
293 param_types,
294 false,
295 )
296 });
297 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
298 match &*METHOD {
299 ::core::result::Result::Ok(mi) => *mi,
300 ::core::result::Result::Err(e) => {
301 panic!(
302 "method lookup failed: {}
303::{}
304: {}
305",
306 <Processor as ::unity::ClassIdentity>::NAME,
307 "EnterProcessor",
308 e
309 )
310 },
311 }
312 }
313 }
314 #[doc(hidden)]
315 #[allow(non_snake_case)]
316 pub mod __lookup_get_coroutine_suspended_location {
317 use super::*;
318 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
319 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
320 ::unity::lookup::method_info_on_class_with_signature(
321 <Processor as ::unity::ClassIdentity>::class(),
322 "GetCoroutineSuspendedLocation",
323 0,
324 param_types,
325 false,
326 )
327 });
328 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
329 match &*METHOD {
330 ::core::result::Result::Ok(mi) => *mi,
331 ::core::result::Result::Err(e) => {
332 panic!(
333 "method lookup failed: {}
334::{}
335: {}
336",
337 <Processor as ::unity::ClassIdentity>::NAME,
338 "GetCoroutineSuspendedLocation",
339 e
340 )
341 },
342 }
343 }
344 }
345 #[doc(hidden)]
346 #[allow(non_snake_case)]
347 pub mod __lookup_is_dump_stream {
348 use super::*;
349 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
350 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<crate::system::io::stream::Stream as ::unity::IlType>::il_type()];
351 ::unity::lookup::method_info_on_class_with_signature(<Processor as ::unity::ClassIdentity>::class(), "IsDumpStream", 1, param_types, true)
352 });
353 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
354 match &*METHOD {
355 ::core::result::Result::Ok(mi) => *mi,
356 ::core::result::Result::Err(e) => {
357 panic!(
358 "method lookup failed: {}
359::{}
360: {}
361",
362 <Processor as ::unity::ClassIdentity>::NAME,
363 "IsDumpStream",
364 e
365 )
366 },
367 }
368 }
369 }
370 #[doc(hidden)]
371 #[allow(non_snake_case)]
372 pub mod __lookup_dump {
373 use super::*;
374 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
375 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
376 <crate::system::io::stream::Stream as ::unity::IlType>::il_type(),
377 <i32 as ::unity::IlType>::il_type(),
378 <bool as ::unity::IlType>::il_type(),
379 ];
380 ::unity::lookup::method_info_on_class_with_signature(<Processor as ::unity::ClassIdentity>::class(), "Dump", 3, param_types, false)
381 });
382 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
383 match &*METHOD {
384 ::core::result::Result::Ok(mi) => *mi,
385 ::core::result::Result::Err(e) => {
386 panic!(
387 "method lookup failed: {}
388::{}
389: {}
390",
391 <Processor as ::unity::ClassIdentity>::NAME,
392 "Dump",
393 e
394 )
395 },
396 }
397 }
398 }
399 #[doc(hidden)]
400 #[allow(non_snake_case)]
401 pub mod __lookup_add_symbol_to_map {
402 use super::*;
403 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
404 let param_types: &[& 'static::unity::il2cpp::Il2CppType]= &[<crate::system::collections::generic::dictionary_2::Dictionary_2<crate::moon_sharp::interpreter::symbolref::SymbolRef,i32>as::unity::IlType> ::il_type(), <crate::moon_sharp::interpreter::symbolref::SymbolRef as::unity::IlType> ::il_type()];
405 ::unity::lookup::method_info_on_class_with_signature(
406 <Processor as ::unity::ClassIdentity>::class(),
407 "AddSymbolToMap",
408 2,
409 param_types,
410 false,
411 )
412 });
413 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
414 match &*METHOD {
415 ::core::result::Result::Ok(mi) => *mi,
416 ::core::result::Result::Err(e) => {
417 panic!(
418 "method lookup failed: {}
419::{}
420: {}
421",
422 <Processor as ::unity::ClassIdentity>::NAME,
423 "AddSymbolToMap",
424 e
425 )
426 },
427 }
428 }
429 }
430 #[doc(hidden)]
431 #[allow(non_snake_case)]
432 pub mod __lookup_undump {
433 use super::*;
434 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
435 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
436 <crate::system::io::stream::Stream as ::unity::IlType>::il_type(),
437 <i32 as ::unity::IlType>::il_type(),
438 <crate::moon_sharp::interpreter::table::Table as ::unity::IlType>::il_type(),
439 <bool as ::unity::IlType>::il_type(),
440 ];
441 ::unity::lookup::method_info_on_class_with_signature(<Processor as ::unity::ClassIdentity>::class(), "Undump", 4, param_types, false)
442 });
443 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
444 match &*METHOD {
445 ::core::result::Result::Ok(mi) => *mi,
446 ::core::result::Result::Err(e) => {
447 panic!(
448 "method lookup failed: {}
449::{}
450: {}
451",
452 <Processor as ::unity::ClassIdentity>::NAME,
453 "Undump",
454 e
455 )
456 },
457 }
458 }
459 }
460 #[doc(hidden)]
461 #[allow(non_snake_case)]
462 pub mod __lookup_coroutine_create {
463 use super::*;
464 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
465 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
466 &[<crate::moon_sharp::interpreter::closure::Closure as ::unity::IlType>::il_type()];
467 ::unity::lookup::method_info_on_class_with_signature(
468 <Processor as ::unity::ClassIdentity>::class(),
469 "Coroutine_Create",
470 1,
471 param_types,
472 false,
473 )
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 <Processor as ::unity::ClassIdentity>::NAME,
485 "Coroutine_Create",
486 e
487 )
488 },
489 }
490 }
491 }
492 #[doc(hidden)]
493 #[allow(non_snake_case)]
494 pub mod __lookup_get_state {
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 ::unity::lookup::method_info_on_class_with_signature(<Processor as ::unity::ClassIdentity>::class(), "get_State", 0, param_types, false)
499 });
500 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
501 match &*METHOD {
502 ::core::result::Result::Ok(mi) => *mi,
503 ::core::result::Result::Err(e) => {
504 panic!(
505 "method lookup failed: {}
506::{}
507: {}
508",
509 <Processor as ::unity::ClassIdentity>::NAME,
510 "get_State",
511 e
512 )
513 },
514 }
515 }
516 }
517 #[doc(hidden)]
518 #[allow(non_snake_case)]
519 pub mod __lookup_get_associated_coroutine {
520 use super::*;
521 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
522 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
523 ::unity::lookup::method_info_on_class_with_signature(
524 <Processor as ::unity::ClassIdentity>::class(),
525 "get_AssociatedCoroutine",
526 0,
527 param_types,
528 false,
529 )
530 });
531 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
532 match &*METHOD {
533 ::core::result::Result::Ok(mi) => *mi,
534 ::core::result::Result::Err(e) => {
535 panic!(
536 "method lookup failed: {}
537::{}
538: {}
539",
540 <Processor as ::unity::ClassIdentity>::NAME,
541 "get_AssociatedCoroutine",
542 e
543 )
544 },
545 }
546 }
547 }
548 #[doc(hidden)]
549 #[allow(non_snake_case)]
550 pub mod __lookup_set_associated_coroutine {
551 use super::*;
552 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
553 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
554 &[<crate::moon_sharp::interpreter::coroutine_2::Coroutine_2 as ::unity::IlType>::il_type()];
555 ::unity::lookup::method_info_on_class_with_signature(
556 <Processor as ::unity::ClassIdentity>::class(),
557 "set_AssociatedCoroutine",
558 1,
559 param_types,
560 false,
561 )
562 });
563 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
564 match &*METHOD {
565 ::core::result::Result::Ok(mi) => *mi,
566 ::core::result::Result::Err(e) => {
567 panic!(
568 "method lookup failed: {}
569::{}
570: {}
571",
572 <Processor as ::unity::ClassIdentity>::NAME,
573 "set_AssociatedCoroutine",
574 e
575 )
576 },
577 }
578 }
579 }
580 #[doc(hidden)]
581 #[allow(non_snake_case)]
582 pub mod __lookup_coroutine_resume {
583 use super::*;
584 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
585 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
586 &[<::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue> as ::unity::IlType>::il_type()];
587 ::unity::lookup::method_info_on_class_with_signature(
588 <Processor as ::unity::ClassIdentity>::class(),
589 "Coroutine_Resume",
590 1,
591 param_types,
592 false,
593 )
594 });
595 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
596 match &*METHOD {
597 ::core::result::Result::Ok(mi) => *mi,
598 ::core::result::Result::Err(e) => {
599 panic!(
600 "method lookup failed: {}
601::{}
602: {}
603",
604 <Processor as ::unity::ClassIdentity>::NAME,
605 "Coroutine_Resume",
606 e
607 )
608 },
609 }
610 }
611 }
612 #[doc(hidden)]
613 #[allow(non_snake_case)]
614 pub mod __lookup_find_meta {
615 use super::*;
616 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
617 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<i32 as ::unity::IlType>::il_type()];
618 ::unity::lookup::method_info_on_class_with_signature(<Processor as ::unity::ClassIdentity>::class(), "FindMeta", 1, param_types, false)
619 });
620 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
621 match &*METHOD {
622 ::core::result::Result::Ok(mi) => *mi,
623 ::core::result::Result::Err(e) => {
624 panic!(
625 "method lookup failed: {}
626::{}
627: {}
628",
629 <Processor as ::unity::ClassIdentity>::NAME,
630 "FindMeta",
631 e
632 )
633 },
634 }
635 }
636 }
637 #[doc(hidden)]
638 #[allow(non_snake_case)]
639 pub mod __lookup_attach_debugger {
640 use super::*;
641 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
642 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
643 &[<crate::moon_sharp::interpreter::debugging::idebugger::IDebugger as ::unity::IlType>::il_type()];
644 ::unity::lookup::method_info_on_class_with_signature(
645 <Processor as ::unity::ClassIdentity>::class(),
646 "AttachDebugger",
647 1,
648 param_types,
649 false,
650 )
651 });
652 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
653 match &*METHOD {
654 ::core::result::Result::Ok(mi) => *mi,
655 ::core::result::Result::Err(e) => {
656 panic!(
657 "method lookup failed: {}
658::{}
659: {}
660",
661 <Processor as ::unity::ClassIdentity>::NAME,
662 "AttachDebugger",
663 e
664 )
665 },
666 }
667 }
668 }
669 #[doc(hidden)]
670 #[allow(non_snake_case)]
671 pub mod __lookup_get_debugger_enabled {
672 use super::*;
673 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
674 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
675 ::unity::lookup::method_info_on_class_with_signature(
676 <Processor as ::unity::ClassIdentity>::class(),
677 "get_DebuggerEnabled",
678 0,
679 param_types,
680 false,
681 )
682 });
683 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
684 match &*METHOD {
685 ::core::result::Result::Ok(mi) => *mi,
686 ::core::result::Result::Err(e) => {
687 panic!(
688 "method lookup failed: {}
689::{}
690: {}
691",
692 <Processor as ::unity::ClassIdentity>::NAME,
693 "get_DebuggerEnabled",
694 e
695 )
696 },
697 }
698 }
699 }
700 #[doc(hidden)]
701 #[allow(non_snake_case)]
702 pub mod __lookup_set_debugger_enabled {
703 use super::*;
704 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
705 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<bool as ::unity::IlType>::il_type()];
706 ::unity::lookup::method_info_on_class_with_signature(
707 <Processor as ::unity::ClassIdentity>::class(),
708 "set_DebuggerEnabled",
709 1,
710 param_types,
711 false,
712 )
713 });
714 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
715 match &*METHOD {
716 ::core::result::Result::Ok(mi) => *mi,
717 ::core::result::Result::Err(e) => {
718 panic!(
719 "method lookup failed: {}
720::{}
721: {}
722",
723 <Processor as ::unity::ClassIdentity>::NAME,
724 "set_DebuggerEnabled",
725 e
726 )
727 },
728 }
729 }
730 }
731 #[doc(hidden)]
732 #[allow(non_snake_case)]
733 pub mod __lookup_listen_debugger {
734 use super::*;
735 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
736 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
737 <crate::moon_sharp::interpreter::execution::vm::instruction::Instruction as ::unity::IlType>::il_type(),
738 <i32 as ::unity::IlType>::il_type(),
739 ];
740 ::unity::lookup::method_info_on_class_with_signature(
741 <Processor as ::unity::ClassIdentity>::class(),
742 "ListenDebugger",
743 2,
744 param_types,
745 false,
746 )
747 });
748 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
749 match &*METHOD {
750 ::core::result::Result::Ok(mi) => *mi,
751 ::core::result::Result::Err(e) => {
752 panic!(
753 "method lookup failed: {}
754::{}
755: {}
756",
757 <Processor as ::unity::ClassIdentity>::NAME,
758 "ListenDebugger",
759 e
760 )
761 },
762 }
763 }
764 }
765 #[doc(hidden)]
766 #[allow(non_snake_case)]
767 pub mod __lookup_reset_break_points {
768 use super::*;
769 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
770 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
771 &[<crate::moon_sharp::interpreter::debugging::debuggeraction::DebuggerAction as ::unity::IlType>::il_type()];
772 ::unity::lookup::method_info_on_class_with_signature(
773 <Processor as ::unity::ClassIdentity>::class(),
774 "ResetBreakPoints",
775 1,
776 param_types,
777 false,
778 )
779 });
780 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
781 match &*METHOD {
782 ::core::result::Result::Ok(mi) => *mi,
783 ::core::result::Result::Err(e) => {
784 panic!(
785 "method lookup failed: {}
786::{}
787: {}
788",
789 <Processor as ::unity::ClassIdentity>::NAME,
790 "ResetBreakPoints",
791 e
792 )
793 },
794 }
795 }
796 }
797 #[doc(hidden)]
798 #[allow(non_snake_case)]
799 pub mod __lookup_reset_break_points_2 {
800 use super::*;
801 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
802 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
803 <crate::moon_sharp::interpreter::debugging::sourcecode::SourceCode as ::unity::IlType>::il_type(),
804 <crate::system::collections::generic::hashset_1::HashSet_1<i32> as ::unity::IlType>::il_type(),
805 ];
806 ::unity::lookup::method_info_on_class_with_signature(
807 <Processor as ::unity::ClassIdentity>::class(),
808 "ResetBreakPoints",
809 2,
810 param_types,
811 false,
812 )
813 });
814 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
815 match &*METHOD {
816 ::core::result::Result::Ok(mi) => *mi,
817 ::core::result::Result::Err(e) => {
818 panic!(
819 "method lookup failed: {}
820::{}
821: {}
822",
823 <Processor as ::unity::ClassIdentity>::NAME,
824 "ResetBreakPoints",
825 e
826 )
827 },
828 }
829 }
830 }
831 #[doc(hidden)]
832 #[allow(non_snake_case)]
833 pub mod __lookup_refresh_debugger {
834 use super::*;
835 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
836 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<bool as ::unity::IlType>::il_type(), <i32 as ::unity::IlType>::il_type()];
837 ::unity::lookup::method_info_on_class_with_signature(
838 <Processor as ::unity::ClassIdentity>::class(),
839 "RefreshDebugger",
840 2,
841 param_types,
842 false,
843 )
844 });
845 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
846 match &*METHOD {
847 ::core::result::Result::Ok(mi) => *mi,
848 ::core::result::Result::Err(e) => {
849 panic!(
850 "method lookup failed: {}
851::{}
852: {}
853",
854 <Processor as ::unity::ClassIdentity>::NAME,
855 "RefreshDebugger",
856 e
857 )
858 },
859 }
860 }
861 }
862 #[doc(hidden)]
863 #[allow(non_snake_case)]
864 pub mod __lookup_debugger_refresh_threads {
865 use super::*;
866 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
867 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
868 &[<crate::moon_sharp::interpreter::scriptexecutioncontext::ScriptExecutionContext as ::unity::IlType>::il_type()];
869 ::unity::lookup::method_info_on_class_with_signature(
870 <Processor as ::unity::ClassIdentity>::class(),
871 "Debugger_RefreshThreads",
872 1,
873 param_types,
874 false,
875 )
876 });
877 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
878 match &*METHOD {
879 ::core::result::Result::Ok(mi) => *mi,
880 ::core::result::Result::Err(e) => {
881 panic!(
882 "method lookup failed: {}
883::{}
884: {}
885",
886 <Processor as ::unity::ClassIdentity>::NAME,
887 "Debugger_RefreshThreads",
888 e
889 )
890 },
891 }
892 }
893 }
894 #[doc(hidden)]
895 #[allow(non_snake_case)]
896 pub mod __lookup_debugger_refresh_v_stack {
897 use super::*;
898 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
899 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
900 ::unity::lookup::method_info_on_class_with_signature(
901 <Processor as ::unity::ClassIdentity>::class(),
902 "Debugger_RefreshVStack",
903 0,
904 param_types,
905 false,
906 )
907 });
908 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
909 match &*METHOD {
910 ::core::result::Result::Ok(mi) => *mi,
911 ::core::result::Result::Err(e) => {
912 panic!(
913 "method lookup failed: {}
914::{}
915: {}
916",
917 <Processor as ::unity::ClassIdentity>::NAME,
918 "Debugger_RefreshVStack",
919 e
920 )
921 },
922 }
923 }
924 }
925 #[doc(hidden)]
926 #[allow(non_snake_case)]
927 pub mod __lookup_debugger_refresh_watches {
928 use super::*;
929 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
930 let param_types: &[& 'static::unity::il2cpp::Il2CppType]= &[<crate::moon_sharp::interpreter::scriptexecutioncontext::ScriptExecutionContext as::unity::IlType> ::il_type(), <crate::system::collections::generic::list_1::List_1<crate::moon_sharp::interpreter::dynamicexpression::DynamicExpression>as::unity::IlType> ::il_type()];
931 ::unity::lookup::method_info_on_class_with_signature(
932 <Processor as ::unity::ClassIdentity>::class(),
933 "Debugger_RefreshWatches",
934 2,
935 param_types,
936 false,
937 )
938 });
939 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
940 match &*METHOD {
941 ::core::result::Result::Ok(mi) => *mi,
942 ::core::result::Result::Err(e) => {
943 panic!(
944 "method lookup failed: {}
945::{}
946: {}
947",
948 <Processor as ::unity::ClassIdentity>::NAME,
949 "Debugger_RefreshWatches",
950 e
951 )
952 },
953 }
954 }
955 }
956 #[doc(hidden)]
957 #[allow(non_snake_case)]
958 pub mod __lookup_debugger_refresh_locals {
959 use super::*;
960 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
961 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
962 &[<crate::moon_sharp::interpreter::scriptexecutioncontext::ScriptExecutionContext as ::unity::IlType>::il_type()];
963 ::unity::lookup::method_info_on_class_with_signature(
964 <Processor as ::unity::ClassIdentity>::class(),
965 "Debugger_RefreshLocals",
966 1,
967 param_types,
968 false,
969 )
970 });
971 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
972 match &*METHOD {
973 ::core::result::Result::Ok(mi) => *mi,
974 ::core::result::Result::Err(e) => {
975 panic!(
976 "method lookup failed: {}
977::{}
978: {}
979",
980 <Processor as ::unity::ClassIdentity>::NAME,
981 "Debugger_RefreshLocals",
982 e
983 )
984 },
985 }
986 }
987 }
988 #[doc(hidden)]
989 #[allow(non_snake_case)]
990 pub mod __lookup_debugger_refresh_watch {
991 use super::*;
992 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
993 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
994 <crate::moon_sharp::interpreter::scriptexecutioncontext::ScriptExecutionContext as ::unity::IlType>::il_type(),
995 <crate::moon_sharp::interpreter::dynamicexpression::DynamicExpression as ::unity::IlType>::il_type(),
996 ];
997 ::unity::lookup::method_info_on_class_with_signature(
998 <Processor as ::unity::ClassIdentity>::class(),
999 "Debugger_RefreshWatch",
1000 2,
1001 param_types,
1002 false,
1003 )
1004 });
1005 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1006 match &*METHOD {
1007 ::core::result::Result::Ok(mi) => *mi,
1008 ::core::result::Result::Err(e) => {
1009 panic!(
1010 "method lookup failed: {}
1011::{}
1012: {}
1013",
1014 <Processor as ::unity::ClassIdentity>::NAME,
1015 "Debugger_RefreshWatch",
1016 e
1017 )
1018 },
1019 }
1020 }
1021 }
1022 #[doc(hidden)]
1023 #[allow(non_snake_case)]
1024 pub mod __lookup_debugger_get_call_stack {
1025 use super::*;
1026 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1027 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
1028 &[<crate::moon_sharp::interpreter::debugging::sourceref::SourceRef as ::unity::IlType>::il_type()];
1029 ::unity::lookup::method_info_on_class_with_signature(
1030 <Processor as ::unity::ClassIdentity>::class(),
1031 "Debugger_GetCallStack",
1032 1,
1033 param_types,
1034 false,
1035 )
1036 });
1037 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1038 match &*METHOD {
1039 ::core::result::Result::Ok(mi) => *mi,
1040 ::core::result::Result::Err(e) => {
1041 panic!(
1042 "method lookup failed: {}
1043::{}
1044: {}
1045",
1046 <Processor as ::unity::ClassIdentity>::NAME,
1047 "Debugger_GetCallStack",
1048 e
1049 )
1050 },
1051 }
1052 }
1053 }
1054 #[doc(hidden)]
1055 #[allow(non_snake_case)]
1056 pub mod __lookup_get_current_source_ref {
1057 use super::*;
1058 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1059 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<i32 as ::unity::IlType>::il_type()];
1060 ::unity::lookup::method_info_on_class_with_signature(
1061 <Processor as ::unity::ClassIdentity>::class(),
1062 "GetCurrentSourceRef",
1063 1,
1064 param_types,
1065 false,
1066 )
1067 });
1068 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1069 match &*METHOD {
1070 ::core::result::Result::Ok(mi) => *mi,
1071 ::core::result::Result::Err(e) => {
1072 panic!(
1073 "method lookup failed: {}
1074::{}
1075: {}
1076",
1077 <Processor as ::unity::ClassIdentity>::NAME,
1078 "GetCurrentSourceRef",
1079 e
1080 )
1081 },
1082 }
1083 }
1084 }
1085 #[doc(hidden)]
1086 #[allow(non_snake_case)]
1087 pub mod __lookup_fill_debug_data {
1088 use super::*;
1089 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1090 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
1091 <crate::moon_sharp::interpreter::interpreterexception::InterpreterException as ::unity::IlType>::il_type(),
1092 <i32 as ::unity::IlType>::il_type(),
1093 ];
1094 ::unity::lookup::method_info_on_class_with_signature(
1095 <Processor as ::unity::ClassIdentity>::class(),
1096 "FillDebugData",
1097 2,
1098 param_types,
1099 false,
1100 )
1101 });
1102 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1103 match &*METHOD {
1104 ::core::result::Result::Ok(mi) => *mi,
1105 ::core::result::Result::Err(e) => {
1106 panic!(
1107 "method lookup failed: {}
1108::{}
1109: {}
1110",
1111 <Processor as ::unity::ClassIdentity>::NAME,
1112 "FillDebugData",
1113 e
1114 )
1115 },
1116 }
1117 }
1118 }
1119 #[doc(hidden)]
1120 #[allow(non_snake_case)]
1121 pub mod __lookup_get_metatable {
1122 use super::*;
1123 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1124 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
1125 &[<crate::moon_sharp::interpreter::dynvalue::DynValue as ::unity::IlType>::il_type()];
1126 ::unity::lookup::method_info_on_class_with_signature(
1127 <Processor as ::unity::ClassIdentity>::class(),
1128 "GetMetatable",
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 <Processor as ::unity::ClassIdentity>::NAME,
1144 "GetMetatable",
1145 e
1146 )
1147 },
1148 }
1149 }
1150 }
1151 #[doc(hidden)]
1152 #[allow(non_snake_case)]
1153 pub mod __lookup_get_binary_metamethod {
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 <crate::moon_sharp::interpreter::dynvalue::DynValue as ::unity::IlType>::il_type(),
1159 <::unity::Il2CppString as ::unity::IlType>::il_type(),
1160 ];
1161 ::unity::lookup::method_info_on_class_with_signature(
1162 <Processor as ::unity::ClassIdentity>::class(),
1163 "GetBinaryMetamethod",
1164 3,
1165 param_types,
1166 false,
1167 )
1168 });
1169 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1170 match &*METHOD {
1171 ::core::result::Result::Ok(mi) => *mi,
1172 ::core::result::Result::Err(e) => {
1173 panic!(
1174 "method lookup failed: {}
1175::{}
1176: {}
1177",
1178 <Processor as ::unity::ClassIdentity>::NAME,
1179 "GetBinaryMetamethod",
1180 e
1181 )
1182 },
1183 }
1184 }
1185 }
1186 #[doc(hidden)]
1187 #[allow(non_snake_case)]
1188 pub mod __lookup_get_metamethod {
1189 use super::*;
1190 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1191 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
1192 <crate::moon_sharp::interpreter::dynvalue::DynValue as ::unity::IlType>::il_type(),
1193 <::unity::Il2CppString as ::unity::IlType>::il_type(),
1194 ];
1195 ::unity::lookup::method_info_on_class_with_signature(
1196 <Processor as ::unity::ClassIdentity>::class(),
1197 "GetMetamethod",
1198 2,
1199 param_types,
1200 false,
1201 )
1202 });
1203 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1204 match &*METHOD {
1205 ::core::result::Result::Ok(mi) => *mi,
1206 ::core::result::Result::Err(e) => {
1207 panic!(
1208 "method lookup failed: {}
1209::{}
1210: {}
1211",
1212 <Processor as ::unity::ClassIdentity>::NAME,
1213 "GetMetamethod",
1214 e
1215 )
1216 },
1217 }
1218 }
1219 }
1220 #[doc(hidden)]
1221 #[allow(non_snake_case)]
1222 pub mod __lookup_get_metamethod_raw {
1223 use super::*;
1224 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1225 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
1226 <crate::moon_sharp::interpreter::dynvalue::DynValue as ::unity::IlType>::il_type(),
1227 <::unity::Il2CppString as ::unity::IlType>::il_type(),
1228 ];
1229 ::unity::lookup::method_info_on_class_with_signature(
1230 <Processor as ::unity::ClassIdentity>::class(),
1231 "GetMetamethodRaw",
1232 2,
1233 param_types,
1234 false,
1235 )
1236 });
1237 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1238 match &*METHOD {
1239 ::core::result::Result::Ok(mi) => *mi,
1240 ::core::result::Result::Err(e) => {
1241 panic!(
1242 "method lookup failed: {}
1243::{}
1244: {}
1245",
1246 <Processor as ::unity::ClassIdentity>::NAME,
1247 "GetMetamethodRaw",
1248 e
1249 )
1250 },
1251 }
1252 }
1253 }
1254 #[doc(hidden)]
1255 #[allow(non_snake_case)]
1256 pub mod __lookup_get_script {
1257 use super::*;
1258 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1259 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
1260 ::unity::lookup::method_info_on_class_with_signature(<Processor as ::unity::ClassIdentity>::class(), "GetScript", 0, param_types, false)
1261 });
1262 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1263 match &*METHOD {
1264 ::core::result::Result::Ok(mi) => *mi,
1265 ::core::result::Result::Err(e) => {
1266 panic!(
1267 "method lookup failed: {}
1268::{}
1269: {}
1270",
1271 <Processor as ::unity::ClassIdentity>::NAME,
1272 "GetScript",
1273 e
1274 )
1275 },
1276 }
1277 }
1278 }
1279 #[doc(hidden)]
1280 #[allow(non_snake_case)]
1281 pub mod __lookup_get_instruction {
1282 use super::*;
1283 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1284 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<i32 as ::unity::IlType>::il_type()];
1285 ::unity::lookup::method_info_on_class_with_signature(
1286 <Processor as ::unity::ClassIdentity>::class(),
1287 "GetInstruction",
1288 1,
1289 param_types,
1290 false,
1291 )
1292 });
1293 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1294 match &*METHOD {
1295 ::core::result::Result::Ok(mi) => *mi,
1296 ::core::result::Result::Err(e) => {
1297 panic!(
1298 "method lookup failed: {}
1299::{}
1300: {}
1301",
1302 <Processor as ::unity::ClassIdentity>::NAME,
1303 "GetInstruction",
1304 e
1305 )
1306 },
1307 }
1308 }
1309 }
1310 #[doc(hidden)]
1311 #[allow(non_snake_case)]
1312 pub mod __lookup_processing_loop {
1313 use super::*;
1314 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1315 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<i32 as ::unity::IlType>::il_type()];
1316 ::unity::lookup::method_info_on_class_with_signature(
1317 <Processor as ::unity::ClassIdentity>::class(),
1318 "Processing_Loop",
1319 1,
1320 param_types,
1321 false,
1322 )
1323 });
1324 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1325 match &*METHOD {
1326 ::core::result::Result::Ok(mi) => *mi,
1327 ::core::result::Result::Err(e) => {
1328 panic!(
1329 "method lookup failed: {}
1330::{}
1331: {}
1332",
1333 <Processor as ::unity::ClassIdentity>::NAME,
1334 "Processing_Loop",
1335 e
1336 )
1337 },
1338 }
1339 }
1340 }
1341 #[doc(hidden)]
1342 #[allow(non_snake_case)]
1343 pub mod __lookup_perform_message_decoration_before_unwind {
1344 use super::*;
1345 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1346 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
1347 <crate::moon_sharp::interpreter::dynvalue::DynValue as ::unity::IlType>::il_type(),
1348 <::unity::Il2CppString as ::unity::IlType>::il_type(),
1349 <crate::moon_sharp::interpreter::debugging::sourceref::SourceRef as ::unity::IlType>::il_type(),
1350 ];
1351 ::unity::lookup::method_info_on_class_with_signature(
1352 <Processor as ::unity::ClassIdentity>::class(),
1353 "PerformMessageDecorationBeforeUnwind",
1354 3,
1355 param_types,
1356 false,
1357 )
1358 });
1359 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1360 match &*METHOD {
1361 ::core::result::Result::Ok(mi) => *mi,
1362 ::core::result::Result::Err(e) => {
1363 panic!(
1364 "method lookup failed: {}
1365::{}
1366: {}
1367",
1368 <Processor as ::unity::ClassIdentity>::NAME,
1369 "PerformMessageDecorationBeforeUnwind",
1370 e
1371 )
1372 },
1373 }
1374 }
1375 }
1376 #[doc(hidden)]
1377 #[allow(non_snake_case)]
1378 pub mod __lookup_assign_local {
1379 use super::*;
1380 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1381 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
1382 <crate::moon_sharp::interpreter::symbolref::SymbolRef as ::unity::IlType>::il_type(),
1383 <crate::moon_sharp::interpreter::dynvalue::DynValue as ::unity::IlType>::il_type(),
1384 ];
1385 ::unity::lookup::method_info_on_class_with_signature(<Processor as ::unity::ClassIdentity>::class(), "AssignLocal", 2, param_types, false)
1386 });
1387 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1388 match &*METHOD {
1389 ::core::result::Result::Ok(mi) => *mi,
1390 ::core::result::Result::Err(e) => {
1391 panic!(
1392 "method lookup failed: {}
1393::{}
1394: {}
1395",
1396 <Processor as ::unity::ClassIdentity>::NAME,
1397 "AssignLocal",
1398 e
1399 )
1400 },
1401 }
1402 }
1403 }
1404 #[doc(hidden)]
1405 #[allow(non_snake_case)]
1406 pub mod __lookup_exec_store_lcl {
1407 use super::*;
1408 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1409 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
1410 &[<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction as ::unity::IlType>::il_type()];
1411 ::unity::lookup::method_info_on_class_with_signature(
1412 <Processor as ::unity::ClassIdentity>::class(),
1413 "ExecStoreLcl",
1414 1,
1415 param_types,
1416 false,
1417 )
1418 });
1419 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1420 match &*METHOD {
1421 ::core::result::Result::Ok(mi) => *mi,
1422 ::core::result::Result::Err(e) => {
1423 panic!(
1424 "method lookup failed: {}
1425::{}
1426: {}
1427",
1428 <Processor as ::unity::ClassIdentity>::NAME,
1429 "ExecStoreLcl",
1430 e
1431 )
1432 },
1433 }
1434 }
1435 }
1436 #[doc(hidden)]
1437 #[allow(non_snake_case)]
1438 pub mod __lookup_exec_store_upv {
1439 use super::*;
1440 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1441 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
1442 &[<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction as ::unity::IlType>::il_type()];
1443 ::unity::lookup::method_info_on_class_with_signature(
1444 <Processor as ::unity::ClassIdentity>::class(),
1445 "ExecStoreUpv",
1446 1,
1447 param_types,
1448 false,
1449 )
1450 });
1451 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1452 match &*METHOD {
1453 ::core::result::Result::Ok(mi) => *mi,
1454 ::core::result::Result::Err(e) => {
1455 panic!(
1456 "method lookup failed: {}
1457::{}
1458: {}
1459",
1460 <Processor as ::unity::ClassIdentity>::NAME,
1461 "ExecStoreUpv",
1462 e
1463 )
1464 },
1465 }
1466 }
1467 }
1468 #[doc(hidden)]
1469 #[allow(non_snake_case)]
1470 pub mod __lookup_exec_swap {
1471 use super::*;
1472 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1473 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
1474 &[<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction as ::unity::IlType>::il_type()];
1475 ::unity::lookup::method_info_on_class_with_signature(<Processor as ::unity::ClassIdentity>::class(), "ExecSwap", 1, param_types, false)
1476 });
1477 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1478 match &*METHOD {
1479 ::core::result::Result::Ok(mi) => *mi,
1480 ::core::result::Result::Err(e) => {
1481 panic!(
1482 "method lookup failed: {}
1483::{}
1484: {}
1485",
1486 <Processor as ::unity::ClassIdentity>::NAME,
1487 "ExecSwap",
1488 e
1489 )
1490 },
1491 }
1492 }
1493 }
1494 #[doc(hidden)]
1495 #[allow(non_snake_case)]
1496 pub mod __lookup_get_store_value {
1497 use super::*;
1498 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1499 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
1500 &[<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction as ::unity::IlType>::il_type()];
1501 ::unity::lookup::method_info_on_class_with_signature(
1502 <Processor as ::unity::ClassIdentity>::class(),
1503 "GetStoreValue",
1504 1,
1505 param_types,
1506 false,
1507 )
1508 });
1509 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1510 match &*METHOD {
1511 ::core::result::Result::Ok(mi) => *mi,
1512 ::core::result::Result::Err(e) => {
1513 panic!(
1514 "method lookup failed: {}
1515::{}
1516: {}
1517",
1518 <Processor as ::unity::ClassIdentity>::NAME,
1519 "GetStoreValue",
1520 e
1521 )
1522 },
1523 }
1524 }
1525 }
1526 #[doc(hidden)]
1527 #[allow(non_snake_case)]
1528 pub mod __lookup_exec_closure {
1529 use super::*;
1530 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1531 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
1532 &[<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction as ::unity::IlType>::il_type()];
1533 ::unity::lookup::method_info_on_class_with_signature(<Processor as ::unity::ClassIdentity>::class(), "ExecClosure", 1, param_types, false)
1534 });
1535 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1536 match &*METHOD {
1537 ::core::result::Result::Ok(mi) => *mi,
1538 ::core::result::Result::Err(e) => {
1539 panic!(
1540 "method lookup failed: {}
1541::{}
1542: {}
1543",
1544 <Processor as ::unity::ClassIdentity>::NAME,
1545 "ExecClosure",
1546 e
1547 )
1548 },
1549 }
1550 }
1551 }
1552 #[doc(hidden)]
1553 #[allow(non_snake_case)]
1554 pub mod __lookup_get_upvalue_symbol {
1555 use super::*;
1556 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1557 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
1558 &[<crate::moon_sharp::interpreter::symbolref::SymbolRef as ::unity::IlType>::il_type()];
1559 ::unity::lookup::method_info_on_class_with_signature(
1560 <Processor as ::unity::ClassIdentity>::class(),
1561 "GetUpvalueSymbol",
1562 1,
1563 param_types,
1564 false,
1565 )
1566 });
1567 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1568 match &*METHOD {
1569 ::core::result::Result::Ok(mi) => *mi,
1570 ::core::result::Result::Err(e) => {
1571 panic!(
1572 "method lookup failed: {}
1573::{}
1574: {}
1575",
1576 <Processor as ::unity::ClassIdentity>::NAME,
1577 "GetUpvalueSymbol",
1578 e
1579 )
1580 },
1581 }
1582 }
1583 }
1584 #[doc(hidden)]
1585 #[allow(non_snake_case)]
1586 pub mod __lookup_exec_mk_tuple {
1587 use super::*;
1588 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1589 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
1590 &[<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction as ::unity::IlType>::il_type()];
1591 ::unity::lookup::method_info_on_class_with_signature(<Processor as ::unity::ClassIdentity>::class(), "ExecMkTuple", 1, param_types, false)
1592 });
1593 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1594 match &*METHOD {
1595 ::core::result::Result::Ok(mi) => *mi,
1596 ::core::result::Result::Err(e) => {
1597 panic!(
1598 "method lookup failed: {}
1599::{}
1600: {}
1601",
1602 <Processor as ::unity::ClassIdentity>::NAME,
1603 "ExecMkTuple",
1604 e
1605 )
1606 },
1607 }
1608 }
1609 }
1610 #[doc(hidden)]
1611 #[allow(non_snake_case)]
1612 pub mod __lookup_exec_to_num {
1613 use super::*;
1614 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1615 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
1616 &[<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction as ::unity::IlType>::il_type()];
1617 ::unity::lookup::method_info_on_class_with_signature(<Processor as ::unity::ClassIdentity>::class(), "ExecToNum", 1, param_types, false)
1618 });
1619 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1620 match &*METHOD {
1621 ::core::result::Result::Ok(mi) => *mi,
1622 ::core::result::Result::Err(e) => {
1623 panic!(
1624 "method lookup failed: {}
1625::{}
1626: {}
1627",
1628 <Processor as ::unity::ClassIdentity>::NAME,
1629 "ExecToNum",
1630 e
1631 )
1632 },
1633 }
1634 }
1635 }
1636 #[doc(hidden)]
1637 #[allow(non_snake_case)]
1638 pub mod __lookup_exec_iter_upd {
1639 use super::*;
1640 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1641 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
1642 &[<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction as ::unity::IlType>::il_type()];
1643 ::unity::lookup::method_info_on_class_with_signature(<Processor as ::unity::ClassIdentity>::class(), "ExecIterUpd", 1, param_types, false)
1644 });
1645 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1646 match &*METHOD {
1647 ::core::result::Result::Ok(mi) => *mi,
1648 ::core::result::Result::Err(e) => {
1649 panic!(
1650 "method lookup failed: {}
1651::{}
1652: {}
1653",
1654 <Processor as ::unity::ClassIdentity>::NAME,
1655 "ExecIterUpd",
1656 e
1657 )
1658 },
1659 }
1660 }
1661 }
1662 #[doc(hidden)]
1663 #[allow(non_snake_case)]
1664 pub mod __lookup_exec_exp_tuple {
1665 use super::*;
1666 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1667 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
1668 &[<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction as ::unity::IlType>::il_type()];
1669 ::unity::lookup::method_info_on_class_with_signature(
1670 <Processor as ::unity::ClassIdentity>::class(),
1671 "ExecExpTuple",
1672 1,
1673 param_types,
1674 false,
1675 )
1676 });
1677 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1678 match &*METHOD {
1679 ::core::result::Result::Ok(mi) => *mi,
1680 ::core::result::Result::Err(e) => {
1681 panic!(
1682 "method lookup failed: {}
1683::{}
1684: {}
1685",
1686 <Processor as ::unity::ClassIdentity>::NAME,
1687 "ExecExpTuple",
1688 e
1689 )
1690 },
1691 }
1692 }
1693 }
1694 #[doc(hidden)]
1695 #[allow(non_snake_case)]
1696 pub mod __lookup_exec_iter_prep {
1697 use super::*;
1698 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1699 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
1700 &[<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction as ::unity::IlType>::il_type()];
1701 ::unity::lookup::method_info_on_class_with_signature(
1702 <Processor as ::unity::ClassIdentity>::class(),
1703 "ExecIterPrep",
1704 1,
1705 param_types,
1706 false,
1707 )
1708 });
1709 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1710 match &*METHOD {
1711 ::core::result::Result::Ok(mi) => *mi,
1712 ::core::result::Result::Err(e) => {
1713 panic!(
1714 "method lookup failed: {}
1715::{}
1716: {}
1717",
1718 <Processor as ::unity::ClassIdentity>::NAME,
1719 "ExecIterPrep",
1720 e
1721 )
1722 },
1723 }
1724 }
1725 }
1726 #[doc(hidden)]
1727 #[allow(non_snake_case)]
1728 pub mod __lookup_exec_j_for {
1729 use super::*;
1730 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1731 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
1732 <crate::moon_sharp::interpreter::execution::vm::instruction::Instruction as ::unity::IlType>::il_type(),
1733 <i32 as ::unity::IlType>::il_type(),
1734 ];
1735 ::unity::lookup::method_info_on_class_with_signature(<Processor as ::unity::ClassIdentity>::class(), "ExecJFor", 2, param_types, false)
1736 });
1737 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1738 match &*METHOD {
1739 ::core::result::Result::Ok(mi) => *mi,
1740 ::core::result::Result::Err(e) => {
1741 panic!(
1742 "method lookup failed: {}
1743::{}
1744: {}
1745",
1746 <Processor as ::unity::ClassIdentity>::NAME,
1747 "ExecJFor",
1748 e
1749 )
1750 },
1751 }
1752 }
1753 }
1754 #[doc(hidden)]
1755 #[allow(non_snake_case)]
1756 pub mod __lookup_exec_incr {
1757 use super::*;
1758 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1759 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
1760 &[<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction as ::unity::IlType>::il_type()];
1761 ::unity::lookup::method_info_on_class_with_signature(<Processor as ::unity::ClassIdentity>::class(), "ExecIncr", 1, param_types, false)
1762 });
1763 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1764 match &*METHOD {
1765 ::core::result::Result::Ok(mi) => *mi,
1766 ::core::result::Result::Err(e) => {
1767 panic!(
1768 "method lookup failed: {}
1769::{}
1770: {}
1771",
1772 <Processor as ::unity::ClassIdentity>::NAME,
1773 "ExecIncr",
1774 e
1775 )
1776 },
1777 }
1778 }
1779 }
1780 #[doc(hidden)]
1781 #[allow(non_snake_case)]
1782 pub mod __lookup_exec_c_not {
1783 use super::*;
1784 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1785 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
1786 &[<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction as ::unity::IlType>::il_type()];
1787 ::unity::lookup::method_info_on_class_with_signature(<Processor as ::unity::ClassIdentity>::class(), "ExecCNot", 1, param_types, false)
1788 });
1789 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1790 match &*METHOD {
1791 ::core::result::Result::Ok(mi) => *mi,
1792 ::core::result::Result::Err(e) => {
1793 panic!(
1794 "method lookup failed: {}
1795::{}
1796: {}
1797",
1798 <Processor as ::unity::ClassIdentity>::NAME,
1799 "ExecCNot",
1800 e
1801 )
1802 },
1803 }
1804 }
1805 }
1806 #[doc(hidden)]
1807 #[allow(non_snake_case)]
1808 pub mod __lookup_exec_not {
1809 use super::*;
1810 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1811 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
1812 &[<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction as ::unity::IlType>::il_type()];
1813 ::unity::lookup::method_info_on_class_with_signature(<Processor as ::unity::ClassIdentity>::class(), "ExecNot", 1, param_types, false)
1814 });
1815 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1816 match &*METHOD {
1817 ::core::result::Result::Ok(mi) => *mi,
1818 ::core::result::Result::Err(e) => {
1819 panic!(
1820 "method lookup failed: {}
1821::{}
1822: {}
1823",
1824 <Processor as ::unity::ClassIdentity>::NAME,
1825 "ExecNot",
1826 e
1827 )
1828 },
1829 }
1830 }
1831 }
1832 #[doc(hidden)]
1833 #[allow(non_snake_case)]
1834 pub mod __lookup_exec_begin_fn {
1835 use super::*;
1836 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1837 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
1838 &[<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction as ::unity::IlType>::il_type()];
1839 ::unity::lookup::method_info_on_class_with_signature(<Processor as ::unity::ClassIdentity>::class(), "ExecBeginFn", 1, param_types, false)
1840 });
1841 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1842 match &*METHOD {
1843 ::core::result::Result::Ok(mi) => *mi,
1844 ::core::result::Result::Err(e) => {
1845 panic!(
1846 "method lookup failed: {}
1847::{}
1848: {}
1849",
1850 <Processor as ::unity::ClassIdentity>::NAME,
1851 "ExecBeginFn",
1852 e
1853 )
1854 },
1855 }
1856 }
1857 }
1858 #[doc(hidden)]
1859 #[allow(non_snake_case)]
1860 pub mod __lookup_pop_to_base_pointer {
1861 use super::*;
1862 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1863 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
1864 ::unity::lookup::method_info_on_class_with_signature(
1865 <Processor as ::unity::ClassIdentity>::class(),
1866 "PopToBasePointer",
1867 0,
1868 param_types,
1869 false,
1870 )
1871 });
1872 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1873 match &*METHOD {
1874 ::core::result::Result::Ok(mi) => *mi,
1875 ::core::result::Result::Err(e) => {
1876 panic!(
1877 "method lookup failed: {}
1878::{}
1879: {}
1880",
1881 <Processor as ::unity::ClassIdentity>::NAME,
1882 "PopToBasePointer",
1883 e
1884 )
1885 },
1886 }
1887 }
1888 }
1889 #[doc(hidden)]
1890 #[allow(non_snake_case)]
1891 pub mod __lookup_pop_exec_stack_and_check_v_stack {
1892 use super::*;
1893 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1894 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<i32 as ::unity::IlType>::il_type()];
1895 ::unity::lookup::method_info_on_class_with_signature(
1896 <Processor as ::unity::ClassIdentity>::class(),
1897 "PopExecStackAndCheckVStack",
1898 1,
1899 param_types,
1900 false,
1901 )
1902 });
1903 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1904 match &*METHOD {
1905 ::core::result::Result::Ok(mi) => *mi,
1906 ::core::result::Result::Err(e) => {
1907 panic!(
1908 "method lookup failed: {}
1909::{}
1910: {}
1911",
1912 <Processor as ::unity::ClassIdentity>::NAME,
1913 "PopExecStackAndCheckVStack",
1914 e
1915 )
1916 },
1917 }
1918 }
1919 }
1920 #[doc(hidden)]
1921 #[allow(non_snake_case)]
1922 pub mod __lookup_create_args_list_for_function_call {
1923 use super::*;
1924 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1925 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<i32 as ::unity::IlType>::il_type(), <i32 as ::unity::IlType>::il_type()];
1926 ::unity::lookup::method_info_on_class_with_signature(
1927 <Processor as ::unity::ClassIdentity>::class(),
1928 "CreateArgsListForFunctionCall",
1929 2,
1930 param_types,
1931 false,
1932 )
1933 });
1934 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1935 match &*METHOD {
1936 ::core::result::Result::Ok(mi) => *mi,
1937 ::core::result::Result::Err(e) => {
1938 panic!(
1939 "method lookup failed: {}
1940::{}
1941: {}
1942",
1943 <Processor as ::unity::ClassIdentity>::NAME,
1944 "CreateArgsListForFunctionCall",
1945 e
1946 )
1947 },
1948 }
1949 }
1950 }
1951 #[doc(hidden)]
1952 #[allow(non_snake_case)]
1953 pub mod __lookup_exec_args {
1954 use super::*;
1955 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1956 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
1957 &[<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction as ::unity::IlType>::il_type()];
1958 ::unity::lookup::method_info_on_class_with_signature(<Processor as ::unity::ClassIdentity>::class(), "ExecArgs", 1, param_types, false)
1959 });
1960 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1961 match &*METHOD {
1962 ::core::result::Result::Ok(mi) => *mi,
1963 ::core::result::Result::Err(e) => {
1964 panic!(
1965 "method lookup failed: {}
1966::{}
1967: {}
1968",
1969 <Processor as ::unity::ClassIdentity>::NAME,
1970 "ExecArgs",
1971 e
1972 )
1973 },
1974 }
1975 }
1976 }
1977 #[doc(hidden)]
1978 #[allow(non_snake_case)]
1979 pub mod __lookup_internal_exec_call {
1980 use super::*;
1981 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1982 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
1983 <i32 as ::unity::IlType>::il_type(),
1984 <i32 as ::unity::IlType>::il_type(),
1985 <crate::moon_sharp::interpreter::callbackfunction::CallbackFunction as ::unity::IlType>::il_type(),
1986 <crate::moon_sharp::interpreter::callbackfunction::CallbackFunction as ::unity::IlType>::il_type(),
1987 <bool as ::unity::IlType>::il_type(),
1988 <::unity::Il2CppString as ::unity::IlType>::il_type(),
1989 <crate::moon_sharp::interpreter::dynvalue::DynValue as ::unity::IlType>::il_type(),
1990 ];
1991 ::unity::lookup::method_info_on_class_with_signature(
1992 <Processor as ::unity::ClassIdentity>::class(),
1993 "Internal_ExecCall",
1994 7,
1995 param_types,
1996 false,
1997 )
1998 });
1999 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2000 match &*METHOD {
2001 ::core::result::Result::Ok(mi) => *mi,
2002 ::core::result::Result::Err(e) => {
2003 panic!(
2004 "method lookup failed: {}
2005::{}
2006: {}
2007",
2008 <Processor as ::unity::ClassIdentity>::NAME,
2009 "Internal_ExecCall",
2010 e
2011 )
2012 },
2013 }
2014 }
2015 }
2016 #[doc(hidden)]
2017 #[allow(non_snake_case)]
2018 pub mod __lookup_perform_tco {
2019 use super::*;
2020 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2021 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<i32 as ::unity::IlType>::il_type(), <i32 as ::unity::IlType>::il_type()];
2022 ::unity::lookup::method_info_on_class_with_signature(<Processor as ::unity::ClassIdentity>::class(), "PerformTCO", 2, param_types, false)
2023 });
2024 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2025 match &*METHOD {
2026 ::core::result::Result::Ok(mi) => *mi,
2027 ::core::result::Result::Err(e) => {
2028 panic!(
2029 "method lookup failed: {}
2030::{}
2031: {}
2032",
2033 <Processor as ::unity::ClassIdentity>::NAME,
2034 "PerformTCO",
2035 e
2036 )
2037 },
2038 }
2039 }
2040 }
2041 #[doc(hidden)]
2042 #[allow(non_snake_case)]
2043 pub mod __lookup_exec_ret {
2044 use super::*;
2045 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2046 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
2047 &[<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction as ::unity::IlType>::il_type()];
2048 ::unity::lookup::method_info_on_class_with_signature(<Processor as ::unity::ClassIdentity>::class(), "ExecRet", 1, param_types, false)
2049 });
2050 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2051 match &*METHOD {
2052 ::core::result::Result::Ok(mi) => *mi,
2053 ::core::result::Result::Err(e) => {
2054 panic!(
2055 "method lookup failed: {}
2056::{}
2057: {}
2058",
2059 <Processor as ::unity::ClassIdentity>::NAME,
2060 "ExecRet",
2061 e
2062 )
2063 },
2064 }
2065 }
2066 }
2067 #[doc(hidden)]
2068 #[allow(non_snake_case)]
2069 pub mod __lookup_internal_check_for_tail_requests {
2070 use super::*;
2071 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2072 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
2073 <crate::moon_sharp::interpreter::execution::vm::instruction::Instruction as ::unity::IlType>::il_type(),
2074 <i32 as ::unity::IlType>::il_type(),
2075 ];
2076 ::unity::lookup::method_info_on_class_with_signature(
2077 <Processor as ::unity::ClassIdentity>::class(),
2078 "Internal_CheckForTailRequests",
2079 2,
2080 param_types,
2081 false,
2082 )
2083 });
2084 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2085 match &*METHOD {
2086 ::core::result::Result::Ok(mi) => *mi,
2087 ::core::result::Result::Err(e) => {
2088 panic!(
2089 "method lookup failed: {}
2090::{}
2091: {}
2092",
2093 <Processor as ::unity::ClassIdentity>::NAME,
2094 "Internal_CheckForTailRequests",
2095 e
2096 )
2097 },
2098 }
2099 }
2100 }
2101 #[doc(hidden)]
2102 #[allow(non_snake_case)]
2103 pub mod __lookup_jump_bool {
2104 use super::*;
2105 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2106 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
2107 <crate::moon_sharp::interpreter::execution::vm::instruction::Instruction as ::unity::IlType>::il_type(),
2108 <bool as ::unity::IlType>::il_type(),
2109 <i32 as ::unity::IlType>::il_type(),
2110 ];
2111 ::unity::lookup::method_info_on_class_with_signature(<Processor as ::unity::ClassIdentity>::class(), "JumpBool", 3, param_types, false)
2112 });
2113 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2114 match &*METHOD {
2115 ::core::result::Result::Ok(mi) => *mi,
2116 ::core::result::Result::Err(e) => {
2117 panic!(
2118 "method lookup failed: {}
2119::{}
2120: {}
2121",
2122 <Processor as ::unity::ClassIdentity>::NAME,
2123 "JumpBool",
2124 e
2125 )
2126 },
2127 }
2128 }
2129 }
2130 #[doc(hidden)]
2131 #[allow(non_snake_case)]
2132 pub mod __lookup_exec_short_circuiting_operator {
2133 use super::*;
2134 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2135 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
2136 <crate::moon_sharp::interpreter::execution::vm::instruction::Instruction as ::unity::IlType>::il_type(),
2137 <i32 as ::unity::IlType>::il_type(),
2138 ];
2139 ::unity::lookup::method_info_on_class_with_signature(
2140 <Processor as ::unity::ClassIdentity>::class(),
2141 "ExecShortCircuitingOperator",
2142 2,
2143 param_types,
2144 false,
2145 )
2146 });
2147 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2148 match &*METHOD {
2149 ::core::result::Result::Ok(mi) => *mi,
2150 ::core::result::Result::Err(e) => {
2151 panic!(
2152 "method lookup failed: {}
2153::{}
2154: {}
2155",
2156 <Processor as ::unity::ClassIdentity>::NAME,
2157 "ExecShortCircuitingOperator",
2158 e
2159 )
2160 },
2161 }
2162 }
2163 }
2164 #[doc(hidden)]
2165 #[allow(non_snake_case)]
2166 pub mod __lookup_exec_add {
2167 use super::*;
2168 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2169 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
2170 <crate::moon_sharp::interpreter::execution::vm::instruction::Instruction as ::unity::IlType>::il_type(),
2171 <i32 as ::unity::IlType>::il_type(),
2172 ];
2173 ::unity::lookup::method_info_on_class_with_signature(<Processor as ::unity::ClassIdentity>::class(), "ExecAdd", 2, param_types, false)
2174 });
2175 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2176 match &*METHOD {
2177 ::core::result::Result::Ok(mi) => *mi,
2178 ::core::result::Result::Err(e) => {
2179 panic!(
2180 "method lookup failed: {}
2181::{}
2182: {}
2183",
2184 <Processor as ::unity::ClassIdentity>::NAME,
2185 "ExecAdd",
2186 e
2187 )
2188 },
2189 }
2190 }
2191 }
2192 #[doc(hidden)]
2193 #[allow(non_snake_case)]
2194 pub mod __lookup_exec_sub {
2195 use super::*;
2196 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2197 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
2198 <crate::moon_sharp::interpreter::execution::vm::instruction::Instruction as ::unity::IlType>::il_type(),
2199 <i32 as ::unity::IlType>::il_type(),
2200 ];
2201 ::unity::lookup::method_info_on_class_with_signature(<Processor as ::unity::ClassIdentity>::class(), "ExecSub", 2, param_types, false)
2202 });
2203 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2204 match &*METHOD {
2205 ::core::result::Result::Ok(mi) => *mi,
2206 ::core::result::Result::Err(e) => {
2207 panic!(
2208 "method lookup failed: {}
2209::{}
2210: {}
2211",
2212 <Processor as ::unity::ClassIdentity>::NAME,
2213 "ExecSub",
2214 e
2215 )
2216 },
2217 }
2218 }
2219 }
2220 #[doc(hidden)]
2221 #[allow(non_snake_case)]
2222 pub mod __lookup_exec_mul {
2223 use super::*;
2224 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2225 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
2226 <crate::moon_sharp::interpreter::execution::vm::instruction::Instruction as ::unity::IlType>::il_type(),
2227 <i32 as ::unity::IlType>::il_type(),
2228 ];
2229 ::unity::lookup::method_info_on_class_with_signature(<Processor as ::unity::ClassIdentity>::class(), "ExecMul", 2, param_types, false)
2230 });
2231 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2232 match &*METHOD {
2233 ::core::result::Result::Ok(mi) => *mi,
2234 ::core::result::Result::Err(e) => {
2235 panic!(
2236 "method lookup failed: {}
2237::{}
2238: {}
2239",
2240 <Processor as ::unity::ClassIdentity>::NAME,
2241 "ExecMul",
2242 e
2243 )
2244 },
2245 }
2246 }
2247 }
2248 #[doc(hidden)]
2249 #[allow(non_snake_case)]
2250 pub mod __lookup_exec_mod {
2251 use super::*;
2252 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2253 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
2254 <crate::moon_sharp::interpreter::execution::vm::instruction::Instruction as ::unity::IlType>::il_type(),
2255 <i32 as ::unity::IlType>::il_type(),
2256 ];
2257 ::unity::lookup::method_info_on_class_with_signature(<Processor as ::unity::ClassIdentity>::class(), "ExecMod", 2, param_types, false)
2258 });
2259 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2260 match &*METHOD {
2261 ::core::result::Result::Ok(mi) => *mi,
2262 ::core::result::Result::Err(e) => {
2263 panic!(
2264 "method lookup failed: {}
2265::{}
2266: {}
2267",
2268 <Processor as ::unity::ClassIdentity>::NAME,
2269 "ExecMod",
2270 e
2271 )
2272 },
2273 }
2274 }
2275 }
2276 #[doc(hidden)]
2277 #[allow(non_snake_case)]
2278 pub mod __lookup_exec_div {
2279 use super::*;
2280 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2281 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
2282 <crate::moon_sharp::interpreter::execution::vm::instruction::Instruction as ::unity::IlType>::il_type(),
2283 <i32 as ::unity::IlType>::il_type(),
2284 ];
2285 ::unity::lookup::method_info_on_class_with_signature(<Processor as ::unity::ClassIdentity>::class(), "ExecDiv", 2, param_types, false)
2286 });
2287 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2288 match &*METHOD {
2289 ::core::result::Result::Ok(mi) => *mi,
2290 ::core::result::Result::Err(e) => {
2291 panic!(
2292 "method lookup failed: {}
2293::{}
2294: {}
2295",
2296 <Processor as ::unity::ClassIdentity>::NAME,
2297 "ExecDiv",
2298 e
2299 )
2300 },
2301 }
2302 }
2303 }
2304 #[doc(hidden)]
2305 #[allow(non_snake_case)]
2306 pub mod __lookup_exec_power {
2307 use super::*;
2308 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2309 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
2310 <crate::moon_sharp::interpreter::execution::vm::instruction::Instruction as ::unity::IlType>::il_type(),
2311 <i32 as ::unity::IlType>::il_type(),
2312 ];
2313 ::unity::lookup::method_info_on_class_with_signature(<Processor as ::unity::ClassIdentity>::class(), "ExecPower", 2, param_types, false)
2314 });
2315 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2316 match &*METHOD {
2317 ::core::result::Result::Ok(mi) => *mi,
2318 ::core::result::Result::Err(e) => {
2319 panic!(
2320 "method lookup failed: {}
2321::{}
2322: {}
2323",
2324 <Processor as ::unity::ClassIdentity>::NAME,
2325 "ExecPower",
2326 e
2327 )
2328 },
2329 }
2330 }
2331 }
2332 #[doc(hidden)]
2333 #[allow(non_snake_case)]
2334 pub mod __lookup_exec_neg {
2335 use super::*;
2336 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2337 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
2338 <crate::moon_sharp::interpreter::execution::vm::instruction::Instruction as ::unity::IlType>::il_type(),
2339 <i32 as ::unity::IlType>::il_type(),
2340 ];
2341 ::unity::lookup::method_info_on_class_with_signature(<Processor as ::unity::ClassIdentity>::class(), "ExecNeg", 2, param_types, false)
2342 });
2343 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2344 match &*METHOD {
2345 ::core::result::Result::Ok(mi) => *mi,
2346 ::core::result::Result::Err(e) => {
2347 panic!(
2348 "method lookup failed: {}
2349::{}
2350: {}
2351",
2352 <Processor as ::unity::ClassIdentity>::NAME,
2353 "ExecNeg",
2354 e
2355 )
2356 },
2357 }
2358 }
2359 }
2360 #[doc(hidden)]
2361 #[allow(non_snake_case)]
2362 pub mod __lookup_exec_eq {
2363 use super::*;
2364 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2365 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
2366 <crate::moon_sharp::interpreter::execution::vm::instruction::Instruction as ::unity::IlType>::il_type(),
2367 <i32 as ::unity::IlType>::il_type(),
2368 ];
2369 ::unity::lookup::method_info_on_class_with_signature(<Processor as ::unity::ClassIdentity>::class(), "ExecEq", 2, param_types, false)
2370 });
2371 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2372 match &*METHOD {
2373 ::core::result::Result::Ok(mi) => *mi,
2374 ::core::result::Result::Err(e) => {
2375 panic!(
2376 "method lookup failed: {}
2377::{}
2378: {}
2379",
2380 <Processor as ::unity::ClassIdentity>::NAME,
2381 "ExecEq",
2382 e
2383 )
2384 },
2385 }
2386 }
2387 }
2388 #[doc(hidden)]
2389 #[allow(non_snake_case)]
2390 pub mod __lookup_exec_less {
2391 use super::*;
2392 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2393 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
2394 <crate::moon_sharp::interpreter::execution::vm::instruction::Instruction as ::unity::IlType>::il_type(),
2395 <i32 as ::unity::IlType>::il_type(),
2396 ];
2397 ::unity::lookup::method_info_on_class_with_signature(<Processor as ::unity::ClassIdentity>::class(), "ExecLess", 2, param_types, false)
2398 });
2399 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2400 match &*METHOD {
2401 ::core::result::Result::Ok(mi) => *mi,
2402 ::core::result::Result::Err(e) => {
2403 panic!(
2404 "method lookup failed: {}
2405::{}
2406: {}
2407",
2408 <Processor as ::unity::ClassIdentity>::NAME,
2409 "ExecLess",
2410 e
2411 )
2412 },
2413 }
2414 }
2415 }
2416 #[doc(hidden)]
2417 #[allow(non_snake_case)]
2418 pub mod __lookup_exec_less_eq {
2419 use super::*;
2420 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2421 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
2422 <crate::moon_sharp::interpreter::execution::vm::instruction::Instruction as ::unity::IlType>::il_type(),
2423 <i32 as ::unity::IlType>::il_type(),
2424 ];
2425 ::unity::lookup::method_info_on_class_with_signature(<Processor as ::unity::ClassIdentity>::class(), "ExecLessEq", 2, param_types, false)
2426 });
2427 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2428 match &*METHOD {
2429 ::core::result::Result::Ok(mi) => *mi,
2430 ::core::result::Result::Err(e) => {
2431 panic!(
2432 "method lookup failed: {}
2433::{}
2434: {}
2435",
2436 <Processor as ::unity::ClassIdentity>::NAME,
2437 "ExecLessEq",
2438 e
2439 )
2440 },
2441 }
2442 }
2443 }
2444 #[doc(hidden)]
2445 #[allow(non_snake_case)]
2446 pub mod __lookup_exec_len {
2447 use super::*;
2448 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2449 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
2450 <crate::moon_sharp::interpreter::execution::vm::instruction::Instruction as ::unity::IlType>::il_type(),
2451 <i32 as ::unity::IlType>::il_type(),
2452 ];
2453 ::unity::lookup::method_info_on_class_with_signature(<Processor as ::unity::ClassIdentity>::class(), "ExecLen", 2, param_types, false)
2454 });
2455 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2456 match &*METHOD {
2457 ::core::result::Result::Ok(mi) => *mi,
2458 ::core::result::Result::Err(e) => {
2459 panic!(
2460 "method lookup failed: {}
2461::{}
2462: {}
2463",
2464 <Processor as ::unity::ClassIdentity>::NAME,
2465 "ExecLen",
2466 e
2467 )
2468 },
2469 }
2470 }
2471 }
2472 #[doc(hidden)]
2473 #[allow(non_snake_case)]
2474 pub mod __lookup_exec_concat {
2475 use super::*;
2476 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2477 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
2478 <crate::moon_sharp::interpreter::execution::vm::instruction::Instruction as ::unity::IlType>::il_type(),
2479 <i32 as ::unity::IlType>::il_type(),
2480 ];
2481 ::unity::lookup::method_info_on_class_with_signature(<Processor as ::unity::ClassIdentity>::class(), "ExecConcat", 2, param_types, false)
2482 });
2483 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2484 match &*METHOD {
2485 ::core::result::Result::Ok(mi) => *mi,
2486 ::core::result::Result::Err(e) => {
2487 panic!(
2488 "method lookup failed: {}
2489::{}
2490: {}
2491",
2492 <Processor as ::unity::ClassIdentity>::NAME,
2493 "ExecConcat",
2494 e
2495 )
2496 },
2497 }
2498 }
2499 }
2500 #[doc(hidden)]
2501 #[allow(non_snake_case)]
2502 pub mod __lookup_exec_tbl_init_i {
2503 use super::*;
2504 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2505 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
2506 &[<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction as ::unity::IlType>::il_type()];
2507 ::unity::lookup::method_info_on_class_with_signature(
2508 <Processor as ::unity::ClassIdentity>::class(),
2509 "ExecTblInitI",
2510 1,
2511 param_types,
2512 false,
2513 )
2514 });
2515 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2516 match &*METHOD {
2517 ::core::result::Result::Ok(mi) => *mi,
2518 ::core::result::Result::Err(e) => {
2519 panic!(
2520 "method lookup failed: {}
2521::{}
2522: {}
2523",
2524 <Processor as ::unity::ClassIdentity>::NAME,
2525 "ExecTblInitI",
2526 e
2527 )
2528 },
2529 }
2530 }
2531 }
2532 #[doc(hidden)]
2533 #[allow(non_snake_case)]
2534 pub mod __lookup_exec_tbl_init_n {
2535 use super::*;
2536 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2537 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
2538 &[<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction as ::unity::IlType>::il_type()];
2539 ::unity::lookup::method_info_on_class_with_signature(
2540 <Processor as ::unity::ClassIdentity>::class(),
2541 "ExecTblInitN",
2542 1,
2543 param_types,
2544 false,
2545 )
2546 });
2547 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2548 match &*METHOD {
2549 ::core::result::Result::Ok(mi) => *mi,
2550 ::core::result::Result::Err(e) => {
2551 panic!(
2552 "method lookup failed: {}
2553::{}
2554: {}
2555",
2556 <Processor as ::unity::ClassIdentity>::NAME,
2557 "ExecTblInitN",
2558 e
2559 )
2560 },
2561 }
2562 }
2563 }
2564 #[doc(hidden)]
2565 #[allow(non_snake_case)]
2566 pub mod __lookup_exec_index_set {
2567 use super::*;
2568 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2569 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
2570 <crate::moon_sharp::interpreter::execution::vm::instruction::Instruction as ::unity::IlType>::il_type(),
2571 <i32 as ::unity::IlType>::il_type(),
2572 ];
2573 ::unity::lookup::method_info_on_class_with_signature(
2574 <Processor as ::unity::ClassIdentity>::class(),
2575 "ExecIndexSet",
2576 2,
2577 param_types,
2578 false,
2579 )
2580 });
2581 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2582 match &*METHOD {
2583 ::core::result::Result::Ok(mi) => *mi,
2584 ::core::result::Result::Err(e) => {
2585 panic!(
2586 "method lookup failed: {}
2587::{}
2588: {}
2589",
2590 <Processor as ::unity::ClassIdentity>::NAME,
2591 "ExecIndexSet",
2592 e
2593 )
2594 },
2595 }
2596 }
2597 }
2598 #[doc(hidden)]
2599 #[allow(non_snake_case)]
2600 pub mod __lookup_exec_index {
2601 use super::*;
2602 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2603 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
2604 <crate::moon_sharp::interpreter::execution::vm::instruction::Instruction as ::unity::IlType>::il_type(),
2605 <i32 as ::unity::IlType>::il_type(),
2606 ];
2607 ::unity::lookup::method_info_on_class_with_signature(<Processor as ::unity::ClassIdentity>::class(), "ExecIndex", 2, param_types, false)
2608 });
2609 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2610 match &*METHOD {
2611 ::core::result::Result::Ok(mi) => *mi,
2612 ::core::result::Result::Err(e) => {
2613 panic!(
2614 "method lookup failed: {}
2615::{}
2616: {}
2617",
2618 <Processor as ::unity::ClassIdentity>::NAME,
2619 "ExecIndex",
2620 e
2621 )
2622 },
2623 }
2624 }
2625 }
2626 #[doc(hidden)]
2627 #[allow(non_snake_case)]
2628 pub mod __lookup_clear_block_data {
2629 use super::*;
2630 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2631 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
2632 &[<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction as ::unity::IlType>::il_type()];
2633 ::unity::lookup::method_info_on_class_with_signature(
2634 <Processor as ::unity::ClassIdentity>::class(),
2635 "ClearBlockData",
2636 1,
2637 param_types,
2638 false,
2639 )
2640 });
2641 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2642 match &*METHOD {
2643 ::core::result::Result::Ok(mi) => *mi,
2644 ::core::result::Result::Err(e) => {
2645 panic!(
2646 "method lookup failed: {}
2647::{}
2648: {}
2649",
2650 <Processor as ::unity::ClassIdentity>::NAME,
2651 "ClearBlockData",
2652 e
2653 )
2654 },
2655 }
2656 }
2657 }
2658 #[doc(hidden)]
2659 #[allow(non_snake_case)]
2660 pub mod __lookup_get_generic_symbol {
2661 use super::*;
2662 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2663 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
2664 &[<crate::moon_sharp::interpreter::symbolref::SymbolRef as ::unity::IlType>::il_type()];
2665 ::unity::lookup::method_info_on_class_with_signature(
2666 <Processor as ::unity::ClassIdentity>::class(),
2667 "GetGenericSymbol",
2668 1,
2669 param_types,
2670 false,
2671 )
2672 });
2673 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2674 match &*METHOD {
2675 ::core::result::Result::Ok(mi) => *mi,
2676 ::core::result::Result::Err(e) => {
2677 panic!(
2678 "method lookup failed: {}
2679::{}
2680: {}
2681",
2682 <Processor as ::unity::ClassIdentity>::NAME,
2683 "GetGenericSymbol",
2684 e
2685 )
2686 },
2687 }
2688 }
2689 }
2690 #[doc(hidden)]
2691 #[allow(non_snake_case)]
2692 pub mod __lookup_get_global_symbol {
2693 use super::*;
2694 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2695 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
2696 <crate::moon_sharp::interpreter::dynvalue::DynValue as ::unity::IlType>::il_type(),
2697 <::unity::Il2CppString as ::unity::IlType>::il_type(),
2698 ];
2699 ::unity::lookup::method_info_on_class_with_signature(
2700 <Processor as ::unity::ClassIdentity>::class(),
2701 "GetGlobalSymbol",
2702 2,
2703 param_types,
2704 false,
2705 )
2706 });
2707 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2708 match &*METHOD {
2709 ::core::result::Result::Ok(mi) => *mi,
2710 ::core::result::Result::Err(e) => {
2711 panic!(
2712 "method lookup failed: {}
2713::{}
2714: {}
2715",
2716 <Processor as ::unity::ClassIdentity>::NAME,
2717 "GetGlobalSymbol",
2718 e
2719 )
2720 },
2721 }
2722 }
2723 }
2724 #[doc(hidden)]
2725 #[allow(non_snake_case)]
2726 pub mod __lookup_set_global_symbol {
2727 use super::*;
2728 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2729 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
2730 <crate::moon_sharp::interpreter::dynvalue::DynValue as ::unity::IlType>::il_type(),
2731 <::unity::Il2CppString as ::unity::IlType>::il_type(),
2732 <crate::moon_sharp::interpreter::dynvalue::DynValue as ::unity::IlType>::il_type(),
2733 ];
2734 ::unity::lookup::method_info_on_class_with_signature(
2735 <Processor as ::unity::ClassIdentity>::class(),
2736 "SetGlobalSymbol",
2737 3,
2738 param_types,
2739 false,
2740 )
2741 });
2742 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2743 match &*METHOD {
2744 ::core::result::Result::Ok(mi) => *mi,
2745 ::core::result::Result::Err(e) => {
2746 panic!(
2747 "method lookup failed: {}
2748::{}
2749: {}
2750",
2751 <Processor as ::unity::ClassIdentity>::NAME,
2752 "SetGlobalSymbol",
2753 e
2754 )
2755 },
2756 }
2757 }
2758 }
2759 #[doc(hidden)]
2760 #[allow(non_snake_case)]
2761 pub mod __lookup_assign_generic_symbol {
2762 use super::*;
2763 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2764 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
2765 <crate::moon_sharp::interpreter::symbolref::SymbolRef as ::unity::IlType>::il_type(),
2766 <crate::moon_sharp::interpreter::dynvalue::DynValue as ::unity::IlType>::il_type(),
2767 ];
2768 ::unity::lookup::method_info_on_class_with_signature(
2769 <Processor as ::unity::ClassIdentity>::class(),
2770 "AssignGenericSymbol",
2771 2,
2772 param_types,
2773 false,
2774 )
2775 });
2776 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2777 match &*METHOD {
2778 ::core::result::Result::Ok(mi) => *mi,
2779 ::core::result::Result::Err(e) => {
2780 panic!(
2781 "method lookup failed: {}
2782::{}
2783: {}
2784",
2785 <Processor as ::unity::ClassIdentity>::NAME,
2786 "AssignGenericSymbol",
2787 e
2788 )
2789 },
2790 }
2791 }
2792 }
2793 #[doc(hidden)]
2794 #[allow(non_snake_case)]
2795 pub mod __lookup_get_top_non_clr_function {
2796 use super::*;
2797 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2798 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
2799 ::unity::lookup::method_info_on_class_with_signature(
2800 <Processor as ::unity::ClassIdentity>::class(),
2801 "GetTopNonClrFunction",
2802 0,
2803 param_types,
2804 false,
2805 )
2806 });
2807 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2808 match &*METHOD {
2809 ::core::result::Result::Ok(mi) => *mi,
2810 ::core::result::Result::Err(e) => {
2811 panic!(
2812 "method lookup failed: {}
2813::{}
2814: {}
2815",
2816 <Processor as ::unity::ClassIdentity>::NAME,
2817 "GetTopNonClrFunction",
2818 e
2819 )
2820 },
2821 }
2822 }
2823 }
2824 #[doc(hidden)]
2825 #[allow(non_snake_case)]
2826 pub mod __lookup_find_symbol_by_name {
2827 use super::*;
2828 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2829 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<::unity::Il2CppString as ::unity::IlType>::il_type()];
2830 ::unity::lookup::method_info_on_class_with_signature(
2831 <Processor as ::unity::ClassIdentity>::class(),
2832 "FindSymbolByName",
2833 1,
2834 param_types,
2835 false,
2836 )
2837 });
2838 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2839 match &*METHOD {
2840 ::core::result::Result::Ok(mi) => *mi,
2841 ::core::result::Result::Err(e) => {
2842 panic!(
2843 "method lookup failed: {}
2844::{}
2845: {}
2846",
2847 <Processor as ::unity::ClassIdentity>::NAME,
2848 "FindSymbolByName",
2849 e
2850 )
2851 },
2852 }
2853 }
2854 }
2855 #[doc(hidden)]
2856 #[allow(non_snake_case)]
2857 pub mod __lookup_internal_adjust_tuple {
2858 use super::*;
2859 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2860 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<crate::system::collections::generic::ilist_1_interface::IList_1_Interface<
2861 crate::moon_sharp::interpreter::dynvalue::DynValue,
2862 > as ::unity::IlType>::il_type()];
2863 ::unity::lookup::method_info_on_class_with_signature(
2864 <Processor as ::unity::ClassIdentity>::class(),
2865 "Internal_AdjustTuple",
2866 1,
2867 param_types,
2868 false,
2869 )
2870 });
2871 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2872 match &*METHOD {
2873 ::core::result::Result::Ok(mi) => *mi,
2874 ::core::result::Result::Err(e) => {
2875 panic!(
2876 "method lookup failed: {}
2877::{}
2878: {}
2879",
2880 <Processor as ::unity::ClassIdentity>::NAME,
2881 "Internal_AdjustTuple",
2882 e
2883 )
2884 },
2885 }
2886 }
2887 }
2888 #[doc(hidden)]
2889 #[allow(non_snake_case)]
2890 pub mod __lookup_internal_invoke_unary_meta_method {
2891 use super::*;
2892 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2893 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
2894 <crate::moon_sharp::interpreter::dynvalue::DynValue as ::unity::IlType>::il_type(),
2895 <::unity::Il2CppString as ::unity::IlType>::il_type(),
2896 <i32 as ::unity::IlType>::il_type(),
2897 ];
2898 ::unity::lookup::method_info_on_class_with_signature(
2899 <Processor as ::unity::ClassIdentity>::class(),
2900 "Internal_InvokeUnaryMetaMethod",
2901 3,
2902 param_types,
2903 false,
2904 )
2905 });
2906 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2907 match &*METHOD {
2908 ::core::result::Result::Ok(mi) => *mi,
2909 ::core::result::Result::Err(e) => {
2910 panic!(
2911 "method lookup failed: {}
2912::{}
2913: {}
2914",
2915 <Processor as ::unity::ClassIdentity>::NAME,
2916 "Internal_InvokeUnaryMetaMethod",
2917 e
2918 )
2919 },
2920 }
2921 }
2922 }
2923 #[doc(hidden)]
2924 #[allow(non_snake_case)]
2925 pub mod __lookup_internal_invoke_binary_meta_method {
2926 use super::*;
2927 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2928 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
2929 <crate::moon_sharp::interpreter::dynvalue::DynValue as ::unity::IlType>::il_type(),
2930 <crate::moon_sharp::interpreter::dynvalue::DynValue as ::unity::IlType>::il_type(),
2931 <::unity::Il2CppString as ::unity::IlType>::il_type(),
2932 <i32 as ::unity::IlType>::il_type(),
2933 <crate::moon_sharp::interpreter::dynvalue::DynValue as ::unity::IlType>::il_type(),
2934 ];
2935 ::unity::lookup::method_info_on_class_with_signature(
2936 <Processor as ::unity::ClassIdentity>::class(),
2937 "Internal_InvokeBinaryMetaMethod",
2938 5,
2939 param_types,
2940 false,
2941 )
2942 });
2943 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2944 match &*METHOD {
2945 ::core::result::Result::Ok(mi) => *mi,
2946 ::core::result::Result::Err(e) => {
2947 panic!(
2948 "method lookup failed: {}
2949::{}
2950: {}
2951",
2952 <Processor as ::unity::ClassIdentity>::NAME,
2953 "Internal_InvokeBinaryMetaMethod",
2954 e
2955 )
2956 },
2957 }
2958 }
2959 }
2960 #[doc(hidden)]
2961 #[allow(non_snake_case)]
2962 pub mod __lookup_stack_top_to_array {
2963 use super::*;
2964 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2965 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<i32 as ::unity::IlType>::il_type(), <bool as ::unity::IlType>::il_type()];
2966 ::unity::lookup::method_info_on_class_with_signature(
2967 <Processor as ::unity::ClassIdentity>::class(),
2968 "StackTopToArray",
2969 2,
2970 param_types,
2971 false,
2972 )
2973 });
2974 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2975 match &*METHOD {
2976 ::core::result::Result::Ok(mi) => *mi,
2977 ::core::result::Result::Err(e) => {
2978 panic!(
2979 "method lookup failed: {}
2980::{}
2981: {}
2982",
2983 <Processor as ::unity::ClassIdentity>::NAME,
2984 "StackTopToArray",
2985 e
2986 )
2987 },
2988 }
2989 }
2990 }
2991 #[doc(hidden)]
2992 #[allow(non_snake_case)]
2993 pub mod __lookup_stack_top_to_array_reverse {
2994 use super::*;
2995 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
2996 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<i32 as ::unity::IlType>::il_type(), <bool as ::unity::IlType>::il_type()];
2997 ::unity::lookup::method_info_on_class_with_signature(
2998 <Processor as ::unity::ClassIdentity>::class(),
2999 "StackTopToArrayReverse",
3000 2,
3001 param_types,
3002 false,
3003 )
3004 });
3005 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
3006 match &*METHOD {
3007 ::core::result::Result::Ok(mi) => *mi,
3008 ::core::result::Result::Err(e) => {
3009 panic!(
3010 "method lookup failed: {}
3011::{}
3012: {}
3013",
3014 <Processor as ::unity::ClassIdentity>::NAME,
3015 "StackTopToArrayReverse",
3016 e
3017 )
3018 },
3019 }
3020 }
3021 }
3022}
3023
3024#[cfg(feature = "moon_sharp-interpreter-execution-vm-processor")]
3025impl Processor {
3026 #[doc = "`IsDumpStream(crate::system::io::stream::Stream)` overload"]
3027 pub fn is_dump_stream(stream: impl ::core::convert::Into<crate::system::io::stream::Stream>) -> bool {
3028 unsafe {
3029 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_is_dump_stream::get_method_info().method_ptr,bool;
3030(crate::system::io::stream::Stream)::core::convert::Into::into(stream))
3031 }
3032 }
3033}
3034
3035#[cfg(feature = "moon_sharp-interpreter-execution-vm-processor")]
3036pub trait IProcessorMethods: IProcessor {
3037 #[doc = "`.ctor(crate::moon_sharp::interpreter::script::Script, crate::moon_sharp::interpreter::table::Table, crate::moon_sharp::interpreter::execution::vm::bytecode::ByteCode)` overload"]
3038 fn ctor(
3039 self,
3040 script: impl ::core::convert::Into<crate::moon_sharp::interpreter::script::Script>,
3041 global_context: impl ::core::convert::Into<crate::moon_sharp::interpreter::table::Table>,
3042 byte_code: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::bytecode::ByteCode>,
3043 ) -> () {
3044 unsafe {
3045 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3046 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_ctor::get_method_info().method_ptr,();
3047(Processor)__receiver,(crate::moon_sharp::interpreter::script::Script)::core::convert::Into::into(script),(crate::moon_sharp::interpreter::table::Table)::core::convert::Into::into(global_context),(crate::moon_sharp::interpreter::execution::vm::bytecode::ByteCode)::core::convert::Into::into(byte_code))
3048 }
3049 }
3050 #[doc = "`.ctor(crate::moon_sharp::interpreter::execution::vm::processor::Processor)` overload"]
3051 fn ctor_2(self, parent_processor: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::processor::Processor>) -> () {
3052 unsafe {
3053 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3054 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_ctor_2::get_method_info().method_ptr,();
3055(Processor)__receiver,(crate::moon_sharp::interpreter::execution::vm::processor::Processor)::core::convert::Into::into(parent_processor))
3056 }
3057 }
3058 #[doc = "`Call(crate::moon_sharp::interpreter::dynvalue::DynValue, ::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue>)` overload"]
3059 fn call(
3060 self,
3061 function: impl ::core::convert::Into<crate::moon_sharp::interpreter::dynvalue::DynValue>,
3062 args: impl ::core::convert::Into<::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue>>,
3063 ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
3064 unsafe {
3065 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3066 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_call::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
3067(Processor)__receiver,(crate::moon_sharp::interpreter::dynvalue::DynValue)::core::convert::Into::into(function),(::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue>)::core::convert::Into::into(args))
3068 }
3069 }
3070 #[doc = "`PushClrToScriptStackFrame(crate::moon_sharp::interpreter::execution::vm::callstackitemflags::CallStackItemFlags, crate::moon_sharp::interpreter::dynvalue::DynValue, ::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue>)` overload"]
3071 fn push_clr_to_script_stack_frame(
3072 self,
3073 flags: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::callstackitemflags::CallStackItemFlags>,
3074 function: impl ::core::convert::Into<crate::moon_sharp::interpreter::dynvalue::DynValue>,
3075 args: impl ::core::convert::Into<::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue>>,
3076 ) -> i32 {
3077 unsafe {
3078 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3079 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_push_clr_to_script_stack_frame::get_method_info().method_ptr,i32;
3080(Processor)__receiver,(crate::moon_sharp::interpreter::execution::vm::callstackitemflags::CallStackItemFlags)::core::convert::Into::into(flags),(crate::moon_sharp::interpreter::dynvalue::DynValue)::core::convert::Into::into(function),(::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue>)::core::convert::Into::into(args))
3081 }
3082 }
3083 #[doc = "`LeaveProcessor()` overload"]
3084 fn leave_processor(self) -> () {
3085 unsafe {
3086 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3087 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_leave_processor::get_method_info().method_ptr,();
3088(Processor)__receiver)
3089 }
3090 }
3091 #[doc = "`GetThreadId()` overload"]
3092 fn get_thread_id(self) -> i32 {
3093 unsafe {
3094 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3095 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_get_thread_id::get_method_info().method_ptr,i32;
3096(Processor)__receiver)
3097 }
3098 }
3099 #[doc = "`EnterProcessor()` overload"]
3100 fn enter_processor(self) -> () {
3101 unsafe {
3102 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3103 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_enter_processor::get_method_info().method_ptr,();
3104(Processor)__receiver)
3105 }
3106 }
3107 #[doc = "`GetCoroutineSuspendedLocation()` overload"]
3108 fn get_coroutine_suspended_location(self) -> crate::moon_sharp::interpreter::debugging::sourceref::SourceRef {
3109 unsafe {
3110 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3111 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_get_coroutine_suspended_location::get_method_info().method_ptr,crate::moon_sharp::interpreter::debugging::sourceref::SourceRef;
3112(Processor)__receiver)
3113 }
3114 }
3115 #[doc = "`Dump(crate::system::io::stream::Stream, i32, bool)` overload"]
3116 fn dump(
3117 self,
3118 stream: impl ::core::convert::Into<crate::system::io::stream::Stream>,
3119 base_address: impl ::core::convert::Into<i32>,
3120 has_upvalues: impl ::core::convert::Into<bool>,
3121 ) -> i32 {
3122 unsafe {
3123 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3124 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_dump::get_method_info().method_ptr,i32;
3125(Processor)__receiver,(crate::system::io::stream::Stream)::core::convert::Into::into(stream),(i32)::core::convert::Into::into(base_address),(bool)::core::convert::Into::into(has_upvalues))
3126 }
3127 }
3128 #[doc = "`AddSymbolToMap(crate::system::collections::generic::dictionary_2::Dictionary_2<crate::moon_sharp::interpreter::symbolref::SymbolRef,i32>, crate::moon_sharp::interpreter::symbolref::SymbolRef)` overload"]
3129 fn add_symbol_to_map(
3130 self,
3131 symbol_map: impl ::core::convert::Into<
3132 crate::system::collections::generic::dictionary_2::Dictionary_2<crate::moon_sharp::interpreter::symbolref::SymbolRef, i32>,
3133 >,
3134 s: impl ::core::convert::Into<crate::moon_sharp::interpreter::symbolref::SymbolRef>,
3135 ) -> () {
3136 unsafe {
3137 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3138 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_add_symbol_to_map::get_method_info().method_ptr,();
3139(Processor)__receiver,(crate::system::collections::generic::dictionary_2::Dictionary_2<crate::moon_sharp::interpreter::symbolref::SymbolRef,i32>)::core::convert::Into::into(symbol_map),(crate::moon_sharp::interpreter::symbolref::SymbolRef)::core::convert::Into::into(s))
3140 }
3141 }
3142 #[doc = "`Undump(crate::system::io::stream::Stream, i32, crate::moon_sharp::interpreter::table::Table, *mutbool)` overload"]
3143 fn undump(
3144 self,
3145 stream: impl ::core::convert::Into<crate::system::io::stream::Stream>,
3146 source_id: impl ::core::convert::Into<i32>,
3147 env_table: impl ::core::convert::Into<crate::moon_sharp::interpreter::table::Table>,
3148 ) -> (i32, bool) {
3149 unsafe {
3150 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3151 let mut __out_0 = ::core::mem::MaybeUninit::<bool>::uninit();
3152 let __ret = {
3153 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_undump::get_method_info().method_ptr,i32;
3154(Processor)__receiver,(crate::system::io::stream::Stream)::core::convert::Into::into(stream),(i32)::core::convert::Into::into(source_id),(crate::moon_sharp::interpreter::table::Table)::core::convert::Into::into(env_table),(*mut bool)__out_0.as_mut_ptr())
3155 };
3156 (__ret, __out_0.assume_init())
3157 }
3158 }
3159 #[doc = "`Coroutine_Create(crate::moon_sharp::interpreter::closure::Closure)` overload"]
3160 fn coroutine_create(
3161 self,
3162 closure: impl ::core::convert::Into<crate::moon_sharp::interpreter::closure::Closure>,
3163 ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
3164 unsafe {
3165 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3166 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_coroutine_create::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
3167(Processor)__receiver,(crate::moon_sharp::interpreter::closure::Closure)::core::convert::Into::into(closure))
3168 }
3169 }
3170 #[doc = "`get_State()` overload"]
3171 fn get_state(self) -> crate::moon_sharp::interpreter::coroutinestate::CoroutineState {
3172 unsafe {
3173 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3174 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_get_state::get_method_info().method_ptr,crate::moon_sharp::interpreter::coroutinestate::CoroutineState;
3175(Processor)__receiver)
3176 }
3177 }
3178 #[doc = "`get_AssociatedCoroutine()` overload"]
3179 fn get_associated_coroutine(self) -> crate::moon_sharp::interpreter::coroutine_2::Coroutine_2 {
3180 unsafe {
3181 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3182 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_get_associated_coroutine::get_method_info().method_ptr,crate::moon_sharp::interpreter::coroutine_2::Coroutine_2;
3183(Processor)__receiver)
3184 }
3185 }
3186 #[doc = "`set_AssociatedCoroutine(crate::moon_sharp::interpreter::coroutine_2::Coroutine_2)` overload"]
3187 fn set_associated_coroutine(self, value: impl ::core::convert::Into<crate::moon_sharp::interpreter::coroutine_2::Coroutine_2>) -> () {
3188 unsafe {
3189 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3190 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_set_associated_coroutine::get_method_info().method_ptr,();
3191(Processor)__receiver,(crate::moon_sharp::interpreter::coroutine_2::Coroutine_2)::core::convert::Into::into(value))
3192 }
3193 }
3194 #[doc = "`Coroutine_Resume(::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue>)` overload"]
3195 fn coroutine_resume(
3196 self,
3197 args: impl ::core::convert::Into<::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue>>,
3198 ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
3199 unsafe {
3200 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3201 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_coroutine_resume::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
3202(Processor)__receiver,(::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue>)::core::convert::Into::into(args))
3203 }
3204 }
3205 #[doc = "`FindMeta(*muti32)` overload"]
3206 fn find_meta(self) -> (crate::moon_sharp::interpreter::execution::vm::instruction::Instruction, i32) {
3207 unsafe {
3208 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3209 let mut __out_0 = ::core::mem::MaybeUninit::<i32>::uninit();
3210 let __ret = {
3211 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_find_meta::get_method_info().method_ptr,crate::moon_sharp::interpreter::execution::vm::instruction::Instruction;
3212(Processor)__receiver,(*mut i32)__out_0.as_mut_ptr())
3213 };
3214 (__ret, __out_0.assume_init())
3215 }
3216 }
3217 #[doc = "`AttachDebugger(crate::moon_sharp::interpreter::debugging::idebugger::IDebugger)` overload"]
3218 fn attach_debugger(self, debugger: impl ::core::convert::Into<crate::moon_sharp::interpreter::debugging::idebugger::IDebugger>) -> () {
3219 unsafe {
3220 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3221 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_attach_debugger::get_method_info().method_ptr,();
3222(Processor)__receiver,(crate::moon_sharp::interpreter::debugging::idebugger::IDebugger)::core::convert::Into::into(debugger))
3223 }
3224 }
3225 #[doc = "`get_DebuggerEnabled()` overload"]
3226 fn get_debugger_enabled(self) -> bool {
3227 unsafe {
3228 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3229 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_get_debugger_enabled::get_method_info().method_ptr,bool;
3230(Processor)__receiver)
3231 }
3232 }
3233 #[doc = "`set_DebuggerEnabled(bool)` overload"]
3234 fn set_debugger_enabled(self, value: impl ::core::convert::Into<bool>) -> () {
3235 unsafe {
3236 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3237 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_set_debugger_enabled::get_method_info().method_ptr,();
3238(Processor)__receiver,(bool)::core::convert::Into::into(value))
3239 }
3240 }
3241 #[doc = "`ListenDebugger(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction, i32)` overload"]
3242 fn listen_debugger(
3243 self,
3244 instr: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction>,
3245 instruction_ptr: impl ::core::convert::Into<i32>,
3246 ) -> () {
3247 unsafe {
3248 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3249 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_listen_debugger::get_method_info().method_ptr,();
3250(Processor)__receiver,(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)::core::convert::Into::into(instr),(i32)::core::convert::Into::into(instruction_ptr))
3251 }
3252 }
3253 #[doc = "`ResetBreakPoints(crate::moon_sharp::interpreter::debugging::debuggeraction::DebuggerAction)` overload"]
3254 fn reset_break_points(self, action: impl ::core::convert::Into<crate::moon_sharp::interpreter::debugging::debuggeraction::DebuggerAction>) -> () {
3255 unsafe {
3256 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3257 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_reset_break_points::get_method_info().method_ptr,();
3258(Processor)__receiver,(crate::moon_sharp::interpreter::debugging::debuggeraction::DebuggerAction)::core::convert::Into::into(action))
3259 }
3260 }
3261 #[doc = "`ResetBreakPoints(crate::moon_sharp::interpreter::debugging::sourcecode::SourceCode, crate::system::collections::generic::hashset_1::HashSet_1<i32>)` overload"]
3262 fn reset_break_points_2(
3263 self,
3264 src: impl ::core::convert::Into<crate::moon_sharp::interpreter::debugging::sourcecode::SourceCode>,
3265 lines: impl ::core::convert::Into<crate::system::collections::generic::hashset_1::HashSet_1<i32>>,
3266 ) -> crate::system::collections::generic::hashset_1::HashSet_1<i32> {
3267 unsafe {
3268 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3269 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_reset_break_points_2::get_method_info().method_ptr,crate::system::collections::generic::hashset_1::HashSet_1<i32> ;
3270(Processor)__receiver,(crate::moon_sharp::interpreter::debugging::sourcecode::SourceCode)::core::convert::Into::into(src),(crate::system::collections::generic::hashset_1::HashSet_1<i32>)::core::convert::Into::into(lines))
3271 }
3272 }
3273 #[doc = "`RefreshDebugger(bool, i32)` overload"]
3274 fn refresh_debugger(self, hard: impl ::core::convert::Into<bool>, instruction_ptr: impl ::core::convert::Into<i32>) -> () {
3275 unsafe {
3276 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3277 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_refresh_debugger::get_method_info().method_ptr,();
3278(Processor)__receiver,(bool)::core::convert::Into::into(hard),(i32)::core::convert::Into::into(instruction_ptr))
3279 }
3280 }
3281 #[doc = "`Debugger_RefreshThreads(crate::moon_sharp::interpreter::scriptexecutioncontext::ScriptExecutionContext)` overload"]
3282 fn debugger_refresh_threads(
3283 self,
3284 context: impl ::core::convert::Into<crate::moon_sharp::interpreter::scriptexecutioncontext::ScriptExecutionContext>,
3285 ) -> crate::system::collections::generic::list_1::List_1<crate::moon_sharp::interpreter::debugging::watchitem::WatchItem> {
3286 unsafe {
3287 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3288 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_debugger_refresh_threads::get_method_info().method_ptr,crate::system::collections::generic::list_1::List_1<crate::moon_sharp::interpreter::debugging::watchitem::WatchItem> ;
3289(Processor)__receiver,(crate::moon_sharp::interpreter::scriptexecutioncontext::ScriptExecutionContext)::core::convert::Into::into(context))
3290 }
3291 }
3292 #[doc = "`Debugger_RefreshVStack()` overload"]
3293 fn debugger_refresh_v_stack(
3294 self,
3295 ) -> crate::system::collections::generic::list_1::List_1<crate::moon_sharp::interpreter::debugging::watchitem::WatchItem> {
3296 unsafe {
3297 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3298 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_debugger_refresh_v_stack::get_method_info().method_ptr,crate::system::collections::generic::list_1::List_1<crate::moon_sharp::interpreter::debugging::watchitem::WatchItem> ;
3299(Processor)__receiver)
3300 }
3301 }
3302 #[doc = "`Debugger_RefreshWatches(crate::moon_sharp::interpreter::scriptexecutioncontext::ScriptExecutionContext, crate::system::collections::generic::list_1::List_1<crate::moon_sharp::interpreter::dynamicexpression::DynamicExpression>)` overload"]
3303 fn debugger_refresh_watches(
3304 self,
3305 context: impl ::core::convert::Into<crate::moon_sharp::interpreter::scriptexecutioncontext::ScriptExecutionContext>,
3306 watch_list: impl ::core::convert::Into<
3307 crate::system::collections::generic::list_1::List_1<crate::moon_sharp::interpreter::dynamicexpression::DynamicExpression>,
3308 >,
3309 ) -> crate::system::collections::generic::list_1::List_1<crate::moon_sharp::interpreter::debugging::watchitem::WatchItem> {
3310 unsafe {
3311 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3312 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_debugger_refresh_watches::get_method_info().method_ptr,crate::system::collections::generic::list_1::List_1<crate::moon_sharp::interpreter::debugging::watchitem::WatchItem> ;
3313(Processor)__receiver,(crate::moon_sharp::interpreter::scriptexecutioncontext::ScriptExecutionContext)::core::convert::Into::into(context),(crate::system::collections::generic::list_1::List_1<crate::moon_sharp::interpreter::dynamicexpression::DynamicExpression>)::core::convert::Into::into(watch_list))
3314 }
3315 }
3316 #[doc = "`Debugger_RefreshLocals(crate::moon_sharp::interpreter::scriptexecutioncontext::ScriptExecutionContext)` overload"]
3317 fn debugger_refresh_locals(
3318 self,
3319 context: impl ::core::convert::Into<crate::moon_sharp::interpreter::scriptexecutioncontext::ScriptExecutionContext>,
3320 ) -> crate::system::collections::generic::list_1::List_1<crate::moon_sharp::interpreter::debugging::watchitem::WatchItem> {
3321 unsafe {
3322 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3323 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_debugger_refresh_locals::get_method_info().method_ptr,crate::system::collections::generic::list_1::List_1<crate::moon_sharp::interpreter::debugging::watchitem::WatchItem> ;
3324(Processor)__receiver,(crate::moon_sharp::interpreter::scriptexecutioncontext::ScriptExecutionContext)::core::convert::Into::into(context))
3325 }
3326 }
3327 #[doc = "`Debugger_RefreshWatch(crate::moon_sharp::interpreter::scriptexecutioncontext::ScriptExecutionContext, crate::moon_sharp::interpreter::dynamicexpression::DynamicExpression)` overload"]
3328 fn debugger_refresh_watch(
3329 self,
3330 context: impl ::core::convert::Into<crate::moon_sharp::interpreter::scriptexecutioncontext::ScriptExecutionContext>,
3331 dyn_expr: impl ::core::convert::Into<crate::moon_sharp::interpreter::dynamicexpression::DynamicExpression>,
3332 ) -> crate::moon_sharp::interpreter::debugging::watchitem::WatchItem {
3333 unsafe {
3334 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3335 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_debugger_refresh_watch::get_method_info().method_ptr,crate::moon_sharp::interpreter::debugging::watchitem::WatchItem;
3336(Processor)__receiver,(crate::moon_sharp::interpreter::scriptexecutioncontext::ScriptExecutionContext)::core::convert::Into::into(context),(crate::moon_sharp::interpreter::dynamicexpression::DynamicExpression)::core::convert::Into::into(dyn_expr))
3337 }
3338 }
3339 #[doc = "`Debugger_GetCallStack(crate::moon_sharp::interpreter::debugging::sourceref::SourceRef)` overload"]
3340 fn debugger_get_call_stack(
3341 self,
3342 starting_ref: impl ::core::convert::Into<crate::moon_sharp::interpreter::debugging::sourceref::SourceRef>,
3343 ) -> crate::system::collections::generic::list_1::List_1<crate::moon_sharp::interpreter::debugging::watchitem::WatchItem> {
3344 unsafe {
3345 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3346 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_debugger_get_call_stack::get_method_info().method_ptr,crate::system::collections::generic::list_1::List_1<crate::moon_sharp::interpreter::debugging::watchitem::WatchItem> ;
3347(Processor)__receiver,(crate::moon_sharp::interpreter::debugging::sourceref::SourceRef)::core::convert::Into::into(starting_ref))
3348 }
3349 }
3350 #[doc = "`GetCurrentSourceRef(i32)` overload"]
3351 fn get_current_source_ref(
3352 self,
3353 instruction_ptr: impl ::core::convert::Into<i32>,
3354 ) -> crate::moon_sharp::interpreter::debugging::sourceref::SourceRef {
3355 unsafe {
3356 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3357 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_get_current_source_ref::get_method_info().method_ptr,crate::moon_sharp::interpreter::debugging::sourceref::SourceRef;
3358(Processor)__receiver,(i32)::core::convert::Into::into(instruction_ptr))
3359 }
3360 }
3361 #[doc = "`FillDebugData(crate::moon_sharp::interpreter::interpreterexception::InterpreterException, i32)` overload"]
3362 fn fill_debug_data(
3363 self,
3364 ex: impl ::core::convert::Into<crate::moon_sharp::interpreter::interpreterexception::InterpreterException>,
3365 ip: impl ::core::convert::Into<i32>,
3366 ) -> () {
3367 unsafe {
3368 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3369 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_fill_debug_data::get_method_info().method_ptr,();
3370(Processor)__receiver,(crate::moon_sharp::interpreter::interpreterexception::InterpreterException)::core::convert::Into::into(ex),(i32)::core::convert::Into::into(ip))
3371 }
3372 }
3373 #[doc = "`GetMetatable(crate::moon_sharp::interpreter::dynvalue::DynValue)` overload"]
3374 fn get_metatable(
3375 self,
3376 value: impl ::core::convert::Into<crate::moon_sharp::interpreter::dynvalue::DynValue>,
3377 ) -> crate::moon_sharp::interpreter::table::Table {
3378 unsafe {
3379 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3380 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_get_metatable::get_method_info().method_ptr,crate::moon_sharp::interpreter::table::Table;
3381(Processor)__receiver,(crate::moon_sharp::interpreter::dynvalue::DynValue)::core::convert::Into::into(value))
3382 }
3383 }
3384 #[doc = "`GetBinaryMetamethod(crate::moon_sharp::interpreter::dynvalue::DynValue, crate::moon_sharp::interpreter::dynvalue::DynValue, ::unity::Il2CppString)` overload"]
3385 fn get_binary_metamethod(
3386 self,
3387 op1: impl ::core::convert::Into<crate::moon_sharp::interpreter::dynvalue::DynValue>,
3388 op2: impl ::core::convert::Into<crate::moon_sharp::interpreter::dynvalue::DynValue>,
3389 event_name: impl ::core::convert::Into<::unity::Il2CppString>,
3390 ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
3391 unsafe {
3392 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3393 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_get_binary_metamethod::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
3394(Processor)__receiver,(crate::moon_sharp::interpreter::dynvalue::DynValue)::core::convert::Into::into(op1),(crate::moon_sharp::interpreter::dynvalue::DynValue)::core::convert::Into::into(op2),(::unity::Il2CppString)::core::convert::Into::into(event_name))
3395 }
3396 }
3397 #[doc = "`GetMetamethod(crate::moon_sharp::interpreter::dynvalue::DynValue, ::unity::Il2CppString)` overload"]
3398 fn get_metamethod(
3399 self,
3400 value: impl ::core::convert::Into<crate::moon_sharp::interpreter::dynvalue::DynValue>,
3401 metamethod: impl ::core::convert::Into<::unity::Il2CppString>,
3402 ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
3403 unsafe {
3404 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3405 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_get_metamethod::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
3406(Processor)__receiver,(crate::moon_sharp::interpreter::dynvalue::DynValue)::core::convert::Into::into(value),(::unity::Il2CppString)::core::convert::Into::into(metamethod))
3407 }
3408 }
3409 #[doc = "`GetMetamethodRaw(crate::moon_sharp::interpreter::dynvalue::DynValue, ::unity::Il2CppString)` overload"]
3410 fn get_metamethod_raw(
3411 self,
3412 value: impl ::core::convert::Into<crate::moon_sharp::interpreter::dynvalue::DynValue>,
3413 metamethod: impl ::core::convert::Into<::unity::Il2CppString>,
3414 ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
3415 unsafe {
3416 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3417 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_get_metamethod_raw::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
3418(Processor)__receiver,(crate::moon_sharp::interpreter::dynvalue::DynValue)::core::convert::Into::into(value),(::unity::Il2CppString)::core::convert::Into::into(metamethod))
3419 }
3420 }
3421 #[doc = "`GetScript()` overload"]
3422 fn get_script(self) -> crate::moon_sharp::interpreter::script::Script {
3423 unsafe {
3424 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3425 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_get_script::get_method_info().method_ptr,crate::moon_sharp::interpreter::script::Script;
3426(Processor)__receiver)
3427 }
3428 }
3429 #[doc = "`GetInstruction(i32)` overload"]
3430 fn get_instruction(self, i_address: impl ::core::convert::Into<i32>) -> crate::moon_sharp::interpreter::execution::vm::instruction::Instruction {
3431 unsafe {
3432 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3433 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_get_instruction::get_method_info().method_ptr,crate::moon_sharp::interpreter::execution::vm::instruction::Instruction;
3434(Processor)__receiver,(i32)::core::convert::Into::into(i_address))
3435 }
3436 }
3437 #[doc = "`Processing_Loop(i32)` overload"]
3438 fn processing_loop(self, instruction_ptr: impl ::core::convert::Into<i32>) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
3439 unsafe {
3440 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3441 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_processing_loop::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
3442(Processor)__receiver,(i32)::core::convert::Into::into(instruction_ptr))
3443 }
3444 }
3445 #[doc = "`PerformMessageDecorationBeforeUnwind(crate::moon_sharp::interpreter::dynvalue::DynValue, ::unity::Il2CppString, crate::moon_sharp::interpreter::debugging::sourceref::SourceRef)` overload"]
3446 fn perform_message_decoration_before_unwind(
3447 self,
3448 message_handler: impl ::core::convert::Into<crate::moon_sharp::interpreter::dynvalue::DynValue>,
3449 decorated_message: impl ::core::convert::Into<::unity::Il2CppString>,
3450 source_ref: impl ::core::convert::Into<crate::moon_sharp::interpreter::debugging::sourceref::SourceRef>,
3451 ) -> ::unity::Il2CppString {
3452 unsafe {
3453 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3454 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_perform_message_decoration_before_unwind::get_method_info().method_ptr, ::unity::Il2CppString;
3455(Processor)__receiver,(crate::moon_sharp::interpreter::dynvalue::DynValue)::core::convert::Into::into(message_handler),(::unity::Il2CppString)::core::convert::Into::into(decorated_message),(crate::moon_sharp::interpreter::debugging::sourceref::SourceRef)::core::convert::Into::into(source_ref))
3456 }
3457 }
3458 #[doc = "`AssignLocal(crate::moon_sharp::interpreter::symbolref::SymbolRef, crate::moon_sharp::interpreter::dynvalue::DynValue)` overload"]
3459 fn assign_local(
3460 self,
3461 symref: impl ::core::convert::Into<crate::moon_sharp::interpreter::symbolref::SymbolRef>,
3462 value: impl ::core::convert::Into<crate::moon_sharp::interpreter::dynvalue::DynValue>,
3463 ) -> () {
3464 unsafe {
3465 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3466 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_assign_local::get_method_info().method_ptr,();
3467(Processor)__receiver,(crate::moon_sharp::interpreter::symbolref::SymbolRef)::core::convert::Into::into(symref),(crate::moon_sharp::interpreter::dynvalue::DynValue)::core::convert::Into::into(value))
3468 }
3469 }
3470 #[doc = "`ExecStoreLcl(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)` overload"]
3471 fn exec_store_lcl(self, i: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction>) -> () {
3472 unsafe {
3473 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3474 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_exec_store_lcl::get_method_info().method_ptr,();
3475(Processor)__receiver,(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)::core::convert::Into::into(i))
3476 }
3477 }
3478 #[doc = "`ExecStoreUpv(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)` overload"]
3479 fn exec_store_upv(self, i: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction>) -> () {
3480 unsafe {
3481 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3482 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_exec_store_upv::get_method_info().method_ptr,();
3483(Processor)__receiver,(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)::core::convert::Into::into(i))
3484 }
3485 }
3486 #[doc = "`ExecSwap(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)` overload"]
3487 fn exec_swap(self, i: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction>) -> () {
3488 unsafe {
3489 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3490 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_exec_swap::get_method_info().method_ptr,();
3491(Processor)__receiver,(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)::core::convert::Into::into(i))
3492 }
3493 }
3494 #[doc = "`GetStoreValue(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)` overload"]
3495 fn get_store_value(
3496 self,
3497 i: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction>,
3498 ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
3499 unsafe {
3500 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3501 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_get_store_value::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
3502(Processor)__receiver,(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)::core::convert::Into::into(i))
3503 }
3504 }
3505 #[doc = "`ExecClosure(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)` overload"]
3506 fn exec_closure(self, i: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction>) -> () {
3507 unsafe {
3508 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3509 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_exec_closure::get_method_info().method_ptr,();
3510(Processor)__receiver,(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)::core::convert::Into::into(i))
3511 }
3512 }
3513 #[doc = "`GetUpvalueSymbol(crate::moon_sharp::interpreter::symbolref::SymbolRef)` overload"]
3514 fn get_upvalue_symbol(
3515 self,
3516 s: impl ::core::convert::Into<crate::moon_sharp::interpreter::symbolref::SymbolRef>,
3517 ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
3518 unsafe {
3519 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3520 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_get_upvalue_symbol::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
3521(Processor)__receiver,(crate::moon_sharp::interpreter::symbolref::SymbolRef)::core::convert::Into::into(s))
3522 }
3523 }
3524 #[doc = "`ExecMkTuple(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)` overload"]
3525 fn exec_mk_tuple(self, i: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction>) -> () {
3526 unsafe {
3527 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3528 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_exec_mk_tuple::get_method_info().method_ptr,();
3529(Processor)__receiver,(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)::core::convert::Into::into(i))
3530 }
3531 }
3532 #[doc = "`ExecToNum(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)` overload"]
3533 fn exec_to_num(self, i: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction>) -> () {
3534 unsafe {
3535 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3536 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_exec_to_num::get_method_info().method_ptr,();
3537(Processor)__receiver,(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)::core::convert::Into::into(i))
3538 }
3539 }
3540 #[doc = "`ExecIterUpd(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)` overload"]
3541 fn exec_iter_upd(self, i: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction>) -> () {
3542 unsafe {
3543 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3544 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_exec_iter_upd::get_method_info().method_ptr,();
3545(Processor)__receiver,(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)::core::convert::Into::into(i))
3546 }
3547 }
3548 #[doc = "`ExecExpTuple(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)` overload"]
3549 fn exec_exp_tuple(self, i: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction>) -> () {
3550 unsafe {
3551 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3552 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_exec_exp_tuple::get_method_info().method_ptr,();
3553(Processor)__receiver,(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)::core::convert::Into::into(i))
3554 }
3555 }
3556 #[doc = "`ExecIterPrep(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)` overload"]
3557 fn exec_iter_prep(self, i: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction>) -> () {
3558 unsafe {
3559 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3560 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_exec_iter_prep::get_method_info().method_ptr,();
3561(Processor)__receiver,(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)::core::convert::Into::into(i))
3562 }
3563 }
3564 #[doc = "`ExecJFor(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction, i32)` overload"]
3565 fn exec_j_for(
3566 self,
3567 i: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction>,
3568 instruction_ptr: impl ::core::convert::Into<i32>,
3569 ) -> i32 {
3570 unsafe {
3571 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3572 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_exec_j_for::get_method_info().method_ptr,i32;
3573(Processor)__receiver,(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)::core::convert::Into::into(i),(i32)::core::convert::Into::into(instruction_ptr))
3574 }
3575 }
3576 #[doc = "`ExecIncr(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)` overload"]
3577 fn exec_incr(self, i: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction>) -> () {
3578 unsafe {
3579 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3580 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_exec_incr::get_method_info().method_ptr,();
3581(Processor)__receiver,(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)::core::convert::Into::into(i))
3582 }
3583 }
3584 #[doc = "`ExecCNot(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)` overload"]
3585 fn exec_c_not(self, i: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction>) -> () {
3586 unsafe {
3587 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3588 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_exec_c_not::get_method_info().method_ptr,();
3589(Processor)__receiver,(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)::core::convert::Into::into(i))
3590 }
3591 }
3592 #[doc = "`ExecNot(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)` overload"]
3593 fn exec_not(self, i: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction>) -> () {
3594 unsafe {
3595 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3596 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_exec_not::get_method_info().method_ptr,();
3597(Processor)__receiver,(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)::core::convert::Into::into(i))
3598 }
3599 }
3600 #[doc = "`ExecBeginFn(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)` overload"]
3601 fn exec_begin_fn(self, i: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction>) -> () {
3602 unsafe {
3603 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3604 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_exec_begin_fn::get_method_info().method_ptr,();
3605(Processor)__receiver,(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)::core::convert::Into::into(i))
3606 }
3607 }
3608 #[doc = "`PopToBasePointer()` overload"]
3609 fn pop_to_base_pointer(self) -> crate::moon_sharp::interpreter::execution::vm::callstackitem::CallStackItem {
3610 unsafe {
3611 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3612 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_pop_to_base_pointer::get_method_info().method_ptr,crate::moon_sharp::interpreter::execution::vm::callstackitem::CallStackItem;
3613(Processor)__receiver)
3614 }
3615 }
3616 #[doc = "`PopExecStackAndCheckVStack(i32)` overload"]
3617 fn pop_exec_stack_and_check_v_stack(self, vstackguard: impl ::core::convert::Into<i32>) -> i32 {
3618 unsafe {
3619 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3620 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_pop_exec_stack_and_check_v_stack::get_method_info().method_ptr,i32;
3621(Processor)__receiver,(i32)::core::convert::Into::into(vstackguard))
3622 }
3623 }
3624 #[doc = "`CreateArgsListForFunctionCall(i32, i32)` overload"]
3625 fn create_args_list_for_function_call(
3626 self,
3627 numargs: impl ::core::convert::Into<i32>,
3628 offs_from_top: impl ::core::convert::Into<i32>,
3629 ) -> crate::system::collections::generic::ilist_1_interface::IList_1_Interface<crate::moon_sharp::interpreter::dynvalue::DynValue> {
3630 unsafe {
3631 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3632 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_create_args_list_for_function_call::get_method_info().method_ptr,crate::system::collections::generic::ilist_1_interface::IList_1_Interface<crate::moon_sharp::interpreter::dynvalue::DynValue> ;
3633(Processor)__receiver,(i32)::core::convert::Into::into(numargs),(i32)::core::convert::Into::into(offs_from_top))
3634 }
3635 }
3636 #[doc = "`ExecArgs(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)` overload"]
3637 fn exec_args(self, i: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction>) -> () {
3638 unsafe {
3639 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3640 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_exec_args::get_method_info().method_ptr,();
3641(Processor)__receiver,(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)::core::convert::Into::into(i))
3642 }
3643 }
3644 #[doc = "`Internal_ExecCall(i32, i32, crate::moon_sharp::interpreter::callbackfunction::CallbackFunction, crate::moon_sharp::interpreter::callbackfunction::CallbackFunction, bool, ::unity::Il2CppString, crate::moon_sharp::interpreter::dynvalue::DynValue)` overload"]
3645 fn internal_exec_call(
3646 self,
3647 args_count: impl ::core::convert::Into<i32>,
3648 instruction_ptr: impl ::core::convert::Into<i32>,
3649 handler: impl ::core::convert::Into<crate::moon_sharp::interpreter::callbackfunction::CallbackFunction>,
3650 continuation: impl ::core::convert::Into<crate::moon_sharp::interpreter::callbackfunction::CallbackFunction>,
3651 this_call: impl ::core::convert::Into<bool>,
3652 debug_text: impl ::core::convert::Into<::unity::Il2CppString>,
3653 unwind_handler: impl ::core::convert::Into<crate::moon_sharp::interpreter::dynvalue::DynValue>,
3654 ) -> i32 {
3655 unsafe {
3656 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3657 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_internal_exec_call::get_method_info().method_ptr,i32;
3658(Processor)__receiver,(i32)::core::convert::Into::into(args_count),(i32)::core::convert::Into::into(instruction_ptr),(crate::moon_sharp::interpreter::callbackfunction::CallbackFunction)::core::convert::Into::into(handler),(crate::moon_sharp::interpreter::callbackfunction::CallbackFunction)::core::convert::Into::into(continuation),(bool)::core::convert::Into::into(this_call),(::unity::Il2CppString)::core::convert::Into::into(debug_text),(crate::moon_sharp::interpreter::dynvalue::DynValue)::core::convert::Into::into(unwind_handler))
3659 }
3660 }
3661 #[doc = "`PerformTCO(i32, i32)` overload"]
3662 fn perform_tco(self, instruction_ptr: impl ::core::convert::Into<i32>, args_count: impl ::core::convert::Into<i32>) -> i32 {
3663 unsafe {
3664 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3665 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_perform_tco::get_method_info().method_ptr,i32;
3666(Processor)__receiver,(i32)::core::convert::Into::into(instruction_ptr),(i32)::core::convert::Into::into(args_count))
3667 }
3668 }
3669 #[doc = "`ExecRet(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)` overload"]
3670 fn exec_ret(self, i: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction>) -> i32 {
3671 unsafe {
3672 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3673 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_exec_ret::get_method_info().method_ptr,i32;
3674(Processor)__receiver,(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)::core::convert::Into::into(i))
3675 }
3676 }
3677 #[doc = "`Internal_CheckForTailRequests(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction, i32)` overload"]
3678 fn internal_check_for_tail_requests(
3679 self,
3680 i: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction>,
3681 instruction_ptr: impl ::core::convert::Into<i32>,
3682 ) -> i32 {
3683 unsafe {
3684 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3685 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_internal_check_for_tail_requests::get_method_info().method_ptr,i32;
3686(Processor)__receiver,(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)::core::convert::Into::into(i),(i32)::core::convert::Into::into(instruction_ptr))
3687 }
3688 }
3689 #[doc = "`JumpBool(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction, bool, i32)` overload"]
3690 fn jump_bool(
3691 self,
3692 i: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction>,
3693 expected_value_for_jump: impl ::core::convert::Into<bool>,
3694 instruction_ptr: impl ::core::convert::Into<i32>,
3695 ) -> i32 {
3696 unsafe {
3697 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3698 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_jump_bool::get_method_info().method_ptr,i32;
3699(Processor)__receiver,(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)::core::convert::Into::into(i),(bool)::core::convert::Into::into(expected_value_for_jump),(i32)::core::convert::Into::into(instruction_ptr))
3700 }
3701 }
3702 #[doc = "`ExecShortCircuitingOperator(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction, i32)` overload"]
3703 fn exec_short_circuiting_operator(
3704 self,
3705 i: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction>,
3706 instruction_ptr: impl ::core::convert::Into<i32>,
3707 ) -> i32 {
3708 unsafe {
3709 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3710 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_exec_short_circuiting_operator::get_method_info().method_ptr,i32;
3711(Processor)__receiver,(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)::core::convert::Into::into(i),(i32)::core::convert::Into::into(instruction_ptr))
3712 }
3713 }
3714 #[doc = "`ExecAdd(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction, i32)` overload"]
3715 fn exec_add(
3716 self,
3717 i: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction>,
3718 instruction_ptr: impl ::core::convert::Into<i32>,
3719 ) -> i32 {
3720 unsafe {
3721 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3722 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_exec_add::get_method_info().method_ptr,i32;
3723(Processor)__receiver,(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)::core::convert::Into::into(i),(i32)::core::convert::Into::into(instruction_ptr))
3724 }
3725 }
3726 #[doc = "`ExecSub(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction, i32)` overload"]
3727 fn exec_sub(
3728 self,
3729 i: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction>,
3730 instruction_ptr: impl ::core::convert::Into<i32>,
3731 ) -> i32 {
3732 unsafe {
3733 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3734 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_exec_sub::get_method_info().method_ptr,i32;
3735(Processor)__receiver,(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)::core::convert::Into::into(i),(i32)::core::convert::Into::into(instruction_ptr))
3736 }
3737 }
3738 #[doc = "`ExecMul(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction, i32)` overload"]
3739 fn exec_mul(
3740 self,
3741 i: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction>,
3742 instruction_ptr: impl ::core::convert::Into<i32>,
3743 ) -> i32 {
3744 unsafe {
3745 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3746 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_exec_mul::get_method_info().method_ptr,i32;
3747(Processor)__receiver,(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)::core::convert::Into::into(i),(i32)::core::convert::Into::into(instruction_ptr))
3748 }
3749 }
3750 #[doc = "`ExecMod(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction, i32)` overload"]
3751 fn exec_mod(
3752 self,
3753 i: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction>,
3754 instruction_ptr: impl ::core::convert::Into<i32>,
3755 ) -> i32 {
3756 unsafe {
3757 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3758 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_exec_mod::get_method_info().method_ptr,i32;
3759(Processor)__receiver,(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)::core::convert::Into::into(i),(i32)::core::convert::Into::into(instruction_ptr))
3760 }
3761 }
3762 #[doc = "`ExecDiv(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction, i32)` overload"]
3763 fn exec_div(
3764 self,
3765 i: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction>,
3766 instruction_ptr: impl ::core::convert::Into<i32>,
3767 ) -> i32 {
3768 unsafe {
3769 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3770 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_exec_div::get_method_info().method_ptr,i32;
3771(Processor)__receiver,(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)::core::convert::Into::into(i),(i32)::core::convert::Into::into(instruction_ptr))
3772 }
3773 }
3774 #[doc = "`ExecPower(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction, i32)` overload"]
3775 fn exec_power(
3776 self,
3777 i: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction>,
3778 instruction_ptr: impl ::core::convert::Into<i32>,
3779 ) -> i32 {
3780 unsafe {
3781 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3782 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_exec_power::get_method_info().method_ptr,i32;
3783(Processor)__receiver,(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)::core::convert::Into::into(i),(i32)::core::convert::Into::into(instruction_ptr))
3784 }
3785 }
3786 #[doc = "`ExecNeg(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction, i32)` overload"]
3787 fn exec_neg(
3788 self,
3789 i: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction>,
3790 instruction_ptr: impl ::core::convert::Into<i32>,
3791 ) -> i32 {
3792 unsafe {
3793 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3794 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_exec_neg::get_method_info().method_ptr,i32;
3795(Processor)__receiver,(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)::core::convert::Into::into(i),(i32)::core::convert::Into::into(instruction_ptr))
3796 }
3797 }
3798 #[doc = "`ExecEq(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction, i32)` overload"]
3799 fn exec_eq(
3800 self,
3801 i: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction>,
3802 instruction_ptr: impl ::core::convert::Into<i32>,
3803 ) -> i32 {
3804 unsafe {
3805 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3806 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_exec_eq::get_method_info().method_ptr,i32;
3807(Processor)__receiver,(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)::core::convert::Into::into(i),(i32)::core::convert::Into::into(instruction_ptr))
3808 }
3809 }
3810 #[doc = "`ExecLess(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction, i32)` overload"]
3811 fn exec_less(
3812 self,
3813 i: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction>,
3814 instruction_ptr: impl ::core::convert::Into<i32>,
3815 ) -> i32 {
3816 unsafe {
3817 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3818 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_exec_less::get_method_info().method_ptr,i32;
3819(Processor)__receiver,(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)::core::convert::Into::into(i),(i32)::core::convert::Into::into(instruction_ptr))
3820 }
3821 }
3822 #[doc = "`ExecLessEq(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction, i32)` overload"]
3823 fn exec_less_eq(
3824 self,
3825 i: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction>,
3826 instruction_ptr: impl ::core::convert::Into<i32>,
3827 ) -> i32 {
3828 unsafe {
3829 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3830 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_exec_less_eq::get_method_info().method_ptr,i32;
3831(Processor)__receiver,(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)::core::convert::Into::into(i),(i32)::core::convert::Into::into(instruction_ptr))
3832 }
3833 }
3834 #[doc = "`ExecLen(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction, i32)` overload"]
3835 fn exec_len(
3836 self,
3837 i: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction>,
3838 instruction_ptr: impl ::core::convert::Into<i32>,
3839 ) -> i32 {
3840 unsafe {
3841 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3842 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_exec_len::get_method_info().method_ptr,i32;
3843(Processor)__receiver,(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)::core::convert::Into::into(i),(i32)::core::convert::Into::into(instruction_ptr))
3844 }
3845 }
3846 #[doc = "`ExecConcat(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction, i32)` overload"]
3847 fn exec_concat(
3848 self,
3849 i: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction>,
3850 instruction_ptr: impl ::core::convert::Into<i32>,
3851 ) -> i32 {
3852 unsafe {
3853 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3854 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_exec_concat::get_method_info().method_ptr,i32;
3855(Processor)__receiver,(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)::core::convert::Into::into(i),(i32)::core::convert::Into::into(instruction_ptr))
3856 }
3857 }
3858 #[doc = "`ExecTblInitI(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)` overload"]
3859 fn exec_tbl_init_i(self, i: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction>) -> () {
3860 unsafe {
3861 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3862 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_exec_tbl_init_i::get_method_info().method_ptr,();
3863(Processor)__receiver,(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)::core::convert::Into::into(i))
3864 }
3865 }
3866 #[doc = "`ExecTblInitN(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)` overload"]
3867 fn exec_tbl_init_n(self, i: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction>) -> () {
3868 unsafe {
3869 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3870 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_exec_tbl_init_n::get_method_info().method_ptr,();
3871(Processor)__receiver,(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)::core::convert::Into::into(i))
3872 }
3873 }
3874 #[doc = "`ExecIndexSet(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction, i32)` overload"]
3875 fn exec_index_set(
3876 self,
3877 i: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction>,
3878 instruction_ptr: impl ::core::convert::Into<i32>,
3879 ) -> i32 {
3880 unsafe {
3881 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3882 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_exec_index_set::get_method_info().method_ptr,i32;
3883(Processor)__receiver,(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)::core::convert::Into::into(i),(i32)::core::convert::Into::into(instruction_ptr))
3884 }
3885 }
3886 #[doc = "`ExecIndex(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction, i32)` overload"]
3887 fn exec_index(
3888 self,
3889 i: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction>,
3890 instruction_ptr: impl ::core::convert::Into<i32>,
3891 ) -> i32 {
3892 unsafe {
3893 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3894 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_exec_index::get_method_info().method_ptr,i32;
3895(Processor)__receiver,(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)::core::convert::Into::into(i),(i32)::core::convert::Into::into(instruction_ptr))
3896 }
3897 }
3898 #[doc = "`ClearBlockData(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)` overload"]
3899 fn clear_block_data(self, i: impl ::core::convert::Into<crate::moon_sharp::interpreter::execution::vm::instruction::Instruction>) -> () {
3900 unsafe {
3901 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3902 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_clear_block_data::get_method_info().method_ptr,();
3903(Processor)__receiver,(crate::moon_sharp::interpreter::execution::vm::instruction::Instruction)::core::convert::Into::into(i))
3904 }
3905 }
3906 #[doc = "`GetGenericSymbol(crate::moon_sharp::interpreter::symbolref::SymbolRef)` overload"]
3907 fn get_generic_symbol(
3908 self,
3909 symref: impl ::core::convert::Into<crate::moon_sharp::interpreter::symbolref::SymbolRef>,
3910 ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
3911 unsafe {
3912 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3913 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_get_generic_symbol::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
3914(Processor)__receiver,(crate::moon_sharp::interpreter::symbolref::SymbolRef)::core::convert::Into::into(symref))
3915 }
3916 }
3917 #[doc = "`GetGlobalSymbol(crate::moon_sharp::interpreter::dynvalue::DynValue, ::unity::Il2CppString)` overload"]
3918 fn get_global_symbol(
3919 self,
3920 dyn_value: impl ::core::convert::Into<crate::moon_sharp::interpreter::dynvalue::DynValue>,
3921 name: impl ::core::convert::Into<::unity::Il2CppString>,
3922 ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
3923 unsafe {
3924 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3925 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_get_global_symbol::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
3926(Processor)__receiver,(crate::moon_sharp::interpreter::dynvalue::DynValue)::core::convert::Into::into(dyn_value),(::unity::Il2CppString)::core::convert::Into::into(name))
3927 }
3928 }
3929 #[doc = "`SetGlobalSymbol(crate::moon_sharp::interpreter::dynvalue::DynValue, ::unity::Il2CppString, crate::moon_sharp::interpreter::dynvalue::DynValue)` overload"]
3930 fn set_global_symbol(
3931 self,
3932 dyn_value: impl ::core::convert::Into<crate::moon_sharp::interpreter::dynvalue::DynValue>,
3933 name: impl ::core::convert::Into<::unity::Il2CppString>,
3934 value: impl ::core::convert::Into<crate::moon_sharp::interpreter::dynvalue::DynValue>,
3935 ) -> () {
3936 unsafe {
3937 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3938 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_set_global_symbol::get_method_info().method_ptr,();
3939(Processor)__receiver,(crate::moon_sharp::interpreter::dynvalue::DynValue)::core::convert::Into::into(dyn_value),(::unity::Il2CppString)::core::convert::Into::into(name),(crate::moon_sharp::interpreter::dynvalue::DynValue)::core::convert::Into::into(value))
3940 }
3941 }
3942 #[doc = "`AssignGenericSymbol(crate::moon_sharp::interpreter::symbolref::SymbolRef, crate::moon_sharp::interpreter::dynvalue::DynValue)` overload"]
3943 fn assign_generic_symbol(
3944 self,
3945 symref: impl ::core::convert::Into<crate::moon_sharp::interpreter::symbolref::SymbolRef>,
3946 value: impl ::core::convert::Into<crate::moon_sharp::interpreter::dynvalue::DynValue>,
3947 ) -> () {
3948 unsafe {
3949 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3950 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_assign_generic_symbol::get_method_info().method_ptr,();
3951(Processor)__receiver,(crate::moon_sharp::interpreter::symbolref::SymbolRef)::core::convert::Into::into(symref),(crate::moon_sharp::interpreter::dynvalue::DynValue)::core::convert::Into::into(value))
3952 }
3953 }
3954 #[doc = "`GetTopNonClrFunction()` overload"]
3955 fn get_top_non_clr_function(self) -> crate::moon_sharp::interpreter::execution::vm::callstackitem::CallStackItem {
3956 unsafe {
3957 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3958 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_get_top_non_clr_function::get_method_info().method_ptr,crate::moon_sharp::interpreter::execution::vm::callstackitem::CallStackItem;
3959(Processor)__receiver)
3960 }
3961 }
3962 #[doc = "`FindSymbolByName(::unity::Il2CppString)` overload"]
3963 fn find_symbol_by_name(self, name: impl ::core::convert::Into<::unity::Il2CppString>) -> crate::moon_sharp::interpreter::symbolref::SymbolRef {
3964 unsafe {
3965 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3966 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_find_symbol_by_name::get_method_info().method_ptr,crate::moon_sharp::interpreter::symbolref::SymbolRef;
3967(Processor)__receiver,(::unity::Il2CppString)::core::convert::Into::into(name))
3968 }
3969 }
3970 #[doc = "`Internal_AdjustTuple(crate::system::collections::generic::ilist_1_interface::IList_1_Interface<crate::moon_sharp::interpreter::dynvalue::DynValue>)` overload"]
3971 fn internal_adjust_tuple(
3972 self,
3973 values: impl ::core::convert::Into<
3974 crate::system::collections::generic::ilist_1_interface::IList_1_Interface<crate::moon_sharp::interpreter::dynvalue::DynValue>,
3975 >,
3976 ) -> ::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue> {
3977 unsafe {
3978 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3979 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_internal_adjust_tuple::get_method_info().method_ptr, ::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue> ;
3980(Processor)__receiver,(crate::system::collections::generic::ilist_1_interface::IList_1_Interface<crate::moon_sharp::interpreter::dynvalue::DynValue>)::core::convert::Into::into(values))
3981 }
3982 }
3983 #[doc = "`Internal_InvokeUnaryMetaMethod(crate::moon_sharp::interpreter::dynvalue::DynValue, ::unity::Il2CppString, i32)` overload"]
3984 fn internal_invoke_unary_meta_method(
3985 self,
3986 op1: impl ::core::convert::Into<crate::moon_sharp::interpreter::dynvalue::DynValue>,
3987 event_name: impl ::core::convert::Into<::unity::Il2CppString>,
3988 instruction_ptr: impl ::core::convert::Into<i32>,
3989 ) -> i32 {
3990 unsafe {
3991 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
3992 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_internal_invoke_unary_meta_method::get_method_info().method_ptr,i32;
3993(Processor)__receiver,(crate::moon_sharp::interpreter::dynvalue::DynValue)::core::convert::Into::into(op1),(::unity::Il2CppString)::core::convert::Into::into(event_name),(i32)::core::convert::Into::into(instruction_ptr))
3994 }
3995 }
3996 #[doc = "`Internal_InvokeBinaryMetaMethod(crate::moon_sharp::interpreter::dynvalue::DynValue, crate::moon_sharp::interpreter::dynvalue::DynValue, ::unity::Il2CppString, i32, crate::moon_sharp::interpreter::dynvalue::DynValue)` overload"]
3997 fn internal_invoke_binary_meta_method(
3998 self,
3999 l: impl ::core::convert::Into<crate::moon_sharp::interpreter::dynvalue::DynValue>,
4000 r: impl ::core::convert::Into<crate::moon_sharp::interpreter::dynvalue::DynValue>,
4001 event_name: impl ::core::convert::Into<::unity::Il2CppString>,
4002 instruction_ptr: impl ::core::convert::Into<i32>,
4003 extra_push: impl ::core::convert::Into<crate::moon_sharp::interpreter::dynvalue::DynValue>,
4004 ) -> i32 {
4005 unsafe {
4006 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4007 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_internal_invoke_binary_meta_method::get_method_info().method_ptr,i32;
4008(Processor)__receiver,(crate::moon_sharp::interpreter::dynvalue::DynValue)::core::convert::Into::into(l),(crate::moon_sharp::interpreter::dynvalue::DynValue)::core::convert::Into::into(r),(::unity::Il2CppString)::core::convert::Into::into(event_name),(i32)::core::convert::Into::into(instruction_ptr),(crate::moon_sharp::interpreter::dynvalue::DynValue)::core::convert::Into::into(extra_push))
4009 }
4010 }
4011 #[doc = "`StackTopToArray(i32, bool)` overload"]
4012 fn stack_top_to_array(
4013 self,
4014 items: impl ::core::convert::Into<i32>,
4015 pop: impl ::core::convert::Into<bool>,
4016 ) -> ::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue> {
4017 unsafe {
4018 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4019 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_stack_top_to_array::get_method_info().method_ptr, ::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue> ;
4020(Processor)__receiver,(i32)::core::convert::Into::into(items),(bool)::core::convert::Into::into(pop))
4021 }
4022 }
4023 #[doc = "`StackTopToArrayReverse(i32, bool)` overload"]
4024 fn stack_top_to_array_reverse(
4025 self,
4026 items: impl ::core::convert::Into<i32>,
4027 pop: impl ::core::convert::Into<bool>,
4028 ) -> ::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue> {
4029 unsafe {
4030 let __receiver = <Processor as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4031 ::unity::il2cpp_call!(__Processor_unity_raw::__lookup_stack_top_to_array_reverse::get_method_info().method_ptr, ::unity::Array<crate::moon_sharp::interpreter::dynvalue::DynValue> ;
4032(Processor)__receiver,(i32)::core::convert::Into::into(items),(bool)::core::convert::Into::into(pop))
4033 }
4034 }
4035}
4036
4037#[cfg(feature = "moon_sharp-interpreter-execution-vm-processor")]
4038impl<__T: IProcessor> IProcessorMethods for __T {}
4039
4040#[cfg(feature = "moon_sharp-interpreter-execution-vm-processor")]
4041impl Processor {
4042 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4043 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4044 }
4045
4046 pub fn ctor_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4047 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
4048 }
4049
4050 pub fn call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4051 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
4052 }
4053
4054 pub fn push_clr_to_script_stack_frame_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4055 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
4056 }
4057
4058 pub fn leave_processor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4059 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
4060 }
4061
4062 pub fn get_thread_id_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4063 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
4064 }
4065
4066 pub fn enter_processor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4067 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
4068 }
4069
4070 pub fn get_coroutine_suspended_location_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4071 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
4072 }
4073
4074 pub fn is_dump_stream_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4075 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
4076 }
4077
4078 pub fn dump_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4079 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
4080 }
4081
4082 pub fn add_symbol_to_map_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4083 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
4084 }
4085
4086 pub fn undump_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4087 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
4088 }
4089
4090 pub fn coroutine_create_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4091 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
4092 }
4093
4094 pub fn get_state_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4095 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
4096 }
4097
4098 pub fn get_associated_coroutine_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4099 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
4100 }
4101
4102 pub fn set_associated_coroutine_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4103 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
4104 }
4105
4106 pub fn coroutine_resume_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4107 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[16]
4108 }
4109
4110 pub fn find_meta_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4111 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[17]
4112 }
4113
4114 pub fn attach_debugger_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4115 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[18]
4116 }
4117
4118 pub fn get_debugger_enabled_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4119 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[19]
4120 }
4121
4122 pub fn set_debugger_enabled_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4123 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[20]
4124 }
4125
4126 pub fn listen_debugger_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4127 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[21]
4128 }
4129
4130 pub fn reset_break_points_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4131 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[22]
4132 }
4133
4134 pub fn reset_break_points_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4135 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[23]
4136 }
4137
4138 pub fn refresh_debugger_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4139 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[25]
4140 }
4141
4142 pub fn debugger_refresh_threads_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4143 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[26]
4144 }
4145
4146 pub fn debugger_refresh_v_stack_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4147 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[27]
4148 }
4149
4150 pub fn debugger_refresh_watches_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4151 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[28]
4152 }
4153
4154 pub fn debugger_refresh_locals_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4155 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[29]
4156 }
4157
4158 pub fn debugger_refresh_watch_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4159 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[30]
4160 }
4161
4162 pub fn debugger_get_call_stack_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4163 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[31]
4164 }
4165
4166 pub fn get_current_source_ref_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4167 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[32]
4168 }
4169
4170 pub fn fill_debug_data_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4171 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[33]
4172 }
4173
4174 pub fn get_metatable_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4175 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[34]
4176 }
4177
4178 pub fn get_binary_metamethod_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4179 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[35]
4180 }
4181
4182 pub fn get_metamethod_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4183 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[36]
4184 }
4185
4186 pub fn get_metamethod_raw_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4187 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[37]
4188 }
4189
4190 pub fn get_script_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4191 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[38]
4192 }
4193
4194 pub fn get_instruction_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4195 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[39]
4196 }
4197
4198 pub fn processing_loop_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4199 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[40]
4200 }
4201
4202 pub fn perform_message_decoration_before_unwind_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4203 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[41]
4204 }
4205
4206 pub fn assign_local_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4207 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[42]
4208 }
4209
4210 pub fn exec_store_lcl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4211 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[43]
4212 }
4213
4214 pub fn exec_store_upv_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4215 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[44]
4216 }
4217
4218 pub fn exec_swap_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4219 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[45]
4220 }
4221
4222 pub fn get_store_value_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4223 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[46]
4224 }
4225
4226 pub fn exec_closure_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4227 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[47]
4228 }
4229
4230 pub fn get_upvalue_symbol_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4231 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[48]
4232 }
4233
4234 pub fn exec_mk_tuple_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4235 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[49]
4236 }
4237
4238 pub fn exec_to_num_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4239 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[50]
4240 }
4241
4242 pub fn exec_iter_upd_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4243 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[51]
4244 }
4245
4246 pub fn exec_exp_tuple_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4247 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[52]
4248 }
4249
4250 pub fn exec_iter_prep_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4251 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[53]
4252 }
4253
4254 pub fn exec_j_for_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4255 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[54]
4256 }
4257
4258 pub fn exec_incr_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4259 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[55]
4260 }
4261
4262 pub fn exec_c_not_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4263 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[56]
4264 }
4265
4266 pub fn exec_not_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4267 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[57]
4268 }
4269
4270 pub fn exec_begin_fn_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4271 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[58]
4272 }
4273
4274 pub fn pop_to_base_pointer_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4275 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[59]
4276 }
4277
4278 pub fn pop_exec_stack_and_check_v_stack_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4279 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[60]
4280 }
4281
4282 pub fn create_args_list_for_function_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4283 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[61]
4284 }
4285
4286 pub fn exec_args_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4287 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[62]
4288 }
4289
4290 pub fn internal_exec_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4291 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[63]
4292 }
4293
4294 pub fn perform_tco_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4295 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[64]
4296 }
4297
4298 pub fn exec_ret_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4299 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[65]
4300 }
4301
4302 pub fn internal_check_for_tail_requests_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4303 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[66]
4304 }
4305
4306 pub fn jump_bool_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4307 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[67]
4308 }
4309
4310 pub fn exec_short_circuiting_operator_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4311 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[68]
4312 }
4313
4314 pub fn exec_add_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4315 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[69]
4316 }
4317
4318 pub fn exec_sub_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4319 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[70]
4320 }
4321
4322 pub fn exec_mul_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4323 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[71]
4324 }
4325
4326 pub fn exec_mod_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4327 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[72]
4328 }
4329
4330 pub fn exec_div_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4331 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[73]
4332 }
4333
4334 pub fn exec_power_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4335 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[74]
4336 }
4337
4338 pub fn exec_neg_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4339 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[75]
4340 }
4341
4342 pub fn exec_eq_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4343 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[76]
4344 }
4345
4346 pub fn exec_less_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4347 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[77]
4348 }
4349
4350 pub fn exec_less_eq_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4351 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[78]
4352 }
4353
4354 pub fn exec_len_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4355 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[79]
4356 }
4357
4358 pub fn exec_concat_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4359 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[80]
4360 }
4361
4362 pub fn exec_tbl_init_i_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4363 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[81]
4364 }
4365
4366 pub fn exec_tbl_init_n_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4367 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[82]
4368 }
4369
4370 pub fn exec_index_set_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4371 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[83]
4372 }
4373
4374 pub fn exec_index_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4375 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[84]
4376 }
4377
4378 pub fn clear_block_data_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4379 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[85]
4380 }
4381
4382 pub fn get_generic_symbol_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4383 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[86]
4384 }
4385
4386 pub fn get_global_symbol_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4387 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[87]
4388 }
4389
4390 pub fn set_global_symbol_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4391 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[88]
4392 }
4393
4394 pub fn assign_generic_symbol_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4395 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[89]
4396 }
4397
4398 pub fn get_top_non_clr_function_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4399 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[90]
4400 }
4401
4402 pub fn find_symbol_by_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4403 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[91]
4404 }
4405
4406 pub fn internal_adjust_tuple_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4407 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[92]
4408 }
4409
4410 pub fn internal_invoke_unary_meta_method_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4411 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[93]
4412 }
4413
4414 pub fn internal_invoke_binary_meta_method_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4415 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[94]
4416 }
4417
4418 pub fn stack_top_to_array_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4419 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[95]
4420 }
4421
4422 pub fn stack_top_to_array_reverse_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4423 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[96]
4424 }
4425}
4426
4427#[cfg(feature = "moon_sharp-interpreter-execution-vm-processor")]
4428impl Processor {
4429 #[doc = "`.ctor(crate::moon_sharp::interpreter::script::Script, crate::moon_sharp::interpreter::table::Table, crate::moon_sharp::interpreter::execution::vm::bytecode::ByteCode)` — overload selector"]
4430 pub fn new(
4431 script: crate::moon_sharp::interpreter::script::Script,
4432 global_context: crate::moon_sharp::interpreter::table::Table,
4433 byte_code: crate::moon_sharp::interpreter::execution::vm::bytecode::ByteCode,
4434 ) -> Self {
4435 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
4436 panic!(
4437 "{}
4438::{}
4439 failed to instantiate",
4440 ::core::stringify!(Processor),
4441 ::core::stringify!(new),
4442 )
4443 });
4444 <Self as IProcessorMethods>::ctor(this, script, global_context, byte_code);
4445 this
4446 }
4447
4448 #[doc = "`.ctor(crate::moon_sharp::interpreter::execution::vm::processor::Processor)` — overload selector"]
4449 pub fn new_2(parent_processor: crate::moon_sharp::interpreter::execution::vm::processor::Processor) -> Self {
4450 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
4451 panic!(
4452 "{}
4453::{}
4454 failed to instantiate",
4455 ::core::stringify!(Processor),
4456 ::core::stringify!(new_2),
4457 )
4458 });
4459 <Self as IProcessorMethods>::ctor_2(this, parent_processor);
4460 this
4461 }
4462}
4463
4464#[cfg(feature = "moon_sharp-interpreter-execution-vm-processor")]
4465#[doc(hidden)]
4466#[allow(non_snake_case, non_camel_case_types, clippy::too_many_arguments)]
4467mod __Processor_DebugContext_unity_raw {
4468 use super::*;
4469 #[doc(hidden)]
4470 #[allow(non_snake_case)]
4471 pub mod __lookup_ctor {
4472 use super::*;
4473 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
4474 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
4475 ::unity::lookup::method_info_on_class_with_signature(
4476 <Processor_DebugContext as ::unity::ClassIdentity>::class(),
4477 ".ctor",
4478 0,
4479 param_types,
4480 false,
4481 )
4482 });
4483 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4484 match &*METHOD {
4485 ::core::result::Result::Ok(mi) => *mi,
4486 ::core::result::Result::Err(e) => {
4487 panic!(
4488 "method lookup failed: {}
4489::{}
4490: {}
4491",
4492 <Processor_DebugContext as ::unity::ClassIdentity>::NAME,
4493 ".ctor",
4494 e
4495 )
4496 },
4497 }
4498 }
4499 }
4500}
4501
4502#[cfg(feature = "moon_sharp-interpreter-execution-vm-processor")]
4503pub trait IProcessor_DebugContextMethods: IProcessor_DebugContext {
4504 #[doc = "`.ctor()` overload"]
4505 fn ctor(self) -> () {
4506 unsafe {
4507 let __receiver =
4508 <Processor_DebugContext as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
4509 ::unity::il2cpp_call!(__Processor_DebugContext_unity_raw::__lookup_ctor::get_method_info().method_ptr,();
4510(Processor_DebugContext)__receiver)
4511 }
4512 }
4513}
4514
4515#[cfg(feature = "moon_sharp-interpreter-execution-vm-processor")]
4516impl<__T: IProcessor_DebugContext> IProcessor_DebugContextMethods for __T {}
4517
4518#[cfg(feature = "moon_sharp-interpreter-execution-vm-processor")]
4519impl Processor_DebugContext {
4520 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
4521 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
4522 }
4523}
4524
4525#[cfg(feature = "moon_sharp-interpreter-execution-vm-processor")]
4526impl Processor_DebugContext {
4527 #[doc = "`.ctor()` — no args"]
4528 pub fn new() -> Self {
4529 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
4530 panic!(
4531 "{}
4532::{}
4533 failed to instantiate",
4534 ::core::stringify!(Processor_DebugContext),
4535 ::core::stringify!(new),
4536 )
4537 });
4538 <Self as IProcessor_DebugContextMethods>::ctor(this);
4539 this
4540 }
4541}
4542
4543#[cfg(feature = "moon_sharp-interpreter-execution-vm-processor")]
4544#[doc(hidden)]
4545pub mod prelude {
4546 pub use super::{IProcessor, IProcessorMethods, IProcessor_DebugContext, IProcessor_DebugContextMethods, Processor, Processor_DebugContext};
4547 pub use crate::system::object::IObject;
4548 #[cfg(feature = "system-object")]
4549 pub use crate::system::object::IObjectMethods;
4550}