1#[cfg(feature = "moon_sharp-interpreter-interop-lua_state_interop-luabase-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/interop/lua_state_interop/luabase/LuaBase.md"))]
11 #[::unity::class(namespace = "MoonSharp.Interpreter.Interop.LuaStateInterop", name = "LuaBase")]
12 #[parent(crate::system::object::Object)]
13 pub struct LuaBase {
14 #[static_field]
15 #[rename(name = "LUA_TNONE")]
16 pub lua_tnone: i32,
17 #[static_field]
18 #[rename(name = "LUA_TNIL")]
19 pub lua_tnil: i32,
20 #[static_field]
21 #[rename(name = "LUA_TBOOLEAN")]
22 pub lua_tboolean: i32,
23 #[static_field]
24 #[rename(name = "LUA_TLIGHTUSERDATA")]
25 pub lua_tlightuserdata: i32,
26 #[static_field]
27 #[rename(name = "LUA_TNUMBER")]
28 pub lua_tnumber: i32,
29 #[static_field]
30 #[rename(name = "LUA_TSTRING")]
31 pub lua_tstring: i32,
32 #[static_field]
33 #[rename(name = "LUA_TTABLE")]
34 pub lua_ttable: i32,
35 #[static_field]
36 #[rename(name = "LUA_TFUNCTION")]
37 pub lua_tfunction: i32,
38 #[static_field]
39 #[rename(name = "LUA_TUSERDATA")]
40 pub lua_tuserdata: i32,
41 #[static_field]
42 #[rename(name = "LUA_TTHREAD")]
43 pub lua_tthread: i32,
44 #[static_field]
45 #[rename(name = "LUA_MULTRET")]
46 pub lua_multret: i32,
47 #[static_field]
48 #[rename(name = "LUA_INTFRMLEN")]
49 pub lua_intfrmlen: ::unity::Il2CppString,
50 }
51}
52
53#[cfg(feature = "moon_sharp-interpreter-interop-lua_state_interop-luabase-types")]
54pub use __types::*;
55
56#[cfg(feature = "moon_sharp-interpreter-interop-lua_state_interop-luabase")]
57#[doc(hidden)]
58#[allow(non_snake_case, non_camel_case_types, clippy::too_many_arguments)]
59mod __LuaBase_unity_raw {
60 use super::*;
61 #[doc(hidden)]
62 #[allow(non_snake_case)]
63 pub mod __lookup_get_argument {
64 use super::*;
65 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
66 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
67 <crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState as ::unity::IlType>::il_type(),
68 <i32 as ::unity::IlType>::il_type(),
69 ];
70 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "GetArgument", 2, param_types, true)
71 });
72 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
73 match &*METHOD {
74 ::core::result::Result::Ok(mi) => *mi,
75 ::core::result::Result::Err(e) => {
76 panic!(
77 "method lookup failed: {}
78::{}
79: {}
80",
81 <LuaBase as ::unity::ClassIdentity>::NAME,
82 "GetArgument",
83 e
84 )
85 },
86 }
87 }
88 }
89 #[doc(hidden)]
90 #[allow(non_snake_case)]
91 pub mod __lookup_arg_as_type {
92 use super::*;
93 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
94 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
95 <crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState as ::unity::IlType>::il_type(),
96 <i32 as ::unity::IlType>::il_type(),
97 <crate::moon_sharp::interpreter::datatype::DataType as ::unity::IlType>::il_type(),
98 <bool as ::unity::IlType>::il_type(),
99 ];
100 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "ArgAsType", 4, param_types, true)
101 });
102 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
103 match &*METHOD {
104 ::core::result::Result::Ok(mi) => *mi,
105 ::core::result::Result::Err(e) => {
106 panic!(
107 "method lookup failed: {}
108::{}
109: {}
110",
111 <LuaBase as ::unity::ClassIdentity>::NAME,
112 "ArgAsType",
113 e
114 )
115 },
116 }
117 }
118 }
119 #[doc(hidden)]
120 #[allow(non_snake_case)]
121 pub mod __lookup_lua_type {
122 use super::*;
123 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
124 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
125 <crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState as ::unity::IlType>::il_type(),
126 <i32 as ::unity::IlType>::il_type(),
127 ];
128 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "LuaType", 2, param_types, true)
129 });
130 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
131 match &*METHOD {
132 ::core::result::Result::Ok(mi) => *mi,
133 ::core::result::Result::Err(e) => {
134 panic!(
135 "method lookup failed: {}
136::{}
137: {}
138",
139 <LuaBase as ::unity::ClassIdentity>::NAME,
140 "LuaType",
141 e
142 )
143 },
144 }
145 }
146 }
147 #[doc(hidden)]
148 #[allow(non_snake_case)]
149 pub mod __lookup_lua_l_check_l_string {
150 use super::*;
151 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
152 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
153 <crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState as ::unity::IlType>::il_type(),
154 <i32 as ::unity::IlType>::il_type(),
155 <u32 as ::unity::IlType>::il_type(),
156 ];
157 ::unity::lookup::method_info_on_class_with_signature(
158 <LuaBase as ::unity::ClassIdentity>::class(),
159 "LuaLCheckLString",
160 3,
161 param_types,
162 true,
163 )
164 });
165 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
166 match &*METHOD {
167 ::core::result::Result::Ok(mi) => *mi,
168 ::core::result::Result::Err(e) => {
169 panic!(
170 "method lookup failed: {}
171::{}
172: {}
173",
174 <LuaBase as ::unity::ClassIdentity>::NAME,
175 "LuaLCheckLString",
176 e
177 )
178 },
179 }
180 }
181 }
182 #[doc(hidden)]
183 #[allow(non_snake_case)]
184 pub mod __lookup_lua_push_integer {
185 use super::*;
186 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
187 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
188 <crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState as ::unity::IlType>::il_type(),
189 <i32 as ::unity::IlType>::il_type(),
190 ];
191 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "LuaPushInteger", 2, param_types, true)
192 });
193 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
194 match &*METHOD {
195 ::core::result::Result::Ok(mi) => *mi,
196 ::core::result::Result::Err(e) => {
197 panic!(
198 "method lookup failed: {}
199::{}
200: {}
201",
202 <LuaBase as ::unity::ClassIdentity>::NAME,
203 "LuaPushInteger",
204 e
205 )
206 },
207 }
208 }
209 }
210 #[doc(hidden)]
211 #[allow(non_snake_case)]
212 pub mod __lookup_lua_to_boolean {
213 use super::*;
214 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
215 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
216 <crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState as ::unity::IlType>::il_type(),
217 <i32 as ::unity::IlType>::il_type(),
218 ];
219 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "LuaToBoolean", 2, param_types, true)
220 });
221 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
222 match &*METHOD {
223 ::core::result::Result::Ok(mi) => *mi,
224 ::core::result::Result::Err(e) => {
225 panic!(
226 "method lookup failed: {}
227::{}
228: {}
229",
230 <LuaBase as ::unity::ClassIdentity>::NAME,
231 "LuaToBoolean",
232 e
233 )
234 },
235 }
236 }
237 }
238 #[doc(hidden)]
239 #[allow(non_snake_case)]
240 pub mod __lookup_lua_to_l_string {
241 use super::*;
242 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
243 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
244 <crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState as ::unity::IlType>::il_type(),
245 <i32 as ::unity::IlType>::il_type(),
246 <u32 as ::unity::IlType>::il_type(),
247 ];
248 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "LuaToLString", 3, param_types, true)
249 });
250 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
251 match &*METHOD {
252 ::core::result::Result::Ok(mi) => *mi,
253 ::core::result::Result::Err(e) => {
254 panic!(
255 "method lookup failed: {}
256::{}
257: {}
258",
259 <LuaBase as ::unity::ClassIdentity>::NAME,
260 "LuaToLString",
261 e
262 )
263 },
264 }
265 }
266 }
267 #[doc(hidden)]
268 #[allow(non_snake_case)]
269 pub mod __lookup_lua_to_string {
270 use super::*;
271 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
272 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
273 <crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState as ::unity::IlType>::il_type(),
274 <i32 as ::unity::IlType>::il_type(),
275 ];
276 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "LuaToString", 2, param_types, true)
277 });
278 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
279 match &*METHOD {
280 ::core::result::Result::Ok(mi) => *mi,
281 ::core::result::Result::Err(e) => {
282 panic!(
283 "method lookup failed: {}
284::{}
285: {}
286",
287 <LuaBase as ::unity::ClassIdentity>::NAME,
288 "LuaToString",
289 e
290 )
291 },
292 }
293 }
294 }
295 #[doc(hidden)]
296 #[allow(non_snake_case)]
297 pub mod __lookup_lua_l_add_value {
298 use super::*;
299 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
300 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
301 &[<crate::moon_sharp::interpreter::interop::lua_state_interop::lualbuffer::LuaLBuffer as ::unity::IlType>::il_type()];
302 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "LuaLAddValue", 1, param_types, true)
303 });
304 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
305 match &*METHOD {
306 ::core::result::Result::Ok(mi) => *mi,
307 ::core::result::Result::Err(e) => {
308 panic!(
309 "method lookup failed: {}
310::{}
311: {}
312",
313 <LuaBase as ::unity::ClassIdentity>::NAME,
314 "LuaLAddValue",
315 e
316 )
317 },
318 }
319 }
320 }
321 #[doc(hidden)]
322 #[allow(non_snake_case)]
323 pub mod __lookup_lua_l_add_l_string {
324 use super::*;
325 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
326 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
327 <crate::moon_sharp::interpreter::interop::lua_state_interop::lualbuffer::LuaLBuffer as ::unity::IlType>::il_type(),
328 <crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr as ::unity::IlType>::il_type(),
329 <u32 as ::unity::IlType>::il_type(),
330 ];
331 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "LuaLAddLString", 3, param_types, true)
332 });
333 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
334 match &*METHOD {
335 ::core::result::Result::Ok(mi) => *mi,
336 ::core::result::Result::Err(e) => {
337 panic!(
338 "method lookup failed: {}
339::{}
340: {}
341",
342 <LuaBase as ::unity::ClassIdentity>::NAME,
343 "LuaLAddLString",
344 e
345 )
346 },
347 }
348 }
349 }
350 #[doc(hidden)]
351 #[allow(non_snake_case)]
352 pub mod __lookup_lua_l_add_string {
353 use super::*;
354 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
355 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
356 <crate::moon_sharp::interpreter::interop::lua_state_interop::lualbuffer::LuaLBuffer as ::unity::IlType>::il_type(),
357 <::unity::Il2CppString as ::unity::IlType>::il_type(),
358 ];
359 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "LuaLAddString", 2, param_types, true)
360 });
361 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
362 match &*METHOD {
363 ::core::result::Result::Ok(mi) => *mi,
364 ::core::result::Result::Err(e) => {
365 panic!(
366 "method lookup failed: {}
367::{}
368: {}
369",
370 <LuaBase as ::unity::ClassIdentity>::NAME,
371 "LuaLAddString",
372 e
373 )
374 },
375 }
376 }
377 }
378 #[doc(hidden)]
379 #[allow(non_snake_case)]
380 pub mod __lookup_lua_l_opt_integer {
381 use super::*;
382 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
383 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
384 <crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState as ::unity::IlType>::il_type(),
385 <i32 as ::unity::IlType>::il_type(),
386 <i32 as ::unity::IlType>::il_type(),
387 ];
388 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "LuaLOptInteger", 3, param_types, true)
389 });
390 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
391 match &*METHOD {
392 ::core::result::Result::Ok(mi) => *mi,
393 ::core::result::Result::Err(e) => {
394 panic!(
395 "method lookup failed: {}
396::{}
397: {}
398",
399 <LuaBase as ::unity::ClassIdentity>::NAME,
400 "LuaLOptInteger",
401 e
402 )
403 },
404 }
405 }
406 }
407 #[doc(hidden)]
408 #[allow(non_snake_case)]
409 pub mod __lookup_lua_l_check_integer {
410 use super::*;
411 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
412 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
413 <crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState as ::unity::IlType>::il_type(),
414 <i32 as ::unity::IlType>::il_type(),
415 ];
416 ::unity::lookup::method_info_on_class_with_signature(
417 <LuaBase as ::unity::ClassIdentity>::class(),
418 "LuaLCheckInteger",
419 2,
420 param_types,
421 true,
422 )
423 });
424 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
425 match &*METHOD {
426 ::core::result::Result::Ok(mi) => *mi,
427 ::core::result::Result::Err(e) => {
428 panic!(
429 "method lookup failed: {}
430::{}
431: {}
432",
433 <LuaBase as ::unity::ClassIdentity>::NAME,
434 "LuaLCheckInteger",
435 e
436 )
437 },
438 }
439 }
440 }
441 #[doc(hidden)]
442 #[allow(non_snake_case)]
443 pub mod __lookup_lua_l_arg_check {
444 use super::*;
445 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
446 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
447 <crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState as ::unity::IlType>::il_type(),
448 <bool as ::unity::IlType>::il_type(),
449 <i32 as ::unity::IlType>::il_type(),
450 <::unity::Il2CppString as ::unity::IlType>::il_type(),
451 ];
452 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "LuaLArgCheck", 4, param_types, true)
453 });
454 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
455 match &*METHOD {
456 ::core::result::Result::Ok(mi) => *mi,
457 ::core::result::Result::Err(e) => {
458 panic!(
459 "method lookup failed: {}
460::{}
461: {}
462",
463 <LuaBase as ::unity::ClassIdentity>::NAME,
464 "LuaLArgCheck",
465 e
466 )
467 },
468 }
469 }
470 }
471 #[doc(hidden)]
472 #[allow(non_snake_case)]
473 pub mod __lookup_lua_l_check_int {
474 use super::*;
475 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
476 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
477 <crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState as ::unity::IlType>::il_type(),
478 <i32 as ::unity::IlType>::il_type(),
479 ];
480 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "LuaLCheckInt", 2, param_types, true)
481 });
482 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
483 match &*METHOD {
484 ::core::result::Result::Ok(mi) => *mi,
485 ::core::result::Result::Err(e) => {
486 panic!(
487 "method lookup failed: {}
488::{}
489: {}
490",
491 <LuaBase as ::unity::ClassIdentity>::NAME,
492 "LuaLCheckInt",
493 e
494 )
495 },
496 }
497 }
498 }
499 #[doc(hidden)]
500 #[allow(non_snake_case)]
501 pub mod __lookup_lua_get_top {
502 use super::*;
503 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
504 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
505 &[<crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState as ::unity::IlType>::il_type()];
506 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "LuaGetTop", 1, param_types, true)
507 });
508 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
509 match &*METHOD {
510 ::core::result::Result::Ok(mi) => *mi,
511 ::core::result::Result::Err(e) => {
512 panic!(
513 "method lookup failed: {}
514::{}
515: {}
516",
517 <LuaBase as ::unity::ClassIdentity>::NAME,
518 "LuaGetTop",
519 e
520 )
521 },
522 }
523 }
524 }
525 #[doc(hidden)]
526 #[allow(non_snake_case)]
527 pub mod __lookup_lua_l_error {
528 use super::*;
529 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
530 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
531 <crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState as ::unity::IlType>::il_type(),
532 <::unity::Il2CppString as ::unity::IlType>::il_type(),
533 <::unity::Array<crate::system::object::Object> as ::unity::IlType>::il_type(),
534 ];
535 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "LuaLError", 3, param_types, true)
536 });
537 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
538 match &*METHOD {
539 ::core::result::Result::Ok(mi) => *mi,
540 ::core::result::Result::Err(e) => {
541 panic!(
542 "method lookup failed: {}
543::{}
544: {}
545",
546 <LuaBase as ::unity::ClassIdentity>::NAME,
547 "LuaLError",
548 e
549 )
550 },
551 }
552 }
553 }
554 #[doc(hidden)]
555 #[allow(non_snake_case)]
556 pub mod __lookup_lua_l_add_char {
557 use super::*;
558 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
559 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
560 <crate::moon_sharp::interpreter::interop::lua_state_interop::lualbuffer::LuaLBuffer as ::unity::IlType>::il_type(),
561 <u16 as ::unity::IlType>::il_type(),
562 ];
563 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "LuaLAddChar", 2, param_types, true)
564 });
565 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
566 match &*METHOD {
567 ::core::result::Result::Ok(mi) => *mi,
568 ::core::result::Result::Err(e) => {
569 panic!(
570 "method lookup failed: {}
571::{}
572: {}
573",
574 <LuaBase as ::unity::ClassIdentity>::NAME,
575 "LuaLAddChar",
576 e
577 )
578 },
579 }
580 }
581 }
582 #[doc(hidden)]
583 #[allow(non_snake_case)]
584 pub mod __lookup_lua_l_buff_init {
585 use super::*;
586 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
587 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
588 <crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState as ::unity::IlType>::il_type(),
589 <crate::moon_sharp::interpreter::interop::lua_state_interop::lualbuffer::LuaLBuffer as ::unity::IlType>::il_type(),
590 ];
591 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "LuaLBuffInit", 2, param_types, true)
592 });
593 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
594 match &*METHOD {
595 ::core::result::Result::Ok(mi) => *mi,
596 ::core::result::Result::Err(e) => {
597 panic!(
598 "method lookup failed: {}
599::{}
600: {}
601",
602 <LuaBase as ::unity::ClassIdentity>::NAME,
603 "LuaLBuffInit",
604 e
605 )
606 },
607 }
608 }
609 }
610 #[doc(hidden)]
611 #[allow(non_snake_case)]
612 pub mod __lookup_lua_push_literal {
613 use super::*;
614 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
615 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
616 <crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState as ::unity::IlType>::il_type(),
617 <::unity::Il2CppString as ::unity::IlType>::il_type(),
618 ];
619 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "LuaPushLiteral", 2, param_types, true)
620 });
621 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
622 match &*METHOD {
623 ::core::result::Result::Ok(mi) => *mi,
624 ::core::result::Result::Err(e) => {
625 panic!(
626 "method lookup failed: {}
627::{}
628: {}
629",
630 <LuaBase as ::unity::ClassIdentity>::NAME,
631 "LuaPushLiteral",
632 e
633 )
634 },
635 }
636 }
637 }
638 #[doc(hidden)]
639 #[allow(non_snake_case)]
640 pub mod __lookup_lua_l_push_result {
641 use super::*;
642 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
643 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
644 &[<crate::moon_sharp::interpreter::interop::lua_state_interop::lualbuffer::LuaLBuffer as ::unity::IlType>::il_type()];
645 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "LuaLPushResult", 1, param_types, true)
646 });
647 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
648 match &*METHOD {
649 ::core::result::Result::Ok(mi) => *mi,
650 ::core::result::Result::Err(e) => {
651 panic!(
652 "method lookup failed: {}
653::{}
654: {}
655",
656 <LuaBase as ::unity::ClassIdentity>::NAME,
657 "LuaLPushResult",
658 e
659 )
660 },
661 }
662 }
663 }
664 #[doc(hidden)]
665 #[allow(non_snake_case)]
666 pub mod __lookup_lua_push_l_string {
667 use super::*;
668 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
669 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
670 <crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState as ::unity::IlType>::il_type(),
671 <crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr as ::unity::IlType>::il_type(),
672 <u32 as ::unity::IlType>::il_type(),
673 ];
674 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "LuaPushLString", 3, param_types, true)
675 });
676 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
677 match &*METHOD {
678 ::core::result::Result::Ok(mi) => *mi,
679 ::core::result::Result::Err(e) => {
680 panic!(
681 "method lookup failed: {}
682::{}
683: {}
684",
685 <LuaBase as ::unity::ClassIdentity>::NAME,
686 "LuaPushLString",
687 e
688 )
689 },
690 }
691 }
692 }
693 #[doc(hidden)]
694 #[allow(non_snake_case)]
695 pub mod __lookup_lua_l_check_stack {
696 use super::*;
697 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
698 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
699 <crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState as ::unity::IlType>::il_type(),
700 <i32 as ::unity::IlType>::il_type(),
701 <::unity::Il2CppString as ::unity::IlType>::il_type(),
702 ];
703 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "LuaLCheckStack", 3, param_types, true)
704 });
705 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
706 match &*METHOD {
707 ::core::result::Result::Ok(mi) => *mi,
708 ::core::result::Result::Err(e) => {
709 panic!(
710 "method lookup failed: {}
711::{}
712: {}
713",
714 <LuaBase as ::unity::ClassIdentity>::NAME,
715 "LuaLCheckStack",
716 e
717 )
718 },
719 }
720 }
721 }
722 #[doc(hidden)]
723 #[allow(non_snake_case)]
724 pub mod __lookup_lua_ql {
725 use super::*;
726 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
727 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<::unity::Il2CppString as ::unity::IlType>::il_type()];
728 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "LUA_QL", 1, param_types, true)
729 });
730 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
731 match &*METHOD {
732 ::core::result::Result::Ok(mi) => *mi,
733 ::core::result::Result::Err(e) => {
734 panic!(
735 "method lookup failed: {}
736::{}
737: {}
738",
739 <LuaBase as ::unity::ClassIdentity>::NAME,
740 "LUA_QL",
741 e
742 )
743 },
744 }
745 }
746 }
747 #[doc(hidden)]
748 #[allow(non_snake_case)]
749 pub mod __lookup_lua_push_nil {
750 use super::*;
751 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
752 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
753 &[<crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState as ::unity::IlType>::il_type()];
754 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "LuaPushNil", 1, param_types, true)
755 });
756 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
757 match &*METHOD {
758 ::core::result::Result::Ok(mi) => *mi,
759 ::core::result::Result::Err(e) => {
760 panic!(
761 "method lookup failed: {}
762::{}
763: {}
764",
765 <LuaBase as ::unity::ClassIdentity>::NAME,
766 "LuaPushNil",
767 e
768 )
769 },
770 }
771 }
772 }
773 #[doc(hidden)]
774 #[allow(non_snake_case)]
775 pub mod __lookup_lua_assert {
776 use super::*;
777 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
778 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<bool as ::unity::IlType>::il_type()];
779 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "LuaAssert", 1, param_types, true)
780 });
781 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
782 match &*METHOD {
783 ::core::result::Result::Ok(mi) => *mi,
784 ::core::result::Result::Err(e) => {
785 panic!(
786 "method lookup failed: {}
787::{}
788: {}
789",
790 <LuaBase as ::unity::ClassIdentity>::NAME,
791 "LuaAssert",
792 e
793 )
794 },
795 }
796 }
797 }
798 #[doc(hidden)]
799 #[allow(non_snake_case)]
800 pub mod __lookup_lua_l_type_name {
801 use super::*;
802 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
803 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
804 <crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState as ::unity::IlType>::il_type(),
805 <i32 as ::unity::IlType>::il_type(),
806 ];
807 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "LuaLTypeName", 2, param_types, true)
808 });
809 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
810 match &*METHOD {
811 ::core::result::Result::Ok(mi) => *mi,
812 ::core::result::Result::Err(e) => {
813 panic!(
814 "method lookup failed: {}
815::{}
816: {}
817",
818 <LuaBase as ::unity::ClassIdentity>::NAME,
819 "LuaLTypeName",
820 e
821 )
822 },
823 }
824 }
825 }
826 #[doc(hidden)]
827 #[allow(non_snake_case)]
828 pub mod __lookup_lua_is_string {
829 use super::*;
830 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
831 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
832 <crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState as ::unity::IlType>::il_type(),
833 <i32 as ::unity::IlType>::il_type(),
834 ];
835 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "LuaIsString", 2, param_types, true)
836 });
837 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
838 match &*METHOD {
839 ::core::result::Result::Ok(mi) => *mi,
840 ::core::result::Result::Err(e) => {
841 panic!(
842 "method lookup failed: {}
843::{}
844: {}
845",
846 <LuaBase as ::unity::ClassIdentity>::NAME,
847 "LuaIsString",
848 e
849 )
850 },
851 }
852 }
853 }
854 #[doc(hidden)]
855 #[allow(non_snake_case)]
856 pub mod __lookup_lua_pop {
857 use super::*;
858 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
859 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
860 <crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState as ::unity::IlType>::il_type(),
861 <i32 as ::unity::IlType>::il_type(),
862 ];
863 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "LuaPop", 2, param_types, true)
864 });
865 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
866 match &*METHOD {
867 ::core::result::Result::Ok(mi) => *mi,
868 ::core::result::Result::Err(e) => {
869 panic!(
870 "method lookup failed: {}
871::{}
872: {}
873",
874 <LuaBase as ::unity::ClassIdentity>::NAME,
875 "LuaPop",
876 e
877 )
878 },
879 }
880 }
881 }
882 #[doc(hidden)]
883 #[allow(non_snake_case)]
884 pub mod __lookup_lua_get_table {
885 use super::*;
886 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
887 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
888 <crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState as ::unity::IlType>::il_type(),
889 <i32 as ::unity::IlType>::il_type(),
890 ];
891 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "LuaGetTable", 2, param_types, true)
892 });
893 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
894 match &*METHOD {
895 ::core::result::Result::Ok(mi) => *mi,
896 ::core::result::Result::Err(e) => {
897 panic!(
898 "method lookup failed: {}
899::{}
900: {}
901",
902 <LuaBase as ::unity::ClassIdentity>::NAME,
903 "LuaGetTable",
904 e
905 )
906 },
907 }
908 }
909 }
910 #[doc(hidden)]
911 #[allow(non_snake_case)]
912 pub mod __lookup_lua_l_opt_int {
913 use super::*;
914 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
915 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
916 <crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState as ::unity::IlType>::il_type(),
917 <i32 as ::unity::IlType>::il_type(),
918 <i32 as ::unity::IlType>::il_type(),
919 ];
920 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "LuaLOptInt", 3, param_types, true)
921 });
922 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
923 match &*METHOD {
924 ::core::result::Result::Ok(mi) => *mi,
925 ::core::result::Result::Err(e) => {
926 panic!(
927 "method lookup failed: {}
928::{}
929: {}
930",
931 <LuaBase as ::unity::ClassIdentity>::NAME,
932 "LuaLOptInt",
933 e
934 )
935 },
936 }
937 }
938 }
939 #[doc(hidden)]
940 #[allow(non_snake_case)]
941 pub mod __lookup_lua_l_check_string {
942 use super::*;
943 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
944 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
945 <crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState as ::unity::IlType>::il_type(),
946 <i32 as ::unity::IlType>::il_type(),
947 ];
948 ::unity::lookup::method_info_on_class_with_signature(
949 <LuaBase as ::unity::ClassIdentity>::class(),
950 "LuaLCheckString",
951 2,
952 param_types,
953 true,
954 )
955 });
956 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
957 match &*METHOD {
958 ::core::result::Result::Ok(mi) => *mi,
959 ::core::result::Result::Err(e) => {
960 panic!(
961 "method lookup failed: {}
962::{}
963: {}
964",
965 <LuaBase as ::unity::ClassIdentity>::NAME,
966 "LuaLCheckString",
967 e
968 )
969 },
970 }
971 }
972 }
973 #[doc(hidden)]
974 #[allow(non_snake_case)]
975 pub mod __lookup_lua_l_check_string_str {
976 use super::*;
977 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
978 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
979 <crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState as ::unity::IlType>::il_type(),
980 <i32 as ::unity::IlType>::il_type(),
981 ];
982 ::unity::lookup::method_info_on_class_with_signature(
983 <LuaBase as ::unity::ClassIdentity>::class(),
984 "LuaLCheckStringStr",
985 2,
986 param_types,
987 true,
988 )
989 });
990 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
991 match &*METHOD {
992 ::core::result::Result::Ok(mi) => *mi,
993 ::core::result::Result::Err(e) => {
994 panic!(
995 "method lookup failed: {}
996::{}
997: {}
998",
999 <LuaBase as ::unity::ClassIdentity>::NAME,
1000 "LuaLCheckStringStr",
1001 e
1002 )
1003 },
1004 }
1005 }
1006 }
1007 #[doc(hidden)]
1008 #[allow(non_snake_case)]
1009 pub mod __lookup_lua_l_arg_error {
1010 use super::*;
1011 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1012 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
1013 <crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState as ::unity::IlType>::il_type(),
1014 <i32 as ::unity::IlType>::il_type(),
1015 <::unity::Il2CppString as ::unity::IlType>::il_type(),
1016 ];
1017 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "LuaLArgError", 3, param_types, true)
1018 });
1019 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1020 match &*METHOD {
1021 ::core::result::Result::Ok(mi) => *mi,
1022 ::core::result::Result::Err(e) => {
1023 panic!(
1024 "method lookup failed: {}
1025::{}
1026: {}
1027",
1028 <LuaBase as ::unity::ClassIdentity>::NAME,
1029 "LuaLArgError",
1030 e
1031 )
1032 },
1033 }
1034 }
1035 }
1036 #[doc(hidden)]
1037 #[allow(non_snake_case)]
1038 pub mod __lookup_lua_l_check_number {
1039 use super::*;
1040 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1041 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
1042 <crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState as ::unity::IlType>::il_type(),
1043 <i32 as ::unity::IlType>::il_type(),
1044 ];
1045 ::unity::lookup::method_info_on_class_with_signature(
1046 <LuaBase as ::unity::ClassIdentity>::class(),
1047 "LuaLCheckNumber",
1048 2,
1049 param_types,
1050 true,
1051 )
1052 });
1053 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1054 match &*METHOD {
1055 ::core::result::Result::Ok(mi) => *mi,
1056 ::core::result::Result::Err(e) => {
1057 panic!(
1058 "method lookup failed: {}
1059::{}
1060: {}
1061",
1062 <LuaBase as ::unity::ClassIdentity>::NAME,
1063 "LuaLCheckNumber",
1064 e
1065 )
1066 },
1067 }
1068 }
1069 }
1070 #[doc(hidden)]
1071 #[allow(non_snake_case)]
1072 pub mod __lookup_lua_push_value {
1073 use super::*;
1074 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1075 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
1076 <crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState as ::unity::IlType>::il_type(),
1077 <i32 as ::unity::IlType>::il_type(),
1078 ];
1079 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "LuaPushValue", 2, param_types, true)
1080 });
1081 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1082 match &*METHOD {
1083 ::core::result::Result::Ok(mi) => *mi,
1084 ::core::result::Result::Err(e) => {
1085 panic!(
1086 "method lookup failed: {}
1087::{}
1088: {}
1089",
1090 <LuaBase as ::unity::ClassIdentity>::NAME,
1091 "LuaPushValue",
1092 e
1093 )
1094 },
1095 }
1096 }
1097 }
1098 #[doc(hidden)]
1099 #[allow(non_snake_case)]
1100 pub mod __lookup_lua_call {
1101 use super::*;
1102 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1103 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
1104 <crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState as ::unity::IlType>::il_type(),
1105 <i32 as ::unity::IlType>::il_type(),
1106 <i32 as ::unity::IlType>::il_type(),
1107 ];
1108 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "LuaCall", 3, param_types, true)
1109 });
1110 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1111 match &*METHOD {
1112 ::core::result::Result::Ok(mi) => *mi,
1113 ::core::result::Result::Err(e) => {
1114 panic!(
1115 "method lookup failed: {}
1116::{}
1117: {}
1118",
1119 <LuaBase as ::unity::ClassIdentity>::NAME,
1120 "LuaCall",
1121 e
1122 )
1123 },
1124 }
1125 }
1126 }
1127 #[doc(hidden)]
1128 #[allow(non_snake_case)]
1129 pub mod __lookup_memcmp {
1130 use super::*;
1131 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1132 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
1133 <crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr as ::unity::IlType>::il_type(),
1134 <crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr as ::unity::IlType>::il_type(),
1135 <u32 as ::unity::IlType>::il_type(),
1136 ];
1137 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "memcmp", 3, param_types, true)
1138 });
1139 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1140 match &*METHOD {
1141 ::core::result::Result::Ok(mi) => *mi,
1142 ::core::result::Result::Err(e) => {
1143 panic!(
1144 "method lookup failed: {}
1145::{}
1146: {}
1147",
1148 <LuaBase as ::unity::ClassIdentity>::NAME,
1149 "memcmp",
1150 e
1151 )
1152 },
1153 }
1154 }
1155 }
1156 #[doc(hidden)]
1157 #[allow(non_snake_case)]
1158 pub mod __lookup_memcmp_2 {
1159 use super::*;
1160 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1161 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
1162 <crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr as ::unity::IlType>::il_type(),
1163 <crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr as ::unity::IlType>::il_type(),
1164 <i32 as ::unity::IlType>::il_type(),
1165 ];
1166 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "memcmp", 3, param_types, true)
1167 });
1168 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1169 match &*METHOD {
1170 ::core::result::Result::Ok(mi) => *mi,
1171 ::core::result::Result::Err(e) => {
1172 panic!(
1173 "method lookup failed: {}
1174::{}
1175: {}
1176",
1177 <LuaBase as ::unity::ClassIdentity>::NAME,
1178 "memcmp",
1179 e
1180 )
1181 },
1182 }
1183 }
1184 }
1185 #[doc(hidden)]
1186 #[allow(non_snake_case)]
1187 pub mod __lookup_memchr {
1188 use super::*;
1189 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1190 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
1191 <crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr as ::unity::IlType>::il_type(),
1192 <u16 as ::unity::IlType>::il_type(),
1193 <u32 as ::unity::IlType>::il_type(),
1194 ];
1195 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "memchr", 3, param_types, true)
1196 });
1197 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1198 match &*METHOD {
1199 ::core::result::Result::Ok(mi) => *mi,
1200 ::core::result::Result::Err(e) => {
1201 panic!(
1202 "method lookup failed: {}
1203::{}
1204: {}
1205",
1206 <LuaBase as ::unity::ClassIdentity>::NAME,
1207 "memchr",
1208 e
1209 )
1210 },
1211 }
1212 }
1213 }
1214 #[doc(hidden)]
1215 #[allow(non_snake_case)]
1216 pub mod __lookup_strpbrk {
1217 use super::*;
1218 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1219 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
1220 <crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr as ::unity::IlType>::il_type(),
1221 <crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr as ::unity::IlType>::il_type(),
1222 ];
1223 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "strpbrk", 2, param_types, true)
1224 });
1225 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1226 match &*METHOD {
1227 ::core::result::Result::Ok(mi) => *mi,
1228 ::core::result::Result::Err(e) => {
1229 panic!(
1230 "method lookup failed: {}
1231::{}
1232: {}
1233",
1234 <LuaBase as ::unity::ClassIdentity>::NAME,
1235 "strpbrk",
1236 e
1237 )
1238 },
1239 }
1240 }
1241 }
1242 #[doc(hidden)]
1243 #[allow(non_snake_case)]
1244 pub mod __lookup_isalpha {
1245 use super::*;
1246 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1247 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<u16 as ::unity::IlType>::il_type()];
1248 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "isalpha", 1, param_types, true)
1249 });
1250 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1251 match &*METHOD {
1252 ::core::result::Result::Ok(mi) => *mi,
1253 ::core::result::Result::Err(e) => {
1254 panic!(
1255 "method lookup failed: {}
1256::{}
1257: {}
1258",
1259 <LuaBase as ::unity::ClassIdentity>::NAME,
1260 "isalpha",
1261 e
1262 )
1263 },
1264 }
1265 }
1266 }
1267 #[doc(hidden)]
1268 #[allow(non_snake_case)]
1269 pub mod __lookup_iscntrl {
1270 use super::*;
1271 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1272 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<u16 as ::unity::IlType>::il_type()];
1273 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "iscntrl", 1, param_types, true)
1274 });
1275 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1276 match &*METHOD {
1277 ::core::result::Result::Ok(mi) => *mi,
1278 ::core::result::Result::Err(e) => {
1279 panic!(
1280 "method lookup failed: {}
1281::{}
1282: {}
1283",
1284 <LuaBase as ::unity::ClassIdentity>::NAME,
1285 "iscntrl",
1286 e
1287 )
1288 },
1289 }
1290 }
1291 }
1292 #[doc(hidden)]
1293 #[allow(non_snake_case)]
1294 pub mod __lookup_isdigit {
1295 use super::*;
1296 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1297 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<u16 as ::unity::IlType>::il_type()];
1298 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "isdigit", 1, param_types, true)
1299 });
1300 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1301 match &*METHOD {
1302 ::core::result::Result::Ok(mi) => *mi,
1303 ::core::result::Result::Err(e) => {
1304 panic!(
1305 "method lookup failed: {}
1306::{}
1307: {}
1308",
1309 <LuaBase as ::unity::ClassIdentity>::NAME,
1310 "isdigit",
1311 e
1312 )
1313 },
1314 }
1315 }
1316 }
1317 #[doc(hidden)]
1318 #[allow(non_snake_case)]
1319 pub mod __lookup_islower {
1320 use super::*;
1321 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1322 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<u16 as ::unity::IlType>::il_type()];
1323 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "islower", 1, param_types, true)
1324 });
1325 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1326 match &*METHOD {
1327 ::core::result::Result::Ok(mi) => *mi,
1328 ::core::result::Result::Err(e) => {
1329 panic!(
1330 "method lookup failed: {}
1331::{}
1332: {}
1333",
1334 <LuaBase as ::unity::ClassIdentity>::NAME,
1335 "islower",
1336 e
1337 )
1338 },
1339 }
1340 }
1341 }
1342 #[doc(hidden)]
1343 #[allow(non_snake_case)]
1344 pub mod __lookup_ispunct {
1345 use super::*;
1346 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1347 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<u16 as ::unity::IlType>::il_type()];
1348 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "ispunct", 1, param_types, true)
1349 });
1350 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1351 match &*METHOD {
1352 ::core::result::Result::Ok(mi) => *mi,
1353 ::core::result::Result::Err(e) => {
1354 panic!(
1355 "method lookup failed: {}
1356::{}
1357: {}
1358",
1359 <LuaBase as ::unity::ClassIdentity>::NAME,
1360 "ispunct",
1361 e
1362 )
1363 },
1364 }
1365 }
1366 }
1367 #[doc(hidden)]
1368 #[allow(non_snake_case)]
1369 pub mod __lookup_isspace {
1370 use super::*;
1371 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1372 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<u16 as ::unity::IlType>::il_type()];
1373 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "isspace", 1, param_types, true)
1374 });
1375 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1376 match &*METHOD {
1377 ::core::result::Result::Ok(mi) => *mi,
1378 ::core::result::Result::Err(e) => {
1379 panic!(
1380 "method lookup failed: {}
1381::{}
1382: {}
1383",
1384 <LuaBase as ::unity::ClassIdentity>::NAME,
1385 "isspace",
1386 e
1387 )
1388 },
1389 }
1390 }
1391 }
1392 #[doc(hidden)]
1393 #[allow(non_snake_case)]
1394 pub mod __lookup_isupper {
1395 use super::*;
1396 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1397 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<u16 as ::unity::IlType>::il_type()];
1398 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "isupper", 1, param_types, true)
1399 });
1400 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1401 match &*METHOD {
1402 ::core::result::Result::Ok(mi) => *mi,
1403 ::core::result::Result::Err(e) => {
1404 panic!(
1405 "method lookup failed: {}
1406::{}
1407: {}
1408",
1409 <LuaBase as ::unity::ClassIdentity>::NAME,
1410 "isupper",
1411 e
1412 )
1413 },
1414 }
1415 }
1416 }
1417 #[doc(hidden)]
1418 #[allow(non_snake_case)]
1419 pub mod __lookup_isalnum {
1420 use super::*;
1421 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1422 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<u16 as ::unity::IlType>::il_type()];
1423 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "isalnum", 1, param_types, true)
1424 });
1425 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1426 match &*METHOD {
1427 ::core::result::Result::Ok(mi) => *mi,
1428 ::core::result::Result::Err(e) => {
1429 panic!(
1430 "method lookup failed: {}
1431::{}
1432: {}
1433",
1434 <LuaBase as ::unity::ClassIdentity>::NAME,
1435 "isalnum",
1436 e
1437 )
1438 },
1439 }
1440 }
1441 }
1442 #[doc(hidden)]
1443 #[allow(non_snake_case)]
1444 pub mod __lookup_isxdigit {
1445 use super::*;
1446 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1447 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<u16 as ::unity::IlType>::il_type()];
1448 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "isxdigit", 1, param_types, true)
1449 });
1450 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1451 match &*METHOD {
1452 ::core::result::Result::Ok(mi) => *mi,
1453 ::core::result::Result::Err(e) => {
1454 panic!(
1455 "method lookup failed: {}
1456::{}
1457: {}
1458",
1459 <LuaBase as ::unity::ClassIdentity>::NAME,
1460 "isxdigit",
1461 e
1462 )
1463 },
1464 }
1465 }
1466 }
1467 #[doc(hidden)]
1468 #[allow(non_snake_case)]
1469 pub mod __lookup_isgraph {
1470 use super::*;
1471 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1472 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<u16 as ::unity::IlType>::il_type()];
1473 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "isgraph", 1, param_types, true)
1474 });
1475 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1476 match &*METHOD {
1477 ::core::result::Result::Ok(mi) => *mi,
1478 ::core::result::Result::Err(e) => {
1479 panic!(
1480 "method lookup failed: {}
1481::{}
1482: {}
1483",
1484 <LuaBase as ::unity::ClassIdentity>::NAME,
1485 "isgraph",
1486 e
1487 )
1488 },
1489 }
1490 }
1491 }
1492 #[doc(hidden)]
1493 #[allow(non_snake_case)]
1494 pub mod __lookup_isalpha_2 {
1495 use super::*;
1496 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1497 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<i32 as ::unity::IlType>::il_type()];
1498 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "isalpha", 1, param_types, true)
1499 });
1500 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1501 match &*METHOD {
1502 ::core::result::Result::Ok(mi) => *mi,
1503 ::core::result::Result::Err(e) => {
1504 panic!(
1505 "method lookup failed: {}
1506::{}
1507: {}
1508",
1509 <LuaBase as ::unity::ClassIdentity>::NAME,
1510 "isalpha",
1511 e
1512 )
1513 },
1514 }
1515 }
1516 }
1517 #[doc(hidden)]
1518 #[allow(non_snake_case)]
1519 pub mod __lookup_iscntrl_2 {
1520 use super::*;
1521 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1522 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<i32 as ::unity::IlType>::il_type()];
1523 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "iscntrl", 1, param_types, true)
1524 });
1525 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1526 match &*METHOD {
1527 ::core::result::Result::Ok(mi) => *mi,
1528 ::core::result::Result::Err(e) => {
1529 panic!(
1530 "method lookup failed: {}
1531::{}
1532: {}
1533",
1534 <LuaBase as ::unity::ClassIdentity>::NAME,
1535 "iscntrl",
1536 e
1537 )
1538 },
1539 }
1540 }
1541 }
1542 #[doc(hidden)]
1543 #[allow(non_snake_case)]
1544 pub mod __lookup_isdigit_2 {
1545 use super::*;
1546 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1547 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<i32 as ::unity::IlType>::il_type()];
1548 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "isdigit", 1, param_types, true)
1549 });
1550 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1551 match &*METHOD {
1552 ::core::result::Result::Ok(mi) => *mi,
1553 ::core::result::Result::Err(e) => {
1554 panic!(
1555 "method lookup failed: {}
1556::{}
1557: {}
1558",
1559 <LuaBase as ::unity::ClassIdentity>::NAME,
1560 "isdigit",
1561 e
1562 )
1563 },
1564 }
1565 }
1566 }
1567 #[doc(hidden)]
1568 #[allow(non_snake_case)]
1569 pub mod __lookup_islower_2 {
1570 use super::*;
1571 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1572 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<i32 as ::unity::IlType>::il_type()];
1573 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "islower", 1, param_types, true)
1574 });
1575 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1576 match &*METHOD {
1577 ::core::result::Result::Ok(mi) => *mi,
1578 ::core::result::Result::Err(e) => {
1579 panic!(
1580 "method lookup failed: {}
1581::{}
1582: {}
1583",
1584 <LuaBase as ::unity::ClassIdentity>::NAME,
1585 "islower",
1586 e
1587 )
1588 },
1589 }
1590 }
1591 }
1592 #[doc(hidden)]
1593 #[allow(non_snake_case)]
1594 pub mod __lookup_ispunct_2 {
1595 use super::*;
1596 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1597 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<i32 as ::unity::IlType>::il_type()];
1598 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "ispunct", 1, param_types, true)
1599 });
1600 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1601 match &*METHOD {
1602 ::core::result::Result::Ok(mi) => *mi,
1603 ::core::result::Result::Err(e) => {
1604 panic!(
1605 "method lookup failed: {}
1606::{}
1607: {}
1608",
1609 <LuaBase as ::unity::ClassIdentity>::NAME,
1610 "ispunct",
1611 e
1612 )
1613 },
1614 }
1615 }
1616 }
1617 #[doc(hidden)]
1618 #[allow(non_snake_case)]
1619 pub mod __lookup_isspace_2 {
1620 use super::*;
1621 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1622 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<i32 as ::unity::IlType>::il_type()];
1623 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "isspace", 1, param_types, true)
1624 });
1625 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1626 match &*METHOD {
1627 ::core::result::Result::Ok(mi) => *mi,
1628 ::core::result::Result::Err(e) => {
1629 panic!(
1630 "method lookup failed: {}
1631::{}
1632: {}
1633",
1634 <LuaBase as ::unity::ClassIdentity>::NAME,
1635 "isspace",
1636 e
1637 )
1638 },
1639 }
1640 }
1641 }
1642 #[doc(hidden)]
1643 #[allow(non_snake_case)]
1644 pub mod __lookup_isupper_2 {
1645 use super::*;
1646 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1647 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<i32 as ::unity::IlType>::il_type()];
1648 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "isupper", 1, param_types, true)
1649 });
1650 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1651 match &*METHOD {
1652 ::core::result::Result::Ok(mi) => *mi,
1653 ::core::result::Result::Err(e) => {
1654 panic!(
1655 "method lookup failed: {}
1656::{}
1657: {}
1658",
1659 <LuaBase as ::unity::ClassIdentity>::NAME,
1660 "isupper",
1661 e
1662 )
1663 },
1664 }
1665 }
1666 }
1667 #[doc(hidden)]
1668 #[allow(non_snake_case)]
1669 pub mod __lookup_isalnum_2 {
1670 use super::*;
1671 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1672 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<i32 as ::unity::IlType>::il_type()];
1673 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "isalnum", 1, param_types, true)
1674 });
1675 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1676 match &*METHOD {
1677 ::core::result::Result::Ok(mi) => *mi,
1678 ::core::result::Result::Err(e) => {
1679 panic!(
1680 "method lookup failed: {}
1681::{}
1682: {}
1683",
1684 <LuaBase as ::unity::ClassIdentity>::NAME,
1685 "isalnum",
1686 e
1687 )
1688 },
1689 }
1690 }
1691 }
1692 #[doc(hidden)]
1693 #[allow(non_snake_case)]
1694 pub mod __lookup_isgraph_2 {
1695 use super::*;
1696 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1697 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<i32 as ::unity::IlType>::il_type()];
1698 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "isgraph", 1, param_types, true)
1699 });
1700 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1701 match &*METHOD {
1702 ::core::result::Result::Ok(mi) => *mi,
1703 ::core::result::Result::Err(e) => {
1704 panic!(
1705 "method lookup failed: {}
1706::{}
1707: {}
1708",
1709 <LuaBase as ::unity::ClassIdentity>::NAME,
1710 "isgraph",
1711 e
1712 )
1713 },
1714 }
1715 }
1716 }
1717 #[doc(hidden)]
1718 #[allow(non_snake_case)]
1719 pub mod __lookup_tolower {
1720 use super::*;
1721 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1722 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<u16 as ::unity::IlType>::il_type()];
1723 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "tolower", 1, param_types, true)
1724 });
1725 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1726 match &*METHOD {
1727 ::core::result::Result::Ok(mi) => *mi,
1728 ::core::result::Result::Err(e) => {
1729 panic!(
1730 "method lookup failed: {}
1731::{}
1732: {}
1733",
1734 <LuaBase as ::unity::ClassIdentity>::NAME,
1735 "tolower",
1736 e
1737 )
1738 },
1739 }
1740 }
1741 }
1742 #[doc(hidden)]
1743 #[allow(non_snake_case)]
1744 pub mod __lookup_toupper {
1745 use super::*;
1746 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1747 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<u16 as ::unity::IlType>::il_type()];
1748 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "toupper", 1, param_types, true)
1749 });
1750 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1751 match &*METHOD {
1752 ::core::result::Result::Ok(mi) => *mi,
1753 ::core::result::Result::Err(e) => {
1754 panic!(
1755 "method lookup failed: {}
1756::{}
1757: {}
1758",
1759 <LuaBase as ::unity::ClassIdentity>::NAME,
1760 "toupper",
1761 e
1762 )
1763 },
1764 }
1765 }
1766 }
1767 #[doc(hidden)]
1768 #[allow(non_snake_case)]
1769 pub mod __lookup_tolower_2 {
1770 use super::*;
1771 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1772 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<i32 as ::unity::IlType>::il_type()];
1773 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "tolower", 1, param_types, true)
1774 });
1775 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1776 match &*METHOD {
1777 ::core::result::Result::Ok(mi) => *mi,
1778 ::core::result::Result::Err(e) => {
1779 panic!(
1780 "method lookup failed: {}
1781::{}
1782: {}
1783",
1784 <LuaBase as ::unity::ClassIdentity>::NAME,
1785 "tolower",
1786 e
1787 )
1788 },
1789 }
1790 }
1791 }
1792 #[doc(hidden)]
1793 #[allow(non_snake_case)]
1794 pub mod __lookup_toupper_2 {
1795 use super::*;
1796 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1797 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[<i32 as ::unity::IlType>::il_type()];
1798 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "toupper", 1, param_types, true)
1799 });
1800 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1801 match &*METHOD {
1802 ::core::result::Result::Ok(mi) => *mi,
1803 ::core::result::Result::Err(e) => {
1804 panic!(
1805 "method lookup failed: {}
1806::{}
1807: {}
1808",
1809 <LuaBase as ::unity::ClassIdentity>::NAME,
1810 "toupper",
1811 e
1812 )
1813 },
1814 }
1815 }
1816 }
1817 #[doc(hidden)]
1818 #[allow(non_snake_case)]
1819 pub mod __lookup_strchr {
1820 use super::*;
1821 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1822 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
1823 <crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr as ::unity::IlType>::il_type(),
1824 <u16 as ::unity::IlType>::il_type(),
1825 ];
1826 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "strchr", 2, param_types, true)
1827 });
1828 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1829 match &*METHOD {
1830 ::core::result::Result::Ok(mi) => *mi,
1831 ::core::result::Result::Err(e) => {
1832 panic!(
1833 "method lookup failed: {}
1834::{}
1835: {}
1836",
1837 <LuaBase as ::unity::ClassIdentity>::NAME,
1838 "strchr",
1839 e
1840 )
1841 },
1842 }
1843 }
1844 }
1845 #[doc(hidden)]
1846 #[allow(non_snake_case)]
1847 pub mod __lookup_strcpy {
1848 use super::*;
1849 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1850 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
1851 <crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr as ::unity::IlType>::il_type(),
1852 <crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr as ::unity::IlType>::il_type(),
1853 ];
1854 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "strcpy", 2, param_types, true)
1855 });
1856 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1857 match &*METHOD {
1858 ::core::result::Result::Ok(mi) => *mi,
1859 ::core::result::Result::Err(e) => {
1860 panic!(
1861 "method lookup failed: {}
1862::{}
1863: {}
1864",
1865 <LuaBase as ::unity::ClassIdentity>::NAME,
1866 "strcpy",
1867 e
1868 )
1869 },
1870 }
1871 }
1872 }
1873 #[doc(hidden)]
1874 #[allow(non_snake_case)]
1875 pub mod __lookup_strncpy {
1876 use super::*;
1877 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1878 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
1879 <crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr as ::unity::IlType>::il_type(),
1880 <crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr as ::unity::IlType>::il_type(),
1881 <i32 as ::unity::IlType>::il_type(),
1882 ];
1883 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "strncpy", 3, param_types, true)
1884 });
1885 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1886 match &*METHOD {
1887 ::core::result::Result::Ok(mi) => *mi,
1888 ::core::result::Result::Err(e) => {
1889 panic!(
1890 "method lookup failed: {}
1891::{}
1892: {}
1893",
1894 <LuaBase as ::unity::ClassIdentity>::NAME,
1895 "strncpy",
1896 e
1897 )
1898 },
1899 }
1900 }
1901 }
1902 #[doc(hidden)]
1903 #[allow(non_snake_case)]
1904 pub mod __lookup_strlen {
1905 use super::*;
1906 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1907 let param_types: &[&'static ::unity::il2cpp::Il2CppType] =
1908 &[<crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr as ::unity::IlType>::il_type()];
1909 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "strlen", 1, param_types, true)
1910 });
1911 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1912 match &*METHOD {
1913 ::core::result::Result::Ok(mi) => *mi,
1914 ::core::result::Result::Err(e) => {
1915 panic!(
1916 "method lookup failed: {}
1917::{}
1918: {}
1919",
1920 <LuaBase as ::unity::ClassIdentity>::NAME,
1921 "strlen",
1922 e
1923 )
1924 },
1925 }
1926 }
1927 }
1928 #[doc(hidden)]
1929 #[allow(non_snake_case)]
1930 pub mod __lookup_sprintf {
1931 use super::*;
1932 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1933 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[
1934 <crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr as ::unity::IlType>::il_type(),
1935 <crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr as ::unity::IlType>::il_type(),
1936 <::unity::Array<crate::system::object::Object> as ::unity::IlType>::il_type(),
1937 ];
1938 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), "sprintf", 3, param_types, true)
1939 });
1940 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1941 match &*METHOD {
1942 ::core::result::Result::Ok(mi) => *mi,
1943 ::core::result::Result::Err(e) => {
1944 panic!(
1945 "method lookup failed: {}
1946::{}
1947: {}
1948",
1949 <LuaBase as ::unity::ClassIdentity>::NAME,
1950 "sprintf",
1951 e
1952 )
1953 },
1954 }
1955 }
1956 }
1957 #[doc(hidden)]
1958 #[allow(non_snake_case)]
1959 pub mod __lookup_ctor {
1960 use super::*;
1961 static METHOD: ::std::sync::LazyLock<::unity::Il2CppResult<&'static ::unity::il2cpp::MethodInfo>> = ::std::sync::LazyLock::new(|| {
1962 let param_types: &[&'static ::unity::il2cpp::Il2CppType] = &[];
1963 ::unity::lookup::method_info_on_class_with_signature(<LuaBase as ::unity::ClassIdentity>::class(), ".ctor", 0, param_types, false)
1964 });
1965 pub fn get_method_info() -> &'static ::unity::il2cpp::MethodInfo {
1966 match &*METHOD {
1967 ::core::result::Result::Ok(mi) => *mi,
1968 ::core::result::Result::Err(e) => {
1969 panic!(
1970 "method lookup failed: {}
1971::{}
1972: {}
1973",
1974 <LuaBase as ::unity::ClassIdentity>::NAME,
1975 ".ctor",
1976 e
1977 )
1978 },
1979 }
1980 }
1981 }
1982}
1983
1984#[cfg(feature = "moon_sharp-interpreter-interop-lua_state_interop-luabase")]
1985impl LuaBase {
1986 #[doc = "`GetArgument(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState, i32)` overload"]
1987 pub fn get_argument(
1988 l: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState>,
1989 pos: impl ::core::convert::Into<i32>,
1990 ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
1991 unsafe {
1992 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_get_argument::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
1993(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState)::core::convert::Into::into(l),(i32)::core::convert::Into::into(pos))
1994 }
1995 }
1996
1997 #[doc = "`ArgAsType(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState, i32, crate::moon_sharp::interpreter::datatype::DataType, bool)` overload"]
1998 pub fn arg_as_type(
1999 l: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState>,
2000 pos: impl ::core::convert::Into<i32>,
2001 r#type: impl ::core::convert::Into<crate::moon_sharp::interpreter::datatype::DataType>,
2002 allow_nil: impl ::core::convert::Into<bool>,
2003 ) -> crate::moon_sharp::interpreter::dynvalue::DynValue {
2004 unsafe {
2005 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_arg_as_type::get_method_info().method_ptr,crate::moon_sharp::interpreter::dynvalue::DynValue;
2006(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState)::core::convert::Into::into(l),(i32)::core::convert::Into::into(pos),(crate::moon_sharp::interpreter::datatype::DataType)::core::convert::Into::into(r#type),(bool)::core::convert::Into::into(allow_nil))
2007 }
2008 }
2009
2010 #[doc = "`LuaType(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState, i32)` overload"]
2011 pub fn lua_type(
2012 l: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState>,
2013 p: impl ::core::convert::Into<i32>,
2014 ) -> i32 {
2015 unsafe {
2016 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_lua_type::get_method_info().method_ptr,i32;
2017(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState)::core::convert::Into::into(l),(i32)::core::convert::Into::into(p))
2018 }
2019 }
2020
2021 #[doc = "`LuaLCheckLString(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState, i32, *mutu32)` overload"]
2022 pub fn lua_l_check_l_string(
2023 l: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState>,
2024 arg_num: impl ::core::convert::Into<i32>,
2025 ) -> (::unity::Il2CppString, u32) {
2026 unsafe {
2027 let mut __out_0 = ::core::mem::MaybeUninit::<u32>::uninit();
2028 let __ret = {
2029 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_lua_l_check_l_string::get_method_info().method_ptr, ::unity::Il2CppString;
2030(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState)::core::convert::Into::into(l),(i32)::core::convert::Into::into(arg_num),(*mut u32)__out_0.as_mut_ptr())
2031 };
2032 (__ret, __out_0.assume_init())
2033 }
2034 }
2035
2036 #[doc = "`LuaPushInteger(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState, i32)` overload"]
2037 pub fn lua_push_integer(
2038 l: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState>,
2039 val: impl ::core::convert::Into<i32>,
2040 ) -> () {
2041 unsafe {
2042 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_lua_push_integer::get_method_info().method_ptr,();
2043(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState)::core::convert::Into::into(l),(i32)::core::convert::Into::into(val))
2044 }
2045 }
2046
2047 #[doc = "`LuaToBoolean(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState, i32)` overload"]
2048 pub fn lua_to_boolean(
2049 l: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState>,
2050 p: impl ::core::convert::Into<i32>,
2051 ) -> i32 {
2052 unsafe {
2053 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_lua_to_boolean::get_method_info().method_ptr,i32;
2054(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState)::core::convert::Into::into(l),(i32)::core::convert::Into::into(p))
2055 }
2056 }
2057
2058 #[doc = "`LuaToLString(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState, i32, *mutu32)` overload"]
2059 pub fn lua_to_l_string(
2060 lua_state: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState>,
2061 p: impl ::core::convert::Into<i32>,
2062 ) -> (::unity::Il2CppString, u32) {
2063 unsafe {
2064 let mut __out_0 = ::core::mem::MaybeUninit::<u32>::uninit();
2065 let __ret = {
2066 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_lua_to_l_string::get_method_info().method_ptr, ::unity::Il2CppString;
2067(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState)::core::convert::Into::into(lua_state),(i32)::core::convert::Into::into(p),(*mut u32)__out_0.as_mut_ptr())
2068 };
2069 (__ret, __out_0.assume_init())
2070 }
2071 }
2072
2073 #[doc = "`LuaToString(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState, i32)` overload"]
2074 pub fn lua_to_string(
2075 lua_state: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState>,
2076 p: impl ::core::convert::Into<i32>,
2077 ) -> ::unity::Il2CppString {
2078 unsafe {
2079 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_lua_to_string::get_method_info().method_ptr, ::unity::Il2CppString;
2080(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState)::core::convert::Into::into(lua_state),(i32)::core::convert::Into::into(p))
2081 }
2082 }
2083
2084 #[doc = "`LuaLAddValue(crate::moon_sharp::interpreter::interop::lua_state_interop::lualbuffer::LuaLBuffer)` overload"]
2085 pub fn lua_l_add_value(b: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::lualbuffer::LuaLBuffer>) -> () {
2086 unsafe {
2087 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_lua_l_add_value::get_method_info().method_ptr,();
2088(crate::moon_sharp::interpreter::interop::lua_state_interop::lualbuffer::LuaLBuffer)::core::convert::Into::into(b))
2089 }
2090 }
2091
2092 #[doc = "`LuaLAddLString(crate::moon_sharp::interpreter::interop::lua_state_interop::lualbuffer::LuaLBuffer, crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr, u32)` overload"]
2093 pub fn lua_l_add_l_string(
2094 b: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::lualbuffer::LuaLBuffer>,
2095 s: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr>,
2096 p: impl ::core::convert::Into<u32>,
2097 ) -> () {
2098 unsafe {
2099 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_lua_l_add_l_string::get_method_info().method_ptr,();
2100(crate::moon_sharp::interpreter::interop::lua_state_interop::lualbuffer::LuaLBuffer)::core::convert::Into::into(b),(crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr)::core::convert::Into::into(s),(u32)::core::convert::Into::into(p))
2101 }
2102 }
2103
2104 #[doc = "`LuaLAddString(crate::moon_sharp::interpreter::interop::lua_state_interop::lualbuffer::LuaLBuffer, ::unity::Il2CppString)` overload"]
2105 pub fn lua_l_add_string(
2106 b: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::lualbuffer::LuaLBuffer>,
2107 s: impl ::core::convert::Into<::unity::Il2CppString>,
2108 ) -> () {
2109 unsafe {
2110 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_lua_l_add_string::get_method_info().method_ptr,();
2111(crate::moon_sharp::interpreter::interop::lua_state_interop::lualbuffer::LuaLBuffer)::core::convert::Into::into(b),(::unity::Il2CppString)::core::convert::Into::into(s))
2112 }
2113 }
2114
2115 #[doc = "`LuaLOptInteger(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState, i32, i32)` overload"]
2116 pub fn lua_l_opt_integer(
2117 l: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState>,
2118 pos: impl ::core::convert::Into<i32>,
2119 def: impl ::core::convert::Into<i32>,
2120 ) -> i32 {
2121 unsafe {
2122 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_lua_l_opt_integer::get_method_info().method_ptr,i32;
2123(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState)::core::convert::Into::into(l),(i32)::core::convert::Into::into(pos),(i32)::core::convert::Into::into(def))
2124 }
2125 }
2126
2127 #[doc = "`LuaLCheckInteger(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState, i32)` overload"]
2128 pub fn lua_l_check_integer(
2129 l: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState>,
2130 pos: impl ::core::convert::Into<i32>,
2131 ) -> i32 {
2132 unsafe {
2133 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_lua_l_check_integer::get_method_info().method_ptr,i32;
2134(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState)::core::convert::Into::into(l),(i32)::core::convert::Into::into(pos))
2135 }
2136 }
2137
2138 #[doc = "`LuaLArgCheck(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState, bool, i32, ::unity::Il2CppString)` overload"]
2139 pub fn lua_l_arg_check(
2140 l: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState>,
2141 condition: impl ::core::convert::Into<bool>,
2142 arg_num: impl ::core::convert::Into<i32>,
2143 message: impl ::core::convert::Into<::unity::Il2CppString>,
2144 ) -> () {
2145 unsafe {
2146 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_lua_l_arg_check::get_method_info().method_ptr,();
2147(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState)::core::convert::Into::into(l),(bool)::core::convert::Into::into(condition),(i32)::core::convert::Into::into(arg_num),(::unity::Il2CppString)::core::convert::Into::into(message))
2148 }
2149 }
2150
2151 #[doc = "`LuaLCheckInt(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState, i32)` overload"]
2152 pub fn lua_l_check_int(
2153 l: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState>,
2154 arg_num: impl ::core::convert::Into<i32>,
2155 ) -> i32 {
2156 unsafe {
2157 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_lua_l_check_int::get_method_info().method_ptr,i32;
2158(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState)::core::convert::Into::into(l),(i32)::core::convert::Into::into(arg_num))
2159 }
2160 }
2161
2162 #[doc = "`LuaGetTop(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState)` overload"]
2163 pub fn lua_get_top(l: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState>) -> i32 {
2164 unsafe {
2165 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_lua_get_top::get_method_info().method_ptr,i32;
2166(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState)::core::convert::Into::into(l))
2167 }
2168 }
2169
2170 #[doc = "`LuaLError(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState, ::unity::Il2CppString, ::unity::Array<crate::system::object::Object>)` overload"]
2171 pub fn lua_l_error(
2172 lua_state: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState>,
2173 message: impl ::core::convert::Into<::unity::Il2CppString>,
2174 args: impl ::core::convert::Into<::unity::Array<crate::system::object::Object>>,
2175 ) -> i32 {
2176 unsafe {
2177 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_lua_l_error::get_method_info().method_ptr,i32;
2178(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState)::core::convert::Into::into(lua_state),(::unity::Il2CppString)::core::convert::Into::into(message),(::unity::Array<crate::system::object::Object>)::core::convert::Into::into(args))
2179 }
2180 }
2181
2182 #[doc = "`LuaLAddChar(crate::moon_sharp::interpreter::interop::lua_state_interop::lualbuffer::LuaLBuffer, u16)` overload"]
2183 pub fn lua_l_add_char(
2184 b: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::lualbuffer::LuaLBuffer>,
2185 p: impl ::core::convert::Into<u16>,
2186 ) -> () {
2187 unsafe {
2188 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_lua_l_add_char::get_method_info().method_ptr,();
2189(crate::moon_sharp::interpreter::interop::lua_state_interop::lualbuffer::LuaLBuffer)::core::convert::Into::into(b),(u16)::core::convert::Into::into(p))
2190 }
2191 }
2192
2193 #[doc = "`LuaLBuffInit(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState, crate::moon_sharp::interpreter::interop::lua_state_interop::lualbuffer::LuaLBuffer)` overload"]
2194 pub fn lua_l_buff_init(
2195 l: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState>,
2196 b: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::lualbuffer::LuaLBuffer>,
2197 ) -> () {
2198 unsafe {
2199 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_lua_l_buff_init::get_method_info().method_ptr,();
2200(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState)::core::convert::Into::into(l),(crate::moon_sharp::interpreter::interop::lua_state_interop::lualbuffer::LuaLBuffer)::core::convert::Into::into(b))
2201 }
2202 }
2203
2204 #[doc = "`LuaPushLiteral(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState, ::unity::Il2CppString)` overload"]
2205 pub fn lua_push_literal(
2206 l: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState>,
2207 literal_string: impl ::core::convert::Into<::unity::Il2CppString>,
2208 ) -> () {
2209 unsafe {
2210 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_lua_push_literal::get_method_info().method_ptr,();
2211(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState)::core::convert::Into::into(l),(::unity::Il2CppString)::core::convert::Into::into(literal_string))
2212 }
2213 }
2214
2215 #[doc = "`LuaLPushResult(crate::moon_sharp::interpreter::interop::lua_state_interop::lualbuffer::LuaLBuffer)` overload"]
2216 pub fn lua_l_push_result(
2217 b: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::lualbuffer::LuaLBuffer>,
2218 ) -> () {
2219 unsafe {
2220 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_lua_l_push_result::get_method_info().method_ptr,();
2221(crate::moon_sharp::interpreter::interop::lua_state_interop::lualbuffer::LuaLBuffer)::core::convert::Into::into(b))
2222 }
2223 }
2224
2225 #[doc = "`LuaPushLString(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState, crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr, u32)` overload"]
2226 pub fn lua_push_l_string(
2227 l: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState>,
2228 s: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr>,
2229 len: impl ::core::convert::Into<u32>,
2230 ) -> () {
2231 unsafe {
2232 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_lua_push_l_string::get_method_info().method_ptr,();
2233(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState)::core::convert::Into::into(l),(crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr)::core::convert::Into::into(s),(u32)::core::convert::Into::into(len))
2234 }
2235 }
2236
2237 #[doc = "`LuaLCheckStack(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState, i32, ::unity::Il2CppString)` overload"]
2238 pub fn lua_l_check_stack(
2239 l: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState>,
2240 n: impl ::core::convert::Into<i32>,
2241 message: impl ::core::convert::Into<::unity::Il2CppString>,
2242 ) -> () {
2243 unsafe {
2244 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_lua_l_check_stack::get_method_info().method_ptr,();
2245(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState)::core::convert::Into::into(l),(i32)::core::convert::Into::into(n),(::unity::Il2CppString)::core::convert::Into::into(message))
2246 }
2247 }
2248
2249 #[doc = "`LUA_QL(::unity::Il2CppString)` overload"]
2250 pub fn lua_ql(p: impl ::core::convert::Into<::unity::Il2CppString>) -> ::unity::Il2CppString {
2251 unsafe {
2252 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_lua_ql::get_method_info().method_ptr, ::unity::Il2CppString;
2253(::unity::Il2CppString)::core::convert::Into::into(p))
2254 }
2255 }
2256
2257 #[doc = "`LuaPushNil(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState)` overload"]
2258 pub fn lua_push_nil(l: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState>) -> () {
2259 unsafe {
2260 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_lua_push_nil::get_method_info().method_ptr,();
2261(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState)::core::convert::Into::into(l))
2262 }
2263 }
2264
2265 #[doc = "`LuaAssert(bool)` overload"]
2266 pub fn lua_assert(p: impl ::core::convert::Into<bool>) -> () {
2267 unsafe {
2268 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_lua_assert::get_method_info().method_ptr,();
2269(bool)::core::convert::Into::into(p))
2270 }
2271 }
2272
2273 #[doc = "`LuaLTypeName(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState, i32)` overload"]
2274 pub fn lua_l_type_name(
2275 l: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState>,
2276 p: impl ::core::convert::Into<i32>,
2277 ) -> ::unity::Il2CppString {
2278 unsafe {
2279 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_lua_l_type_name::get_method_info().method_ptr, ::unity::Il2CppString;
2280(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState)::core::convert::Into::into(l),(i32)::core::convert::Into::into(p))
2281 }
2282 }
2283
2284 #[doc = "`LuaIsString(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState, i32)` overload"]
2285 pub fn lua_is_string(
2286 l: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState>,
2287 p: impl ::core::convert::Into<i32>,
2288 ) -> i32 {
2289 unsafe {
2290 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_lua_is_string::get_method_info().method_ptr,i32;
2291(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState)::core::convert::Into::into(l),(i32)::core::convert::Into::into(p))
2292 }
2293 }
2294
2295 #[doc = "`LuaPop(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState, i32)` overload"]
2296 pub fn lua_pop(
2297 l: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState>,
2298 p: impl ::core::convert::Into<i32>,
2299 ) -> () {
2300 unsafe {
2301 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_lua_pop::get_method_info().method_ptr,();
2302(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState)::core::convert::Into::into(l),(i32)::core::convert::Into::into(p))
2303 }
2304 }
2305
2306 #[doc = "`LuaGetTable(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState, i32)` overload"]
2307 pub fn lua_get_table(
2308 l: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState>,
2309 p: impl ::core::convert::Into<i32>,
2310 ) -> () {
2311 unsafe {
2312 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_lua_get_table::get_method_info().method_ptr,();
2313(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState)::core::convert::Into::into(l),(i32)::core::convert::Into::into(p))
2314 }
2315 }
2316
2317 #[doc = "`LuaLOptInt(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState, i32, i32)` overload"]
2318 pub fn lua_l_opt_int(
2319 l: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState>,
2320 pos: impl ::core::convert::Into<i32>,
2321 def: impl ::core::convert::Into<i32>,
2322 ) -> i32 {
2323 unsafe {
2324 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_lua_l_opt_int::get_method_info().method_ptr,i32;
2325(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState)::core::convert::Into::into(l),(i32)::core::convert::Into::into(pos),(i32)::core::convert::Into::into(def))
2326 }
2327 }
2328
2329 #[doc = "`LuaLCheckString(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState, i32)` overload"]
2330 pub fn lua_l_check_string(
2331 l: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState>,
2332 p: impl ::core::convert::Into<i32>,
2333 ) -> crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr {
2334 unsafe {
2335 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_lua_l_check_string::get_method_info().method_ptr,crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr;
2336(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState)::core::convert::Into::into(l),(i32)::core::convert::Into::into(p))
2337 }
2338 }
2339
2340 #[doc = "`LuaLCheckStringStr(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState, i32)` overload"]
2341 pub fn lua_l_check_string_str(
2342 l: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState>,
2343 p: impl ::core::convert::Into<i32>,
2344 ) -> ::unity::Il2CppString {
2345 unsafe {
2346 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_lua_l_check_string_str::get_method_info().method_ptr, ::unity::Il2CppString;
2347(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState)::core::convert::Into::into(l),(i32)::core::convert::Into::into(p))
2348 }
2349 }
2350
2351 #[doc = "`LuaLArgError(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState, i32, ::unity::Il2CppString)` overload"]
2352 pub fn lua_l_arg_error(
2353 l: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState>,
2354 arg: impl ::core::convert::Into<i32>,
2355 p: impl ::core::convert::Into<::unity::Il2CppString>,
2356 ) -> () {
2357 unsafe {
2358 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_lua_l_arg_error::get_method_info().method_ptr,();
2359(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState)::core::convert::Into::into(l),(i32)::core::convert::Into::into(arg),(::unity::Il2CppString)::core::convert::Into::into(p))
2360 }
2361 }
2362
2363 #[doc = "`LuaLCheckNumber(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState, i32)` overload"]
2364 pub fn lua_l_check_number(
2365 l: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState>,
2366 pos: impl ::core::convert::Into<i32>,
2367 ) -> f64 {
2368 unsafe {
2369 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_lua_l_check_number::get_method_info().method_ptr,f64;
2370(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState)::core::convert::Into::into(l),(i32)::core::convert::Into::into(pos))
2371 }
2372 }
2373
2374 #[doc = "`LuaPushValue(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState, i32)` overload"]
2375 pub fn lua_push_value(
2376 l: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState>,
2377 arg: impl ::core::convert::Into<i32>,
2378 ) -> () {
2379 unsafe {
2380 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_lua_push_value::get_method_info().method_ptr,();
2381(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState)::core::convert::Into::into(l),(i32)::core::convert::Into::into(arg))
2382 }
2383 }
2384
2385 #[doc = "`LuaCall(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState, i32, i32)` overload"]
2386 pub fn lua_call(
2387 l: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState>,
2388 nargs: impl ::core::convert::Into<i32>,
2389 nresults: impl ::core::convert::Into<i32>,
2390 ) -> () {
2391 unsafe {
2392 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_lua_call::get_method_info().method_ptr,();
2393(crate::moon_sharp::interpreter::interop::lua_state_interop::luastate::LuaState)::core::convert::Into::into(l),(i32)::core::convert::Into::into(nargs),(i32)::core::convert::Into::into(nresults))
2394 }
2395 }
2396
2397 #[doc = "`memcmp(crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr, crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr, u32)` overload"]
2398 pub fn memcmp(
2399 ptr1: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr>,
2400 ptr2: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr>,
2401 size: impl ::core::convert::Into<u32>,
2402 ) -> i32 {
2403 unsafe {
2404 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_memcmp::get_method_info().method_ptr,i32;
2405(crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr)::core::convert::Into::into(ptr1),(crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr)::core::convert::Into::into(ptr2),(u32)::core::convert::Into::into(size))
2406 }
2407 }
2408
2409 #[doc = "`memcmp(crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr, crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr, i32)` overload"]
2410 pub fn memcmp_2(
2411 ptr1: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr>,
2412 ptr2: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr>,
2413 size: impl ::core::convert::Into<i32>,
2414 ) -> i32 {
2415 unsafe {
2416 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_memcmp_2::get_method_info().method_ptr,i32;
2417(crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr)::core::convert::Into::into(ptr1),(crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr)::core::convert::Into::into(ptr2),(i32)::core::convert::Into::into(size))
2418 }
2419 }
2420
2421 #[doc = "`memchr(crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr, u16, u32)` overload"]
2422 pub fn memchr(
2423 ptr: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr>,
2424 c: impl ::core::convert::Into<u16>,
2425 count: impl ::core::convert::Into<u32>,
2426 ) -> crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr {
2427 unsafe {
2428 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_memchr::get_method_info().method_ptr,crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr;
2429(crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr)::core::convert::Into::into(ptr),(u16)::core::convert::Into::into(c),(u32)::core::convert::Into::into(count))
2430 }
2431 }
2432
2433 #[doc = "`strpbrk(crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr, crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr)` overload"]
2434 pub fn strpbrk(
2435 str: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr>,
2436 charset: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr>,
2437 ) -> crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr {
2438 unsafe {
2439 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_strpbrk::get_method_info().method_ptr,crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr;
2440(crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr)::core::convert::Into::into(str),(crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr)::core::convert::Into::into(charset))
2441 }
2442 }
2443
2444 #[doc = "`isalpha(u16)` overload"]
2445 pub fn isalpha(c: impl ::core::convert::Into<u16>) -> bool {
2446 unsafe {
2447 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_isalpha::get_method_info().method_ptr,bool;
2448(u16)::core::convert::Into::into(c))
2449 }
2450 }
2451
2452 #[doc = "`iscntrl(u16)` overload"]
2453 pub fn iscntrl(c: impl ::core::convert::Into<u16>) -> bool {
2454 unsafe {
2455 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_iscntrl::get_method_info().method_ptr,bool;
2456(u16)::core::convert::Into::into(c))
2457 }
2458 }
2459
2460 #[doc = "`isdigit(u16)` overload"]
2461 pub fn isdigit(c: impl ::core::convert::Into<u16>) -> bool {
2462 unsafe {
2463 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_isdigit::get_method_info().method_ptr,bool;
2464(u16)::core::convert::Into::into(c))
2465 }
2466 }
2467
2468 #[doc = "`islower(u16)` overload"]
2469 pub fn islower(c: impl ::core::convert::Into<u16>) -> bool {
2470 unsafe {
2471 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_islower::get_method_info().method_ptr,bool;
2472(u16)::core::convert::Into::into(c))
2473 }
2474 }
2475
2476 #[doc = "`ispunct(u16)` overload"]
2477 pub fn ispunct(c: impl ::core::convert::Into<u16>) -> bool {
2478 unsafe {
2479 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_ispunct::get_method_info().method_ptr,bool;
2480(u16)::core::convert::Into::into(c))
2481 }
2482 }
2483
2484 #[doc = "`isspace(u16)` overload"]
2485 pub fn isspace(c: impl ::core::convert::Into<u16>) -> bool {
2486 unsafe {
2487 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_isspace::get_method_info().method_ptr,bool;
2488(u16)::core::convert::Into::into(c))
2489 }
2490 }
2491
2492 #[doc = "`isupper(u16)` overload"]
2493 pub fn isupper(c: impl ::core::convert::Into<u16>) -> bool {
2494 unsafe {
2495 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_isupper::get_method_info().method_ptr,bool;
2496(u16)::core::convert::Into::into(c))
2497 }
2498 }
2499
2500 #[doc = "`isalnum(u16)` overload"]
2501 pub fn isalnum(c: impl ::core::convert::Into<u16>) -> bool {
2502 unsafe {
2503 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_isalnum::get_method_info().method_ptr,bool;
2504(u16)::core::convert::Into::into(c))
2505 }
2506 }
2507
2508 #[doc = "`isxdigit(u16)` overload"]
2509 pub fn isxdigit(c: impl ::core::convert::Into<u16>) -> bool {
2510 unsafe {
2511 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_isxdigit::get_method_info().method_ptr,bool;
2512(u16)::core::convert::Into::into(c))
2513 }
2514 }
2515
2516 #[doc = "`isgraph(u16)` overload"]
2517 pub fn isgraph(c: impl ::core::convert::Into<u16>) -> bool {
2518 unsafe {
2519 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_isgraph::get_method_info().method_ptr,bool;
2520(u16)::core::convert::Into::into(c))
2521 }
2522 }
2523
2524 #[doc = "`isalpha(i32)` overload"]
2525 pub fn isalpha_2(c: impl ::core::convert::Into<i32>) -> bool {
2526 unsafe {
2527 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_isalpha_2::get_method_info().method_ptr,bool;
2528(i32)::core::convert::Into::into(c))
2529 }
2530 }
2531
2532 #[doc = "`iscntrl(i32)` overload"]
2533 pub fn iscntrl_2(c: impl ::core::convert::Into<i32>) -> bool {
2534 unsafe {
2535 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_iscntrl_2::get_method_info().method_ptr,bool;
2536(i32)::core::convert::Into::into(c))
2537 }
2538 }
2539
2540 #[doc = "`isdigit(i32)` overload"]
2541 pub fn isdigit_2(c: impl ::core::convert::Into<i32>) -> bool {
2542 unsafe {
2543 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_isdigit_2::get_method_info().method_ptr,bool;
2544(i32)::core::convert::Into::into(c))
2545 }
2546 }
2547
2548 #[doc = "`islower(i32)` overload"]
2549 pub fn islower_2(c: impl ::core::convert::Into<i32>) -> bool {
2550 unsafe {
2551 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_islower_2::get_method_info().method_ptr,bool;
2552(i32)::core::convert::Into::into(c))
2553 }
2554 }
2555
2556 #[doc = "`ispunct(i32)` overload"]
2557 pub fn ispunct_2(c: impl ::core::convert::Into<i32>) -> bool {
2558 unsafe {
2559 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_ispunct_2::get_method_info().method_ptr,bool;
2560(i32)::core::convert::Into::into(c))
2561 }
2562 }
2563
2564 #[doc = "`isspace(i32)` overload"]
2565 pub fn isspace_2(c: impl ::core::convert::Into<i32>) -> bool {
2566 unsafe {
2567 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_isspace_2::get_method_info().method_ptr,bool;
2568(i32)::core::convert::Into::into(c))
2569 }
2570 }
2571
2572 #[doc = "`isupper(i32)` overload"]
2573 pub fn isupper_2(c: impl ::core::convert::Into<i32>) -> bool {
2574 unsafe {
2575 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_isupper_2::get_method_info().method_ptr,bool;
2576(i32)::core::convert::Into::into(c))
2577 }
2578 }
2579
2580 #[doc = "`isalnum(i32)` overload"]
2581 pub fn isalnum_2(c: impl ::core::convert::Into<i32>) -> bool {
2582 unsafe {
2583 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_isalnum_2::get_method_info().method_ptr,bool;
2584(i32)::core::convert::Into::into(c))
2585 }
2586 }
2587
2588 #[doc = "`isgraph(i32)` overload"]
2589 pub fn isgraph_2(c: impl ::core::convert::Into<i32>) -> bool {
2590 unsafe {
2591 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_isgraph_2::get_method_info().method_ptr,bool;
2592(i32)::core::convert::Into::into(c))
2593 }
2594 }
2595
2596 #[doc = "`tolower(u16)` overload"]
2597 pub fn tolower(c: impl ::core::convert::Into<u16>) -> u16 {
2598 unsafe {
2599 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_tolower::get_method_info().method_ptr,u16;
2600(u16)::core::convert::Into::into(c))
2601 }
2602 }
2603
2604 #[doc = "`toupper(u16)` overload"]
2605 pub fn toupper(c: impl ::core::convert::Into<u16>) -> u16 {
2606 unsafe {
2607 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_toupper::get_method_info().method_ptr,u16;
2608(u16)::core::convert::Into::into(c))
2609 }
2610 }
2611
2612 #[doc = "`tolower(i32)` overload"]
2613 pub fn tolower_2(c: impl ::core::convert::Into<i32>) -> u16 {
2614 unsafe {
2615 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_tolower_2::get_method_info().method_ptr,u16;
2616(i32)::core::convert::Into::into(c))
2617 }
2618 }
2619
2620 #[doc = "`toupper(i32)` overload"]
2621 pub fn toupper_2(c: impl ::core::convert::Into<i32>) -> u16 {
2622 unsafe {
2623 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_toupper_2::get_method_info().method_ptr,u16;
2624(i32)::core::convert::Into::into(c))
2625 }
2626 }
2627
2628 #[doc = "`strchr(crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr, u16)` overload"]
2629 pub fn strchr(
2630 str: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr>,
2631 c: impl ::core::convert::Into<u16>,
2632 ) -> crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr {
2633 unsafe {
2634 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_strchr::get_method_info().method_ptr,crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr;
2635(crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr)::core::convert::Into::into(str),(u16)::core::convert::Into::into(c))
2636 }
2637 }
2638
2639 #[doc = "`strcpy(crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr, crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr)` overload"]
2640 pub fn strcpy(
2641 dst: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr>,
2642 src: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr>,
2643 ) -> crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr {
2644 unsafe {
2645 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_strcpy::get_method_info().method_ptr,crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr;
2646(crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr)::core::convert::Into::into(dst),(crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr)::core::convert::Into::into(src))
2647 }
2648 }
2649
2650 #[doc = "`strncpy(crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr, crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr, i32)` overload"]
2651 pub fn strncpy(
2652 dst: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr>,
2653 src: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr>,
2654 length: impl ::core::convert::Into<i32>,
2655 ) -> crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr {
2656 unsafe {
2657 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_strncpy::get_method_info().method_ptr,crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr;
2658(crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr)::core::convert::Into::into(dst),(crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr)::core::convert::Into::into(src),(i32)::core::convert::Into::into(length))
2659 }
2660 }
2661
2662 #[doc = "`strlen(crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr)` overload"]
2663 pub fn strlen(str: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr>) -> i32 {
2664 unsafe {
2665 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_strlen::get_method_info().method_ptr,i32;
2666(crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr)::core::convert::Into::into(str))
2667 }
2668 }
2669
2670 #[doc = "`sprintf(crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr, crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr, ::unity::Array<crate::system::object::Object>)` overload"]
2671 pub fn sprintf(
2672 buffer: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr>,
2673 str: impl ::core::convert::Into<crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr>,
2674 argv: impl ::core::convert::Into<::unity::Array<crate::system::object::Object>>,
2675 ) -> () {
2676 unsafe {
2677 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_sprintf::get_method_info().method_ptr,();
2678(crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr)::core::convert::Into::into(buffer),(crate::moon_sharp::interpreter::interop::lua_state_interop::charptr::CharPtr)::core::convert::Into::into(str),(::unity::Array<crate::system::object::Object>)::core::convert::Into::into(argv))
2679 }
2680 }
2681}
2682
2683#[cfg(feature = "moon_sharp-interpreter-interop-lua_state_interop-luabase")]
2684pub trait ILuaBaseMethods: ILuaBase {
2685 #[doc = "`.ctor()` overload"]
2686 fn ctor(self) -> () {
2687 unsafe {
2688 let __receiver = <LuaBase as ::unity::FromIlInstance>::from_il_instance(<Self as ::unity::SystemObject>::as_instance(self));
2689 ::unity::il2cpp_call!(__LuaBase_unity_raw::__lookup_ctor::get_method_info().method_ptr,();
2690(LuaBase)__receiver)
2691 }
2692 }
2693}
2694
2695#[cfg(feature = "moon_sharp-interpreter-interop-lua_state_interop-luabase")]
2696impl<__T: ILuaBase> ILuaBaseMethods for __T {}
2697
2698#[cfg(feature = "moon_sharp-interpreter-interop-lua_state_interop-luabase")]
2699impl LuaBase {
2700 pub fn get_argument_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2701 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[0]
2702 }
2703
2704 pub fn arg_as_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2705 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[1]
2706 }
2707
2708 pub fn lua_type_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2709 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[2]
2710 }
2711
2712 pub fn lua_l_check_l_string_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2713 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[3]
2714 }
2715
2716 pub fn lua_push_integer_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2717 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[4]
2718 }
2719
2720 pub fn lua_to_boolean_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2721 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[5]
2722 }
2723
2724 pub fn lua_to_l_string_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2725 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[6]
2726 }
2727
2728 pub fn lua_to_string_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2729 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[7]
2730 }
2731
2732 pub fn lua_l_add_value_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2733 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[8]
2734 }
2735
2736 pub fn lua_l_add_l_string_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2737 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[9]
2738 }
2739
2740 pub fn lua_l_add_string_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2741 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[10]
2742 }
2743
2744 pub fn lua_l_opt_integer_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2745 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[11]
2746 }
2747
2748 pub fn lua_l_check_integer_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2749 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[12]
2750 }
2751
2752 pub fn lua_l_arg_check_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2753 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[13]
2754 }
2755
2756 pub fn lua_l_check_int_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2757 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[14]
2758 }
2759
2760 pub fn lua_get_top_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2761 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[15]
2762 }
2763
2764 pub fn lua_l_error_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2765 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[16]
2766 }
2767
2768 pub fn lua_l_add_char_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2769 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[17]
2770 }
2771
2772 pub fn lua_l_buff_init_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2773 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[18]
2774 }
2775
2776 pub fn lua_push_literal_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2777 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[19]
2778 }
2779
2780 pub fn lua_l_push_result_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2781 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[20]
2782 }
2783
2784 pub fn lua_push_l_string_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2785 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[21]
2786 }
2787
2788 pub fn lua_l_check_stack_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2789 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[22]
2790 }
2791
2792 pub fn lua_ql_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2793 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[23]
2794 }
2795
2796 pub fn lua_push_nil_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2797 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[24]
2798 }
2799
2800 pub fn lua_assert_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2801 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[25]
2802 }
2803
2804 pub fn lua_l_type_name_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2805 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[26]
2806 }
2807
2808 pub fn lua_is_string_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2809 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[27]
2810 }
2811
2812 pub fn lua_pop_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2813 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[28]
2814 }
2815
2816 pub fn lua_get_table_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2817 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[29]
2818 }
2819
2820 pub fn lua_l_opt_int_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2821 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[30]
2822 }
2823
2824 pub fn lua_l_check_string_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2825 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[31]
2826 }
2827
2828 pub fn lua_l_check_string_str_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2829 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[32]
2830 }
2831
2832 pub fn lua_l_arg_error_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2833 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[33]
2834 }
2835
2836 pub fn lua_l_check_number_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2837 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[34]
2838 }
2839
2840 pub fn lua_push_value_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2841 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[35]
2842 }
2843
2844 pub fn lua_call_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2845 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[36]
2846 }
2847
2848 pub fn memcmp_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2849 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[37]
2850 }
2851
2852 pub fn memcmp_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2853 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[38]
2854 }
2855
2856 pub fn memchr_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2857 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[39]
2858 }
2859
2860 pub fn strpbrk_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2861 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[40]
2862 }
2863
2864 pub fn isalpha_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2865 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[41]
2866 }
2867
2868 pub fn iscntrl_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2869 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[42]
2870 }
2871
2872 pub fn isdigit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2873 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[43]
2874 }
2875
2876 pub fn islower_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2877 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[44]
2878 }
2879
2880 pub fn ispunct_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2881 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[45]
2882 }
2883
2884 pub fn isspace_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2885 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[46]
2886 }
2887
2888 pub fn isupper_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2889 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[47]
2890 }
2891
2892 pub fn isalnum_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2893 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[48]
2894 }
2895
2896 pub fn isxdigit_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2897 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[49]
2898 }
2899
2900 pub fn isgraph_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2901 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[50]
2902 }
2903
2904 pub fn isalpha_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2905 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[51]
2906 }
2907
2908 pub fn iscntrl_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2909 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[52]
2910 }
2911
2912 pub fn isdigit_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2913 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[53]
2914 }
2915
2916 pub fn islower_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2917 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[54]
2918 }
2919
2920 pub fn ispunct_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2921 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[55]
2922 }
2923
2924 pub fn isspace_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2925 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[56]
2926 }
2927
2928 pub fn isupper_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2929 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[57]
2930 }
2931
2932 pub fn isalnum_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2933 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[58]
2934 }
2935
2936 pub fn isgraph_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2937 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[59]
2938 }
2939
2940 pub fn tolower_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2941 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[60]
2942 }
2943
2944 pub fn toupper_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2945 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[61]
2946 }
2947
2948 pub fn tolower_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2949 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[62]
2950 }
2951
2952 pub fn toupper_2_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2953 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[63]
2954 }
2955
2956 pub fn strchr_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2957 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[64]
2958 }
2959
2960 pub fn strcpy_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2961 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[65]
2962 }
2963
2964 pub fn strncpy_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2965 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[66]
2966 }
2967
2968 pub fn strlen_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2969 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[67]
2970 }
2971
2972 pub fn sprintf_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2973 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[68]
2974 }
2975
2976 pub fn ctor_method_info() -> &'static ::unity::il2cpp::MethodInfo {
2977 <Self as ::unity::ClassIdentity>::class().raw().get_methods()[69]
2978 }
2979}
2980
2981#[cfg(feature = "moon_sharp-interpreter-interop-lua_state_interop-luabase")]
2982impl LuaBase {
2983 #[doc = "`.ctor()` — no args"]
2984 pub fn new() -> Self {
2985 let this = <Self as ::unity::FromIlInstance>::instantiate().unwrap_or_else(|| {
2986 panic!(
2987 "{}
2988::{}
2989 failed to instantiate",
2990 ::core::stringify!(LuaBase),
2991 ::core::stringify!(new),
2992 )
2993 });
2994 <Self as ILuaBaseMethods>::ctor(this);
2995 this
2996 }
2997}
2998
2999#[cfg(feature = "moon_sharp-interpreter-interop-lua_state_interop-luabase")]
3000#[doc(hidden)]
3001pub mod prelude {
3002 pub use super::{ILuaBase, ILuaBaseMethods, LuaBase};
3003 pub use crate::system::object::IObject;
3004 #[cfg(feature = "system-object")]
3005 pub use crate::system::object::IObjectMethods;
3006}