-
Notifications
You must be signed in to change notification settings - Fork 0
/
ESLIF.xs
6396 lines (5637 loc) · 290 KB
/
ESLIF.xs
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
/* Shall this module determine automatically string encoding ? */
/* #define MARPAESLIFPERL_AUTO_ENCODING_DETECT */
/* When we receive a string claimed to be in UTF-8, shall we cross check ? */
/* #define MARPAESLIFPERL_UTF8_CROSSCHECK */
/* As a general note, we maintain object dependencies in perl itself, because */
/* EVERY object is a hash that has an 'args_ref' member, the later containting */
/* a reference to all arguments. */
#define PERL_NO_GET_CONTEXT 1 /* we want efficiency */
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"
#define NEED_newSVpvn_flags
#include "ppport.h"
#include <marpaESLIF.h>
#include <genericLogger.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <float.h>
#include <limits.h>
/* #include <valgrind/callgrind.h> */
/* Perl wrapper around malloc, free, etc... are just painful for genericStack, which is */
/* is implemented using header files, not a library... */
#ifdef malloc
#define current_malloc malloc
#endif
#ifdef calloc
#define current_calloc calloc
#endif
#ifdef realloc
#define current_realloc realloc
#endif
#ifdef free
#define current_free free
#endif
#ifdef memset
#define current_memset memset
#endif
#ifdef memcpy
#define current_memcpy memcpy
#endif
#ifdef memmove
#define current_memmove memmove
#endif
#undef malloc
#undef calloc
#undef realloc
#undef free
#undef memset
#undef memcpy
#undef memmove
#include <genericStack.h>
PERL_STATIC_INLINE void marpaESLIFPerl_SYSTEM_FREE(void *p) { free(p); }
PERL_STATIC_INLINE genericStack_t *marpaESLIFPerl_GENERICSTACK_NEW() { genericStack_t *stackp;
GENERICSTACK_NEW(stackp);
return stackp; }
PERL_STATIC_INLINE void marpaESLIFPerl_GENERICSTACK_INIT(genericStack_t *stackp) { GENERICSTACK_INIT(stackp); }
PERL_STATIC_INLINE void marpaESLIFPerl_GENERICSTACK_RESET(genericStack_t *stackp) { GENERICSTACK_RESET(stackp); }
PERL_STATIC_INLINE void marpaESLIFPerl_GENERICSTACK_FREE(genericStack_t *stackp) { GENERICSTACK_FREE(stackp); }
PERL_STATIC_INLINE void *marpaESLIFPerl_GENERICSTACK_GET_PTR(genericStack_t *stackp, int indicei) { return GENERICSTACK_GET_PTR(stackp, indicei); }
PERL_STATIC_INLINE void *marpaESLIFPerl_GENERICSTACK_POP_PTR(genericStack_t *stackp) { return GENERICSTACK_POP_PTR(stackp); }
PERL_STATIC_INLINE short marpaESLIFPerl_GENERICSTACK_IS_PTR(genericStack_t *stackp, int indicei) { return GENERICSTACK_IS_PTR(stackp, indicei); }
PERL_STATIC_INLINE void marpaESLIFPerl_GENERICSTACK_PUSH_PTR(genericStack_t *stackp, void *p) { GENERICSTACK_PUSH_PTR(stackp, p); }
PERL_STATIC_INLINE void marpaESLIFPerl_GENERICSTACK_SET_PTR(genericStack_t *stackp, void *p, int i) { GENERICSTACK_SET_PTR(stackp, p, i); }
PERL_STATIC_INLINE void marpaESLIFPerl_GENERICSTACK_SET_NA(genericStack_t *stackp, int indicei) { GENERICSTACK_SET_NA(stackp, indicei); }
PERL_STATIC_INLINE short marpaESLIFPerl_GENERICSTACK_ERROR(genericStack_t *stackp) { return GENERICSTACK_ERROR(stackp); }
PERL_STATIC_INLINE int marpaESLIFPerl_GENERICSTACK_USED(genericStack_t *stackp) { return GENERICSTACK_USED(stackp); }
PERL_STATIC_INLINE int marpaESLIFPerl_GENERICSTACK_SET_USED(genericStack_t *stackp, int usedi) { return GENERICSTACK_USED(stackp) = usedi; }
#ifdef current_malloc
#define malloc current_malloc
#endif
#ifdef current_calloc
#define calloc current_calloc
#endif
#ifdef current_free
#define free current_free
#endif
#ifdef current_memset
#define memset current_memset
#endif
#ifdef current_memcpy
#define memcpy current_memcpy
#endif
#ifdef current_memmove
#define memmove current_memmove
#endif
#define MARPAESLIFPERL_CHUNKED_SIZE_UPPER(size, chunk) ((size) < (chunk)) ? (chunk) : ((1 + ((size) / (chunk))) * (chunk))
/* For perl interpreter retrieval */
#ifndef tTHX
# define marpaESLIFPerlTHX PerlInterpreter*
#else
# define marpaESLIFPerlTHX tTHX
#endif
#ifdef PERL_IMPLICIT_CONTEXT
# define marpaESLIFPerlaTHX aTHX
#else
# define marpaESLIFPerlaTHX NULL
#endif
/* Interpret specific things */
typedef struct MarpaX_ESLIF_constants {
SV *MarpaX__ESLIF_svp;
SV *MarpaX__ESLIF__is_bool_svp;
SV *MarpaX__ESLIF__UTF_8_svp;
SV *Math__BigFloat_svp;
SV *Math__BigFloat__new_svp;
SV *Math__BigInt_svp;
SV *Math__BigInt__new_svp;
SV *Math__BigInt__binf_svp;
SV *Math__BigInt__bnan_svp;
short nvtype_is_long_doubleb;
short nvtype_is___float128;
SV *MarpaX__ESLIF__true_svp;
SV *MarpaX__ESLIF__false_svp;
SV *MarpaX__ESLIF__Grammar__Properties_svp;
SV *MarpaX__ESLIF__Grammar__Rule__Properties_svp;
SV *MarpaX__ESLIF__Grammar__Symbol__Properties_svp;
SV *MarpaX__ESLIF__String_svp;
SV *MarpaX__ESLIF__String__new_svp;
SV *MarpaX__ESLIF__String__encoding_svp;
SV *MarpaX__ESLIF__String__value_svp;
SV *Encode_svp;
SV *Encode__decode_svp;
SV *MarpaX__ESLIF__Recognizer_svp;
SV *MarpaX__ESLIF__Recognizer__SHALLOW_svp;
SV *MarpaX__ESLIF__Context__symbolName_svp;
SV *MarpaX__ESLIF__Context__symbolNumber_svp;
SV *MarpaX__ESLIF__Context__ruleName_svp;
SV *MarpaX__ESLIF__Context__ruleNumber_svp;
SV *MarpaX__ESLIF__Context__grammar_svp;
} MarpaX_ESLIF_constants_t;
typedef struct marpaESLIFPerl_stringGeneratorContext {
char *s; /* Pointer */
size_t l; /* Used size */
short okb; /* Status */
size_t allocl; /* Allocated size */
#ifdef PERL_IMPLICIT_CONTEXT
marpaESLIFPerlTHX PerlInterpreterp;
#endif
} marpaESLIFPerl_stringGeneratorContext_t;
typedef struct marpaESLIFPerl_importContext {
marpaESLIF_t *marpaESLIFp;
genericStack_t *stackp;
MarpaX_ESLIF_constants_t *constantsp;
#ifdef PERL_IMPLICIT_CONTEXT
marpaESLIFPerlTHX PerlInterpreterp;
#endif
} marpaESLIFPerl_importContext_t;
#include "c-constant-types.inc"
#include "c-event-types.inc"
#include "c-value-types.inc"
#include "c-loggerLevel-types.inc"
#include "c-rulePropertyBitSet-types.inc"
#include "c-symbolPropertyBitSet-types.inc"
#include "c-symbolEventBitSet-types.inc"
#include "c-symbol-types.inc"
/* Encode constants as per the documentation */
#define MARPAESLIFPERL_ENCODE_DIE_ON_ERR 0x0001
#define MARPAESLIFPERL_ENCODE_WARN_ON_ERR 0x0002
#define MARPAESLIFPERL_ENCODE_RETURN_ON_ERR 0x0004
#define MARPAESLIFPERL_ENCODE_LEAVE_SRC 0x0008
#define MARPAESLIFPERL_ENCODE_PERLQQ 0x0100
#define MARPAESLIFPERL_ENCODE_HTMLCREF 0x0200
#define MARPAESLIFPERL_ENCODE_XMLCREF 0x0400
#define MARPAESLIFPERL_ENCODE_FB_DEFAULT 0
#define MARPAESLIFPERL_ENCODE_FB_CROAK MARPAESLIFPERL_ENCODE_DIE_ON_ERR
#define MARPAESLIFPERL_ENCODE_FB_QUIET MARPAESLIFPERL_ENCODE_RETURN_ON_ERR
#define MARPAESLIFPERL_ENCODE_FB_WARN MARPAESLIFPERL_ENCODE_RETURN_ON_ERR | MARPAESLIFPERL_ENCODE_WARN_ON_ERR
#define MARPAESLIFPERL_ENCODE_FB_PERLQQ MARPAESLIFPERL_ENCODE_LEAVE_SRC | MARPAESLIFPERL_ENCODE_PERLQQ
#define MARPAESLIFPERL_NEWSVPVN_UTF8(keys, sizel) newSVpvn_flags((const char *) keys, (STRLEN) sizel, is_utf8_string((const U8 *) keys, (STRLEN) sizel) ? SVf_UTF8 : 0)
/* Use the inc and dec macros that fit the best our code */
#ifdef SvREFCNT_dec_NN
# define MARPAESLIFPERL_SvREFCNT_dec(svp) SvREFCNT_dec_NN(svp)
#else
# define MARPAESLIFPERL_SvREFCNT_dec(svp) SvREFCNT_dec(svp)
#endif
/* Why is there no need for encodingl ? Because it is guaranteed that encodings */
/* is a NUL terminated ASCII string. So when character at position i is != '\0' */
/* then the character at position i+1 exists (and it may be the NUL byte...). */
/* We do not rely on strcasecmp, _stricmp etc... not in C std and too much */
/* bound to locale. */
/* In addition you may wonder why I both to do strcmp() because the case */
/* insensitive version. This is because almost nobody export UTF-8 as something */
/* else but "UTF-8". So the probability to have strcmp() successful when it is */
/* an UTF-8 string is unvaluable compared to somebody that would use "utf-8". */
/* And of course strcmp() is bound by any compiler to an optimized assemby */
/* version ;) */
/* Note that we do NOT test if encodings is != NULL because when ESLIF exports */
/* a marpaESLIFValueResult of type STRING it guarantees that encodingasciis is */
/* set. */
#define MARPAESLIFPERL_ENCODING_IS_UTF8(encodings) \
((strcmp(encodings, "UTF-8") == 0) \
|| \
( \
((encodings[0] == 'U') || (encodings[0] == 'u')) && \
((encodings[1] == 'T') || (encodings[1] == 't')) && \
((encodings[2] == 'F') || (encodings[2] == 'f')) && \
(((encodings[3] == '-') && (encodings[4] == '8') && (encodings[5] == '\0')) /* UTF-8 */ \
|| \
((encodings[3] == '8') && (encodings[4] == '\0')) /* UTF8 */ \
) \
) \
)
#if defined(SvREFCNT_inc_simple_void_NN)
# define MARPAESLIFPERL_SvREFCNT_inc(svp) SvREFCNT_inc_simple_void_NN(svp)
#elif defined(SvREFCNT_inc_void_NN)
# define MARPAESLIFPERL_SvREFCNT_inc(svp) SvREFCNT_inc_void_NN(svp)
#elif defined(SvREFCNT_inc_simple_NN)
# define MARPAESLIFPERL_SvREFCNT_inc(svp) SvREFCNT_inc_simple_NN(svp)
#elif defined(SvREFCNT_inc_NN)
# define MARPAESLIFPERL_SvREFCNT_inc(svp) SvREFCNT_inc_NN(svp)
#elif defined(SvREFCNT_inc_simple_void)
# define MARPAESLIFPERL_SvREFCNT_inc(svp) SvREFCNT_inc_simple_void(svp)
#elif defined(SvREFCNT_inc_void)
# define MARPAESLIFPERL_SvREFCNT_inc(svp) SvREFCNT_inc_void(svp)
#elif defined(SvREFCNT_inc_simple)
# define MARPAESLIFPERL_SvREFCNT_inc(svp) SvREFCNT_inc_simple(svp)
#else
# define MARPAESLIFPERL_SvREFCNT_inc(svp) SvREFCNT_inc(svp)
#endif
/* ESLIF context */
static char _MARPAESLIFPERL_CONTEXT;
#define MARPAESLIFPERL_CONTEXT &_MARPAESLIFPERL_CONTEXT
typedef struct MarpaX_ESLIF {
SV *Perl_loggerInterfacep;
genericLogger_t *genericLoggerp;
marpaESLIF_t *marpaESLIFp;
#ifdef PERL_IMPLICIT_CONTEXT
marpaESLIFPerlTHX PerlInterpreterp;
#endif
MarpaX_ESLIF_constants_t constants;
} MarpaX_ESLIF_t;
/* Nothing special for the grammar type */
typedef struct MarpaX_ESLIF_Grammar {
SV *Perl_MarpaX_ESLIFp;
MarpaX_ESLIF_t *MarpaX_ESLIFp;
marpaESLIFGrammar_t *marpaESLIFGrammarp;
MarpaX_ESLIF_constants_t *constantsp;
} MarpaX_ESLIF_Grammar_t, MarpaX_ESLIF_JSON_Encoder_t, MarpaX_ESLIF_JSON_Decoder_t;
/* Symbol type */
typedef struct MarpaX_ESLIF_Symbol {
SV *Perl_MarpaX_ESLIFp;
MarpaX_ESLIF_t *MarpaX_ESLIFp;
marpaESLIFSymbol_t *marpaESLIFSymbolp;
MarpaX_ESLIF_constants_t *constantsp;
genericStack_t *internalStackp;
#ifdef PERL_IMPLICIT_CONTEXT
marpaESLIFPerlTHX PerlInterpreterp;
#endif
} MarpaX_ESLIF_Symbol_t;
/* Recognizer context */
typedef struct MarpaX_ESLIF_Recognizer {
MarpaX_ESLIF_Grammar_t *MarpaX_ESLIF_Grammarp;
MarpaX_ESLIF_t *MarpaX_ESLIFp;
marpaESLIFRecognizer_t *marpaESLIFRecognizerp;
marpaESLIFRecognizer_t *marpaESLIFRecognizerBackupp; /* Used recognizer callbacks */
marpaESLIFRecognizer_t *marpaESLIFRecognizerLastp; /* Last used marpaESLIFRecognizerp in recognizer callbacks */
SV *Perl_MarpaX_ESLIF_Grammarp;
SV *Perl_recognizerInterfacep;
SV *Perl_recognizer_origp;
char *actions; /* Shallow copy of last resolved name */
SV *Perl_datap;
SV *Perl_encodingp;
#ifdef PERL_IMPLICIT_CONTEXT
marpaESLIFPerlTHX PerlInterpreterp;
#endif
genericStack_t *internalStackp;
/* For regex callback, we store the stash pointer of MarpaX::ESLIF::RegexCallout */
MarpaX_ESLIF_constants_t *constantsp;
SV *readSvp;
SV *isEofSvp;
SV *isCharacterStreamSvp;
SV *encodingSvp;
SV *dataSvp;
SV *isWithDisableThresholdSvp;
SV *isWithExhaustionSvp;
SV *isWithNewlineSvp;
SV *isWithTrackSvp;
SV *setRecognizerSvp;
SV *resolverSvp;
SV *resolvedActionSvp;
} MarpaX_ESLIF_Recognizer_t;
/* Value context */
typedef struct MarpaX_ESLIF_Value {
SV *Perl_valueInterfacep;
MarpaX_ESLIF_t *MarpaX_ESLIFp;
SV *Perl_MarpaX_ESLIF_Grammarp;
char *actions; /* Shallow copy of last resolved name */
marpaESLIFValue_t *marpaESLIFValuep;
short canSetSymbolNameb;
short canSetSymbolNumberb;
short canSetRuleNameb;
short canSetRuleNumberb;
short canSetGrammarb;
SV *setSymbolNameSvp;
SV *setSymbolNumberSvp;
SV *setRuleNameSvp;
SV *setRuleNumberSvp;
SV *setGrammarSvp;
char *symbols;
int symboli;
char *rules;
int rulei;
genericStack_t *internalStackp;
#ifdef PERL_IMPLICIT_CONTEXT
marpaESLIFPerlTHX PerlInterpreterp;
#endif
MarpaX_ESLIF_constants_t *constantsp;
SV *isWithHighRankOnlySvp;
SV *isWithOrderByRankSvp;
SV *isWithAmbiguousSvp;
SV *isWithNullSvp;
SV *maxParsesSvp;
SV *setResultSvp;
SV *getResultSvp;
SV *resolverSvp;
SV *resolvedActionSvp;
} MarpaX_ESLIF_Value_t;
/* Static functions declarations */
PERL_STATIC_INLINE void marpaESLIFPerl_constants_initv(pTHX_ MarpaX_ESLIF_constants_t *constantsp);
PERL_STATIC_INLINE void marpaESLIFPerl_constants_disposev(pTHX_ MarpaX_ESLIF_constants_t *constantsp);
PERL_STATIC_INLINE int marpaESLIFPerl_getTypei(pTHX_ SV* svp);
PERL_STATIC_INLINE short marpaESLIFPerl_canb(pTHX_ SV *svp, const char *methods, SV **svpp, SV *subSvp);
PERL_STATIC_INLINE void marpaESLIFPerl_call_methodv(pTHX_ SV *interfacep, const char *methods, SV *argsvp, SV *subSvp);
PERL_STATIC_INLINE SV *marpaESLIFPerl_call_methodp(pTHX_ SV *interfacep, const char *methods, AV *avp, SV *subSvp);
PERL_STATIC_INLINE SV *marpaESLIFPerl_call_actionp(pTHX_ SV *interfacep, const char *methods, AV *avp, MarpaX_ESLIF_Value_t *MarpaX_ESLIF_Valuep, short evalb, short evalSilentb, SV *subSvp);
PERL_STATIC_INLINE SV *marpaESLIFPerl_recognizerCallbackActionp(pTHX_ MarpaX_ESLIF_Recognizer_t *MarpaX_ESLIF_Recognizerp, marpaESLIFRecognizer_t *marpaESLIFRecognizerp, AV *avp);
PERL_STATIC_INLINE SV *marpaESLIFPerl_valueCallbackActionp(pTHX_ MarpaX_ESLIF_Value_t *MarpaX_ESLIF_Valuep, AV *avp);
PERL_STATIC_INLINE IV marpaESLIFPerl_call_methodi(pTHX_ SV *interfacep, const char *methods, SV *subSvp);
PERL_STATIC_INLINE short marpaESLIFPerl_call_methodb(pTHX_ SV *interfacep, const char *methods, SV *subSvp);
PERL_STATIC_INLINE void marpaESLIFPerl_genericLoggerCallbackv(void *userDatavp, genericLoggerLevel_t logLeveli, const char *msgs);
PERL_STATIC_INLINE void marpaESLIFPerl_readerCallbackDisposev(void *userDatavp, char *inputcp, size_t inputl, short eofb, short characterStreamb, char *encodings, size_t encodingl);
PERL_STATIC_INLINE short marpaESLIFPerl_readerCallbackb(void *userDatavp, char **inputcpp, size_t *inputlp, short *eofbp, short *characterStreambp, char **encodingsp, size_t *encodinglp, marpaESLIFReaderDispose_t *disposeCallbackpp);
PERL_STATIC_INLINE void marpaESLIFPerl_valueActionResolver(pTHX_ MarpaX_ESLIF_Value_t *MarpaX_ESLIF_Valuep, char *actions);
PERL_STATIC_INLINE marpaESLIFValueRuleCallback_t marpaESLIFPerl_valueRuleActionResolver(void *userDatavp, marpaESLIFValue_t *marpaESLIFValuep, char *actions);
PERL_STATIC_INLINE marpaESLIFValueSymbolCallback_t marpaESLIFPerl_valueSymbolActionResolver(void *userDatavp, marpaESLIFValue_t *marpaESLIFValuep, char *actions);
PERL_STATIC_INLINE void marpaESLIFPerl_recognizerActionResolver(pTHX_ MarpaX_ESLIF_Recognizer_t *MarpaX_ESLIF_Recognizerp, char *actions);
PERL_STATIC_INLINE marpaESLIFRecognizerIfCallback_t marpaESLIFPerl_recognizerIfActionResolver(void *userDatavp, marpaESLIFRecognizer_t *marpaESLIFRecognizerp, char *actions);
PERL_STATIC_INLINE marpaESLIFRecognizerEventCallback_t marpaESLIFPerl_recognizerEventActionResolver(void *userDatavp, marpaESLIFRecognizer_t *marpaESLIFRecognizerp, char *actions);
PERL_STATIC_INLINE marpaESLIFRecognizerRegexCallback_t marpaESLIFPerl_recognizerRegexActionResolver(void *userDatavp, marpaESLIFRecognizer_t *marpaESLIFRecognizerp, char *actions);
PERL_STATIC_INLINE marpaESLIFRecognizerGeneratorCallback_t marpaESLIFPerl_recognizerGeneratorActionResolver(void *userDatavp, marpaESLIFRecognizer_t *marpaESLIFRecognizerp, char *actions);
PERL_STATIC_INLINE SV *marpaESLIFPerl_valueGetSvp(pTHX_ marpaESLIFValue_t *marpaESLIFValuep, genericStack_t *internalStackp, int stackindicei, marpaESLIFValueResult_t *marpaESLIFValueResultLexemep);
PERL_STATIC_INLINE SV *marpaESLIFPerl_recognizerGetSvp(pTHX_ marpaESLIFRecognizer_t *marpaESLIFRecognizerp, genericStack_t *internalStackp, marpaESLIFValueResult_t *marpaESLIFValueResultp);
PERL_STATIC_INLINE short marpaESLIFPerl_valueRuleCallbackb(void *userDatavp, marpaESLIFValue_t *marpaESLIFValuep, int arg0i, int argni, int resulti, short nullableb);
PERL_STATIC_INLINE short marpaESLIFPerl_valueSymbolCallbackb(void *userDatavp, marpaESLIFValue_t *marpaESLIFValuep, marpaESLIFValueResult_t *marpaESLIFValueResultp, int resulti);
PERL_STATIC_INLINE short marpaESLIFPerl_recognizerIfCallbackb(void *userDatavp, marpaESLIFRecognizer_t *marpaESLIFRecognizerp, marpaESLIFValueResult_t *marpaESLIFValueResultLexemep, marpaESLIFValueResultBool_t *marpaESLIFValueResultBoolp);
PERL_STATIC_INLINE short marpaESLIFPerl_recognizerEventCallbackb(void *userDatavp, marpaESLIFRecognizer_t *marpaESLIFRecognizerp, marpaESLIFEvent_t *eventArrayp, size_t eventArrayl, marpaESLIFValueResultBool_t *marpaESLIFValueResultBoolp);
PERL_STATIC_INLINE short marpaESLIFPerl_recognizerRegexCallbackb(void *userDatavp, marpaESLIFRecognizer_t *marpaESLIFRecognizerp, marpaESLIFValueResult_t *marpaESLIFCalloutBlockp, marpaESLIFValueResultInt_t *marpaESLIFValueResultOutp);
PERL_STATIC_INLINE short marpaESLIFPerl_recognizerGeneratorCallbackb(void *userDatavp, marpaESLIFRecognizer_t *marpaESLIFRecognizerp, marpaESLIFValueResult_t *contextp, marpaESLIFValueResultString_t *marpaESLIFValueResultOutp);
PERL_STATIC_INLINE void marpaESLIFPerl_genericFreeCallbackv(void *userDatavp, marpaESLIFValueResult_t *marpaESLIFValueResultp);
PERL_STATIC_INLINE void marpaESLIFPerl_ContextInitv(pTHX_ MarpaX_ESLIF_t *MarpaX_ESLIFp);
PERL_STATIC_INLINE void marpaESLIFPerl_ContextFreev(pTHX_ MarpaX_ESLIF_t *MarpaX_ESLIFp);
PERL_STATIC_INLINE void marpaESLIFPerl_grammarContextFreev(pTHX_ MarpaX_ESLIF_Grammar_t *MarpaX_ESLIF_Grammarp);
PERL_STATIC_INLINE void marpaESLIFPerl_symbolContextFreev(pTHX_ MarpaX_ESLIF_Symbol_t *MarpaX_ESLIF_Symbolp);
PERL_STATIC_INLINE void marpaESLIFPerl_valueContextFreev(pTHX_ MarpaX_ESLIF_Value_t *MarpaX_ESLIF_Valuep, short onStackb);
PERL_STATIC_INLINE void marpaESLIFPerl_recognizerContextFreev(pTHX_ MarpaX_ESLIF_Recognizer_t *MarpaX_ESLIF_Recognizerp, short onStackb);
PERL_STATIC_INLINE void marpaESLIFPerl_freeInternalStackv(pTHX_ genericStack_t *internalStackp);
PERL_STATIC_INLINE void marpaESLIFPerl_grammarContextInitv(pTHX_ SV *Perl_MarpaX_ESLIFp, MarpaX_ESLIF_t *MarpaX_ESLIFp, MarpaX_ESLIF_Grammar_t *MarpaX_ESLIF_Grammarp, MarpaX_ESLIF_constants_t *constantsp);
PERL_STATIC_INLINE void marpaESLIFPerl_symbolContextInitv(pTHX_ MarpaX_ESLIF_t *MarpaX_ESLIFp, SV *Perl_MarpaX_ESLIFp, MarpaX_ESLIF_Symbol_t *MarpaX_ESLIF_Symbolp, MarpaX_ESLIF_constants_t *constantsp);
PERL_STATIC_INLINE void marpaESLIFPerl_recognizerContextInitv(pTHX_ MarpaX_ESLIF_Grammar_t *MarpaX_ESLIF_Grammarp, SV *Perl_MarpaX_ESLIF_Grammarp, SV *Perl_recognizerInterfacep, MarpaX_ESLIF_Recognizer_t *MarpaX_ESLIF_Recognizerp, SV *Perl_recognizer_origp, MarpaX_ESLIF_constants_t *constantsp, MarpaX_ESLIF_t *MarpaX_ESLIFp);
PERL_STATIC_INLINE void marpaESLIFPerl_valueContextInitv(pTHX_ SV *Perl_MarpaX_ESLIF_Grammarp, SV *Perl_valueInterfacep, MarpaX_ESLIF_Value_t *MarpaX_ESLIF_Valuep, MarpaX_ESLIF_constants_t *constantsp, MarpaX_ESLIF_t *MarpaX_ESLIFp);
PERL_STATIC_INLINE void marpaESLIFPerl_paramIsGrammarv(pTHX_ SV *sv);
PERL_STATIC_INLINE void marpaESLIFPerl_paramIsEncodingv(pTHX_ SV *sv);
PERL_STATIC_INLINE short marpaESLIFPerl_paramIsLoggerInterfaceOrUndefb(pTHX_ SV *sv);
PERL_STATIC_INLINE void marpaESLIFPerl_representationDisposev(void *userDatavp, char *inputcp, size_t inputl, char *encodingasciis);
PERL_STATIC_INLINE short marpaESLIFPerl_representationb(void *userDatavp, marpaESLIFValueResult_t *marpaESLIFValueResultp, char **inputcpp, size_t *inputlp, char **encodingasciisp, marpaESLIFRepresentationDispose_t *disposeCallbackpp, short *stringbp);
PERL_STATIC_INLINE char *marpaESLIFPerl_sv2byte(pTHX_ marpaESLIF_t *marpaESLIFp, SV *svp, char **bytepp, size_t *bytelp, short encodingInformationb, short *characterStreambp, char **encodingsp, size_t *encodinglp, short warnIsFatalb, short marpaESLIFStringb, MarpaX_ESLIF_constants_t *constantsp);
PERL_STATIC_INLINE short marpaESLIFPerl_valueImportb(marpaESLIFValue_t *marpaESLIFValuep, void *userDatavp, marpaESLIFValueResult_t *marpaESLIFValueResultp, short haveUndefb);
PERL_STATIC_INLINE short marpaESLIFPerl_recognizerImportb(marpaESLIFRecognizer_t *marpaESLIFRecognizerp, void *userDatavp, marpaESLIFValueResult_t *marpaESLIFValueResultp, short haveUndefb);
PERL_STATIC_INLINE short marpaESLIFPerl_symbolImportb(marpaESLIFSymbol_t *marpaESLIFSymbolp, void *userDatavp, marpaESLIFValueResult_t *marpaESLIFValueResultp, short haveUndefb);
PERL_STATIC_INLINE short marpaESLIFPerl_importb(pTHX_ marpaESLIFPerl_importContext_t *importContextp, marpaESLIFValueResult_t *marpaESLIFValueResultp, short arraycopyb, short haveUndefb);
PERL_STATIC_INLINE void marpaESLIFPerl_generateStringWithLoggerCallback(void *userDatavp, genericLoggerLevel_t logLeveli, const char *msgs);
PERL_STATIC_INLINE short marpaESLIFPerl_appendOpaqueDataToStringGenerator(marpaESLIFPerl_stringGeneratorContext_t *marpaESLIFPerl_stringGeneratorContextp, char *p, size_t sizel);
PERL_STATIC_INLINE short marpaESLIFPerl_is_scalar_string_only(pTHX_ SV *svp, int typei);
PERL_STATIC_INLINE short marpaESLIFPerl_is_undef(pTHX_ SV *svp, int typei);
PERL_STATIC_INLINE short marpaESLIFPerl_is_arrayref(pTHX_ SV *svp, int typei);
PERL_STATIC_INLINE short marpaESLIFPerl_is_MarpaX__ESLIF__String(pTHX_ SV *svp, int typei);
PERL_STATIC_INLINE short marpaESLIFPerl_is_Math__BigInt(pTHX_ SV *svp, int typei);
PERL_STATIC_INLINE short marpaESLIFPerl_is_Math__BigFloat(pTHX_ SV *svp, int typei);
PERL_STATIC_INLINE short marpaESLIFPerl_is_hashref(pTHX_ SV *svp, int typei);
PERL_STATIC_INLINE short marpaESLIFPerl_is_bool(pTHX_ SV *svp, int typei, MarpaX_ESLIF_constants_t *constantsp);
PERL_STATIC_INLINE SV *marpaESLIFPerl_true(pTHX_ MarpaX_ESLIF_constants_t *constantsp);
PERL_STATIC_INLINE SV *marpaESLIFPerl_false(pTHX_ MarpaX_ESLIF_constants_t *constantsp);
PERL_STATIC_INLINE void marpaESLIFPerl_stack_setv(pTHX_ marpaESLIF_t *marpaESLIFp, marpaESLIFValue_t *marpaESLIFValuep, int resulti, SV *svp, marpaESLIFValueResult_t *marpaESLIFValueResultOutputp, short incb, MarpaX_ESLIF_constants_t *constantsp);
PERL_STATIC_INLINE short marpaESLIFPerl_JSONDecodePositiveInfinityAction(void *userDatavp, char *strings, size_t stringl, marpaESLIFValueResult_t *marpaESLIFValueResultp, short confidenceb);
PERL_STATIC_INLINE short marpaESLIFPerl_JSONDecodeNegativeInfinityAction(void *userDatavp, char *strings, size_t stringl, marpaESLIFValueResult_t *marpaESLIFValueResultp, short confidenceb);
PERL_STATIC_INLINE short marpaESLIFPerl_JSONDecodePositiveNanAction(void *userDatavp, char *strings, size_t stringl, marpaESLIFValueResult_t *marpaESLIFValueResultp, short confidenceb);
PERL_STATIC_INLINE short marpaESLIFPerl_JSONDecodeNegativeNanAction(void *userDatavp, char *strings, size_t stringl, marpaESLIFValueResult_t *marpaESLIFValueResultp, short confidenceb);
PERL_STATIC_INLINE short marpaESLIFPerl_JSONDecodeNumberAction(void *userDatavp, char *strings, size_t stringl, marpaESLIFValueResult_t *marpaESLIFValueResultp, short confidenceb);
PERL_STATIC_INLINE void *marpaESLIFPerl_Perl2enginep(pTHX_ SV *Perl_argumentp);
PERL_STATIC_INLINE SV *marpaESLIFPerl_engine2Perlp(pTHX_ MarpaX_ESLIF_Recognizer_t *MarpaX_ESLIF_Recognizerp);
PERL_STATIC_INLINE void marpaESLIFPerl_setRecognizerEngineForCallbackv(pTHX_ MarpaX_ESLIF_Recognizer_t *MarpaX_ESLIF_Recognizerp, marpaESLIFRecognizer_t *marpaESLIFRecognizerp);
PERL_STATIC_INLINE void marpaESLIFPerl_restoreRecognizerEngineForCallbackv(pTHX_ MarpaX_ESLIF_Recognizer_t *MarpaX_ESLIF_Recognizerp);
PERL_STATIC_INLINE SV *marpaESLIFPerl_arraycopyp(pTHX_ char *p, STRLEN sizel, short arraycopyb);
/* Static constants */
static const char *UTF8s = "UTF-8";
static const size_t UTF8l = 5; /* "UTF-8" is 5 bytes in ASCII encoding */
/*****************************************************************************/
/* Static variables initialized at boot */
/*****************************************************************************/
/*****************************************************************************/
/* Macros */
/*****************************************************************************/
#define MARPAESLIFPERL_FILENAMES "ESLIF.xs"
#define MARPAESLIFPERL_CROAK(msgs) croak("[In %s at %s:%d] %s", funcs, MARPAESLIFPERL_FILENAMES, __LINE__, msgs)
#define MARPAESLIFPERL_CROAKF(fmts, ...) croak("[In %s at %s:%d] " fmts, funcs, MARPAESLIFPERL_FILENAMES, __LINE__, __VA_ARGS__)
#define MARPAESLIFPERL_WARN(msgs) warn("[In %s at %s:%d] %s", funcs, MARPAESLIFPERL_FILENAMES, __LINE__, msgs)
#define MARPAESLIFPERL_WARNF(fmts, ...) warn("[In %s at %s:%d] " fmts, funcs, MARPAESLIFPERL_FILENAMES, __LINE__, __VA_ARGS__)
#define MARPAESLIFPERL_FREE_SVP(svp) do { \
SV *_svp = svp; \
if (((_svp) != NULL) && \
((_svp) != &PL_sv_undef) && \
((_svp) != &PL_sv_yes) && \
((_svp) != &PL_sv_no)) { \
while (SvREFCNT(_svp) > 0) { \
MARPAESLIFPERL_SvREFCNT_dec(_svp); \
} \
} \
} while (0)
#define MARPAESLIFPERL_REFCNT_DEC(svp) do { \
SV *_svp = svp; \
if (((_svp) != NULL) && \
((_svp) != &PL_sv_undef) && \
((_svp) != &PL_sv_yes) && \
((_svp) != &PL_sv_no)) { \
if (SvREFCNT(_svp) > 0) { \
MARPAESLIFPERL_SvREFCNT_dec(_svp); \
} \
} \
} while (0)
#define MARPAESLIFPERL_REFCNT_INC(svp) do { \
SV *_svp = svp; \
if (((_svp) != NULL) && \
((_svp) != &PL_sv_undef) && \
((_svp) != &PL_sv_yes) && \
((_svp) != &PL_sv_no)) { \
MARPAESLIFPERL_SvREFCNT_inc(_svp); \
} \
} while (0)
/* In this macro we hack the difference between hv_store and av_push by testing xvp type */
/* Remember that hv_store() and av_push() takes over one reference count. */
#define MARPAESLIFPERL_XV_STORE(xvp, key, svp) do { \
if (SvTYPE((SV *)xvp) == SVt_PVHV) { \
hv_store((HV *) xvp, key, strlen(key), (svp == &PL_sv_undef) ? newSV(0) : svp, 0); \
} else { \
av_push((AV *) xvp, MARPAESLIFPERL_NEWSVPVN_UTF8(key, strlen(key))); \
av_push((AV *) xvp, (svp == &PL_sv_undef) ? newSV(0) : svp); \
} \
} while (0)
#define MARPAESLIFPERL_XV_STORE_UNDEF(xvp, key) MARPAESLIFPERL_XV_STORE(xvp, key, &PL_sv_undef)
#define MARPAESLIFPERL_XV_STORE_ACTION(hvp, key, actionp) do { \
SV *_svp; \
\
if (actionp != NULL) { \
switch (actionp->type) { \
case MARPAESLIF_ACTION_TYPE_NAME: \
MARPAESLIFPERL_XV_STORE(hvp, key, newSVpv(actionp->u.names, 0)); \
break; \
case MARPAESLIF_ACTION_TYPE_STRING: \
_svp = MARPAESLIFPERL_NEWSVPVN_UTF8(actionp->u.stringp->bytep, actionp->u.stringp->bytel); \
MARPAESLIFPERL_XV_STORE(hvp, key, _svp); \
break; \
case MARPAESLIF_ACTION_TYPE_LUA: \
MARPAESLIFPERL_XV_STORE(hvp, key, newSVpv(actionp->u.luas, 0)); \
break; \
case MARPAESLIF_ACTION_TYPE_LUA_FUNCTION: \
MARPAESLIFPERL_XV_STORE(hvp, key, newSVpv(actionp->u.luaFunction.luas, 0)); \
break; \
default: \
warn("Unsupported action type %d", actionp->type); \
MARPAESLIFPERL_XV_STORE_UNDEF(hvp, key); \
break; \
} \
} else { \
MARPAESLIFPERL_XV_STORE_UNDEF(hvp, key); \
} \
} while (0)
#define MARPAESLIFPERL_XV_STORE_STRING(hvp, key, stringp) do { \
SV *_svp; \
\
if (stringp != NULL) { \
_svp = MARPAESLIFPERL_NEWSVPVN_UTF8(stringp->bytep, stringp->bytel); \
MARPAESLIFPERL_XV_STORE(hvp, key, _svp); \
} else { \
MARPAESLIFPERL_XV_STORE_UNDEF(hvp, key); \
} \
} while (0)
#define MARPAESLIFPERL_XV_STORE_ASCIISTRING(hvp, key, asciis) do { \
if (asciis != NULL) { \
MARPAESLIFPERL_XV_STORE(hvp, key, newSVpv(asciis, 0)); \
} else { \
MARPAESLIFPERL_XV_STORE_UNDEF(hvp, key); \
} \
} while (0)
#define MARPAESLIFPERL_XV_STORE_IV(hvp, key, iv) do { \
MARPAESLIFPERL_XV_STORE(hvp, key, newSViv((IV) iv)); \
} while (0)
#define MARPAESLIFPERL_XV_STORE_YESNO(hvp, key, yesno) do { \
MARPAESLIFPERL_XV_STORE(hvp, key, ((yesno) ? &PL_sv_yes : &PL_sv_no)); \
} while (0)
#define MARPAESLIFPERL_XV_STORE_IVARRAY(hvp, key, ivl, ivp) do { \
AV *_avp; \
size_t _i; \
\
if (ivp != NULL) { \
_avp = newAV(); \
if (ivl > 0) { \
for (_i = 0; _i < ivl; _i++) { \
av_push(_avp, newSViv((IV) ivp[_i])); \
} \
} \
MARPAESLIFPERL_XV_STORE(hvp, key, newRV_inc((SV *) _avp)); \
} else { \
MARPAESLIFPERL_XV_STORE_UNDEF(hvp, key); \
} \
} while (0)
/*****************************************************************************/
/* Copy of Params-Validate-1.26/lib/Params/Validate/XS.xs */
/*****************************************************************************/
#define SCALAR 1
#define ARRAYREF 2
#define HASHREF 4
#define CODEREF 8
#define GLOB 16
#define GLOBREF 32
#define SCALARREF 64
#define UNKNOWN 128
#define UNDEF 256
#define OBJECT 512
PERL_STATIC_INLINE int marpaESLIFPerl_getTypei(pTHX_ SV* svp) {
int type = 0;
if (SvTYPE(svp) == SVt_PVGV) {
return GLOB;
}
if (!SvOK(svp)) {
return UNDEF;
}
if (!SvROK(svp)) {
return SCALAR;
}
switch (SvTYPE(SvRV(svp))) {
case SVt_NULL:
case SVt_IV:
case SVt_NV:
case SVt_PV:
#if PERL_VERSION <= 10
case SVt_RV:
#endif
case SVt_PVMG:
case SVt_PVIV:
case SVt_PVNV:
#if PERL_VERSION <= 8
case SVt_PVBM:
#elif PERL_VERSION >= 11
case SVt_REGEXP:
#endif
type = SCALARREF;
break;
case SVt_PVAV:
type = ARRAYREF;
break;
case SVt_PVHV:
type = HASHREF;
break;
case SVt_PVCV:
type = CODEREF;
break;
case SVt_PVGV:
type = GLOBREF;
break;
/* Perl 5.10 has a bunch of new types that I don't think will ever
actually show up here (I hope), but not handling them makes the
C compiler cranky. */
default:
type = UNKNOWN;
break;
}
if (type) {
if (sv_isobject(svp)) return type | OBJECT;
return type;
}
/* Getting here should not be possible */
return UNKNOWN;
}
/*****************************************************************************/
PERL_STATIC_INLINE short marpaESLIFPerl_canb(pTHX_ SV *svp, const char *methods, SV **svpp, SV *subSvp)
/*****************************************************************************/
{
AV *list = newAV();
SV *rcp;
int type;
/* We always check methods that have ASCII only characters */
av_push(list, newSVpv(methods, 0));
rcp = marpaESLIFPerl_call_actionp(aTHX_ svp, "can", list, NULL /* MarpaX_ESLIF_Valuep */, 0 /* evalb */, 0 /* evalSilentb */, subSvp);
av_undef(list);
type = marpaESLIFPerl_getTypei(aTHX_ rcp);
if (svpp != NULL) {
*svpp = rcp;
} else {
MARPAESLIFPERL_REFCNT_DEC(rcp);
}
return (type & CODEREF) == CODEREF;
}
/*****************************************************************************/
PERL_STATIC_INLINE void marpaESLIFPerl_call_methodv(pTHX_ SV *interfacep, const char *methods, SV *argsvp, SV *subSvp)
/*****************************************************************************/
{
dSP;
ENTER;
SAVETMPS;
PUSHMARK(SP);
EXTEND(SP, 1 + ((argsvp != NULL) ? 1 : 0));
PUSHs(sv_2mortal(newSVsv(interfacep)));
if (argsvp != NULL) {
PUSHs(sv_2mortal(newSVsv(argsvp)));
}
PUTBACK;
if (subSvp != NULL) {
call_sv(subSvp, G_DISCARD);
} else {
call_method(methods, G_DISCARD);
}
FREETMPS;
LEAVE;
}
/*****************************************************************************/
PERL_STATIC_INLINE SV *marpaESLIFPerl_call_methodp(pTHX_ SV *interfacep, const char *methods, AV *avp, SV *subSvp)
/*****************************************************************************/
{
SV *rcp;
rcp = marpaESLIFPerl_call_actionp(aTHX_ interfacep, methods, avp, NULL /* MarpaX_ESLIF_Valuep */, 0 /* evalb */, 0 /* evalSilentb */, subSvp);
return rcp;
}
/*****************************************************************************/
PERL_STATIC_INLINE SV *marpaESLIFPerl_call_actionp(pTHX_ SV *interfacep, const char *methods, AV *avp, MarpaX_ESLIF_Value_t *MarpaX_ESLIF_Valuep, short evalb, short evalSilentb, SV *subSvp)
/*****************************************************************************/
{
static const char *funcs = "marpaESLIFPerl_call_actionp";
SSize_t avsizel = (avp != NULL) ? av_len(avp) + 1 : 0;
SV **svargs = NULL;
I32 flags = G_SCALAR;
SV *rcp;
SV *Perl_valueInterfacep;
SV *Perl_MarpaX_ESLIF_Grammarp;
SV *svlocalp;
char *symbols;
int symboli;
char *rules;
int rulei;
SSize_t aviteratorl;
SV *err_tmp;
dSP;
if (evalb) {
flags |= G_EVAL;
}
ENTER;
SAVETMPS;
if (MarpaX_ESLIF_Valuep != NULL) {
/* This is an action context - we localize some variable */
/* For GV_ADD: value is created once if needed - Perl will destroy it at exit */
Perl_valueInterfacep = MarpaX_ESLIF_Valuep->Perl_valueInterfacep;
Perl_MarpaX_ESLIF_Grammarp = MarpaX_ESLIF_Valuep->Perl_MarpaX_ESLIF_Grammarp;
symbols = MarpaX_ESLIF_Valuep->symbols;
svlocalp = MarpaX_ESLIF_Valuep->constantsp->MarpaX__ESLIF__Context__symbolName_svp;
save_item(svlocalp); /* We control this variable - no magic involved */
if (symbols != NULL) {
sv_setpvn(svlocalp, symbols, strlen(symbols));
} else {
sv_setsv(svlocalp, &PL_sv_undef);
}
if (MarpaX_ESLIF_Valuep->canSetSymbolNameb) {
marpaESLIFPerl_call_methodv(aTHX_ Perl_valueInterfacep, "setSymbolName", svlocalp, MarpaX_ESLIF_Valuep->setSymbolNameSvp);
}
symboli = MarpaX_ESLIF_Valuep->symboli;
svlocalp = MarpaX_ESLIF_Valuep->constantsp->MarpaX__ESLIF__Context__symbolNumber_svp;
save_item(svlocalp); /* We control this variable - no magic involved */
sv_setiv(svlocalp, symboli);
if (MarpaX_ESLIF_Valuep->canSetSymbolNumberb) {
marpaESLIFPerl_call_methodv(aTHX_ Perl_valueInterfacep, "setSymbolNumber", svlocalp, MarpaX_ESLIF_Valuep->setSymbolNumberSvp);
}
rules = MarpaX_ESLIF_Valuep->rules;
svlocalp = MarpaX_ESLIF_Valuep->constantsp->MarpaX__ESLIF__Context__ruleName_svp;
save_item(svlocalp); /* We control this variable - no magic involved */
if (rules != NULL) {
sv_setpvn(svlocalp, rules, strlen(rules));
} else {
sv_setsv(svlocalp, &PL_sv_undef);
}
if (MarpaX_ESLIF_Valuep->canSetRuleNameb) {
marpaESLIFPerl_call_methodv(aTHX_ Perl_valueInterfacep, "setRuleName", svlocalp, MarpaX_ESLIF_Valuep->setRuleNameSvp);
}
rulei = MarpaX_ESLIF_Valuep->rulei;
svlocalp = MarpaX_ESLIF_Valuep->constantsp->MarpaX__ESLIF__Context__ruleNumber_svp;
save_item(svlocalp); /* We control this variable - no magic involved */
sv_setiv(svlocalp, rulei);
if (MarpaX_ESLIF_Valuep->canSetRuleNumberb) {
marpaESLIFPerl_call_methodv(aTHX_ Perl_valueInterfacep, "setRuleNumber", svlocalp, MarpaX_ESLIF_Valuep->setRuleNumberSvp);
}
svlocalp = MarpaX_ESLIF_Valuep->constantsp->MarpaX__ESLIF__Context__grammar_svp;
save_item(svlocalp); /* We control this variable - no magic involved */
sv_setsv(svlocalp, Perl_MarpaX_ESLIF_Grammarp);
if (MarpaX_ESLIF_Valuep->canSetGrammarb) {
marpaESLIFPerl_call_methodv(aTHX_ Perl_valueInterfacep, "setGrammar", svlocalp, MarpaX_ESLIF_Valuep->setGrammarSvp);
}
}
PUSHMARK(SP);
if (interfacep != NULL) {
EXTEND(SP, 1 + avsizel);
PUSHs(sv_2mortal(newSVsv(interfacep)));
for (aviteratorl = 0; aviteratorl < avsizel; aviteratorl++) {
SV **svpp = av_fetch(avp, aviteratorl, 0); /* We manage ourself the avp, SV's are real */
if (UNLIKELY(svpp == NULL)) {
MARPAESLIFPERL_CROAKF("av_fetch returned NULL during arguments preparation for method %s", (methods != NULL) ? methods : "undef");
}
PUSHs(sv_2mortal(newSVsv(*svpp)));
}
} else {
if (avsizel > 0) {
EXTEND(SP, avsizel);
for (aviteratorl = 0; aviteratorl < avsizel; aviteratorl++) {
SV **svpp = av_fetch(avp, aviteratorl, 0); /* We manage ourself the avp, SV's are real */
if (UNLIKELY(svpp == NULL)) {
MARPAESLIFPERL_CROAKF("av_fetch returned NULL during arguments preparation for method %s", (methods != NULL) ? methods : "undef");
}
PUSHs(sv_2mortal(newSVsv(*svpp)));
}
}
}
PUTBACK;
if (subSvp) {
call_sv(subSvp, flags);
} else if (interfacep != NULL) {
call_method(methods, flags);
} else {
call_pv(methods, flags);
}
if (evalb && (! evalSilentb)) {
/* Check the eval */
err_tmp = ERRSV;
if (SvTRUE(err_tmp)) {
warn("%s\n", SvPV_nolen(err_tmp));
}
}
SPAGAIN;
rcp = POPs;
MARPAESLIFPERL_REFCNT_INC(rcp);
PUTBACK;
FREETMPS;
LEAVE;
return rcp;
}
/*****************************************************************************/
PERL_STATIC_INLINE SV *marpaESLIFPerl_recognizerCallbackActionp(pTHX_ MarpaX_ESLIF_Recognizer_t *MarpaX_ESLIF_Recognizerp, marpaESLIFRecognizer_t *marpaESLIFRecognizerp, AV *avp)
/*****************************************************************************/
{
SV *svp;
marpaESLIFPerl_setRecognizerEngineForCallbackv(aTHX_ MarpaX_ESLIF_Recognizerp, marpaESLIFRecognizerp);
svp = marpaESLIFPerl_call_methodp(aTHX_ MarpaX_ESLIF_Recognizerp->Perl_recognizerInterfacep,
MarpaX_ESLIF_Recognizerp->actions,
avp,
MarpaX_ESLIF_Recognizerp->resolvedActionSvp);
marpaESLIFPerl_restoreRecognizerEngineForCallbackv(aTHX_ MarpaX_ESLIF_Recognizerp);
/* In any case we relax the eventual MarpaX_ESLIF_Recognizerp->resolvedActionSvp ref count */
MARPAESLIFPERL_REFCNT_DEC(MarpaX_ESLIF_Recognizerp->resolvedActionSvp);
MarpaX_ESLIF_Recognizerp->resolvedActionSvp = NULL;
return svp;
}
/*****************************************************************************/
PERL_STATIC_INLINE SV *marpaESLIFPerl_valueCallbackActionp(pTHX_ MarpaX_ESLIF_Value_t *MarpaX_ESLIF_Valuep, AV *avp)
/*****************************************************************************/
{
SV *svp;
svp = marpaESLIFPerl_call_actionp(aTHX_ MarpaX_ESLIF_Valuep->Perl_valueInterfacep,
MarpaX_ESLIF_Valuep->actions,
avp,
MarpaX_ESLIF_Valuep,
0, /* evalb */
0, /* evalSilentb */
MarpaX_ESLIF_Valuep->resolvedActionSvp);
/* In any case we relax the eventual MarpaX_ESLIF_Recognizerp->resolvedActionSvp ref count */
MARPAESLIFPERL_REFCNT_DEC(MarpaX_ESLIF_Valuep->resolvedActionSvp);
MarpaX_ESLIF_Valuep->resolvedActionSvp = NULL;
return svp;
}
/*****************************************************************************/
PERL_STATIC_INLINE IV marpaESLIFPerl_call_methodi(pTHX_ SV *interfacep, const char *methods, SV *subSvp)
/*****************************************************************************/
{
IV rci;
dSP;
ENTER;
SAVETMPS;
PUSHMARK(SP);
EXTEND(SP, 1);
PUSHs(sv_2mortal(newSVsv(interfacep)));
PUTBACK;
if (subSvp != NULL) {
call_sv(subSvp, G_SCALAR);
} else {
call_method(methods, G_SCALAR);
}
SPAGAIN;
rci = POPi;
PUTBACK;
FREETMPS;
LEAVE;
return rci;
}
/*****************************************************************************/
PERL_STATIC_INLINE short marpaESLIFPerl_call_methodb(pTHX_ SV *interfacep, const char *methods, SV *subSvp)
/*****************************************************************************/
{
short rcb;
dSP;
ENTER;
SAVETMPS;
PUSHMARK(SP);
EXTEND(SP, 1);
PUSHs(sv_2mortal(newSVsv(interfacep)));
PUTBACK;
if (subSvp != NULL) {
call_sv(subSvp, G_SCALAR);
} else {
call_method(methods, G_SCALAR);
}
SPAGAIN;
rcb = (POPi != 0);
PUTBACK;
FREETMPS;
LEAVE;
return rcb;
}
/*****************************************************************************/
PERL_STATIC_INLINE void marpaESLIFPerl_genericLoggerCallbackv(void *userDatavp, genericLoggerLevel_t logLeveli, const char *msgs)
/*****************************************************************************/
{
MarpaX_ESLIF_t *MarpaX_ESLIFp = (MarpaX_ESLIF_t *) userDatavp;
SV *Perl_loggerInterfacep = MarpaX_ESLIFp->Perl_loggerInterfacep;
char *method;
dTHXa(MarpaX_ESLIFp->PerlInterpreterp); /* dNOOP if no PERL_IMPLICIT_CONTEXT */
switch (logLeveli) {
case GENERICLOGGER_LOGLEVEL_TRACE: method = "trace"; break;
case GENERICLOGGER_LOGLEVEL_DEBUG: method = "debug"; break;
case GENERICLOGGER_LOGLEVEL_INFO: method = "info"; break;
case GENERICLOGGER_LOGLEVEL_NOTICE: method = "notice"; break;
case GENERICLOGGER_LOGLEVEL_WARNING: method = "warning"; break;
case GENERICLOGGER_LOGLEVEL_ERROR: method = "error"; break;
case GENERICLOGGER_LOGLEVEL_CRITICAL: method = "critical"; break;
case GENERICLOGGER_LOGLEVEL_ALERT: method = "alert"; break;
case GENERICLOGGER_LOGLEVEL_EMERGENCY: method = "emergency"; break;
default: method = NULL; break;
}
if (method != NULL) {
/* It should never happen that method is NULL -; */
/* In addition ESLIF rarelly logs, propagating envp in the context */
/* is an optimization that is almost useless */
dSP;
ENTER;
SAVETMPS;
PUSHMARK(SP);
EXTEND(SP, 2);
PUSHs(sv_2mortal(newSVsv(Perl_loggerInterfacep)));
/* We always log only with ASCII characters */
PUSHs(sv_2mortal(newSVpv(msgs,0)));
PUTBACK;
call_method(method, G_DISCARD);
FREETMPS;
LEAVE;
}
}
/*****************************************************************************/
PERL_STATIC_INLINE void marpaESLIFPerl_readerCallbackDisposev(void *userDatavp, char *inputcp, size_t inputl, short eofb, short characterStreamb, char *encodings, size_t encodingl)
/*****************************************************************************/
{
static const char *funcs = "marpaESLIFPerl_readerCallbackDisposev";
MarpaX_ESLIF_Recognizer_t *MarpaX_ESLIF_Recognizerp = (MarpaX_ESLIF_Recognizer_t *) userDatavp;
SV *Perl_recognizerInterfacep = MarpaX_ESLIF_Recognizerp->Perl_recognizerInterfacep;
dTHXa(MarpaX_ESLIF_Recognizerp->PerlInterpreterp);
if (MarpaX_ESLIF_Recognizerp != NULL) {
MARPAESLIFPERL_REFCNT_DEC(MarpaX_ESLIF_Recognizerp->Perl_datap);
MarpaX_ESLIF_Recognizerp->Perl_datap = NULL;
MARPAESLIFPERL_REFCNT_DEC(MarpaX_ESLIF_Recognizerp->Perl_encodingp);
MarpaX_ESLIF_Recognizerp->Perl_encodingp = NULL;
}
}