-
Notifications
You must be signed in to change notification settings - Fork 1
/
Copy pathlibRedRT-include.red
1127 lines (1126 loc) · 68.9 KB
/
libRedRT-include.red
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
red: context [
#include %$ROOT-PATH$runtime/definitions.reds
#include %$ROOT-PATH$runtime/macros.reds
#include %$ROOT-PATH$runtime/structures.reds
cell!: alias struct! [
header [integer!]
data1 [integer!]
data2 [integer!]
data3 [integer!]
]
series-buffer!: alias struct! [
flags [integer!]
node [int-ptr!]
size [integer!]
offset [cell!]
tail [cell!]
]
root-base: as cell! 0
get-root: func [
idx [integer!]
return: [red-block!]
] [
as red-block! root-base + idx
]
get-root-node: func [
idx [integer!]
return: [node!]
/local
obj [red-object!]
] [
obj: as red-object! get-root idx
obj/ctx
]
#import [libRedRT-file stdcall [
boot: "red/boot" []
get-build-date: "red/get-build-date" [return: [c-string!]]
copy-cell: "red/copy-cell" [src [cell!] dst [cell!] return: [cell!]]
get-root-node2: "red/get-root-node2" [idx [integer!] return: [pointer! [integer!]]]
type-check-alt: "red/type-check-alt" [ref [cell!] expected [red-typeset!] index [integer!] arg [cell!] return: [cell!]]
type-check: "red/type-check" [expected [red-typeset!] index [integer!] arg [cell!] return: [cell!]]
set-int-path*: "red/set-int-path*" [parent [cell!] index [integer!]]
eval-int-path*: "red/eval-int-path*" [parent [cell!] index [integer!]]
set-path*: "red/set-path*" [parent [cell!] element [cell!]]
eval-path*: "red/eval-path*" [parent [cell!] element [cell!]]
eval-int-path: "red/eval-int-path" [parent [cell!] index [integer!] return: [cell!]]
eval-path: "red/eval-path" [parent [cell!] element [cell!] return: [cell!]]
select-key*: "red/select-key*" [sub? [logic!] fetch? [logic!] return: [cell!]]
alloc-bytes: "red/alloc-bytes" [size [integer!] return: [pointer! [integer!]]]
alloc-cells: "red/alloc-cells" [size [integer!] return: [pointer! [integer!]]]
get-cmdline-args: "red/get-cmdline-args" [return: [cell!]]
fire: "red/fire" [[variadic] count [integer!] list [pointer! [integer!]]]
set-type: "red/set-type" [cell [cell!] type [integer!]]
report: "red/report" [type [cell!] id [cell!] arg1 [cell!] arg2 [cell!] arg3 [cell!]]
f_routine: "f_routine" []
f_also: "f_also" []
f_attempt: "f_attempt" []
f_comment: "f_comment" []
f_quit: "f_quit" []
f_empty?: "f_empty?" []
f_??: "f_??" []
f_probe: "f_probe" []
f_quote: "f_quote" []
f_first: "f_first" []
f_second: "f_second" []
f_third: "f_third" []
f_fourth: "f_fourth" []
f_fifth: "f_fifth" []
f_last: "f_last" []
f_spec-of: "f_spec-of" []
f_body-of: "f_body-of" []
f_words-of: "f_words-of" []
f_class-of: "f_class-of" []
f_values-of: "f_values-of" []
f_bitset?: "f_bitset?" []
f_binary?: "f_binary?" []
f_block?: "f_block?" []
f_char?: "f_char?" []
f_email?: "f_email?" []
f_file?: "f_file?" []
f_float?: "f_float?" []
f_get-path?: "f_get-path?" []
f_get-word?: "f_get-word?" []
f_hash?: "f_hash?" []
f_integer?: "f_integer?" []
f_issue?: "f_issue?" []
f_lit-path?: "f_lit-path?" []
f_lit-word?: "f_lit-word?" []
f_logic?: "f_logic?" []
f_map?: "f_map?" []
f_none?: "f_none?" []
f_pair?: "f_pair?" []
f_paren?: "f_paren?" []
f_path?: "f_path?" []
f_percent?: "f_percent?" []
f_refinement?: "f_refinement?" []
f_set-path?: "f_set-path?" []
f_set-word?: "f_set-word?" []
f_string?: "f_string?" []
f_tag?: "f_tag?" []
f_time?: "f_time?" []
f_typeset?: "f_typeset?" []
f_tuple?: "f_tuple?" []
f_unset?: "f_unset?" []
f_url?: "f_url?" []
f_word?: "f_word?" []
f_image?: "f_image?" []
f_date?: "f_date?" []
f_money?: "f_money?" []
f_ref?: "f_ref?" []
f_handle?: "f_handle?" []
f_error?: "f_error?" []
f_action?: "f_action?" []
f_native?: "f_native?" []
f_datatype?: "f_datatype?" []
f_function?: "f_function?" []
f_object?: "f_object?" []
f_op?: "f_op?" []
f_routine?: "f_routine?" []
f_vector?: "f_vector?" []
f_any-list?: "f_any-list?" []
f_any-block?: "f_any-block?" []
f_any-function?: "f_any-function?" []
f_any-object?: "f_any-object?" []
f_any-path?: "f_any-path?" []
f_any-string?: "f_any-string?" []
f_any-word?: "f_any-word?" []
f_series?: "f_series?" []
f_number?: "f_number?" []
f_immediate?: "f_immediate?" []
f_scalar?: "f_scalar?" []
f_all-word?: "f_all-word?" []
f_to-bitset: "f_to-bitset" []
f_to-binary: "f_to-binary" []
f_to-block: "f_to-block" []
f_to-char: "f_to-char" []
f_to-email: "f_to-email" []
f_to-file: "f_to-file" []
f_to-float: "f_to-float" []
f_to-get-path: "f_to-get-path" []
f_to-get-word: "f_to-get-word" []
f_to-hash: "f_to-hash" []
f_to-integer: "f_to-integer" []
f_to-issue: "f_to-issue" []
f_to-lit-path: "f_to-lit-path" []
f_to-lit-word: "f_to-lit-word" []
f_to-logic: "f_to-logic" []
f_to-map: "f_to-map" []
f_to-none: "f_to-none" []
f_to-pair: "f_to-pair" []
f_to-paren: "f_to-paren" []
f_to-path: "f_to-path" []
f_to-percent: "f_to-percent" []
f_to-refinement: "f_to-refinement" []
f_to-set-path: "f_to-set-path" []
f_to-set-word: "f_to-set-word" []
f_to-string: "f_to-string" []
f_to-tag: "f_to-tag" []
f_to-time: "f_to-time" []
f_to-typeset: "f_to-typeset" []
f_to-tuple: "f_to-tuple" []
f_to-unset: "f_to-unset" []
f_to-url: "f_to-url" []
f_to-word: "f_to-word" []
f_to-image: "f_to-image" []
f_to-date: "f_to-date" []
f_to-money: "f_to-money" []
f_to-ref: "f_to-ref" []
f_context: "f_context" []
f_alter: "f_alter" []
f_offset?: "f_offset?" []
f_repend: "f_repend" []
f_replace: "f_replace" []
f_math: "f_math" []
f_charset: "f_charset" []
f_ctx||174~on-parse-event: "f_ctx||174~on-parse-event" [octx [pointer! [integer!]]]
f_parse-trace: "f_parse-trace" [octx [pointer! [integer!]]]
f_suffix?: "f_suffix?" []
f_scan: "f_scan" []
f_load: "f_load" []
f_save: "f_save" []
f_cause-error: "f_cause-error" []
f_pad: "f_pad" []
f_mod: "f_mod" []
f_modulo: "f_modulo" []
f_eval-set-path: "f_eval-set-path" []
f_to-red-file: "f_to-red-file" []
f_dir?: "f_dir?" []
f_normalize-dir: "f_normalize-dir" []
f_what-dir: "f_what-dir" []
f_change-dir: "f_change-dir" []
f_make-dir: "f_make-dir" []
f_extract: "f_extract" []
f_extract-boot-args: "f_extract-boot-args" []
f_collect: "f_collect" []
f_flip-exe-flag: "f_flip-exe-flag" []
f_split: "f_split" []
f_dirize: "f_dirize" []
f_clean-path: "f_clean-path" []
f_split-path: "f_split-path" []
f_do-file: "f_do-file" []
f_path-thru: "f_path-thru" []
f_exists-thru?: "f_exists-thru?" []
f_read-thru: "f_read-thru" []
f_load-thru: "f_load-thru" []
f_do-thru: "f_do-thru" []
f_cos: "f_cos" []
f_sin: "f_sin" []
f_tan: "f_tan" []
f_acos: "f_acos" []
f_asin: "f_asin" []
f_atan: "f_atan" []
f_atan2: "f_atan2" []
f_sqrt: "f_sqrt" []
f_to-UTC-date: "f_to-UTC-date" []
f_to-local-date: "f_to-local-date" []
f_transcode-trace: "f_transcode-trace" []
f_rejoin: "f_rejoin" []
f_sum: "f_sum" []
f_average: "f_average" []
f_last?: "f_last?" []
f_dt: "f_dt" []
f_clock: "f_clock" []
f_ctx||256~interpreted?: "f_ctx||256~interpreted?" [octx [pointer! [integer!]]]
f_ctx||259~on-change*: "f_ctx||259~on-change*" [octx [pointer! [integer!]]]
f_ctx||266~on-change*: "f_ctx||266~on-change*" [octx [pointer! [integer!]]]
f_ctx||266~on-deep-change*: "f_ctx||266~on-deep-change*" [octx [pointer! [integer!]]]
f_ctx||272~on-change*: "f_ctx||272~on-change*" [octx [pointer! [integer!]]]
f_ctx||270~on-change*: "f_ctx||270~on-change*" [octx [pointer! [integer!]]]
f_ctx||270~on-deep-change*: "f_ctx||270~on-deep-change*" [octx [pointer! [integer!]]]
f_ctx||300~lex: "f_ctx||300~lex" [octx [pointer! [integer!]]]
f_ctx||318~on-change*: "f_ctx||318~on-change*" [octx [pointer! [integer!]]]
f_ctx||321~on-change*: "f_ctx||321~on-change*" [octx [pointer! [integer!]]]
f_ctx||321~on-deep-change*: "f_ctx||321~on-deep-change*" [octx [pointer! [integer!]]]
f_reactor: "f_reactor" []
f_deep-reactor: "f_deep-reactor" []
f_ctx||326~add-relation: "f_ctx||326~add-relation" [octx [pointer! [integer!]]]
f_ctx||326~eval: "f_ctx||326~eval" [octx [pointer! [integer!]]]
f_ctx||326~eval-reaction: "f_ctx||326~eval-reaction" [octx [pointer! [integer!]]]
f_ctx||326~pending?: "f_ctx||326~pending?" [octx [pointer! [integer!]]]
f_ctx||326~check: "f_ctx||326~check" [octx [pointer! [integer!]]]
f_stop-reactor: "f_stop-reactor" [octx [pointer! [integer!]]]
f_clear-reactions: "f_clear-reactions" [octx [pointer! [integer!]]]
f_dump-reactions: "f_dump-reactions" [octx [pointer! [integer!]]]
f_ctx||326~is~: "f_ctx||326~is~" [octx [pointer! [integer!]]]
f_react?: "f_react?" [octx [pointer! [integer!]]]
f_react: "f_react" [octx [pointer! [integer!]]]
f_register-scheme: "f_register-scheme" []
f_ctx||340~alpha-num+: "f_ctx||340~alpha-num+" [octx [pointer! [integer!]]]
f_ctx||340~parse-url: "f_ctx||340~parse-url" [octx [pointer! [integer!]]]
f_decode-url: "f_decode-url" [octx [pointer! [integer!]]]
f_encode-url: "f_encode-url" [octx [pointer! [integer!]]]
f_ctx||346~do-quit: "f_ctx||346~do-quit" [octx [pointer! [integer!]]]
f_ctx||346~throw-error: "f_ctx||346~throw-error" [octx [pointer! [integer!]]]
f_ctx||346~syntax-error: "f_ctx||346~syntax-error" [octx [pointer! [integer!]]]
f_ctx||346~do-safe: "f_ctx||346~do-safe" [octx [pointer! [integer!]]]
f_ctx||346~do-code: "f_ctx||346~do-code" [octx [pointer! [integer!]]]
f_ctx||346~rebind-all: "f_ctx||346~rebind-all" [octx [pointer! [integer!]]]
f_ctx||346~count-args: "f_ctx||346~count-args" [octx [pointer! [integer!]]]
f_ctx||346~arg-mode?: "f_ctx||346~arg-mode?" [octx [pointer! [integer!]]]
f_ctx||346~func-arity?: "f_ctx||346~func-arity?" [octx [pointer! [integer!]]]
f_ctx||346~value-path?: "f_ctx||346~value-path?" [octx [pointer! [integer!]]]
f_ctx||346~fetch-next: "f_ctx||346~fetch-next" [octx [pointer! [integer!]]]
f_ctx||346~eval: "f_ctx||346~eval" [octx [pointer! [integer!]]]
f_ctx||346~do-macro: "f_ctx||346~do-macro" [octx [pointer! [integer!]]]
f_ctx||346~register-macro: "f_ctx||346~register-macro" [octx [pointer! [integer!]]]
f_ctx||346~reset: "f_ctx||346~reset" [octx [pointer! [integer!]]]
f_ctx||346~expand: "f_ctx||346~expand" [octx [pointer! [integer!]]]
f_expand-directives: "f_expand-directives" [octx [pointer! [integer!]]]
f_ctx||365~calc-max: "f_ctx||365~calc-max" [octx [pointer! [integer!]]]
f_ctx||365~show-context: "f_ctx||365~show-context" [octx [pointer! [integer!]]]
f_ctx||365~show-parents: "f_ctx||365~show-parents" [octx [pointer! [integer!]]]
f_ctx||365~show-stack: "f_ctx||365~show-stack" [octx [pointer! [integer!]]]
f_ctx||365~show-watching: "f_ctx||365~show-watching" [octx [pointer! [integer!]]]
f_ctx||365~do-command: "f_ctx||365~do-command" [octx [pointer! [integer!]]]
f_ctx||365~debugger: "f_ctx||365~debugger" [octx [pointer! [integer!]]]
f_ctx||382~dumper: "f_ctx||382~dumper" [octx [pointer! [integer!]]]
f_ctx||382~push: "f_ctx||382~push" [octx [pointer! [integer!]]]
f_ctx||382~drop: "f_ctx||382~drop" [octx [pointer! [integer!]]]
f_ctx||382~pop: "f_ctx||382~pop" [octx [pointer! [integer!]]]
f_ctx||382~top-of: "f_ctx||382~top-of" [octx [pointer! [integer!]]]
f_ctx||382~step: "f_ctx||382~step" [octx [pointer! [integer!]]]
f_ctx||390~reset: "f_ctx||390~reset" [octx [pointer! [integer!]]]
f_ctx||390~collector: "f_ctx||390~collector" [octx [pointer! [integer!]]]
f_ctx||382~guided-trace: "f_ctx||382~guided-trace" [octx [pointer! [integer!]]]
f_ctx||395~mold-part: "f_ctx||395~mold-part" [octx [pointer! [integer!]]]
f_ctx||395~inspect: "f_ctx||395~inspect" [octx [pointer! [integer!]]]
f_ctx||365~profiler: "f_ctx||365~profiler" [octx [pointer! [integer!]]]
f_ctx||365~do-handler: "f_ctx||365~do-handler" [octx [pointer! [integer!]]]
f_profile: "f_profile" [octx [pointer! [integer!]]]
f_trace: "f_trace" [octx [pointer! [integer!]]]
f_debug: "f_debug" [octx [pointer! [integer!]]]
f_hex-to-rgb: "f_hex-to-rgb" []
f_within?: "f_within?" []
f_overlap?: "f_overlap?" []
f_distance?: "f_distance?" []
f_face?: "f_face?" []
f_size-text: "f_size-text" []
f_caret-to-offset: "f_caret-to-offset" []
f_offset-to-caret: "f_offset-to-caret" []
f_offset-to-char: "f_offset-to-char" []
f_ctx||415~tail-idx?: "f_ctx||415~tail-idx?" [octx [pointer! [integer!]]]
f_ctx||415~push-color: "f_ctx||415~push-color" [octx [pointer! [integer!]]]
f_ctx||415~pop-color: "f_ctx||415~pop-color" [octx [pointer! [integer!]]]
f_ctx||415~close-colors: "f_ctx||415~close-colors" [octx [pointer! [integer!]]]
f_ctx||415~push: "f_ctx||415~push" [octx [pointer! [integer!]]]
f_ctx||415~pop: "f_ctx||415~pop" [octx [pointer! [integer!]]]
f_ctx||415~pop-all: "f_ctx||415~pop-all" [octx [pointer! [integer!]]]
f_ctx||415~optimize: "f_ctx||415~optimize" [octx [pointer! [integer!]]]
f_rtd-layout: "f_rtd-layout" [octx [pointer! [integer!]]]
f_ctx||413~line-height?: "f_ctx||413~line-height?" [octx [pointer! [integer!]]]
f_ctx||413~line-count?: "f_ctx||413~line-count?" [octx [pointer! [integer!]]]
f_metrics?: "f_metrics?" []
f_set-flag: "f_set-flag" []
f_debug-info?: "f_debug-info?" []
f_on-face-deep-change*: "f_on-face-deep-change*" []
f_link-tabs-to-parent: "f_link-tabs-to-parent" []
f_link-sub-to-parent: "f_link-sub-to-parent" []
f_update-font-faces: "f_update-font-faces" []
f_ctx||435~on-change*: "f_ctx||435~on-change*" [octx [pointer! [integer!]]]
f_ctx||435~on-deep-change*: "f_ctx||435~on-deep-change*" [octx [pointer! [integer!]]]
f_ctx||439~on-change*: "f_ctx||439~on-change*" [octx [pointer! [integer!]]]
f_ctx||439~on-deep-change*: "f_ctx||439~on-deep-change*" [octx [pointer! [integer!]]]
f_ctx||443~on-change*: "f_ctx||443~on-change*" [octx [pointer! [integer!]]]
f_ctx||446~on-change*: "f_ctx||446~on-change*" [octx [pointer! [integer!]]]
f_ctx||449~capture-events: "f_ctx||449~capture-events" [octx [pointer! [integer!]]]
f_ctx||449~awake: "f_ctx||449~awake" [octx [pointer! [integer!]]]
f_ctx||457~init: "f_ctx||457~init" [octx [pointer! [integer!]]]
f_draw: "f_draw" []
f_ctx||465~Cancel-OK: "f_ctx||465~Cancel-OK" [octx [pointer! [integer!]]]
f_ctx||463~process: "f_ctx||463~process" [octx [pointer! [integer!]]]
f_ctx||461~throw-error: "f_ctx||461~throw-error" [octx [pointer! [integer!]]]
f_ctx||461~process-reactors: "f_ctx||461~process-reactors" [octx [pointer! [integer!]]]
f_ctx||461~calc-size: "f_ctx||461~calc-size" [octx [pointer! [integer!]]]
f_ctx||461~align-faces: "f_ctx||461~align-faces" [octx [pointer! [integer!]]]
f_ctx||461~resize-child-panels: "f_ctx||461~resize-child-panels" [octx [pointer! [integer!]]]
f_ctx||461~clean-style: "f_ctx||461~clean-style" [octx [pointer! [integer!]]]
f_ctx||461~process-draw: "f_ctx||461~process-draw" [octx [pointer! [integer!]]]
f_ctx||461~pre-load: "f_ctx||461~pre-load" [octx [pointer! [integer!]]]
f_ctx||461~add-option: "f_ctx||461~add-option" [octx [pointer! [integer!]]]
f_ctx||461~add-flag: "f_ctx||461~add-flag" [octx [pointer! [integer!]]]
f_ctx||461~fetch-value: "f_ctx||461~fetch-value" [octx [pointer! [integer!]]]
f_ctx||461~fetch-argument: "f_ctx||461~fetch-argument" [octx [pointer! [integer!]]]
f_ctx||461~fetch-expr: "f_ctx||461~fetch-expr" [octx [pointer! [integer!]]]
f_ctx||461~fetch-options: "f_ctx||461~fetch-options" [octx [pointer! [integer!]]]
f_ctx||461~make-actor: "f_ctx||461~make-actor" [octx [pointer! [integer!]]]
f_layout: "f_layout" [octx [pointer! [integer!]]]
f_do-events: "f_do-events" []
f_stop-events: "f_stop-events" []
f_do-safe: "f_do-safe" []
f_do-actor: "f_do-actor" []
f_show: "f_show" []
f_unview: "f_unview" []
f_view: "f_view" []
f_center-face: "f_center-face" []
f_make-face: "f_make-face" []
f_dump-face: "f_dump-face" []
f_get-scroller: "f_get-scroller" []
f_insert-event-func: "f_insert-event-func" []
f_remove-event-func: "f_remove-event-func" []
f_request-font: "f_request-font" []
f_request-file: "f_request-file" []
f_request-dir: "f_request-dir" []
f_set-focus: "f_set-focus" []
f_foreach-face: "f_foreach-face" []
f_alert: "f_alert" []
f_ctx||506~encode: "f_ctx||506~encode" [octx [pointer! [integer!]]]
f_ctx||506~decode: "f_ctx||506~decode" [octx [pointer! [integer!]]]
f_ctx||513~to-csv-line: "f_ctx||513~to-csv-line" [octx [pointer! [integer!]]]
f_ctx||513~escape-value: "f_ctx||513~escape-value" [octx [pointer! [integer!]]]
f_ctx||513~next-column-name: "f_ctx||513~next-column-name" [octx [pointer! [integer!]]]
f_ctx||513~make-header: "f_ctx||513~make-header" [octx [pointer! [integer!]]]
f_ctx||513~get-columns: "f_ctx||513~get-columns" [octx [pointer! [integer!]]]
f_ctx||513~encode-map: "f_ctx||513~encode-map" [octx [pointer! [integer!]]]
f_ctx||513~encode-maps: "f_ctx||513~encode-maps" [octx [pointer! [integer!]]]
f_ctx||513~encode-flat: "f_ctx||513~encode-flat" [octx [pointer! [integer!]]]
f_ctx||513~encode-blocks: "f_ctx||513~encode-blocks" [octx [pointer! [integer!]]]
f_load-csv: "f_load-csv" [octx [pointer! [integer!]]]
f_to-csv: "f_to-csv" [octx [pointer! [integer!]]]
f_ctx||526~decode-unicode-char: "f_ctx||526~decode-unicode-char" [octx [pointer! [integer!]]]
f_ctx||526~push: "f_ctx||526~push" [octx [pointer! [integer!]]]
f_ctx||526~pop: "f_ctx||526~pop" [octx [pointer! [integer!]]]
f_ctx||526~emit: "f_ctx||526~emit" [octx [pointer! [integer!]]]
f_load-json: "f_load-json" [octx [pointer! [integer!]]]
f_ctx||533~init-state: "f_ctx||533~init-state" [octx [pointer! [integer!]]]
f_ctx||533~emit-indent: "f_ctx||533~emit-indent" [octx [pointer! [integer!]]]
f_ctx||533~emit-key-value: "f_ctx||533~emit-key-value" [octx [pointer! [integer!]]]
f_ctx||533~red-to-json-value: "f_ctx||533~red-to-json-value" [octx [pointer! [integer!]]]
f_to-json: "f_to-json" [octx [pointer! [integer!]]]
f_ctx||540~encode: "f_ctx||540~encode" [octx [pointer! [integer!]]]
f_ctx||540~decode: "f_ctx||540~decode" [octx [pointer! [integer!]]]
f_keep: "f_keep" []
quit-return: "quit-return" [status [integer!]]
set-quiet: "set-quiet" [word [cell!] value [cell!] return: [cell!]]
set-slot-quiet: "set-slot-quiet" [series [cell!] value [cell!]]
shift-right: "shift-right" [data [integer!] bits [integer!]]
shift-left: "shift-left" [data [integer!] bits [integer!]]
shift-logical: "shift-logical" [data [integer!] bits [integer!]]
last-lf?: "last-lf?" []
get-current-dir: "get-current-dir" []
set-current-dir: "set-current-dir" [path [red-file!]]
create-dir: "create-dir" [path [red-file!]]
exists?: "exists?" [path [red-file!] return: [logic!]]
os-info: "os-info" []
as-color: "as-color" [r [integer!] g [integer!] b [integer!]]
as-ipv4: "as-ipv4" [a [integer!] b [integer!] c [integer!] d [integer!]]
as-rgba: "as-rgba" [r [integer!] g [integer!] b [integer!] a [integer!]]
count-chars: "count-chars" [start [red-binary!] pos [red-binary!] return: [integer!]]
stack-size?: "stack-size?" [return: [integer!]]
pick-stack: "pick-stack" [idx [integer!]]
frame-index?: "frame-index?" [return: [integer!]]
collect-calls: "collect-calls" [blk [red-block!]]
tracing?: "tracing?" []
read-clipboard: "read-clipboard" [return: [cell!]]
write-clipboard: "write-clipboard" [data [cell!] return: [logic!]]
write-stdout: "write-stdout" [data [cell!]]
__make-sys-object: "__make-sys-object" []
ctx||303~encode: "ctx||303~encode" [img [red-image!] where [cell!]]
ctx||303~decode: "ctx||303~decode" [data [cell!]]
ctx||306~encode: "ctx||306~encode" [img [red-image!] where [cell!]]
ctx||306~decode: "ctx||306~decode" [data [cell!]]
ctx||309~encode: "ctx||309~encode" [img [red-image!] where [cell!]]
ctx||309~decode: "ctx||309~decode" [data [cell!]]
ctx||312~encode: "ctx||312~encode" [img [red-image!] where [cell!]]
ctx||312~decode: "ctx||312~decode" [data [cell!]]
ctx||315~encode: "ctx||315~encode" [data [cell!] where [cell!]]
ctx||315~decode: "ctx||315~decode" [payload [cell!]]
event?: "event?" [value [cell!] return: [logic!]]
find-flag?: "find-flag?" [facet [cell!] flag [red-word!]]
ctx||457~make-null-handle: "ctx||457~make-null-handle" []
ctx||457~get-screen-size: "ctx||457~get-screen-size" [id [integer!]]
ctx||457~size-text: "ctx||457~size-text" [face [red-object!] value [cell!]]
ctx||457~on-change-facet: "ctx||457~on-change-facet" [owner [red-object!] word [red-word!] value [cell!] action [red-word!] new [cell!] index [integer!] part [integer!]]
ctx||457~update-font: "ctx||457~update-font" [font [red-object!] flags [integer!]]
ctx||457~update-para: "ctx||457~update-para" [face [red-object!] flags [integer!]]
ctx||457~destroy-view: "ctx||457~destroy-view" [face [red-object!] empty? [logic!]]
ctx||457~update-view: "ctx||457~update-view" [face [red-object!]]
ctx||457~refresh-window: "ctx||457~refresh-window" [h [red-handle!]]
ctx||457~redraw: "ctx||457~redraw" [face [red-object!]]
ctx||457~show-window: "ctx||457~show-window" [id [red-handle!]]
ctx||457~make-view: "ctx||457~make-view" [face [red-object!] parent [red-handle!]]
ctx||457~draw-image: "ctx||457~draw-image" [image [red-image!] cmds [red-block!]]
ctx||457~draw-face: "ctx||457~draw-face" [face [red-object!] cmds [red-block!]]
ctx||457~do-event-loop: "ctx||457~do-event-loop" [no-wait? [logic!]]
ctx||457~exit-event-loop: "ctx||457~exit-event-loop" []
ctx||457~request-font: "ctx||457~request-font" [font [red-object!] selected [cell!] mono? [logic!]]
ctx||457~request-file: "ctx||457~request-file" [title [cell!] name [cell!] filter [cell!] save? [logic!] multi? [logic!]]
ctx||457~request-dir: "ctx||457~request-dir" [title [cell!] dir [cell!] filter [cell!] keep? [logic!] multi? [logic!]]
ctx||457~text-box-metrics: "ctx||457~text-box-metrics" [box [red-object!] arg0 [cell!] type [integer!]]
ctx||457~update-scroller: "ctx||457~update-scroller" [scroller [red-object!] flags [integer!]]
throw-draw-error: "throw-draw-error" [cmds [red-block!] cmd [cell!] catch? [logic!]]
transparent-color?: "transparent-color?" [color [red-tuple!] return: [logic!]]
get-color-int: "get-color-int" [tp [red-tuple!] alpha? [pointer! [integer!]] return: [integer!]]
get-float: "get-float" [int [red-integer!] return: [float!]]
get-float32: "get-float32" [int [red-integer!] return: [float32!]]
reverse-int-array: "reverse-int-array" [array [pointer! [integer!]] count [integer!]]
reverse-float32-array: "reverse-float32-array" [array [pointer! [float32!]] count [integer!]]
old-gradient-pen: "old-gradient-pen" [DC [draw-ctx!] cmds [red-block!] start [cell!] tail [cell!] cmd [cell!] sym [integer!] catch? [logic!] return: [cell!]]
check-pen: "check-pen" [DC [draw-ctx!] cmds [red-block!] start [cell!] tail [cell!] cmd [cell!] sym [integer!] catch? [logic!] return: [cell!]]
check-line: "check-line" [DC [draw-ctx!] cmds [red-block!] start [cell!] tail [cell!] cmd [cell!] sym [integer!] catch? [logic!] return: [cell!]]
parse-shape: "parse-shape" [DC [draw-ctx!] cmds [red-block!] draw? [logic!] catch? [logic!]]
parse-draw: "parse-draw" [DC [draw-ctx!] cmds [red-block!] catch? [logic!]]
do-draw: "do-draw" [handle [pointer! [integer!]] img [red-image!] cmds [red-block!] on-graphic? [logic!] cache? [logic!] paint? [logic!] catch? [logic!]]
parse-text-styles: "parse-text-styles" [dc [pointer! [integer!]] layout [pointer! [integer!]] cmds [red-block!] text [red-string!] catch? [logic!]]
ctx||526~unescape: "ctx||526~unescape" [str [red-string!] return: [red-string!]]
f_time-it: "f_dt" []
f_single?: "f_last?" []
f_keys-of: "f_words-of" []
f_object: "f_context" []
f_halt: "f_quit" []
root: "red/root" [red-block!]
stk-bottom: "red/stk-bottom" [int-ptr!]
unset-value: "red/unset-value" [cell!]
none-value: "red/none-value" [cell!]
true-value: "red/true-value" [cell!]
false-value: "red/false-value" [cell!]
boot?: "red/boot?" [logic!]
]]
redbin: context [
#import [libRedRT-file stdcall [
boot-load: "red/redbin/boot-load" [payload [pointer! [byte!]] keep? [logic!] return: [cell!]]
]]
]
platform: context [
#import [libRedRT-file stdcall [
prin*: "red/platform/prin*" [s [c-string!] return: [c-string!]]
prin-int*: "red/platform/prin-int*" [i [integer!] return: [integer!]]
prin-hex*: "red/platform/prin-hex*" [i [integer!] return: [integer!]]
prin-2hex*: "red/platform/prin-2hex*" [i [integer!] return: [integer!]]
prin-float*: "red/platform/prin-float*" [f [float!] return: [float!]]
prin-float32*: "red/platform/prin-float32*" [f [float32!] return: [float32!]]
]]
]
stack: context [
#import [libRedRT-file stdcall [
mark: "red/stack/mark" [fun [red-word!] type [integer!]]
mark-native: "red/stack/mark-native" [fun [red-word!]]
mark-func: "red/stack/mark-func" [fun [red-word!] ctx-name [pointer! [integer!]]]
mark-loop: "red/stack/mark-loop" [fun [red-word!]]
mark-try: "red/stack/mark-try" [fun [red-word!]]
mark-try-all: "red/stack/mark-try-all" [fun [red-word!]]
mark-catch: "red/stack/mark-catch" [fun [red-word!]]
mark-func-body: "red/stack/mark-func-body" [fun [red-word!]]
unwind: "red/stack/unwind" []
unwind-last: "red/stack/unwind-last" [return: [cell!]]
reset: "red/stack/reset" [return: [cell!]]
keep: "red/stack/keep" [return: [cell!]]
push: "red/stack/push" [value [cell!] return: [cell!]]
unroll: "red/stack/unroll" [flags [integer!]]
unroll-loop: "red/stack/unroll-loop" [inner? [logic!]]
revert: "red/stack/revert" []
adjust-post-try: "red/stack/adjust-post-try" []
pop: "red/stack/pop" [positions [integer!]]
set-last: "red/stack/set-last" [last [cell!] return: [cell!]]
push*: "red/stack/push*" [return: [cell!]]
arguments: "red/stack/arguments" [cell!]
top: "red/stack/top" [cell!]
bottom: "red/stack/bottom" [cell!]
]]
#enum flags! [FRAME_FUNCTION: 16777216]
]
interpreter: context [
#import [libRedRT-file stdcall [
eval-path: "red/interpreter/eval-path" [value [cell!] pc [cell!] end [cell!] code [red-block!] set? [logic!] get? [logic!] sub? [logic!] case? [logic!] return: [cell!]]
]]
]
lexer: context [
#import [libRedRT-file stdcall [
scan: "red/lexer/scan" [dst [cell!] src [pointer! [byte!]] size [integer!] one? [logic!] scan? [logic!] load? [logic!] wrap? [logic!] len [pointer! [integer!]] fun [red-function!] ser [red-series!] out [red-block!] return: [integer!]]
scan-alt: "red/lexer/scan-alt" [dst [cell!] str [red-string!] size [integer!] one? [logic!] scan? [logic!] load? [logic!] wrap? [logic!] len [pointer! [integer!]] fun [red-function!] out [red-block!] return: [integer!]]
]]
]
none: context [
#import [libRedRT-file stdcall [
push-last: "red/none/push-last" [return: [cell!]]
push: "red/none/push" [return: [cell!]]
make-in: "red/none/make-in" [parent [red-block!] return: [cell!]]
]]
]
logic: context [
#import [libRedRT-file stdcall [
false?: "red/logic/false?" [return: [logic!]]
true?: "red/logic/true?" [return: [logic!]]
push: "red/logic/push" [value [logic!] return: [red-logic!]]
get: "red/logic/get" [value [cell!] return: [logic!]]
box: "red/logic/box" [value [logic!] return: [red-logic!]]
make-in: "red/logic/make-in" [parent [red-block!] value [logic!] return: [red-logic!]]
]]
]
refinement: context [
#import [libRedRT-file stdcall [
push-local: "red/refinement/push-local" [node [pointer! [integer!]] index [integer!] return: [red-refinement!]]
push: "red/refinement/push" [w [red-word!]]
]]
]
lit-word: context [
#import [libRedRT-file stdcall [
push-local: "red/lit-word/push-local" [node [pointer! [integer!]] index [integer!] return: [red-word!]]
push: "red/lit-word/push" [w [red-word!] return: [red-word!]]
]]
]
binary: context [
#import [libRedRT-file stdcall [
push: "red/binary/push" [bin [red-binary!]]
rs-head: "red/binary/rs-head" [bin [red-binary!] return: [pointer! [byte!]]]
rs-tail: "red/binary/rs-tail" [bin [red-binary!] return: [pointer! [byte!]]]
rs-length?: "red/binary/rs-length?" [bin [red-binary!] return: [integer!]]
]]
]
block: context [
#import [libRedRT-file stdcall [
push: "red/block/push" [blk [red-block!]]
push-only*: "red/block/push-only*" [size [integer!] return: [red-block!]]
insert-thru: "red/block/insert-thru" []
append-thru: "red/block/append-thru" []
rs-head: "red/block/rs-head" [blk [red-block!] return: [cell!]]
rs-next: "red/block/rs-next" [blk [red-block!] return: [logic!]]
rs-tail?: "red/block/rs-tail?" [blk [red-block!] return: [logic!]]
rs-length?: "red/block/rs-length?" [blk [red-block!] return: [integer!]]
rs-abs-at: "red/block/rs-abs-at" [blk [red-block!] pos [integer!] return: [cell!]]
rs-append: "red/block/rs-append" [blk [red-block!] value [cell!] return: [cell!]]
rs-tail: "red/block/rs-tail" [blk [red-block!] return: [cell!]]
rs-clear: "red/block/rs-clear" [blk [red-block!]]
make-at: "red/block/make-at" [blk [red-block!] size [integer!] return: [red-block!]]
select-word: "red/block/select-word" [blk [red-block!] word [red-word!] case? [logic!] return: [cell!]]
find: "red/block/find" [blk [red-block!] value [cell!] part [cell!] only? [logic!] case? [logic!] same? [logic!] any? [logic!] with-arg [red-string!] skip [red-integer!] last? [logic!] reverse? [logic!] tail? [logic!] match? [logic!] return: [cell!]]
]]
]
char: context [
#import [libRedRT-file stdcall [
push: "red/char/push" [value [integer!] return: [red-char!]]
]]
]
datatype: context [
#import [libRedRT-file stdcall [
push: "red/datatype/push" [type [integer!] return: [red-datatype!]]
register: "red/datatype/register" [[variadic] count [integer!] list [pointer! [integer!]]]
]]
]
date: context [
#import [libRedRT-file stdcall [
push: "red/date/push" [date [integer!] time [float!] return: [red-date!]]
make-at: "red/date/make-at" [slot [cell!] year [integer!] month [integer!] day [integer!] tm [float!] TZ-h [integer!] TZ-m [integer!] time? [logic!] TZ? [logic!] return: [red-date!]]
]]
]
email: context [
#import [libRedRT-file stdcall [
push: "red/email/push" [email [red-email!]]
]]
]
file: context [
#import [libRedRT-file stdcall [
push: "red/file/push" [file [red-file!]]
to-OS-path: "red/file/to-OS-path" [src [red-file!] return: [c-string!]]
]]
]
float: context [
#import [libRedRT-file stdcall [
push: "red/float/push" [value [float!] return: [red-float!]]
push64: "red/float/push64" [high [integer!] low [integer!] return: [red-float!]]
get: "red/float/get" [value [cell!] return: [float!]]
box: "red/float/box" [value [float!] return: [red-float!]]
]]
]
_function: context [
#import [libRedRT-file stdcall [
push: "red/_function/push" [spec [red-block!] body [red-block!] ctx [pointer! [integer!]] code [integer!] obj-ctx [pointer! [integer!]] flags [integer!] return: [pointer! [integer!]]]
init-locals: "red/_function/init-locals" [nb [integer!]]
]]
]
get-path: context [
#import [libRedRT-file stdcall [
push: "red/get-path/push" [p [red-block!]]
]]
]
get-word: context [
#import [libRedRT-file stdcall [
push: "red/get-word/push" [w [red-word!] return: [red-word!]]
get: "red/get-word/get" [word [red-word!] return: [cell!]]
]]
]
integer: context [
#import [libRedRT-file stdcall [
push: "red/integer/push" [value [integer!] return: [red-integer!]]
get-any*: "red/integer/get-any*" [return: [integer!]]
get*: "red/integer/get*" [return: [integer!]]
get: "red/integer/get" [value [cell!] return: [integer!]]
make-at: "red/integer/make-at" [slot [cell!] value [integer!] return: [red-integer!]]
form-signed: "red/integer/form-signed" [i [integer!] return: [c-string!]]
box: "red/integer/box" [value [integer!] return: [red-integer!]]
make-in: "red/integer/make-in" [parent [red-block!] value [integer!] return: [red-integer!]]
]]
]
issue: context [
#import [libRedRT-file stdcall [
push: "red/issue/push" [w [red-word!]]
]]
]
lit-path: context [
#import [libRedRT-file stdcall [
push: "red/lit-path/push" [p [red-block!]]
]]
]
map: context [
#import [libRedRT-file stdcall [
push: "red/map/push" [map [red-hash!]]
]]
]
money: context [
#import [libRedRT-file stdcall [
push: "red/money/push" [sign [logic!] currency [integer!] amount [c-string!] return: [red-money!]]
]]
]
object: context [
#import [libRedRT-file stdcall [
push: "red/object/push" [ctx [pointer! [integer!]] evt [pointer! [integer!]] class [integer!] idx-s [integer!] loc-s [integer!] idx-d [integer!] loc-d [integer!] return: [red-object!]]
clone-series: "red/object/clone-series" [src [pointer! [integer!]] dst [pointer! [integer!]] copy? [logic!]]
transfer: "red/object/transfer" [src [pointer! [integer!]] dst [pointer! [integer!]]]
init-push: "red/object/init-push" [node [pointer! [integer!]] class [integer!] return: [red-object!]]
init-events: "red/object/init-events" [ctx [pointer! [integer!]] idx-s [integer!] loc-s [integer!] idx-d [integer!] loc-d [integer!] return: [pointer! [integer!]]]
loc-fire-on-set*: "red/object/loc-fire-on-set*" [parent [cell!] field [red-word!]]
loc-ctx-fire-on-set*: "red/object/loc-ctx-fire-on-set*" [parent-ctx [pointer! [integer!]] field [red-word!]]
fire-on-set*: "red/object/fire-on-set*" [parent [red-word!] field [red-word!]]
get-values: "red/object/get-values" [obj [red-object!] return: [cell!]]
unchanged?: "red/object/unchanged?" [word [red-word!] id [integer!] return: [logic!]]
unchanged2?: "red/object/unchanged2?" [node [pointer! [integer!]] index [integer!] id [integer!] return: [logic!]]
get-word: "red/object/get-word" [obj [pointer! [integer!]] index [integer!] return: [cell!]]
rs-find: "red/object/rs-find" [obj [red-object!] value [cell!] return: [integer!]]
path-parent: "red/object/path-parent" [cell!]
field-parent: "red/object/field-parent" [cell!]
]]
]
op: context [
#import [libRedRT-file stdcall [
push: "red/op/push" []
]]
]
pair: context [
#import [libRedRT-file stdcall [
push: "red/pair/push" [x [integer!] y [integer!] return: [red-pair!]]
]]
]
paren: context [
#import [libRedRT-file stdcall [
push: "red/paren/push" [paren [red-paren!]]
]]
]
path: context [
#import [libRedRT-file stdcall [
push: "red/path/push" [p [red-path!]]
]]
]
percent: context [
#import [libRedRT-file stdcall [
push: "red/percent/push" [value [float!] return: [red-float!]]
push64: "red/percent/push64" [high [integer!] low [integer!] return: [red-float!]]
]]
]
ref: context [
#import [libRedRT-file stdcall [
push: "red/ref/push" [ref [red-ref!]]
]]
]
routine: context [
#import [libRedRT-file stdcall [
push: "red/routine/push" [spec [red-block!] body [red-block!] code [integer!] ret-type [integer!] extern? [logic!] return: [red-routine!]]
]]
]
set-path: context [
#import [libRedRT-file stdcall [
push: "red/set-path/push" [p [red-block!]]
]]
]
set-word: context [
#import [libRedRT-file stdcall [
push: "red/set-word/push" [w [red-word!] return: [red-word!]]
push-local: "red/set-word/push-local" [node [pointer! [integer!]] index [integer!] return: [red-word!]]
]]
]
string: context [
#import [libRedRT-file stdcall [
push: "red/string/push" [str [red-string!] return: [red-string!]]
rs-head: "red/string/rs-head" [str [red-string!] return: [pointer! [byte!]]]
rs-tail?: "red/string/rs-tail?" [str [red-string!] return: [logic!]]
equal?: "red/string/equal?" [str1 [red-string!] str2 [red-string!] op [integer!] match? [logic!] return: [integer!]]
rs-make-at: "red/string/rs-make-at" [slot [cell!] size [integer!] return: [red-string!]]
get-char: "red/string/get-char" [p [pointer! [byte!]] unit [integer!] return: [integer!]]
rs-reset: "red/string/rs-reset" [str [red-string!]]
concatenate: "red/string/concatenate" [str1 [red-string!] str2 [red-string!] part [integer!] offset [integer!] keep? [logic!] insert? [logic!]]
rs-length?: "red/string/rs-length?" [str [red-string!] return: [integer!]]
concatenate-literal: "red/string/concatenate-literal" [str [red-string!] p [c-string!] return: [series-buffer!]]
append-char: "red/string/append-char" [s [series-buffer!] cp [integer!] return: [series-buffer!]]
insert-char: "red/string/insert-char" [s [series-buffer!] offset [integer!] cp [integer!] return: [series-buffer!]]
rs-abs-length?: "red/string/rs-abs-length?" [str [red-string!] return: [integer!]]
remove-char: "red/string/remove-char" [str [red-string!] offset [integer!] return: [red-string!]]
poke-char: "red/string/poke-char" [s [series-buffer!] p [pointer! [byte!]] cp [integer!] return: [series-buffer!]]
remove-part: "red/string/remove-part" [str [red-string!] offset [integer!] part [integer!] return: [red-string!]]
to-hex: "red/string/to-hex" [value [integer!] char? [logic!] return: [c-string!]]
make-at: "red/string/make-at" [slot [cell!] size [integer!] unit [integer!] return: [red-string!]]
load: "red/string/load" [src [c-string!] size [integer!] encoding [integer!] return: [red-string!]]
load-at: "red/string/load-at" [src [c-string!] size [integer!] slot [cell!] encoding [integer!] return: [red-string!]]
overwrite-char: "red/string/overwrite-char" [s [series-buffer!] offset [integer!] cp [integer!] return: [series-buffer!]]
]]
]
tag: context [
#import [libRedRT-file stdcall [
push: "red/tag/push" [tag [red-tag!]]
]]
]
time: context [
#import [libRedRT-file stdcall [
push: "red/time/push" [time [float!] return: [red-time!]]
]]
]
tuple: context [
#import [libRedRT-file stdcall [
push: "red/tuple/push" [size [integer!] arr1 [integer!] arr2 [integer!] arr3 [integer!] return: [red-tuple!]]
]]
]
typeset: context [
#import [libRedRT-file stdcall [
push: "red/typeset/push" [sets [red-typeset!]]
]]
]
unset: context [
#import [libRedRT-file stdcall [
push: "red/unset/push" [return: [red-unset!]]
]]
]
url: context [
#import [libRedRT-file stdcall [
push: "red/url/push" [url [red-url!]]
]]
]
vector: context [
#import [libRedRT-file stdcall [
push: "red/vector/push" [vec [red-vector!]]
rs-head: "red/vector/rs-head" [vec [red-vector!] return: [pointer! [byte!]]]
rs-tail: "red/vector/rs-tail" [vec [red-vector!] return: [pointer! [byte!]]]
rs-tail?: "red/vector/rs-tail?" [vec [red-vector!] return: [logic!]]
rs-length?: "red/vector/rs-length?" [vec [red-vector!] return: [integer!]]
rs-skip: "red/vector/rs-skip" [vec [red-vector!] len [integer!] return: [logic!]]
rs-next: "red/vector/rs-next" [vec [red-vector!] return: [logic!]]
rs-clear: "red/vector/rs-clear" [vec [red-vector!]]
rs-append: "red/vector/rs-append" [vec [red-vector!] value [cell!] return: [cell!]]
rs-append-int: "red/vector/rs-append-int" [vec [red-vector!] n [integer!]]
rs-overwrite: "red/vector/rs-overwrite" [vec [red-vector!] offset [integer!] value [cell!] return: [series-buffer!]]
rs-insert: "red/vector/rs-insert" [vec [red-vector!] offset [integer!] value [cell!] return: [series-buffer!]]
get-value: "red/vector/get-value" [p [pointer! [byte!]] unit [integer!] type [integer!] return: [cell!]]
get-value-int: "red/vector/get-value-int" [p [pointer! [integer!]] unit [integer!] return: [integer!]]
get-value-float: "red/vector/get-value-float" [p [pointer! [byte!]] unit [integer!] return: [float!]]
set-value: "red/vector/set-value" [p [pointer! [byte!]] value [cell!] unit [integer!]]
]]
]
word: context [
#import [libRedRT-file stdcall [
push: "red/word/push" [word [red-word!] return: [red-word!]]
get: "red/word/get" [word [red-word!] return: [cell!]]
get-local: "red/word/get-local" [node [pointer! [integer!]] index [integer!] return: [cell!]]
get-any: "red/word/get-any" [word [red-word!] return: [cell!]]
get-in: "red/word/get-in" [node [pointer! [integer!]] index [integer!] return: [cell!]]
set-in: "red/word/set-in" [node [pointer! [integer!]] index [integer!] return: [cell!]]
set-in-ctx: "red/word/set-in-ctx" [node [pointer! [integer!]] index [integer!]]
set: "red/word/set" []
replace: "red/word/replace" [node [pointer! [integer!]] index [integer!]]
from: "red/word/from" [node [pointer! [integer!]] index [integer!] return: [red-word!]]
load: "red/word/load" [str [c-string!] return: [red-word!]]
push-local: "red/word/push-local" [node [pointer! [integer!]] index [integer!] return: [red-word!]]
duplicate: "red/word/duplicate" [w [red-word!] return: [red-word!]]
push*: "red/word/push*" [id [integer!] return: [red-word!]]
make-at: "red/word/make-at" [id [integer!] pos [cell!] return: [red-word!]]
push-in: "red/word/push-in" [id [integer!] blk [red-block!] return: [red-word!]]
]]
]
_context: context [
#import [libRedRT-file stdcall [
get: "red/_context/get" [word [red-word!] return: [cell!]]
clone-words: "red/_context/clone-words" [slot [red-block!] type [context-type!] return: [pointer! [integer!]]]
set-integer: "red/_context/set-integer" [word [red-word!] value [integer!] return: [integer!]]
set: "red/_context/set" [word [red-word!] value [cell!] return: [cell!]]
]]
]
handle: context [
#import [libRedRT-file stdcall [
box: "red/handle/box" [value [integer!] return: [red-handle!]]
make-in: "red/handle/make-in" [parent [red-block!] value [integer!] return: [red-handle!]]
]]
]
_series: context [
#import [libRedRT-file stdcall [
copy: "red/_series/copy" [ser [red-series!] new [red-series!] part-arg [cell!] deep? [logic!] types [cell!] return: [red-series!]]
remove: "red/_series/remove" [ser [red-series!] part-arg [cell!] key-arg [cell!] return: [red-series!]]
]]
]
symbol: context [
#import [libRedRT-file stdcall [
make: "red/symbol/make" [s [c-string!] return: [integer!]]
resolve: "red/symbol/resolve" [id [integer!] return: [integer!]]
make-opt: "red/symbol/make-opt" [s [c-string!] return: [integer!]]
get-c-string: "red/symbol/get-c-string" [id [integer!] return: [c-string!]]
]]
]
unicode: context [
#import [libRedRT-file stdcall [
load-utf8: "red/unicode/load-utf8" [src [c-string!] size [integer!] return: [pointer! [integer!]]]
decode-utf8-char: "red/unicode/decode-utf8-char" [src [c-string!] cnt [pointer! [integer!]] return: [integer!]]
to-utf8: "red/unicode/to-utf8" [str [red-string!] len [pointer! [integer!]] return: [c-string!]]
load-utf8-buffer: "red/unicode/load-utf8-buffer" [src [c-string!] size [integer!] dst [series-buffer!] remain [pointer! [integer!]] convert? [logic!] return: [pointer! [integer!]]]
load-utf8-stream: "red/unicode/load-utf8-stream" [src [c-string!] size [integer!] output [red-string!] remain [pointer! [integer!]] return: [pointer! [integer!]]]
utf8-char-size?: "red/unicode/utf8-char-size?" [byte-1st [integer!] return: [integer!]]
]]
]
natives: context [
#import [libRedRT-file stdcall [
remove-each-init: "red/natives/remove-each-init" []
remove-each-next: "red/natives/remove-each-next" [size [integer!]]
foreach-next-block: "red/natives/foreach-next-block" [size [integer!] return: [logic!]]
foreach-next: "red/natives/foreach-next" [return: [logic!]]
forall-next?: "red/natives/forall-next?" [return: [logic!]]
forall-end: "red/natives/forall-end" []
forall-end-adjust: "red/natives/forall-end-adjust" []
coerce-counter*: "red/natives/coerce-counter*" []
inc-counter: "red/natives/inc-counter" [w [red-word!]]
get-series-length: "red/natives/get-series-length" [series [red-series!] return: [integer!]]
if*: "red/natives/if*" [check? [logic!]]
unless*: "red/natives/unless*" [check? [logic!]]
either*: "red/natives/either*" [check? [logic!]]
any*: "red/natives/any*" [check? [logic!]]
all*: "red/natives/all*" [check? [logic!]]
while*: "red/natives/while*" [check? [logic!]]
until*: "red/natives/until*" [check? [logic!]]
loop*: "red/natives/loop*" [check? [logic!]]
repeat*: "red/natives/repeat*" [check? [logic!]]
forever*: "red/natives/forever*" [check? [logic!]]
foreach*: "red/natives/foreach*" [check? [logic!]]
forall*: "red/natives/forall*" [check? [logic!]]
func*: "red/natives/func*" [check? [logic!]]
function*: "red/natives/function*" [check? [logic!]]
does*: "red/natives/does*" [check? [logic!]]
has*: "red/natives/has*" [check? [logic!]]
switch*: "red/natives/switch*" [check? [logic!] default? [integer!]]
case*: "red/natives/case*" [check? [logic!] all? [integer!]]
do*: "red/natives/do*" [check? [logic!] expand? [integer!] args [integer!] next [integer!] trace [integer!] return: [integer!]]
get*: "red/natives/get*" [check? [logic!] any? [integer!] case? [integer!]]
set*: "red/natives/set*" [check? [logic!] _any? [integer!] case? [integer!] _only? [integer!] _some? [integer!]]
print*: "red/natives/print*" [check? [logic!]]
prin*: "red/natives/prin*" [check? [logic!]]
equal?*: "red/natives/equal?*" [check? [logic!] return: [red-logic!]]
not-equal?*: "red/natives/not-equal?*" [check? [logic!] return: [red-logic!]]
strict-equal?*: "red/natives/strict-equal?*" [check? [logic!] return: [red-logic!]]
lesser?*: "red/natives/lesser?*" [check? [logic!] return: [red-logic!]]
greater?*: "red/natives/greater?*" [check? [logic!] return: [red-logic!]]
lesser-or-equal?*: "red/natives/lesser-or-equal?*" [check? [logic!] return: [red-logic!]]
greater-or-equal?*: "red/natives/greater-or-equal?*" [check? [logic!] return: [red-logic!]]
same?*: "red/natives/same?*" [check? [logic!] return: [red-logic!]]
not*: "red/natives/not*" [check? [logic!]]
type?*: "red/natives/type?*" [check? [logic!] word? [integer!] return: [cell!]]
reduce*: "red/natives/reduce*" [check? [logic!] into [integer!]]
compose*: "red/natives/compose*" [check? [logic!] deep [integer!] only [integer!] into [integer!]]
stats*: "red/natives/stats*" [check? [logic!] show [integer!] info [integer!]]
bind*: "red/natives/bind*" [check? [logic!] copy [integer!]]
in*: "red/natives/in*" [check? [logic!]]
parse*: "red/natives/parse*" [check? [logic!] case? [integer!] part [integer!] trace [integer!] return: [integer!]]
union*: "red/natives/union*" [check? [logic!] cased [integer!] skip [integer!]]
intersect*: "red/natives/intersect*" [check? [logic!] cased [integer!] skip [integer!]]
unique*: "red/natives/unique*" [check? [logic!] cased [integer!] skip [integer!]]
difference*: "red/natives/difference*" [check? [logic!] cased [integer!] skip [integer!]]
exclude*: "red/natives/exclude*" [check? [logic!] cased [integer!] skip [integer!]]
complement?*: "red/natives/complement?*" [check? [logic!] return: [red-logic!]]
dehex*: "red/natives/dehex*" [check? [logic!] return: [red-string!]]
enhex*: "red/natives/enhex*" [check? [logic!] return: [red-string!]]
negative?*: "red/natives/negative?*" [check? [logic!] return: [red-logic!]]
positive?*: "red/natives/positive?*" [check? [logic!] return: [red-logic!]]
max*: "red/natives/max*" [check? [logic!]]
min*: "red/natives/min*" [check? [logic!]]
shift*: "red/natives/shift*" [check? [logic!] left [integer!] logical [integer!]]
to-hex*: "red/natives/to-hex*" [check? [logic!] size [integer!]]
sine*: "red/natives/sine*" [check? [logic!] radians [integer!]]
cosine*: "red/natives/cosine*" [check? [logic!] radians [integer!]]
tangent*: "red/natives/tangent*" [check? [logic!] radians [integer!]]
arcsine*: "red/natives/arcsine*" [check? [logic!] radians [integer!]]
arccosine*: "red/natives/arccosine*" [check? [logic!] radians [integer!]]
arctangent*: "red/natives/arctangent*" [check? [logic!] radians [integer!]]
arctangent2*: "red/natives/arctangent2*" [check? [logic!] radians [integer!]]
NaN?*: "red/natives/NaN?*" [check? [logic!] return: [red-logic!]]
log-2*: "red/natives/log-2*" [check? [logic!]]
log-10*: "red/natives/log-10*" [check? [logic!]]
log-e*: "red/natives/log-e*" [check? [logic!]]
exp*: "red/natives/exp*" [check? [logic!]]
square-root*: "red/natives/square-root*" [check? [logic!]]
construct*: "red/natives/construct*" [check? [logic!] _with [integer!] only [integer!]]
value?*: "red/natives/value?*" [check? [logic!]]
try*: "red/natives/try*" [check? [logic!] _all [integer!] keep [integer!] return: [integer!]]
uppercase*: "red/natives/uppercase*" [check? [logic!] part [integer!]]
lowercase*: "red/natives/lowercase*" [check? [logic!] part [integer!]]
as-pair*: "red/natives/as-pair*" [check? [logic!]]
break*: "red/natives/break*" [check? [logic!] returned [integer!]]
continue*: "red/natives/continue*" [check? [logic!]]
exit*: "red/natives/exit*" [check? [logic!]]
return*: "red/natives/return*" [check? [logic!]]
throw*: "red/natives/throw*" [check? [logic!] name [integer!]]
catch*: "red/natives/catch*" [check? [logic!] name [integer!]]
extend*: "red/natives/extend*" [check? [logic!] case? [integer!]]
debase*: "red/natives/debase*" [check? [logic!] base-arg [integer!]]
to-local-file*: "red/natives/to-local-file*" [check? [logic!] full? [integer!]]
wait*: "red/natives/wait*" [check? [logic!] all? [integer!]]
checksum*: "red/natives/checksum*" [check? [logic!] _with [integer!]]
unset*: "red/natives/unset*" [check? [logic!]]
new-line*: "red/natives/new-line*" [check? [logic!] _all [integer!] skip [integer!]]
new-line?*: "red/natives/new-line?*" [check? [logic!]]
enbase*: "red/natives/enbase*" [check? [logic!] base-arg [integer!]]
handle-thrown-error: "red/natives/handle-thrown-error" []
now*: "red/natives/now*" [check? [logic!] year [integer!] month [integer!] day [integer!] time [integer!] zone [integer!] _date [integer!] weekday [integer!] yearday [integer!] precise [integer!] utc [integer!]]
get-env*: "red/natives/get-env*" [check? [logic!]]
set-env*: "red/natives/set-env*" [check? [logic!]]
list-env*: "red/natives/list-env*" [check? [logic!]]
sign?*: "red/natives/sign?*" [check? [logic!] return: [red-integer!]]
as*: "red/natives/as*" [check? [logic!]]
call*: "red/natives/call*" [check? [logic!] wait [integer!] show [integer!] console [integer!] shell [integer!] input [integer!] output [integer!] error [integer!] return: [red-integer!]]
zero?*: "red/natives/zero?*" [check? [logic!] return: [red-logic!]]
size?*: "red/natives/size?*" [check? [logic!]]
browse*: "red/natives/browse*" [check? [logic!]]
context?*: "red/natives/context?*" [check? [logic!]]
compress*: "red/natives/compress*" [check? [logic!]]
decompress*: "red/natives/decompress*" [check? [logic!] size [integer!]]
recycle*: "red/natives/recycle*" [check? [logic!] on? [integer!] off? [integer!]]
transcode*: "red/natives/transcode*" [check? [logic!] next [integer!] one [integer!] prescan [integer!] scan [integer!] part [integer!] into [integer!] trace [integer!]]
as-money*: "red/natives/as-money*" [check? [logic!]]
buffer-blk: "red/natives/buffer-blk" [red-block!]
]]
]
actions: context [
#import [libRedRT-file stdcall [
make*: "red/actions/make*" [return: [cell!]]
random*: "red/actions/random*" [seed [integer!] secure [integer!] only [integer!] return: [cell!]]
reflect*: "red/actions/reflect*" [return: [red-block!]]
to*: "red/actions/to*" [return: [cell!]]
form*: "red/actions/form*" [part [integer!]]
mold*: "red/actions/mold*" [only [integer!] _all [integer!] flat [integer!] part [integer!]]
eval-path*: "red/actions/eval-path*" [set? [logic!] return: [cell!]]