-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathrasm.c
7156 lines (7156 loc) · 376 KB
/
rasm.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/* Generated by Nelua 0.2.0-dev */
/* Compile command: gcc -x c "../rasm.c" -x none -fwrapv -fno-strict-aliasing -g -lm -o "../rasm" */
/* Compile hash: 2oMCHwpzNsD8QhGmtyinxNjMxQJB */
/* ------------------------------ DIRECTIVES -------------------------------- */
/* Disable some warnings that the generated code can trigger. */
#if defined(__clang__) && __clang_major__ >= 3
#pragma clang diagnostic ignored "-Wtype-limits"
#pragma clang diagnostic ignored "-Wwrite-strings"
#pragma clang diagnostic ignored "-Wunused"
#pragma clang diagnostic ignored "-Wunused-parameter"
#pragma clang diagnostic ignored "-Wmissing-field-initializers"
#pragma clang diagnostic ignored "-Wparentheses-equality"
#pragma clang diagnostic ignored "-Wtautological-compare"
#pragma clang diagnostic ignored "-Wmissing-braces"
#ifndef __cplusplus
#pragma clang diagnostic ignored "-Wincompatible-pointer-types"
#pragma clang diagnostic error "-Wimplicit-function-declaration"
#pragma clang diagnostic error "-Wimplicit-int"
#else
#pragma clang diagnostic ignored "-Wnarrowing"
#pragma clang diagnostic ignored "-Wc99-designator"
#endif
#elif defined(__GNUC__) && __GNUC__ >= 5
#pragma GCC diagnostic ignored "-Wtype-limits"
#pragma GCC diagnostic ignored "-Wwrite-strings"
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wunused-value"
#pragma GCC diagnostic ignored "-Wunused-variable"
#pragma GCC diagnostic ignored "-Wunused-function"
#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
#ifndef __cplusplus
#pragma GCC diagnostic ignored "-Wmissing-braces"
#pragma GCC diagnostic ignored "-Wincompatible-pointer-types"
#pragma GCC diagnostic ignored "-Wdiscarded-qualifiers"
#pragma GCC diagnostic error "-Wimplicit-function-declaration"
#pragma GCC diagnostic error "-Wimplicit-int"
#else
#pragma GCC diagnostic ignored "-Wnarrowing"
#endif
#endif
#if defined(_WIN32) && !defined(_CRT_SECURE_NO_WARNINGS)
#define _CRT_SECURE_NO_WARNINGS
#endif
/* Macro used to perform compile-time checks. */
#if __STDC_VERSION__ >= 201112L
#define NELUA_STATIC_ASSERT _Static_assert
#elif __cplusplus >= 201103L
#define NELUA_STATIC_ASSERT static_assert
#else
#define NELUA_STATIC_ASSERT(x, y)
#endif
/* Macro used to get alignment of a type. */
#if __STDC_VERSION__ >= 201112L
#define NELUA_ALIGNOF _Alignof
#elif __cplusplus >= 201103L
#define NELUA_ALIGNOF alignof
#elif defined(__GNUC__)
#define NELUA_ALIGNOF __alignof__
#elif defined(_MSC_VER)
#define NELUA_ALIGNOF __alignof
#else
#define NELUA_ALIGNOF(x)
#endif
/* Checks if Nelua and C agrees on pointer size. */
NELUA_STATIC_ASSERT(sizeof(void*) == 8 && NELUA_ALIGNOF(void*) == 8, "Nelua and C disagree on pointer size or alignment");
/* Enable 64 bit offsets for stdio APIs. */
#if !defined(_FILE_OFFSET_BITS) && __SIZEOF_LONG__ >= 8
#define _FILE_OFFSET_BITS 64
#endif
/* Enable POSIX APIs in included headers. */
#if !defined(_POSIX_C_SOURCE) && !defined(_XOPEN_SOURCE) && !defined(_GNU_SOURCE) && !defined(_DEFAULT_SOURCE)
#if defined(__gnu_linux__)
#define _GNU_SOURCE
#else
#define _XOPEN_SOURCE 600
#endif
#endif
#include <string.h>
/* Macro used to force inlining a function. */
#ifdef __GNUC__
#define NELUA_INLINE __attribute__((always_inline)) inline
#elif defined(_MSC_VER)
#define NELUA_INLINE __forceinline
#elif __STDC_VERSION__ >= 199901L
#define NELUA_INLINE inline
#else
#define NELUA_INLINE
#endif
#include <stdint.h>
/* Macro used for branch prediction. */
#if defined(__GNUC__) || defined(__clang__)
#define NELUA_UNLIKELY(x) __builtin_expect(x, 0)
#else
#define NELUA_UNLIKELY(x) (x)
#endif
#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
/* Macro used to import/export extern C functions. */
#ifdef __cplusplus
#define NELUA_EXTERN extern "C"
#else
#define NELUA_EXTERN extern
#endif
/* Macro used to generate traceback on aborts when sanitizing. */
#if defined(__clang__) && defined(__has_feature)
#if __has_feature(undefined_behavior_sanitizer)
#define NELUA_UBSAN_UNREACHABLE __builtin_unreachable
#endif
#elif defined(__gnu_linux__) && defined(__GNUC__) && __GNUC__ >= 5
NELUA_EXTERN void __ubsan_handle_builtin_unreachable(void*) __attribute__((weak));
#define NELUA_UBSAN_UNREACHABLE() {if(&__ubsan_handle_builtin_unreachable) __builtin_unreachable();}
#endif
#ifndef NELUA_UBSAN_UNREACHABLE
#define NELUA_UBSAN_UNREACHABLE()
#endif
/* Macro used to specify a function that never returns. */
#if __STDC_VERSION__ >= 201112L
#define NELUA_NORETURN _Noreturn
#elif defined(__GNUC__)
#define NELUA_NORETURN __attribute__((noreturn))
#elif defined(_MSC_VER)
#define NELUA_NORETURN __declspec(noreturn)
#else
#define NELUA_NORETURN
#endif
#include <stddef.h>
#define NELUA_NIL (nlniltype){}
/* Macro used for branch prediction. */
#if defined(__GNUC__) || defined(__clang__)
#define NELUA_LIKELY(x) __builtin_expect(x, 1)
#else
#define NELUA_LIKELY(x) (x)
#endif
/* Macro used to force not inlining a function. */
#ifdef __GNUC__
#define NELUA_NOINLINE __attribute__((noinline))
#elif defined(_MSC_VER)
#define NELUA_NOINLINE __declspec(noinline)
#else
#define NELUA_NOINLINE
#endif
/* Macro used sign that a type punning cast may alias (related to strict aliasing). */
#ifdef __GNUC__
#define NELUA_MAYALIAS __attribute__((may_alias))
#else
#define NELUA_MAYALIAS
#endif
/* Macro used suppress sanitizer errors when the GC is scanning. */
#if defined(__has_feature)
#if __has_feature(address_sanitizer)
#define NELUA_GC_NO_SANITIZE __attribute__((no_sanitize_address))
#elif __has_feature(memory_sanitizer)
#define NELUA_GC_NO_SANITIZE __attribute__((no_sanitize_memory))
#endif
#endif
#ifndef NELUA_GC_NO_SANITIZE
#if defined(__SANITIZE_ADDRESS__)
#define NELUA_GC_NO_SANITIZE __attribute__((no_sanitize_address))
#else
#define NELUA_GC_NO_SANITIZE
#endif
#endif
#include <setjmp.h>
#include <errno.h>
/* Include basic POSIX constants and APIs */
#if !defined(_WIN32) && (defined(__unix__) || defined(__unix) || \
(defined(__APPLE__) && defined(__MACH__)) || \
defined(__HAIKU__))
#include <unistd.h>
#endif
/* Macro used to silence fallthrough warnings. */
#if defined(__GNUC__) && __GNUC__ >= 7
#define NELUA_FALLTHROUGH() __attribute__((fallthrough))
#else
#define NELUA_FALLTHROUGH() ((void)0)
#endif
/* Macro used to take reference of literals. */
#define NELUA_LITERAL_REF(T, x) (&((struct{T v;}){x}.v))
/* ------------------------------ DECLARATIONS ------------------------------ */
static NELUA_INLINE void nelua_memory_copy(void* dest, void* src, uintptr_t n);
static NELUA_INLINE void nelua_write_stderr(const char* msg, uintptr_t len, bool flush);
static NELUA_NORETURN void nelua_abort(void);
typedef struct nlstring nlstring;
typedef uint8_t* nluint8_arr0_ptr;
struct nlstring {
nluint8_arr0_ptr data;
uintptr_t size;
};
NELUA_STATIC_ASSERT(sizeof(nlstring) == 16 && NELUA_ALIGNOF(nlstring) == 8, "Nelua and C disagree on type size or align");
static void nelua_assert_line_1(bool cond, nlstring msg);
static NELUA_INLINE void nelua_memory_zero(void* dest, uintptr_t n);
static void nelua_assert_line_2(bool cond, nlstring msg);
static NELUA_INLINE int32_t nelua_memory_compare(void* a, void* b, uintptr_t n);
static void nelua_assert_line_3(bool cond, nlstring msg);
static NELUA_INLINE bool nelua_memory_equals(void* a, void* b, uintptr_t n);
static void nelua_assert_line_4(bool cond, nlstring msg);
static void* nelua_memory_find(void* haystack, uintptr_t haystacksize, void* needle, uintptr_t needlesize);
static void nelua_assert_line_5(bool cond, nlstring msg);
static NELUA_NORETURN void nelua_panic_cstring(const char* s);
static NELUA_INLINE void* nelua_assert_deref(void* p);
typedef uint8_t* nluint8_ptr;
typedef struct nelua_span_uint8_ nelua_span_uint8_;
struct nelua_span_uint8_ {
nluint8_arr0_ptr data;
uintptr_t size;
};
NELUA_STATIC_ASSERT(sizeof(nelua_span_uint8_) == 16 && NELUA_ALIGNOF(nelua_span_uint8_) == 8, "Nelua and C disagree on type size or align");
static NELUA_INLINE bool nelua_span_uint8__empty(nelua_span_uint8_ self);
static NELUA_INLINE nluint8_ptr nelua_span_uint8____atindex(nelua_span_uint8_ self, uintptr_t i);
static void nelua_assert_line_6(bool cond, nlstring msg);
typedef void** nlpointer_ptr;
typedef struct nelua_span_pointer_ nelua_span_pointer_;
typedef void** nlpointer_arr0_ptr;
struct nelua_span_pointer_ {
nlpointer_arr0_ptr data;
uintptr_t size;
};
NELUA_STATIC_ASSERT(sizeof(nelua_span_pointer_) == 16 && NELUA_ALIGNOF(nelua_span_pointer_) == 8, "Nelua and C disagree on type size or align");
static NELUA_INLINE nlpointer_ptr nelua_span_pointer____atindex(nelua_span_pointer_ self, uintptr_t i);
static void nelua_assert_line_7(bool cond, nlstring msg);
typedef struct nelua_GCScanRange nelua_GCScanRange;
typedef nelua_GCScanRange* nelua_GCScanRange_ptr;
struct nelua_GCScanRange {
uintptr_t low;
uintptr_t high;
};
NELUA_STATIC_ASSERT(sizeof(nelua_GCScanRange) == 16 && NELUA_ALIGNOF(nelua_GCScanRange) == 8, "Nelua and C disagree on type size or align");
typedef struct nelua_span_GCScanRange_ nelua_span_GCScanRange_;
typedef nelua_GCScanRange* nelua_GCScanRange_arr0_ptr;
struct nelua_span_GCScanRange_ {
nelua_GCScanRange_arr0_ptr data;
uintptr_t size;
};
NELUA_STATIC_ASSERT(sizeof(nelua_span_GCScanRange_) == 16 && NELUA_ALIGNOF(nelua_span_GCScanRange_) == 8, "Nelua and C disagree on type size or align");
static NELUA_INLINE nelua_GCScanRange_ptr nelua_span_GCScanRange____atindex(nelua_span_GCScanRange_ self, uintptr_t i);
static void nelua_assert_line_8(bool cond, nlstring msg);
typedef uintptr_t* nlusize_ptr;
typedef struct nelua_span_usize_ nelua_span_usize_;
typedef uintptr_t* nlusize_arr0_ptr;
struct nelua_span_usize_ {
nlusize_arr0_ptr data;
uintptr_t size;
};
NELUA_STATIC_ASSERT(sizeof(nelua_span_usize_) == 16 && NELUA_ALIGNOF(nelua_span_usize_) == 8, "Nelua and C disagree on type size or align");
static NELUA_INLINE nlusize_ptr nelua_span_usize____atindex(nelua_span_usize_ self, uintptr_t i);
static void nelua_assert_line_9(bool cond, nlstring msg);
typedef struct nelua_hashmapnode_pointer__GCItem_ nelua_hashmapnode_pointer__GCItem_;
typedef nelua_hashmapnode_pointer__GCItem_* nelua_hashmapnode_pointer__GCItem__ptr;
typedef struct nelua_GCItem nelua_GCItem;
typedef void (*nelua_GCFinalizerCallback)(void*, void*);
struct nelua_GCItem {
uintptr_t flags;
uintptr_t size;
nelua_GCFinalizerCallback finalizer;
void* userdata;
};
NELUA_STATIC_ASSERT(sizeof(nelua_GCItem) == 32 && NELUA_ALIGNOF(nelua_GCItem) == 8, "Nelua and C disagree on type size or align");
struct nelua_hashmapnode_pointer__GCItem_ {
void* key;
nelua_GCItem value;
bool filled;
uintptr_t next;
};
NELUA_STATIC_ASSERT(sizeof(nelua_hashmapnode_pointer__GCItem_) == 56 && NELUA_ALIGNOF(nelua_hashmapnode_pointer__GCItem_) == 8, "Nelua and C disagree on type size or align");
typedef struct nelua_span_hashmapnode_pointer__GCItem__ nelua_span_hashmapnode_pointer__GCItem__;
typedef nelua_hashmapnode_pointer__GCItem_* nelua_hashmapnode_pointer__GCItem__arr0_ptr;
struct nelua_span_hashmapnode_pointer__GCItem__ {
nelua_hashmapnode_pointer__GCItem__arr0_ptr data;
uintptr_t size;
};
NELUA_STATIC_ASSERT(sizeof(nelua_span_hashmapnode_pointer__GCItem__) == 16 && NELUA_ALIGNOF(nelua_span_hashmapnode_pointer__GCItem__) == 8, "Nelua and C disagree on type size or align");
static NELUA_INLINE nelua_hashmapnode_pointer__GCItem__ptr nelua_span_hashmapnode_pointer__GCItem_____atindex(nelua_span_hashmapnode_pointer__GCItem__ self, uintptr_t i);
static void nelua_assert_line_10(bool cond, nlstring msg);
typedef struct nelua_hashmapnode_pointer__usize_ nelua_hashmapnode_pointer__usize_;
typedef nelua_hashmapnode_pointer__usize_* nelua_hashmapnode_pointer__usize__ptr;
struct nelua_hashmapnode_pointer__usize_ {
void* key;
uintptr_t value;
bool filled;
uintptr_t next;
};
NELUA_STATIC_ASSERT(sizeof(nelua_hashmapnode_pointer__usize_) == 32 && NELUA_ALIGNOF(nelua_hashmapnode_pointer__usize_) == 8, "Nelua and C disagree on type size or align");
typedef struct nelua_span_hashmapnode_pointer__usize__ nelua_span_hashmapnode_pointer__usize__;
typedef nelua_hashmapnode_pointer__usize_* nelua_hashmapnode_pointer__usize__arr0_ptr;
struct nelua_span_hashmapnode_pointer__usize__ {
nelua_hashmapnode_pointer__usize__arr0_ptr data;
uintptr_t size;
};
NELUA_STATIC_ASSERT(sizeof(nelua_span_hashmapnode_pointer__usize__) == 16 && NELUA_ALIGNOF(nelua_span_hashmapnode_pointer__usize__) == 8, "Nelua and C disagree on type size or align");
static NELUA_INLINE nelua_hashmapnode_pointer__usize__ptr nelua_span_hashmapnode_pointer__usize_____atindex(nelua_span_hashmapnode_pointer__usize__ self, uintptr_t i);
static void nelua_assert_line_11(bool cond, nlstring msg);
typedef nlstring* nlstring_ptr;
typedef struct nelua_span_string_ nelua_span_string_;
typedef nlstring* nlstring_arr0_ptr;
struct nelua_span_string_ {
nlstring_arr0_ptr data;
uintptr_t size;
};
NELUA_STATIC_ASSERT(sizeof(nelua_span_string_) == 16 && NELUA_ALIGNOF(nelua_span_string_) == 8, "Nelua and C disagree on type size or align");
static NELUA_INLINE nlstring_ptr nelua_span_string____atindex(nelua_span_string_ self, uintptr_t i);
static void nelua_assert_line_12(bool cond, nlstring msg);
typedef struct nelua_hashmapnode_uint8__V_ nelua_hashmapnode_uint8__V_;
typedef nelua_hashmapnode_uint8__V_* nelua_hashmapnode_uint8__V__ptr;
typedef struct nelua_V_2 nelua_V_2;
typedef int64_t argHandling_optType;
struct nelua_V_2 {
argHandling_optType type;
void* execArgsP;
};
NELUA_STATIC_ASSERT(sizeof(nelua_V_2) == 16 && NELUA_ALIGNOF(nelua_V_2) == 8, "Nelua and C disagree on type size or align");
struct nelua_hashmapnode_uint8__V_ {
uint8_t key;
nelua_V_2 value;
bool filled;
uintptr_t next;
};
NELUA_STATIC_ASSERT(sizeof(nelua_hashmapnode_uint8__V_) == 40 && NELUA_ALIGNOF(nelua_hashmapnode_uint8__V_) == 8, "Nelua and C disagree on type size or align");
typedef struct nelua_span_hashmapnode_uint8__V__ nelua_span_hashmapnode_uint8__V__;
typedef nelua_hashmapnode_uint8__V_* nelua_hashmapnode_uint8__V__arr0_ptr;
struct nelua_span_hashmapnode_uint8__V__ {
nelua_hashmapnode_uint8__V__arr0_ptr data;
uintptr_t size;
};
NELUA_STATIC_ASSERT(sizeof(nelua_span_hashmapnode_uint8__V__) == 16 && NELUA_ALIGNOF(nelua_span_hashmapnode_uint8__V__) == 8, "Nelua and C disagree on type size or align");
static NELUA_INLINE nelua_hashmapnode_uint8__V__ptr nelua_span_hashmapnode_uint8__V_____atindex(nelua_span_hashmapnode_uint8__V__ self, uintptr_t i);
static void nelua_assert_line_13(bool cond, nlstring msg);
typedef struct nelua_hashmapnode_string__V_ nelua_hashmapnode_string__V_;
typedef nelua_hashmapnode_string__V_* nelua_hashmapnode_string__V__ptr;
typedef struct nelua_V_3 nelua_V_3;
struct nelua_V_3 {
uint64_t value;
int64_t length;
};
NELUA_STATIC_ASSERT(sizeof(nelua_V_3) == 16 && NELUA_ALIGNOF(nelua_V_3) == 8, "Nelua and C disagree on type size or align");
struct nelua_hashmapnode_string__V_ {
nlstring key;
nelua_V_3 value;
bool filled;
uintptr_t next;
};
NELUA_STATIC_ASSERT(sizeof(nelua_hashmapnode_string__V_) == 48 && NELUA_ALIGNOF(nelua_hashmapnode_string__V_) == 8, "Nelua and C disagree on type size or align");
typedef struct nelua_span_hashmapnode_string__V__ nelua_span_hashmapnode_string__V__;
typedef nelua_hashmapnode_string__V_* nelua_hashmapnode_string__V__arr0_ptr;
struct nelua_span_hashmapnode_string__V__ {
nelua_hashmapnode_string__V__arr0_ptr data;
uintptr_t size;
};
NELUA_STATIC_ASSERT(sizeof(nelua_span_hashmapnode_string__V__) == 16 && NELUA_ALIGNOF(nelua_span_hashmapnode_string__V__) == 8, "Nelua and C disagree on type size or align");
static NELUA_INLINE nelua_hashmapnode_string__V__ptr nelua_span_hashmapnode_string__V_____atindex(nelua_span_hashmapnode_string__V__ self, uintptr_t i);
static void nelua_assert_line_14(bool cond, nlstring msg);
typedef struct nelua_hashmapnode_string__V__1 nelua_hashmapnode_string__V__1;
typedef nelua_hashmapnode_string__V__1* nelua_hashmapnode_string__V__1_ptr;
typedef struct nelua_V_4 nelua_V_4;
typedef int64_t instr_instrType;
struct nelua_V_4 {
instr_instrType type;
uint8_t opcode;
uint8_t func3;
uint8_t func7;
};
NELUA_STATIC_ASSERT(sizeof(nelua_V_4) == 16 && NELUA_ALIGNOF(nelua_V_4) == 8, "Nelua and C disagree on type size or align");
struct nelua_hashmapnode_string__V__1 {
nlstring key;
nelua_V_4 value;
bool filled;
uintptr_t next;
};
NELUA_STATIC_ASSERT(sizeof(nelua_hashmapnode_string__V__1) == 48 && NELUA_ALIGNOF(nelua_hashmapnode_string__V__1) == 8, "Nelua and C disagree on type size or align");
typedef struct nelua_span_hashmapnode_string__V___1 nelua_span_hashmapnode_string__V___1;
typedef nelua_hashmapnode_string__V__1* nelua_hashmapnode_string__V__1_arr0_ptr;
struct nelua_span_hashmapnode_string__V___1 {
nelua_hashmapnode_string__V__1_arr0_ptr data;
uintptr_t size;
};
NELUA_STATIC_ASSERT(sizeof(nelua_span_hashmapnode_string__V___1) == 16 && NELUA_ALIGNOF(nelua_span_hashmapnode_string__V___1) == 8, "Nelua and C disagree on type size or align");
static NELUA_INLINE nelua_hashmapnode_string__V__1_ptr nelua_span_hashmapnode_string__V___1___atindex(nelua_span_hashmapnode_string__V___1 self, uintptr_t i);
static void nelua_assert_line_15(bool cond, nlstring msg);
typedef uint64_t* nluint64_ptr;
typedef struct nelua_span_uint64_ nelua_span_uint64_;
typedef uint64_t* nluint64_arr0_ptr;
struct nelua_span_uint64_ {
nluint64_arr0_ptr data;
uintptr_t size;
};
NELUA_STATIC_ASSERT(sizeof(nelua_span_uint64_) == 16 && NELUA_ALIGNOF(nelua_span_uint64_) == 8, "Nelua and C disagree on type size or align");
static NELUA_INLINE nluint64_ptr nelua_span_uint64____atindex(nelua_span_uint64_ self, uintptr_t i);
static void nelua_assert_line_16(bool cond, nlstring msg);
typedef struct nelua_hashmapnode_string__V__2 nelua_hashmapnode_string__V__2;
typedef nelua_hashmapnode_string__V__2* nelua_hashmapnode_string__V__2_ptr;
typedef struct nelua_V_5 nelua_V_5;
typedef struct nelua_sequence_uint8_ nelua_sequence_uint8_;
typedef struct nelua_sequenceimpl_uint8_ nelua_sequenceimpl_uint8_;
typedef nelua_sequenceimpl_uint8_* nelua_sequenceimpl_uint8__ptr;
typedef struct nelua_GCAllocator nelua_GCAllocator;
struct nelua_GCAllocator {};
struct nelua_sequence_uint8_ {
nelua_sequenceimpl_uint8__ptr impl;
nelua_GCAllocator allocator;
};
NELUA_STATIC_ASSERT(sizeof(nelua_sequence_uint8_) == 8 && NELUA_ALIGNOF(nelua_sequence_uint8_) == 8, "Nelua and C disagree on type size or align");
typedef struct nelua_sequence_uint64_ nelua_sequence_uint64_;
typedef struct nelua_sequenceimpl_uint64_ nelua_sequenceimpl_uint64_;
typedef nelua_sequenceimpl_uint64_* nelua_sequenceimpl_uint64__ptr;
struct nelua_sequence_uint64_ {
nelua_sequenceimpl_uint64__ptr impl;
nelua_GCAllocator allocator;
};
NELUA_STATIC_ASSERT(sizeof(nelua_sequence_uint64_) == 8 && NELUA_ALIGNOF(nelua_sequence_uint64_) == 8, "Nelua and C disagree on type size or align");
typedef nelua_sequence_uint8_ (*function_dZWinLkmVZrbymrX)(nelua_sequence_uint64_);
struct nelua_V_5 {
uint8_t argc;
function_dZWinLkmVZrbymrX assemble;
};
NELUA_STATIC_ASSERT(sizeof(nelua_V_5) == 16 && NELUA_ALIGNOF(nelua_V_5) == 8, "Nelua and C disagree on type size or align");
struct nelua_hashmapnode_string__V__2 {
nlstring key;
nelua_V_5 value;
bool filled;
uintptr_t next;
};
NELUA_STATIC_ASSERT(sizeof(nelua_hashmapnode_string__V__2) == 48 && NELUA_ALIGNOF(nelua_hashmapnode_string__V__2) == 8, "Nelua and C disagree on type size or align");
struct nelua_sequenceimpl_uint64_ {
nelua_span_uint64_ data;
uintptr_t size;
};
NELUA_STATIC_ASSERT(sizeof(nelua_sequenceimpl_uint64_) == 24 && NELUA_ALIGNOF(nelua_sequenceimpl_uint64_) == 8, "Nelua and C disagree on type size or align");
struct nelua_sequenceimpl_uint8_ {
nelua_span_uint8_ data;
uintptr_t size;
};
NELUA_STATIC_ASSERT(sizeof(nelua_sequenceimpl_uint8_) == 24 && NELUA_ALIGNOF(nelua_sequenceimpl_uint8_) == 8, "Nelua and C disagree on type size or align");
typedef struct nelua_span_hashmapnode_string__V___2 nelua_span_hashmapnode_string__V___2;
typedef nelua_hashmapnode_string__V__2* nelua_hashmapnode_string__V__2_arr0_ptr;
struct nelua_span_hashmapnode_string__V___2 {
nelua_hashmapnode_string__V__2_arr0_ptr data;
uintptr_t size;
};
NELUA_STATIC_ASSERT(sizeof(nelua_span_hashmapnode_string__V___2) == 16 && NELUA_ALIGNOF(nelua_span_hashmapnode_string__V___2) == 8, "Nelua and C disagree on type size or align");
static NELUA_INLINE nelua_hashmapnode_string__V__2_ptr nelua_span_hashmapnode_string__V___2___atindex(nelua_span_hashmapnode_string__V___2 self, uintptr_t i);
static void nelua_assert_line_17(bool cond, nlstring msg);
typedef struct elf_elf64Shdr elf_elf64Shdr;
typedef elf_elf64Shdr* elf_elf64Shdr_ptr;
struct elf_elf64Shdr {
uint32_t sh_name;
uint32_t sh_type;
uint64_t sh_flags;
uint64_t sh_addr;
uint64_t sh_offset;
uint64_t sh_size;
uint32_t sh_link;
uint32_t sh_info;
uint64_t sh_addralign;
uint64_t sh_entsize;
};
NELUA_STATIC_ASSERT(sizeof(elf_elf64Shdr) == 64 && NELUA_ALIGNOF(elf_elf64Shdr) == 8, "Nelua and C disagree on type size or align");
typedef struct nelua_span_elf64Shdr_ nelua_span_elf64Shdr_;
typedef elf_elf64Shdr* elf_elf64Shdr_arr0_ptr;
struct nelua_span_elf64Shdr_ {
elf_elf64Shdr_arr0_ptr data;
uintptr_t size;
};
NELUA_STATIC_ASSERT(sizeof(nelua_span_elf64Shdr_) == 16 && NELUA_ALIGNOF(nelua_span_elf64Shdr_) == 8, "Nelua and C disagree on type size or align");
static NELUA_INLINE elf_elf64Shdr_ptr nelua_span_elf64Shdr____atindex(nelua_span_elf64Shdr_ self, uintptr_t i);
static void nelua_assert_line_18(bool cond, nlstring msg);
typedef struct elf_elf64Sym elf_elf64Sym;
typedef elf_elf64Sym* elf_elf64Sym_ptr;
struct elf_elf64Sym {
uint32_t st_name;
uint8_t st_info;
uint8_t st_other;
uint16_t st_shndx;
uint64_t st_value;
uint64_t st_size;
};
NELUA_STATIC_ASSERT(sizeof(elf_elf64Sym) == 24 && NELUA_ALIGNOF(elf_elf64Sym) == 8, "Nelua and C disagree on type size or align");
typedef struct nelua_span_elf64Sym_ nelua_span_elf64Sym_;
typedef elf_elf64Sym* elf_elf64Sym_arr0_ptr;
struct nelua_span_elf64Sym_ {
elf_elf64Sym_arr0_ptr data;
uintptr_t size;
};
NELUA_STATIC_ASSERT(sizeof(nelua_span_elf64Sym_) == 16 && NELUA_ALIGNOF(nelua_span_elf64Sym_) == 8, "Nelua and C disagree on type size or align");
static NELUA_INLINE elf_elf64Sym_ptr nelua_span_elf64Sym____atindex(nelua_span_elf64Sym_ self, uintptr_t i);
static void nelua_assert_line_19(bool cond, nlstring msg);
typedef struct nelua_hashmapnode_string__uint32_ nelua_hashmapnode_string__uint32_;
typedef nelua_hashmapnode_string__uint32_* nelua_hashmapnode_string__uint32__ptr;
struct nelua_hashmapnode_string__uint32_ {
nlstring key;
uint32_t value;
bool filled;
uintptr_t next;
};
NELUA_STATIC_ASSERT(sizeof(nelua_hashmapnode_string__uint32_) == 32 && NELUA_ALIGNOF(nelua_hashmapnode_string__uint32_) == 8, "Nelua and C disagree on type size or align");
typedef struct nelua_span_hashmapnode_string__uint32__ nelua_span_hashmapnode_string__uint32__;
typedef nelua_hashmapnode_string__uint32_* nelua_hashmapnode_string__uint32__arr0_ptr;
struct nelua_span_hashmapnode_string__uint32__ {
nelua_hashmapnode_string__uint32__arr0_ptr data;
uintptr_t size;
};
NELUA_STATIC_ASSERT(sizeof(nelua_span_hashmapnode_string__uint32__) == 16 && NELUA_ALIGNOF(nelua_span_hashmapnode_string__uint32__) == 8, "Nelua and C disagree on type size or align");
static NELUA_INLINE nelua_hashmapnode_string__uint32__ptr nelua_span_hashmapnode_string__uint32_____atindex(nelua_span_hashmapnode_string__uint32__ self, uintptr_t i);
static void nelua_assert_line_20(bool cond, nlstring msg);
typedef struct nlmulret_nlboolean_nlint64_nluint8 {
bool r1;
int64_t r2;
uint8_t r3;
} nlmulret_nlboolean_nlint64_nluint8;
typedef nlmulret_nlboolean_nlint64_nluint8 (*function_3LPNAr7nduHuY3ETf)(nlstring_ptr, int64_t);
typedef struct nlmulret_function_3LPNAr7nduHuY3ETf_nlstring_ptr_nlint64 {
function_3LPNAr7nduHuY3ETf r1;
nlstring_ptr r2;
int64_t r3;
} nlmulret_function_3LPNAr7nduHuY3ETf_nlstring_ptr_nlint64;
static NELUA_INLINE nlmulret_function_3LPNAr7nduHuY3ETf_nlstring_ptr_nlint64 nelua_ipairs_1(nlstring_ptr a);
static NELUA_INLINE nlmulret_nlboolean_nlint64_nluint8 nelua_ipairs_next(nlstring_ptr a_1, int64_t k);
static NELUA_INLINE uintptr_t nelua_assert_narrow_nlint64_nlusize(int64_t x);
typedef struct nlmulret_nlboolean_nlint64_nlstring {
bool r1;
int64_t r2;
nlstring r3;
} nlmulret_nlboolean_nlint64_nlstring;
typedef struct nelua_sequence_string__1 nelua_sequence_string__1;
typedef struct nelua_sequenceimpl_string__1 nelua_sequenceimpl_string__1;
typedef nelua_sequenceimpl_string__1* nelua_sequenceimpl_string__1_ptr;
typedef struct nelua_GeneralAllocator nelua_GeneralAllocator;
struct nelua_GeneralAllocator {};
struct nelua_sequence_string__1 {
nelua_sequenceimpl_string__1_ptr impl;
nelua_GeneralAllocator allocator;
};
NELUA_STATIC_ASSERT(sizeof(nelua_sequence_string__1) == 8 && NELUA_ALIGNOF(nelua_sequence_string__1) == 8, "Nelua and C disagree on type size or align");
typedef nlmulret_nlboolean_nlint64_nlstring (*function_eUm9hA9ggP1BUyYv)(nelua_sequence_string__1, int64_t);
struct nelua_sequenceimpl_string__1 {
nelua_span_string_ data;
uintptr_t size;
};
NELUA_STATIC_ASSERT(sizeof(nelua_sequenceimpl_string__1) == 24 && NELUA_ALIGNOF(nelua_sequenceimpl_string__1) == 8, "Nelua and C disagree on type size or align");
typedef struct nlmulret_function_eUm9hA9ggP1BUyYv_nelua_sequence_string__1_nlint64 {
function_eUm9hA9ggP1BUyYv r1;
nelua_sequence_string__1 r2;
int64_t r3;
} nlmulret_function_eUm9hA9ggP1BUyYv_nelua_sequence_string__1_nlint64;
static NELUA_INLINE nlmulret_function_eUm9hA9ggP1BUyYv_nelua_sequence_string__1_nlint64 nelua_ipairs_2(nelua_sequence_string__1 a);
static NELUA_INLINE nlmulret_nlboolean_nlint64_nlstring nelua_ipairs_next_1(nelua_sequence_string__1 a_2, int64_t k);
typedef struct nlmulret_nlboolean_nlint64_nluint64 {
bool r1;
int64_t r2;
uint64_t r3;
} nlmulret_nlboolean_nlint64_nluint64;
typedef nlmulret_nlboolean_nlint64_nluint64 (*function_4JwRVx4oQFacTf3dV)(nelua_sequence_uint64_, int64_t);
typedef struct nlmulret_function_4JwRVx4oQFacTf3dV_nelua_sequence_uint64__nlint64 {
function_4JwRVx4oQFacTf3dV r1;
nelua_sequence_uint64_ r2;
int64_t r3;
} nlmulret_function_4JwRVx4oQFacTf3dV_nelua_sequence_uint64__nlint64;
static NELUA_INLINE nlmulret_function_4JwRVx4oQFacTf3dV_nelua_sequence_uint64__nlint64 nelua_ipairs_3(nelua_sequence_uint64_ a);
static NELUA_INLINE nlmulret_nlboolean_nlint64_nluint64 nelua_ipairs_next_2(nelua_sequence_uint64_ a_3, int64_t k);
typedef nlmulret_nlboolean_nlint64_nluint8 (*function_2jz3PiVxWVVz2SR8n)(nelua_sequence_uint8_, int64_t);
typedef struct nlmulret_function_2jz3PiVxWVVz2SR8n_nelua_sequence_uint8__nlint64 {
function_2jz3PiVxWVVz2SR8n r1;
nelua_sequence_uint8_ r2;
int64_t r3;
} nlmulret_function_2jz3PiVxWVVz2SR8n_nelua_sequence_uint8__nlint64;
static NELUA_INLINE nlmulret_function_2jz3PiVxWVVz2SR8n_nelua_sequence_uint8__nlint64 nelua_ipairs_4(nelua_sequence_uint8_ a);
static NELUA_INLINE nlmulret_nlboolean_nlint64_nluint8 nelua_ipairs_next_3(nelua_sequence_uint8_ a_4, int64_t k);
typedef struct nlmulret_nlboolean_nlpointer_nlusize {
bool r1;
void* r2;
uintptr_t r3;
} nlmulret_nlboolean_nlpointer_nlusize;
typedef struct nelua_hashmap_iteratorT_1 nelua_hashmap_iteratorT_1;
typedef nelua_hashmap_iteratorT_1* nelua_hashmap_iteratorT_1_ptr;
typedef nlmulret_nlboolean_nlpointer_nlusize (*function_2mALLZkSFbNDkE6o4)(nelua_hashmap_iteratorT_1_ptr, void*);
typedef struct nelua_hashmap_pointer__usize_ nelua_hashmap_pointer__usize_;
typedef nelua_hashmap_pointer__usize_* nelua_hashmap_pointer__usize__ptr;
struct nelua_hashmap_iteratorT_1 {
nelua_hashmap_pointer__usize__ptr container;
uintptr_t index;
};
NELUA_STATIC_ASSERT(sizeof(nelua_hashmap_iteratorT_1) == 16 && NELUA_ALIGNOF(nelua_hashmap_iteratorT_1) == 8, "Nelua and C disagree on type size or align");
struct nelua_hashmap_pointer__usize_ {
nelua_span_usize_ buckets;
nelua_span_hashmapnode_pointer__usize__ nodes;
uintptr_t size;
uintptr_t free_index;
nelua_GeneralAllocator allocator;
};
NELUA_STATIC_ASSERT(sizeof(nelua_hashmap_pointer__usize_) == 48 && NELUA_ALIGNOF(nelua_hashmap_pointer__usize_) == 8, "Nelua and C disagree on type size or align");
typedef struct nlmulret_function_2mALLZkSFbNDkE6o4_nelua_hashmap_iteratorT_1_nlpointer {
function_2mALLZkSFbNDkE6o4 r1;
nelua_hashmap_iteratorT_1 r2;
void* r3;
} nlmulret_function_2mALLZkSFbNDkE6o4_nelua_hashmap_iteratorT_1_nlpointer;
static NELUA_INLINE nlmulret_function_2mALLZkSFbNDkE6o4_nelua_hashmap_iteratorT_1_nlpointer nelua_pairs_1(nelua_hashmap_pointer__usize__ptr a);
typedef struct nlmulret_nlboolean_nlstring_nluint32 {
bool r1;
nlstring r2;
uint32_t r3;
} nlmulret_nlboolean_nlstring_nluint32;
typedef struct nelua_hashmap_iteratorT_6 nelua_hashmap_iteratorT_6;
typedef nelua_hashmap_iteratorT_6* nelua_hashmap_iteratorT_6_ptr;
typedef nlmulret_nlboolean_nlstring_nluint32 (*function_Be9dheYyhVZZMPGH)(nelua_hashmap_iteratorT_6_ptr, nlstring);
typedef struct nelua_hashmap_string__uint32_ nelua_hashmap_string__uint32_;
typedef nelua_hashmap_string__uint32_* nelua_hashmap_string__uint32__ptr;
struct nelua_hashmap_iteratorT_6 {
nelua_hashmap_string__uint32__ptr container;
uintptr_t index;
};
NELUA_STATIC_ASSERT(sizeof(nelua_hashmap_iteratorT_6) == 16 && NELUA_ALIGNOF(nelua_hashmap_iteratorT_6) == 8, "Nelua and C disagree on type size or align");
struct nelua_hashmap_string__uint32_ {
nelua_span_usize_ buckets;
nelua_span_hashmapnode_string__uint32__ nodes;
uintptr_t size;
uintptr_t free_index;
nelua_GCAllocator allocator;
};
NELUA_STATIC_ASSERT(sizeof(nelua_hashmap_string__uint32_) == 48 && NELUA_ALIGNOF(nelua_hashmap_string__uint32_) == 8, "Nelua and C disagree on type size or align");
typedef struct nlmulret_function_Be9dheYyhVZZMPGH_nelua_hashmap_iteratorT_6_nlstring {
function_Be9dheYyhVZZMPGH r1;
nelua_hashmap_iteratorT_6 r2;
nlstring r3;
} nlmulret_function_Be9dheYyhVZZMPGH_nelua_hashmap_iteratorT_6_nlstring;
static NELUA_INLINE nlmulret_function_Be9dheYyhVZZMPGH_nelua_hashmap_iteratorT_6_nlstring nelua_pairs_2(nelua_hashmap_string__uint32__ptr a);
typedef nelua_GCItem* nelua_GCItem_ptr;
typedef struct nlmulret_nlboolean_nlpointer_nelua_GCItem_ptr {
bool r1;
void* r2;
nelua_GCItem_ptr r3;
} nlmulret_nlboolean_nlpointer_nelua_GCItem_ptr;
typedef struct nelua_hashmap_iteratorT nelua_hashmap_iteratorT;
typedef nelua_hashmap_iteratorT* nelua_hashmap_iteratorT_ptr;
typedef nlmulret_nlboolean_nlpointer_nelua_GCItem_ptr (*function_4vXvvEhXfi6WJuzfV)(nelua_hashmap_iteratorT_ptr, void*);
typedef struct nelua_hashmap_pointer__GCItem_ nelua_hashmap_pointer__GCItem_;
typedef nelua_hashmap_pointer__GCItem_* nelua_hashmap_pointer__GCItem__ptr;
struct nelua_hashmap_iteratorT {
nelua_hashmap_pointer__GCItem__ptr container;
uintptr_t index;
};
NELUA_STATIC_ASSERT(sizeof(nelua_hashmap_iteratorT) == 16 && NELUA_ALIGNOF(nelua_hashmap_iteratorT) == 8, "Nelua and C disagree on type size or align");
struct nelua_hashmap_pointer__GCItem_ {
nelua_span_usize_ buckets;
nelua_span_hashmapnode_pointer__GCItem__ nodes;
uintptr_t size;
uintptr_t free_index;
nelua_GeneralAllocator allocator;
};
NELUA_STATIC_ASSERT(sizeof(nelua_hashmap_pointer__GCItem_) == 48 && NELUA_ALIGNOF(nelua_hashmap_pointer__GCItem_) == 8, "Nelua and C disagree on type size or align");
typedef struct nlmulret_function_4vXvvEhXfi6WJuzfV_nelua_hashmap_iteratorT_nlpointer {
function_4vXvvEhXfi6WJuzfV r1;
nelua_hashmap_iteratorT r2;
void* r3;
} nlmulret_function_4vXvvEhXfi6WJuzfV_nelua_hashmap_iteratorT_nlpointer;
static NELUA_INLINE nlmulret_function_4vXvvEhXfi6WJuzfV_nelua_hashmap_iteratorT_nlpointer nelua_mpairs_1(nelua_hashmap_pointer__GCItem__ptr a);
typedef struct nlniltype {} nlniltype;
typedef struct nlniltype nltype;
static NELUA_INLINE void nelua_memory_spanset_1(nelua_span_usize_ dest, uintptr_t x);
typedef struct nelua_sequence_string_ nelua_sequence_string_;
typedef nelua_sequence_string_* nelua_sequence_string__ptr;
typedef struct nelua_sequenceimpl_string_ nelua_sequenceimpl_string_;
typedef nelua_sequenceimpl_string_* nelua_sequenceimpl_string__ptr;
struct nelua_sequence_string_ {
nelua_sequenceimpl_string__ptr impl;
nelua_GCAllocator allocator;
};
NELUA_STATIC_ASSERT(sizeof(nelua_sequence_string_) == 8 && NELUA_ALIGNOF(nelua_sequence_string_) == 8, "Nelua and C disagree on type size or align");
struct nelua_sequenceimpl_string_ {
nelua_span_string_ data;
uintptr_t size;
};
NELUA_STATIC_ASSERT(sizeof(nelua_sequenceimpl_string_) == 24 && NELUA_ALIGNOF(nelua_sequenceimpl_string_) == 8, "Nelua and C disagree on type size or align");
static void nelua_sequence_string___init(nelua_sequence_string__ptr self);
static void nelua_sequence_string__reserve(nelua_sequence_string__ptr self, uintptr_t n);
static void nelua_sequence_string__resize(nelua_sequence_string__ptr self, uintptr_t n);
static NELUA_NOINLINE void nelua_sequenceT_grow(nelua_sequence_string__ptr self);
static void nelua_assert_line_21(bool cond, nlstring msg);
static NELUA_INLINE nlstring_ptr nelua_sequence_string____atindex(nelua_sequence_string__ptr self, uintptr_t pos);
static void nelua_assert_line_22(bool cond, nlstring msg);
static NELUA_INLINE intptr_t nelua_sequence_string____len(nelua_sequence_string__ptr self);
typedef nelua_sequence_string__1* nelua_sequence_string__1_ptr;
static void nelua_sequence_string__1__init(nelua_sequence_string__1_ptr self);
static void nelua_sequence_string__1_reserve(nelua_sequence_string__1_ptr self, uintptr_t n);
static NELUA_NOINLINE void nelua_sequenceT_grow_1(nelua_sequence_string__1_ptr self);
static void nelua_assert_line_23(bool cond, nlstring msg);
static NELUA_INLINE nlstring_ptr nelua_sequence_string__1___atindex(nelua_sequence_string__1_ptr self, uintptr_t pos);
static void nelua_assert_line_24(bool cond, nlstring msg);
static NELUA_INLINE intptr_t nelua_sequence_string__1___len(nelua_sequence_string__1_ptr self);
typedef nelua_sequence_uint8_* nelua_sequence_uint8__ptr;
static void nelua_sequence_uint8___init(nelua_sequence_uint8__ptr self);
static void nelua_sequence_uint8__reserve(nelua_sequence_uint8__ptr self, uintptr_t n);
static NELUA_NOINLINE void nelua_sequenceT_grow_2(nelua_sequence_uint8__ptr self);
static void nelua_assert_line_25(bool cond, nlstring msg);
static NELUA_INLINE nluint8_ptr nelua_sequence_uint8____atindex(nelua_sequence_uint8__ptr self, uintptr_t pos);
static void nelua_assert_line_26(bool cond, nlstring msg);
static NELUA_INLINE intptr_t nelua_sequence_uint8____len(nelua_sequence_uint8__ptr self);
typedef struct NELUA_MAYALIAS nluint8_arr4 {uint8_t v[4];} nluint8_arr4;
typedef union NELUA_MAYALIAS nluint8_arr4_cast {nluint8_arr4 a; uint8_t p[4];} nluint8_arr4_cast;
NELUA_STATIC_ASSERT(sizeof(nluint8_arr4) == 4 && NELUA_ALIGNOF(nluint8_arr4) == 1, "Nelua and C disagree on type size or align");
static NELUA_INLINE nelua_sequence_uint8_ nelua_sequence_uint8____convert_1(nluint8_arr4 values);
static NELUA_INLINE uintptr_t nelua_assert_bounds_nlusize(uintptr_t index, uintptr_t len);
typedef nelua_sequence_uint64_* nelua_sequence_uint64__ptr;
static void nelua_sequence_uint64___init(nelua_sequence_uint64__ptr self);
static void nelua_sequence_uint64__reserve(nelua_sequence_uint64__ptr self, uintptr_t n);
static NELUA_NOINLINE void nelua_sequenceT_grow_3(nelua_sequence_uint64__ptr self);
static void nelua_assert_line_27(bool cond, nlstring msg);
static NELUA_INLINE nluint64_ptr nelua_sequence_uint64____atindex(nelua_sequence_uint64__ptr self, uintptr_t pos);
static void nelua_assert_line_28(bool cond, nlstring msg);
static NELUA_INLINE intptr_t nelua_sequence_uint64____len(nelua_sequence_uint64__ptr self);
typedef struct NELUA_MAYALIAS nluint64_arr3 {uint64_t v[3];} nluint64_arr3;
typedef union NELUA_MAYALIAS nluint64_arr3_cast {nluint64_arr3 a; uint64_t p[3];} nluint64_arr3_cast;
NELUA_STATIC_ASSERT(sizeof(nluint64_arr3) == 24 && NELUA_ALIGNOF(nluint64_arr3) == 8, "Nelua and C disagree on type size or align");
static NELUA_INLINE nelua_sequence_uint64_ nelua_sequence_uint64____convert_1(nluint64_arr3 values);
typedef struct NELUA_MAYALIAS nluint64_arr2 {uint64_t v[2];} nluint64_arr2;
typedef union NELUA_MAYALIAS nluint64_arr2_cast {nluint64_arr2 a; uint64_t p[2];} nluint64_arr2_cast;
NELUA_STATIC_ASSERT(sizeof(nluint64_arr2) == 16 && NELUA_ALIGNOF(nluint64_arr2) == 8, "Nelua and C disagree on type size or align");
static NELUA_INLINE nelua_sequence_uint64_ nelua_sequence_uint64____convert_2(nluint64_arr2 values);
typedef struct nelua_sequence_elf64Shdr_ nelua_sequence_elf64Shdr_;
typedef nelua_sequence_elf64Shdr_* nelua_sequence_elf64Shdr__ptr;
typedef struct nelua_sequenceimpl_elf64Shdr_ nelua_sequenceimpl_elf64Shdr_;
typedef nelua_sequenceimpl_elf64Shdr_* nelua_sequenceimpl_elf64Shdr__ptr;
struct nelua_sequence_elf64Shdr_ {
nelua_sequenceimpl_elf64Shdr__ptr impl;
nelua_GCAllocator allocator;
};
NELUA_STATIC_ASSERT(sizeof(nelua_sequence_elf64Shdr_) == 8 && NELUA_ALIGNOF(nelua_sequence_elf64Shdr_) == 8, "Nelua and C disagree on type size or align");
struct nelua_sequenceimpl_elf64Shdr_ {
nelua_span_elf64Shdr_ data;
uintptr_t size;
};
NELUA_STATIC_ASSERT(sizeof(nelua_sequenceimpl_elf64Shdr_) == 24 && NELUA_ALIGNOF(nelua_sequenceimpl_elf64Shdr_) == 8, "Nelua and C disagree on type size or align");
static void nelua_sequence_elf64Shdr___init(nelua_sequence_elf64Shdr__ptr self);
static NELUA_NOINLINE void nelua_sequenceT_grow_4(nelua_sequence_elf64Shdr__ptr self);
static void nelua_assert_line_29(bool cond, nlstring msg);
static NELUA_INLINE elf_elf64Shdr_ptr nelua_sequence_elf64Shdr____atindex(nelua_sequence_elf64Shdr__ptr self, uintptr_t pos);
static void nelua_assert_line_30(bool cond, nlstring msg);
static NELUA_INLINE intptr_t nelua_sequence_elf64Shdr____len(nelua_sequence_elf64Shdr__ptr self);
typedef struct nelua_sequence_elf64Sym_ nelua_sequence_elf64Sym_;
typedef nelua_sequence_elf64Sym_* nelua_sequence_elf64Sym__ptr;
typedef struct nelua_sequenceimpl_elf64Sym_ nelua_sequenceimpl_elf64Sym_;
typedef nelua_sequenceimpl_elf64Sym_* nelua_sequenceimpl_elf64Sym__ptr;
struct nelua_sequence_elf64Sym_ {
nelua_sequenceimpl_elf64Sym__ptr impl;
nelua_GCAllocator allocator;
};
NELUA_STATIC_ASSERT(sizeof(nelua_sequence_elf64Sym_) == 8 && NELUA_ALIGNOF(nelua_sequence_elf64Sym_) == 8, "Nelua and C disagree on type size or align");
struct nelua_sequenceimpl_elf64Sym_ {
nelua_span_elf64Sym_ data;
uintptr_t size;
};
NELUA_STATIC_ASSERT(sizeof(nelua_sequenceimpl_elf64Sym_) == 24 && NELUA_ALIGNOF(nelua_sequenceimpl_elf64Sym_) == 8, "Nelua and C disagree on type size or align");
static void nelua_sequence_elf64Sym___init(nelua_sequence_elf64Sym__ptr self);
static NELUA_NOINLINE void nelua_sequenceT_grow_5(nelua_sequence_elf64Sym__ptr self);
static void nelua_assert_line_31(bool cond, nlstring msg);
static NELUA_INLINE elf_elf64Sym_ptr nelua_sequence_elf64Sym____atindex(nelua_sequence_elf64Sym__ptr self, uintptr_t pos);
static void nelua_assert_line_32(bool cond, nlstring msg);
static NELUA_INLINE intptr_t nelua_sequence_elf64Sym____len(nelua_sequence_elf64Sym__ptr self);
static nelua_GeneralAllocator nelua_general_allocator;
typedef nelua_GeneralAllocator* nelua_GeneralAllocator_ptr;
static NELUA_INLINE void* nelua_GeneralAllocator_alloc_1(nelua_GeneralAllocator_ptr self, uintptr_t size, uintptr_t flags);
static NELUA_INLINE void* nelua_GeneralAllocator_alloc_2(nelua_GeneralAllocator_ptr self, uintptr_t size, nlniltype flags);
static NELUA_INLINE void* nelua_GeneralAllocator_alloc0_1(nelua_GeneralAllocator_ptr self, uintptr_t size, nlniltype flags);
static NELUA_INLINE void* nelua_GeneralAllocator_alloc0_2(nelua_GeneralAllocator_ptr self, uintptr_t size, uintptr_t flags);
static NELUA_INLINE void nelua_GeneralAllocator_dealloc(nelua_GeneralAllocator_ptr self, void* p);
static NELUA_INLINE void* nelua_GeneralAllocator_realloc(nelua_GeneralAllocator_ptr self, void* p, uintptr_t newsize, uintptr_t oldsize);
static void* nelua_GeneralAllocator_xalloc0_1(nelua_GeneralAllocator_ptr self, uintptr_t size, nlniltype flags);
static NELUA_NORETURN void nelua_panic_string(nlstring s);
static void* nelua_GeneralAllocator_realloc0(nelua_GeneralAllocator_ptr self, void* p, uintptr_t newsize, uintptr_t oldsize);
static nelua_span_pointer_ nelua_GeneralAllocator_spanalloc_1(nelua_GeneralAllocator_ptr self, nlniltype T, uintptr_t size, nlniltype flags);
static nelua_span_GCScanRange_ nelua_GeneralAllocator_spanalloc_2(nelua_GeneralAllocator_ptr self, nlniltype T, uintptr_t size, nlniltype flags);
static nelua_span_usize_ nelua_GeneralAllocator_spanalloc_3(nelua_GeneralAllocator_ptr self, nlniltype T, uintptr_t size, nlniltype flags);
static nelua_span_string_ nelua_GeneralAllocator_spanalloc_4(nelua_GeneralAllocator_ptr self, nlniltype T, uintptr_t size, nlniltype flags);
static nelua_span_hashmapnode_pointer__GCItem__ nelua_GeneralAllocator_spanalloc0_1(nelua_GeneralAllocator_ptr self, nlniltype T, uintptr_t size, nlniltype flags);
static nelua_span_hashmapnode_pointer__usize__ nelua_GeneralAllocator_spanalloc0_2(nelua_GeneralAllocator_ptr self, nlniltype T, uintptr_t size, nlniltype flags);
static void nelua_GeneralAllocator_spandealloc_1(nelua_GeneralAllocator_ptr self, nelua_span_pointer_ s);
static void nelua_GeneralAllocator_spandealloc_2(nelua_GeneralAllocator_ptr self, nelua_span_GCScanRange_ s);
static void nelua_GeneralAllocator_spandealloc_3(nelua_GeneralAllocator_ptr self, nelua_span_usize_ s);
static void nelua_GeneralAllocator_spandealloc_4(nelua_GeneralAllocator_ptr self, nelua_span_hashmapnode_pointer__GCItem__ s);
static void nelua_GeneralAllocator_spandealloc_5(nelua_GeneralAllocator_ptr self, nelua_span_hashmapnode_pointer__usize__ s);
static nelua_span_pointer_ nelua_GeneralAllocator_spanrealloc_1(nelua_GeneralAllocator_ptr self, nelua_span_pointer_ s, uintptr_t size);
static nelua_span_GCScanRange_ nelua_GeneralAllocator_spanrealloc_2(nelua_GeneralAllocator_ptr self, nelua_span_GCScanRange_ s, uintptr_t size);
static nelua_span_usize_ nelua_GeneralAllocator_spanrealloc_3(nelua_GeneralAllocator_ptr self, nelua_span_usize_ s, uintptr_t size);
static nelua_span_string_ nelua_GeneralAllocator_spanrealloc_4(nelua_GeneralAllocator_ptr self, nelua_span_string_ s, uintptr_t size);
static nelua_span_pointer_ nelua_GeneralAllocator_xspanrealloc_1(nelua_GeneralAllocator_ptr self, nelua_span_pointer_ s, uintptr_t size);
static nelua_span_GCScanRange_ nelua_GeneralAllocator_xspanrealloc_2(nelua_GeneralAllocator_ptr self, nelua_span_GCScanRange_ s, uintptr_t size);
static nelua_span_usize_ nelua_GeneralAllocator_xspanrealloc_3(nelua_GeneralAllocator_ptr self, nelua_span_usize_ s, uintptr_t size);
static nelua_span_string_ nelua_GeneralAllocator_xspanrealloc_4(nelua_GeneralAllocator_ptr self, nelua_span_string_ s, uintptr_t size);
static nelua_span_hashmapnode_pointer__GCItem__ nelua_GeneralAllocator_spanrealloc0_1(nelua_GeneralAllocator_ptr self, nelua_span_hashmapnode_pointer__GCItem__ s, uintptr_t size);
static nelua_span_hashmapnode_pointer__usize__ nelua_GeneralAllocator_spanrealloc0_2(nelua_GeneralAllocator_ptr self, nelua_span_hashmapnode_pointer__usize__ s, uintptr_t size);
static nelua_span_hashmapnode_pointer__GCItem__ nelua_GeneralAllocator_xspanrealloc0_1(nelua_GeneralAllocator_ptr self, nelua_span_hashmapnode_pointer__GCItem__ s, uintptr_t size);
static nelua_span_hashmapnode_pointer__usize__ nelua_GeneralAllocator_xspanrealloc0_2(nelua_GeneralAllocator_ptr self, nelua_span_hashmapnode_pointer__usize__ s, uintptr_t size);
static nelua_sequenceimpl_string__1_ptr nelua_GeneralAllocator_new_1(nelua_GeneralAllocator_ptr self, nlniltype what, nlniltype size, nlniltype flags);
static NELUA_INLINE uintptr_t nelua_lhash(nluint8_arr0_ptr data, uintptr_t len, uintptr_t seed, uintptr_t step);
static NELUA_INLINE uintptr_t nelua_hash_long(nelua_span_uint8_ data);
static uintptr_t nelua_hash_hash_1(void* v);
static uintptr_t nelua_hash_hash_2(uint8_t v);
static uintptr_t nelua_hash_hash_3(nlstring v);
static NELUA_INLINE uintptr_t nelua_ceilidiv(uintptr_t x, uintptr_t y);
static NELUA_INLINE uintptr_t nelua_hashmod(uintptr_t h, uintptr_t n);
static NELUA_INLINE uintptr_t nelua_roundpow2(uintptr_t n);
static void nelua_hashmap_pointer__GCItem__destroy(nelua_hashmap_pointer__GCItem__ptr self);
typedef struct nlmulret_nlusize_nlusize_nlusize {
uintptr_t r1;
uintptr_t r2;
uintptr_t r3;
} nlmulret_nlusize_nlusize_nlusize;
static NELUA_INLINE nlmulret_nlusize_nlusize_nlusize nelua_hashmap_pointer__GCItem___find(nelua_hashmap_pointer__GCItem__ptr self, void* key);
static NELUA_NOINLINE void nelua_hashmap_pointer__GCItem__rehash(nelua_hashmap_pointer__GCItem__ptr self, uintptr_t bucket_count);
static void nelua_assert_line_33(bool cond);
static uintptr_t nelua_hashmap_pointer__GCItem___at(nelua_hashmap_pointer__GCItem__ptr self, void* key);
static void nelua_assert_line_34(bool cond, nlstring msg);
static nelua_GCItem_ptr nelua_hashmap_pointer__GCItem____atindex(nelua_hashmap_pointer__GCItem__ptr self, void* key);
static nelua_GCItem_ptr nelua_hashmap_pointer__GCItem__peek(nelua_hashmap_pointer__GCItem__ptr self, void* key);
static nelua_GCItem nelua_hashmap_pointer__GCItem__remove(nelua_hashmap_pointer__GCItem__ptr self, void* key);
static bool nelua_hashmap_pointer__GCItem__erase(nelua_hashmap_pointer__GCItem__ptr self, void* key);
static NELUA_INLINE nelua_hashmapnode_pointer__GCItem__ptr nelua_hashmap_iteratorT__next_node(nelua_hashmap_iteratorT_ptr self, void* key);
static NELUA_INLINE nlmulret_nlboolean_nlpointer_nelua_GCItem_ptr nelua_hashmap_iteratorT_mnext(nelua_hashmap_iteratorT_ptr self, void* key);
static NELUA_INLINE nlmulret_function_4vXvvEhXfi6WJuzfV_nelua_hashmap_iteratorT_nlpointer nelua_hashmap_pointer__GCItem____mpairs(nelua_hashmap_pointer__GCItem__ptr self);
static void nelua_hashmap_pointer__usize__destroy(nelua_hashmap_pointer__usize__ptr self);
static NELUA_INLINE nlmulret_nlusize_nlusize_nlusize nelua_hashmap_pointer__usize___find(nelua_hashmap_pointer__usize__ptr self, void* key);
static NELUA_NOINLINE void nelua_hashmap_pointer__usize__rehash(nelua_hashmap_pointer__usize__ptr self, uintptr_t bucket_count);
static void nelua_assert_line_35(bool cond);
static uintptr_t nelua_hashmap_pointer__usize___at(nelua_hashmap_pointer__usize__ptr self, void* key);
static void nelua_assert_line_36(bool cond, nlstring msg);
static nlusize_ptr nelua_hashmap_pointer__usize____atindex(nelua_hashmap_pointer__usize__ptr self, void* key);
static uintptr_t nelua_hashmap_pointer__usize__remove(nelua_hashmap_pointer__usize__ptr self, void* key);
static NELUA_INLINE nelua_hashmapnode_pointer__usize__ptr nelua_hashmap_iteratorT_1__next_node(nelua_hashmap_iteratorT_1_ptr self, void* key);
static NELUA_INLINE nlmulret_nlboolean_nlpointer_nlusize nelua_hashmap_iteratorT_1_next(nelua_hashmap_iteratorT_1_ptr self, void* key);
static NELUA_INLINE nlmulret_function_2mALLZkSFbNDkE6o4_nelua_hashmap_iteratorT_1_nlpointer nelua_hashmap_pointer__usize____pairs(nelua_hashmap_pointer__usize__ptr self);
typedef struct nelua_hashmap_uint8__V_ nelua_hashmap_uint8__V_;
typedef nelua_hashmap_uint8__V_* nelua_hashmap_uint8__V__ptr;
struct nelua_hashmap_uint8__V_ {
nelua_span_usize_ buckets;
nelua_span_hashmapnode_uint8__V__ nodes;
uintptr_t size;
uintptr_t free_index;
nelua_GCAllocator allocator;
};
NELUA_STATIC_ASSERT(sizeof(nelua_hashmap_uint8__V_) == 48 && NELUA_ALIGNOF(nelua_hashmap_uint8__V_) == 8, "Nelua and C disagree on type size or align");
static NELUA_INLINE nlmulret_nlusize_nlusize_nlusize nelua_hashmap_uint8__V___find(nelua_hashmap_uint8__V__ptr self, uint8_t key);
static NELUA_NOINLINE void nelua_hashmap_uint8__V__rehash(nelua_hashmap_uint8__V__ptr self, uintptr_t bucket_count);
static void nelua_assert_line_37(bool cond);
static uintptr_t nelua_hashmap_uint8__V___at(nelua_hashmap_uint8__V__ptr self, uint8_t key);
static void nelua_assert_line_38(bool cond, nlstring msg);
typedef nelua_V_2* nelua_V_2_ptr;
static nelua_V_2_ptr nelua_hashmap_uint8__V____atindex(nelua_hashmap_uint8__V__ptr self, uint8_t key);
static nelua_V_2_ptr nelua_hashmap_uint8__V__peek(nelua_hashmap_uint8__V__ptr self, uint8_t key);
static bool nelua_hashmap_uint8__V__has(nelua_hashmap_uint8__V__ptr self, uint8_t key);
typedef struct nelua_hashmap_string__V_ nelua_hashmap_string__V_;
typedef nelua_hashmap_string__V_* nelua_hashmap_string__V__ptr;
struct nelua_hashmap_string__V_ {
nelua_span_usize_ buckets;
nelua_span_hashmapnode_string__V__ nodes;
uintptr_t size;
uintptr_t free_index;
nelua_GCAllocator allocator;
};
NELUA_STATIC_ASSERT(sizeof(nelua_hashmap_string__V_) == 48 && NELUA_ALIGNOF(nelua_hashmap_string__V_) == 8, "Nelua and C disagree on type size or align");
static NELUA_INLINE nlmulret_nlusize_nlusize_nlusize nelua_hashmap_string__V___find(nelua_hashmap_string__V__ptr self, nlstring key);
static NELUA_NOINLINE void nelua_hashmap_string__V__rehash(nelua_hashmap_string__V__ptr self, uintptr_t bucket_count);
static void nelua_assert_line_39(bool cond);
static uintptr_t nelua_hashmap_string__V___at(nelua_hashmap_string__V__ptr self, nlstring key);
static void nelua_assert_line_40(bool cond, nlstring msg);
typedef nelua_V_3* nelua_V_3_ptr;
static nelua_V_3_ptr nelua_hashmap_string__V____atindex(nelua_hashmap_string__V__ptr self, nlstring key);
static nelua_V_3_ptr nelua_hashmap_string__V__peek(nelua_hashmap_string__V__ptr self, nlstring key);
static bool nelua_hashmap_string__V__has(nelua_hashmap_string__V__ptr self, nlstring key);
typedef struct nelua_hashmap_string__V__1 nelua_hashmap_string__V__1;
typedef nelua_hashmap_string__V__1* nelua_hashmap_string__V__1_ptr;
struct nelua_hashmap_string__V__1 {
nelua_span_usize_ buckets;
nelua_span_hashmapnode_string__V___1 nodes;
uintptr_t size;
uintptr_t free_index;
nelua_GCAllocator allocator;
};
NELUA_STATIC_ASSERT(sizeof(nelua_hashmap_string__V__1) == 48 && NELUA_ALIGNOF(nelua_hashmap_string__V__1) == 8, "Nelua and C disagree on type size or align");
static NELUA_INLINE nlmulret_nlusize_nlusize_nlusize nelua_hashmap_string__V__1__find(nelua_hashmap_string__V__1_ptr self, nlstring key);
static NELUA_NOINLINE void nelua_hashmap_string__V__1_rehash(nelua_hashmap_string__V__1_ptr self, uintptr_t bucket_count);
static void nelua_assert_line_41(bool cond);
static uintptr_t nelua_hashmap_string__V__1__at(nelua_hashmap_string__V__1_ptr self, nlstring key);
static void nelua_assert_line_42(bool cond, nlstring msg);
typedef nelua_V_4* nelua_V_4_ptr;
static nelua_V_4_ptr nelua_hashmap_string__V__1___atindex(nelua_hashmap_string__V__1_ptr self, nlstring key);
static nelua_V_4_ptr nelua_hashmap_string__V__1_peek(nelua_hashmap_string__V__1_ptr self, nlstring key);
static bool nelua_hashmap_string__V__1_has(nelua_hashmap_string__V__1_ptr self, nlstring key);
typedef struct nelua_hashmap_string__V__2 nelua_hashmap_string__V__2;
typedef nelua_hashmap_string__V__2* nelua_hashmap_string__V__2_ptr;
struct nelua_hashmap_string__V__2 {
nelua_span_usize_ buckets;
nelua_span_hashmapnode_string__V___2 nodes;
uintptr_t size;
uintptr_t free_index;
nelua_GCAllocator allocator;
};
NELUA_STATIC_ASSERT(sizeof(nelua_hashmap_string__V__2) == 48 && NELUA_ALIGNOF(nelua_hashmap_string__V__2) == 8, "Nelua and C disagree on type size or align");
static NELUA_INLINE nlmulret_nlusize_nlusize_nlusize nelua_hashmap_string__V__2__find(nelua_hashmap_string__V__2_ptr self, nlstring key);
static NELUA_NOINLINE void nelua_hashmap_string__V__2_rehash(nelua_hashmap_string__V__2_ptr self, uintptr_t bucket_count);
static void nelua_assert_line_43(bool cond);
static uintptr_t nelua_hashmap_string__V__2__at(nelua_hashmap_string__V__2_ptr self, nlstring key);
static void nelua_assert_line_44(bool cond, nlstring msg);
typedef nelua_V_5* nelua_V_5_ptr;
static nelua_V_5_ptr nelua_hashmap_string__V__2___atindex(nelua_hashmap_string__V__2_ptr self, nlstring key);
static nelua_V_5_ptr nelua_hashmap_string__V__2_peek(nelua_hashmap_string__V__2_ptr self, nlstring key);
static bool nelua_hashmap_string__V__2_has(nelua_hashmap_string__V__2_ptr self, nlstring key);
static NELUA_INLINE nlmulret_nlusize_nlusize_nlusize nelua_hashmap_string__uint32___find(nelua_hashmap_string__uint32__ptr self, nlstring key);
static NELUA_NOINLINE void nelua_hashmap_string__uint32__rehash(nelua_hashmap_string__uint32__ptr self, uintptr_t bucket_count);
static void nelua_assert_line_45(bool cond);
static uintptr_t nelua_hashmap_string__uint32___at(nelua_hashmap_string__uint32__ptr self, nlstring key);
static void nelua_assert_line_46(bool cond, nlstring msg);
typedef uint32_t* nluint32_ptr;
static nluint32_ptr nelua_hashmap_string__uint32____atindex(nelua_hashmap_string__uint32__ptr self, nlstring key);
static nluint32_ptr nelua_hashmap_string__uint32__peek(nelua_hashmap_string__uint32__ptr self, nlstring key);
static bool nelua_hashmap_string__uint32__has(nelua_hashmap_string__uint32__ptr self, nlstring key);
static NELUA_INLINE nelua_hashmapnode_string__uint32__ptr nelua_hashmap_iteratorT_6__next_node(nelua_hashmap_iteratorT_6_ptr self, nlstring key);
static NELUA_INLINE nlmulret_nlboolean_nlstring_nluint32 nelua_hashmap_iteratorT_6_next(nelua_hashmap_iteratorT_6_ptr self, nlstring key);
static NELUA_INLINE nlmulret_function_Be9dheYyhVZZMPGH_nelua_hashmap_iteratorT_6_nlstring nelua_hashmap_string__uint32____pairs(nelua_hashmap_string__uint32__ptr self);
typedef struct nelua_vector_pointer_ nelua_vector_pointer_;
typedef nelua_vector_pointer_* nelua_vector_pointer__ptr;
struct nelua_vector_pointer_ {
nelua_span_pointer_ data;
uintptr_t size;
nelua_GeneralAllocator allocator;
};
NELUA_STATIC_ASSERT(sizeof(nelua_vector_pointer_) == 24 && NELUA_ALIGNOF(nelua_vector_pointer_) == 8, "Nelua and C disagree on type size or align");
static void nelua_vector_pointer__clear(nelua_vector_pointer__ptr self);
static void nelua_vector_pointer__destroy(nelua_vector_pointer__ptr self);
static NELUA_NOINLINE void nelua_vectorT_grow(nelua_vector_pointer__ptr self);
static void nelua_assert_line_47(bool cond, nlstring msg);
static void nelua_vector_pointer__push(nelua_vector_pointer__ptr self, void* v);
static NELUA_INLINE nlpointer_ptr nelua_vector_pointer____atindex(nelua_vector_pointer__ptr self, uintptr_t pos);
static void nelua_assert_line_48(bool cond, nlstring msg);
typedef struct nelua_vector_GCScanRange_ nelua_vector_GCScanRange_;
typedef nelua_vector_GCScanRange_* nelua_vector_GCScanRange__ptr;
struct nelua_vector_GCScanRange_ {
nelua_span_GCScanRange_ data;
uintptr_t size;
nelua_GeneralAllocator allocator;
};
NELUA_STATIC_ASSERT(sizeof(nelua_vector_GCScanRange_) == 24 && NELUA_ALIGNOF(nelua_vector_GCScanRange_) == 8, "Nelua and C disagree on type size or align");
static void nelua_vector_GCScanRange__destroy(nelua_vector_GCScanRange__ptr self);
static NELUA_NOINLINE void nelua_vectorT_grow_1(nelua_vector_GCScanRange__ptr self);
static void nelua_assert_line_49(bool cond, nlstring msg);
static void nelua_vector_GCScanRange__push(nelua_vector_GCScanRange__ptr self, nelua_GCScanRange v);
static nelua_GCScanRange nelua_vector_GCScanRange__pop(nelua_vector_GCScanRange__ptr self);
static void nelua_assert_line_50(bool cond, nlstring msg);
static NELUA_INLINE bool nelua_hasflag(uintptr_t flags, uintptr_t flag);
static NELUA_INLINE uintptr_t nelua_align_forward(uintptr_t addr, uintptr_t align);
typedef struct nelua_GC nelua_GC;
struct nelua_GC {
bool running;
bool collecting;
uintptr_t pause;
uintptr_t membytes;
uintptr_t lastmembytes;
uintptr_t addrormask;
uintptr_t addrandmask;
uintptr_t stacktop;
uintptr_t stackbottom;
nelua_vector_pointer_ finalizeitems;
nelua_vector_GCScanRange_ scanranges;
nelua_hashmap_pointer__GCItem_ items;
nelua_hashmap_pointer__usize_ rootitems;
};
NELUA_STATIC_ASSERT(sizeof(nelua_GC) == 208 && NELUA_ALIGNOF(nelua_GC) == 8, "Nelua and C disagree on type size or align");
static nelua_GC nelua_gc;
typedef nelua_GC* nelua_GC_ptr;
static void nelua_GC_unregister_1(nelua_GC_ptr self, void* ptr, bool finalize);
static void nelua_assert_line_51(bool cond, nlstring msg);
static NELUA_NOINLINE NELUA_GC_NO_SANITIZE void nelua_GC_markptrs(nelua_GC_ptr self);
static NELUA_NOINLINE void nelua_GC_scanrange(nelua_GC_ptr self, uintptr_t low, uintptr_t high);
static NELUA_NOINLINE void nelua_GC_scanptr(nelua_GC_ptr self, void* ptr);
static NELUA_NOINLINE NELUA_GC_NO_SANITIZE void nelua_GC_scanstack(nelua_GC_ptr self);
typedef union nelua_RegsBuf nelua_RegsBuf;
union nelua_RegsBuf {
jmp_buf regs;
void* firstreg;
};
static NELUA_NOINLINE void nelua_GC_mark(nelua_GC_ptr self);
typedef void (*function_2jfxAcq6U1dnkseqH)(nelua_GC_ptr);
static NELUA_NOINLINE void nelua_GC_sweep(nelua_GC_ptr self);
static void nelua_assert_line_52(bool cond, nlstring msg);
static void nelua_assert_line_53(bool cond, nlstring msg);
static void nelua_assert_line_54(bool cond, nlstring msg);
static NELUA_NOINLINE void nelua_GC_rehash(nelua_GC_ptr self);
static NELUA_NOINLINE void nelua_GC_collect(nelua_GC_ptr self);
static NELUA_NOINLINE void nelua_GC_registerroots(nelua_GC_ptr self);
typedef void (*function_2JB2mT5p6U8prYAPj)(void*, void*);
static bool nelua_GC_step(nelua_GC_ptr self);
static void nelua_GC_register(nelua_GC_ptr self, void* ptr, uintptr_t size, uintptr_t flags, function_2JB2mT5p6U8prYAPj finalizer, void* userdata);
static void nelua_assert_line_55(bool cond, nlstring msg);
static void nelua_assert_line_56(bool cond, nlstring msg);
static void nelua_assert_line_57(bool cond, nlstring msg);
static void nelua_assert_line_58(bool cond, nlstring msg);
static void nelua_GC_reregister(nelua_GC_ptr self, void* oldptr, void* newptr, uintptr_t newsize);
static void nelua_assert_line_59(bool cond, nlstring msg);
static void nelua_assert_line_60(bool cond, nlstring msg);
static void nelua_assert_line_61(bool cond, nlstring msg);
static void nelua_GC_restart(nelua_GC_ptr self);
static NELUA_NOINLINE void nelua_GC_init(nelua_GC_ptr self, void* stack);