share-keyword/include/XSParseKeyword.h

filter: Statementstmt 80.0% 16 / 20 Branchbran 50.0% 5 / 10 Conditioncond n/a MC/DCmcdc n/a Subroutinesub n/a Podpod n/a totaltotal 70.0% 21 / 30 CC 0 SCAR 0
CC
0
Cov
0%
CRAP 0
« src/infix.c ↑ Summary hax/force_list_keeping_pushmark.c.inc »
1 #ifndef __XS_PARSE_KEYWORD_H__
2 #define __XS_PARSE_KEYWORD_H__
3  
4 #define XSPARSEKEYWORD_ABI_VERSION 2
5  
6 struct XSParseKeywordPieceType;
7 struct XSParseKeywordPieceType {
8 int type;
9 union {
10 char c; /* LITERALCHAR */
11 const char *str; /* LITERALSTR */
12 const struct XSParseKeywordPieceType *pieces; /* containers */
13 void (*callback)(pTHX_ void *hookdata); /* SETUP, ANONSUB PREPARE+START */
14  
15 OP *(*op_wrap_callback)(pTHX_ OP *o, void *hookdata);
16 } u;
17 };
18  
19 enum {
20 XPK_FLAG_EXPR = (1<<0),
21 XPK_FLAG_STMT = (1<<1),
22 XPK_FLAG_AUTOSEMI = (1<<2),
23 XPK_FLAG_BLOCKSCOPE = (1<<3),
24 XPK_FLAG_PERMIT_LEXICAL = (1<<4),
25 };
26  
27 enum {
28 /* skip zero */
29  
30 /* emits */
31 XS_PARSE_KEYWORD_LITERALCHAR = 1, /* nothing */
32 XS_PARSE_KEYWORD_LITERALSTR, /* nothing */
33 XS_PARSE_KEYWORD_AUTOSEMI, /* nothing */
34 XS_PARSE_KEYWORD_WARNING = 0x0e, /* nothing */
35 XS_PARSE_KEYWORD_FAILURE, /* nothing */
36  
37 XS_PARSE_KEYWORD_BLOCK = 0x10, /* op */
38 XS_PARSE_KEYWORD_ANONSUB, /* cv */
39 XS_PARSE_KEYWORD_ARITHEXPR, /* op */
40 XS_PARSE_KEYWORD_TERMEXPR, /* op */
41 XS_PARSE_KEYWORD_LISTEXPR, /* op */
42 /* TODO: XS_PARSE_KEYWORD_FULLEXPR = 0x15 */
43 XS_PARSE_KEYWORD_IDENT = 0x16, /* sv */
44 XS_PARSE_KEYWORD_PACKAGENAME, /* sv */
45 XS_PARSE_KEYWORD_LEXVARNAME, /* sv */
46 XS_PARSE_KEYWORD_LEXVAR, /* padix */
47 XS_PARSE_KEYWORD_ATTRS, /* i / {attr.name + attr.val} */
48 XS_PARSE_KEYWORD_VSTRING, /* sv */
49  
50 XS_PARSE_KEYWORD_INFIX = 0x40, /* infix */
51  
52 XS_PARSE_KEYWORD_INTRO_MY = 0x60, /* emits nothing */
53  
54 XS_PARSE_KEYWORD_SETUP = 0x70, /* invokes callback, emits nothing */
55  
56 XS_PARSE_KEYWORD_ANONSUB_PREPARE, /* invokes callback, emits nothing */
57 XS_PARSE_KEYWORD_ANONSUB_START, /* invokes callback, emits nothing */
58 XS_PARSE_KEYWORD_ANONSUB_END, /* invokes op_wrap_callback, emits nothing */
59 XS_PARSE_KEYWORD_ANONSUB_WRAP, /* invokes op_wrap_callback, emits nothing */
60  
61 XS_PARSE_KEYWORD_SEQUENCE = 0x80, /* contained */
62 XS_PARSE_KEYWORD_REPEATED, /* i, contained */
63 XS_PARSE_KEYWORD_CHOICE, /* i, contained */
64 XS_PARSE_KEYWORD_TAGGEDCHOICE, /* i, contained */
65 XS_PARSE_KEYWORD_SEPARATEDLIST, /* i, contained */
66 XS_PARSE_KEYWORD_PARENS = 0xb0, /* contained */
67 XS_PARSE_KEYWORD_BRACKETS, /* contained */
68 XS_PARSE_KEYWORD_BRACES, /* contained */
69 XS_PARSE_KEYWORD_CHEVRONS, /* contained */
70 };
71  
72 enum {
73 XPK_LEXVAR_SCALAR = (1<<0),
74 XPK_LEXVAR_ARRAY = (1<<1),
75 XPK_LEXVAR_HASH = (1<<2),
76 XPK_LEXVAR_ANY = XPK_LEXVAR_SCALAR|XPK_LEXVAR_ARRAY|XPK_LEXVAR_HASH,
77 };
78  
79 enum {
80 XPK_TYPEFLAG_OPT = (1<<16),
81 XPK_TYPEFLAG_SPECIAL = (1<<17), /* on XPK_LITERALSTR: keyword
82 on XPK_BLOCK: scoped
83 on XPK_LEXVAR: my */
84  
85 /* These three are shifted versions of perl's G_VOID, G_SCALAR, G_LIST */
86 XPK_TYPEFLAG_G_VOID = (1<<18),
87 XPK_TYPEFLAG_G_SCALAR = (2<<18),
88 XPK_TYPEFLAG_G_LIST = (3<<18),
89  
90 XPK_TYPEFLAG_ENTERLEAVE = (1<<20), /* wrap ENTER/LEAVE pair around the item */
91  
92 XPK_TYPEFLAG_MAYBEPARENS = (1<<21), /* parens themselves are optional on PARENS */
93 };
94  
95 #define XPK_PREFIXED(typecode,...) \
96 {.type = typecode, .u.pieces = (const struct XSParseKeywordPieceType []){ __VA_ARGS__, {0} }}
97  
98 #define XPK_BLOCK_flags(flags) {.type = XS_PARSE_KEYWORD_BLOCK|(flags), .u.pieces = NULL}
99 #define XPK_BLOCK XPK_BLOCK_flags(0)
100 #define XPK_BLOCK_VOIDCTX XPK_BLOCK_flags(XPK_TYPEFLAG_SPECIAL|XPK_TYPEFLAG_G_VOID)
101 #define XPK_BLOCK_SCALARCTX XPK_BLOCK_flags(XPK_TYPEFLAG_SPECIAL|XPK_TYPEFLAG_G_SCALAR)
102 #define XPK_BLOCK_LISTCTX XPK_BLOCK_flags(XPK_TYPEFLAG_SPECIAL|XPK_TYPEFLAG_G_LIST)
103  
104 #define XPK_PREFIXED_BLOCK(...) XPK_PREFIXED(XS_PARSE_KEYWORD_BLOCK, __VA_ARGS__)
105 #define XPK_PREFIXED_BLOCK_ENTERLEAVE(...) XPK_PREFIXED(XS_PARSE_KEYWORD_BLOCK|XPK_TYPEFLAG_ENTERLEAVE, __VA_ARGS__)
106  
107 #define XPK_SETUP(setup) {.type = XS_PARSE_KEYWORD_SETUP, .u.callback = setup}
108  
109 #define XPK_ANONSUB {.type = XS_PARSE_KEYWORD_ANONSUB}
110  
111 #define XPK_ANONSUB_PREPARE(func) {.type = XS_PARSE_KEYWORD_ANONSUB_PREPARE, .u.callback = func}
112 #define XPK_ANONSUB_START(func) {.type = XS_PARSE_KEYWORD_ANONSUB_START, .u.callback = func}
113 #define XPK_ANONSUB_END(func) {.type = XS_PARSE_KEYWORD_ANONSUB_END, .u.op_wrap_callback = func}
114 #define XPK_ANONSUB_WRAP(func) {.type = XS_PARSE_KEYWORD_ANONSUB_WRAP, .u.op_wrap_callback = func}
115  
116 #define XPK_STAGED_ANONSUB(...) \
117 {.type = XS_PARSE_KEYWORD_ANONSUB, .u.pieces = (const struct XSParseKeywordPieceType []){ __VA_ARGS__, {0} }}
118  
119 #define XPK_ARITHEXPR_flags(flags) {.type = XS_PARSE_KEYWORD_ARITHEXPR|(flags)}
120 #define XPK_ARITHEXPR XPK_ARITHEXPR_flags(0)
121 #define XPK_ARITHEXPR_VOIDCTX XPK_ARITHEXPR_flags(XPK_TYPEFLAG_G_VOID)
122 #define XPK_ARITHEXPR_SCALARCTX XPK_ARITHEXPR_flags(XPK_TYPEFLAG_G_SCALAR)
123 #define XPK_ARITHEXPR_OPT XPK_ARITHEXPR_flags(XPK_TYPEFLAG_OPT)
124 #define XPK_ARITHEXPR_VOIDCTX_OPT XPK_ARITHEXPR_flags(XPK_TYPEFLAG_G_VOID|XPK_TYPEFLAG_OPT)
125 #define XPK_ARITHEXPR_SCALARCTX_OPT XPK_ARITHEXPR_flags(XPK_TYPEFLAG_G_SCALAR|XPK_TYPEFLAG_OPT)
126  
127 #define XPK_TERMEXPR_flags(flags) {.type = XS_PARSE_KEYWORD_TERMEXPR|(flags)}
128 #define XPK_TERMEXPR XPK_TERMEXPR_flags(0)
129 #define XPK_TERMEXPR_VOIDCTX XPK_TERMEXPR_flags(XPK_TYPEFLAG_G_VOID)
130 #define XPK_TERMEXPR_SCALARCTX XPK_TERMEXPR_flags(XPK_TYPEFLAG_G_SCALAR)
131 #define XPK_TERMEXPR_OPT XPK_TERMEXPR_flags(XPK_TYPEFLAG_OPT)
132 #define XPK_TERMEXPR_VOIDCTX_OPT XPK_TERMEXPR_flags(XPK_TYPEFLAG_G_VOID|XPK_TYPEFLAG_OPT)
133 #define XPK_TERMEXPR_SCALARCTX_OPT XPK_TERMEXPR_flags(XPK_TYPEFLAG_G_SCALAR|XPK_TYPEFLAG_OPT)
134  
135 #define XPK_PREFIXED_TERMEXPR_ENTERLEAVE(...) XPK_PREFIXED(XS_PARSE_KEYWORD_TERMEXPR|XPK_TYPEFLAG_ENTERLEAVE, __VA_ARGS__)
136  
137 #define XPK_LISTEXPR_flags(flags) {.type = XS_PARSE_KEYWORD_LISTEXPR|(flags)}
138 #define XPK_LISTEXPR XPK_LISTEXPR_flags(0)
139 #define XPK_LISTEXPR_LISTCTX XPK_LISTEXPR_flags(XPK_TYPEFLAG_G_LIST)
140 #define XPK_LISTEXPR_OPT XPK_LISTEXPR_flags(XPK_TYPEFLAG_OPT)
141 #define XPK_LISTEXPR_LISTCTX_OPT XPK_LISTEXPR_flags(XPK_TYPEFLAG_G_LIST|XPK_TYPEFLAG_OPT)
142  
143 #define XPK_PREFIXED_LISTEXPR_ENTERLEAVE(...) XPK_PREFIXED(XS_PARSE_KEYWORD_LISTEXPR|XPK_TYPEFLAG_ENTERLEAVE, __VA_ARGS__)
144  
145 #define XPK_IDENT {.type = XS_PARSE_KEYWORD_IDENT }
146 #define XPK_IDENT_OPT {.type = XS_PARSE_KEYWORD_IDENT |XPK_TYPEFLAG_OPT}
147 #define XPK_PACKAGENAME {.type = XS_PARSE_KEYWORD_PACKAGENAME }
148 #define XPK_PACKAGENAME_OPT {.type = XS_PARSE_KEYWORD_PACKAGENAME|XPK_TYPEFLAG_OPT}
149  
150 #define XPK_LEXVARNAME(kind) {.type = XS_PARSE_KEYWORD_LEXVARNAME, .u.c = kind}
151  
152 #define XPK_LEXVAR(kind) {.type = XS_PARSE_KEYWORD_LEXVAR, .u.c = kind}
153 #define XPK_LEXVAR_MY(kind) {.type = XS_PARSE_KEYWORD_LEXVAR|XPK_TYPEFLAG_SPECIAL, .u.c = kind}
154  
155 #define XPK_ATTRIBUTES {.type = XS_PARSE_KEYWORD_ATTRS}
156  
157 #define XPK_VSTRING {.type = XS_PARSE_KEYWORD_VSTRING}
158 #define XPK_VSTRING_OPT {.type = XS_PARSE_KEYWORD_VSTRING|XPK_TYPEFLAG_OPT}
159  
160 #define XPK_COMMA {.type = XS_PARSE_KEYWORD_LITERALCHAR, .u.c = ','}
161 #define XPK_COLON {.type = XS_PARSE_KEYWORD_LITERALCHAR, .u.c = ':'}
162 #define XPK_EQUALS {.type = XS_PARSE_KEYWORD_LITERALCHAR, .u.c = '='}
163  
164 #define XPK_LITERAL(s) {.type = XS_PARSE_KEYWORD_LITERALSTR, .u.str = (const char *)s}
165 #define XPK_STRING(s) XPK_LITERAL(s)
166 #define XPK_AUTOSEMI {.type = XS_PARSE_KEYWORD_AUTOSEMI}
167 #define XPK_KEYWORD(s) {.type = XS_PARSE_KEYWORD_LITERALSTR|XPK_TYPEFLAG_SPECIAL, .u.str = (const char *)s}
168  
169 #define XPK_INFIX(select) {.type = XS_PARSE_KEYWORD_INFIX, .u.c = select}
170 #define XPK_INFIX_RELATION XPK_INFIX(XPI_SELECT_RELATION)
171 #define XPK_INFIX_EQUALITY XPK_INFIX(XPI_SELECT_EQUALITY)
172 #define XPK_INFIX_MATCH_NOSMART XPK_INFIX(XPI_SELECT_MATCH_NOSMART)
173 #define XPK_INFIX_MATCH_SMART XPK_INFIX(XPI_SELECT_MATCH_SMART)
174  
175 #define XPK_INTRO_MY {.type = XS_PARSE_KEYWORD_INTRO_MY}
176  
177 #define XPK_SEQUENCE_pieces(p) {.type = XS_PARSE_KEYWORD_SEQUENCE, .u.pieces = p}
178 #define XPK_SEQUENCE(...) XPK_SEQUENCE_pieces(((const struct XSParseKeywordPieceType []){ __VA_ARGS__, {0} }))
179  
180 /* First piece of these must be something probe-able */
181 #define XPK_OPTIONAL_pieces(p) {.type = XS_PARSE_KEYWORD_SEQUENCE|XPK_TYPEFLAG_OPT, .u.pieces = p}
182 #define XPK_OPTIONAL(...) XPK_OPTIONAL_pieces(((const struct XSParseKeywordPieceType []){ __VA_ARGS__, {0} }))
183  
184 #define XPK_REPEATED_pieces(p) {.type = XS_PARSE_KEYWORD_REPEATED, .u.pieces = p}
185 #define XPK_REPEATED(...) XPK_REPEATED_pieces(((const struct XSParseKeywordPieceType []){ __VA_ARGS__, {0} }))
186  
187 /* Every piece must be probeable */
188 #define XPK_CHOICE_pieces(p) {.type = XS_PARSE_KEYWORD_CHOICE, .u.pieces = p}
189 #define XPK_CHOICE(...) XPK_CHOICE_pieces(((const struct XSParseKeywordPieceType []){ __VA_ARGS__, {0} }))
190  
191 /* Every piece must be probeable, and followed by XPK_TAG */
192 #define XPK_TAGGEDCHOICE_pieces(p) {.type = XS_PARSE_KEYWORD_TAGGEDCHOICE, .u.pieces = p}
193 #define XPK_TAGGEDCHOICE(...) XPK_TAGGEDCHOICE_pieces(((const struct XSParseKeywordPieceType []){ __VA_ARGS__, {0}, {0} }))
194 #define XPK_TAG(val) {.type = val}
195  
196 #define XPK_COMMALIST(...) \
197 {.type = XS_PARSE_KEYWORD_SEPARATEDLIST, .u.pieces = (const struct XSParseKeywordPieceType []){ \
198 {.type = XS_PARSE_KEYWORD_LITERALCHAR, .u.c = ','}, __VA_ARGS__, {0}}}
199  
200 #define XPK_WARNING_bit(bit,s) {.type = (XS_PARSE_KEYWORD_WARNING|(bit << 24)), .u.str = (const char *)s}
201 #define XPK_WARNING(s) XPK_WARNING_bit(0,s)
202 #define XPK_WARNING_AMBIGUOUS(s) XPK_WARNING_bit(WARN_AMBIGUOUS, s)
203 #define XPK_WARNING_DEPRECATED(s) XPK_WARNING_bit(WARN_DEPRECATED, s)
204 #define XPK_WARNING_EXPERIMENTAL(s) XPK_WARNING_bit(WARN_EXPERIMENTAL,s)
205 #define XPK_WARNING_PRECEDENCE(s) XPK_WARNING_bit(WARN_PRECEDENCE, s)
206 #define XPK_WARNING_SYNTAX(s) XPK_WARNING_bit(WARN_SYNTAX, s)
207  
208 #define XPK_FAILURE(s) {.type = XS_PARSE_KEYWORD_FAILURE, .u.str = (const char *)s}
209  
210 #define XPK_PARENS_pieces(p) {.type = XS_PARSE_KEYWORD_PARENS, .u.pieces = p}
211 #define XPK_PARENS(...) XPK_PARENS_pieces(((const struct XSParseKeywordPieceType []){ __VA_ARGS__, {0} }))
212 #define XPK_PARENS_OPT(...) \
213 {.type = XS_PARSE_KEYWORD_PARENS|XPK_TYPEFLAG_OPT, .u.pieces = (const struct XSParseKeywordPieceType []){ __VA_ARGS__, {0} }}
214  
215 #define XPK_ARGS_pieces(p) {.type = XS_PARSE_KEYWORD_PARENS|XPK_TYPEFLAG_MAYBEPARENS, .u.pieces = p}
216 #define XPK_ARGS(...) XPK_ARGS_pieces(((const struct XSParseKeywordPieceType []){ __VA_ARGS__, {0} }))
217  
218 #define XPK_BRACKETS_pieces(p) {.type = XS_PARSE_KEYWORD_BRACKETS, .u.pieces = p}
219 #define XPK_BRACKETS(...) XPK_BRACKETS_pieces(((const struct XSParseKeywordPieceType []){ __VA_ARGS__, {0} }))
220 #define XPK_BRACKETS_OPT(...) \
221 {.type = XS_PARSE_KEYWORD_BRACKETS|XPK_TYPEFLAG_OPT, .u.pieces = (const struct XSParseKeywordPieceType []){ __VA_ARGS__, {0} }}
222  
223 #define XPK_BRACES_pieces(p) {.type = XS_PARSE_KEYWORD_BRACES, .u.pieces = p}
224 #define XPK_BRACES(...) XPK_BRACES_pieces(((const struct XSParseKeywordPieceType []){ __VA_ARGS__, {0} }))
225 #define XPK_BRACES_OPT(...) \
226 {.type = XS_PARSE_KEYWORD_BRACES|XPK_TYPEFLAG_OPT, .u.pieces = (const struct XSParseKeywordPieceType []){ __VA_ARGS__, {0} }}
227  
228 #define XPK_CHEVRONS_pieces(p) {.type = XS_PARSE_KEYWORD_CHEVRONS, .u.pieces = p}
229 #define XPK_CHEVRONS(...) XPK_CHEVRONS_pieces(((const struct XSParseKeywordPieceType []){ __VA_ARGS__, {0} }))
230 #define XPK_CHEVRONS_OPT(...) \
231 {.type = XS_PARSE_KEYWORD_CHEVRONS|XPK_TYPEFLAG_OPT, .u.pieces = (const struct XSParseKeywordPieceType []){ __VA_ARGS__, {0} }}
232  
233 /* back-compat for older names */
234 #define XPK_PARENSCOPE_pieces XPK_PARENS_pieces
235 #define XPK_PARENSCOPE XPK_PARENS
236 #define XPK_PARENSCOPE_OPT XPK_PARENS_OPT
237 #define XPK_ARGSCOPE_pieces XPK_ARGS_pieces
238 #define XPK_ARGSCOPE XPK_ARGS
239 #define XPK_BRACKETSCOPE_pieces XPK_BRACKETS_pieces
240 #define XPK_BRACKETSCOPE XPK_BRACKETS
241 #define XPK_BRACKETSCOPE_OPT XPK_BRACKETS_OPT
242 #define XPK_BRACESCOPE_pieces XPK_BRACES_pieces
243 #define XPK_BRACESCOPE XPK_BRACES
244 #define XPK_BRACESCOPE_OPT XPK_BRACES_OPT
245 #define XPK_CHEVRONSCOPE_pieces XPK_CHEVRONS_pieces
246 #define XPK_CHEVRONSCOPE XPK_CHEVRONS
247 #define XPK_CHEVRONSCOPE_OPT XPK_CHEVRONS_OPT
248  
249 /* This type defined in XSParseInfix.h */
250 typedef struct XSParseInfixInfo XSParseInfixInfo;
251  
252 typedef struct {
253 union {
254 OP *op;
255 CV *cv;
256 SV *sv;
257 int i;
258 struct { SV *name; SV *value; } attr;
259 PADOFFSET padix;
260 XSParseInfixInfo *infix;
261 };
262 int line;
263 } XSParseKeywordPiece;
264  
265 struct XSParseKeywordHooks {
266 U32 flags;
267  
268 /* used by build1 */
269 struct XSParseKeywordPieceType piece1;
270 /* alternatively, used by build */
271 const struct XSParseKeywordPieceType *pieces;
272  
273 /* These two hooks are ANDed together; both must pass, if present */
274 const char *permit_hintkey;
275 bool (*permit) (pTHX_ void *hookdata);
276  
277 void (*check)(pTHX_ void *hookdata);
278  
279 /* These are alternatives; the first one defined is used */
280 int (*parse)(pTHX_ OP **opp, void *hookdata);
281 int (*build)(pTHX_ OP **out, XSParseKeywordPiece *args[], size_t nargs, void *hookdata);
282 int (*build1)(pTHX_ OP **out, XSParseKeywordPiece *arg0, void *hookdata);
283 };
284  
285 static void (*register_xs_parse_keyword_func)(pTHX_ const char *kwname, const struct XSParseKeywordHooks *hooks, void *hookdata);
286 #define register_xs_parse_keyword(kwname, hooks, hookdata) S_register_xs_parse_keyword(aTHX_ kwname, hooks, hookdata)
287 22 static void S_register_xs_parse_keyword(pTHX_ const char *kwname, const struct XSParseKeywordHooks *hooks, void *hookdata)
288 {
289 22 ▶ if(!register_xs_parse_keyword_func)
Branch: 1 branch
BranchTrueFalseTotal
if(!register_xs_parse_keyword_func) 0 22 22
290 0 croak("Must call boot_xs_parse_keyword() first");
291  
292 22 (*register_xs_parse_keyword_func)(aTHX_ kwname, hooks, hookdata);
293 22 }
294  
295 #define boot_xs_parse_keyword(ver) S_boot_xs_parse_keyword(aTHX_ ver)
296 2 static void S_boot_xs_parse_keyword(pTHX_ double ver) {
297 SV **svp;
298 2 ▶ SV *versv = ver ? newSVnv(ver) : NULL;
Branch: 1 branch
BranchTrueFalseTotal
SV *versv = ver ? newSVnv(ver) : NULL; 0 2 2
299  
300 2 load_module(PERL_LOADMOD_NOIMPORT, newSVpvs("XS::Parse::Keyword"), versv, NULL);
301  
302 2 svp = hv_fetchs(PL_modglobal, "XS::Parse::Keyword/ABIVERSION_MIN", 0);
303 2 ▶ if(!svp)
Branch: 1 branch
BranchTrueFalseTotal
if(!svp) 0 2 2
304 0 croak("XS::Parse::Keyword ABI minimum version missing");
305 2 int abi_ver = SvIV(*svp);
306 2 ▶ if(abi_ver > XSPARSEKEYWORD_ABI_VERSION)
Branch: 1 branch
BranchTrueFalseTotal
if(abi_ver > XSPARSEKEYWORD_ABI_VERSION) 0 2 2
307 0 croak("XS::Parse::Keyword ABI version mismatch - library supports >= %d, compiled for %d",
308 abi_ver, XSPARSEKEYWORD_ABI_VERSION);
309  
310 2 svp = hv_fetchs(PL_modglobal, "XS::Parse::Keyword/ABIVERSION_MAX", 0);
311 2 abi_ver = SvIV(*svp);
312 2 ▶ if(abi_ver < XSPARSEKEYWORD_ABI_VERSION)
Branch: 1 branch
BranchTrueFalseTotal
if(abi_ver < XSPARSEKEYWORD_ABI_VERSION) 0 2 2
313 0 croak("XS::Parse::Keyword ABI version mismatch - library supports <= %d, compiled for %d",
314 abi_ver, XSPARSEKEYWORD_ABI_VERSION);
315  
316 2 register_xs_parse_keyword_func = INT2PTR(void (*)(pTHX_ const char *, const struct XSParseKeywordHooks *, void *),
317 SvUV(*hv_fetchs(PL_modglobal, "XS::Parse::Keyword/register()@2", 0)));
318 2 }
319  
320 #endif
« src/infix.c ↑ Summary hax/force_list_keeping_pushmark.c.inc »