include/punk/punk_import.h

filter: Statementstmt 98.5% 129 / 133 (2 uncoverable) Branchbran 72.8% 73 / 114 (10 uncoverable) Conditioncond n/a MC/DCmcdc n/a Subroutinesub n/a Podpod n/a totaltotal 86.6% 202 / 247 (12 uncoverable) CC 0 SCAR 0
CC
0
Cov
0%
CRAP 0
« include/punk/punk_serve.h ↑ Summary xs/sse.xs »
1 /* punk_import.h - `use Punk` and the DSL it exports, in C.
2 *
3 * Every keyword is a magic CV carrying the application registrar it forwards
4 * to (the punk_closure pattern from punk_static.h, the same one Punk::Model's
5 * DSL uses), rather than a Perl closure over $app.
6 *
7 * This is a boot-time path - import runs once per application class - so the
8 * point is not speed. It is that the DSL surface is now described in one table
9 * instead of twenty-five near-identical closures, and that adding a keyword
10 * means adding a row.
11 *
12 * Include after punk_static.h (punk_closure, punk_clos_cap).
13 */
14  
15 #ifndef PUNK_IMPORT_H
16 #define PUNK_IMPORT_H
17  
18 /* How a keyword relates to the registrar method behind it. */
19 enum {
20 PKW_FWD = 0, /* $app->$method(@_) - most of them */
21 PKW_NOARG, /* $app->$method() - to_app ignores its class */
22 PKW_SELF, /* $app - punk_app */
23 PKW_ROUTE, /* $app->route($HTTP, @_, []) - get/post/... */
24 PKW_HELPER /* $app->helper(@_, $caller) - helpers know their owner */
25 };
26  
27 /* capture slots */
28 enum { PKI_APP = 0, PKI_KIND, PKI_NAME, PKI_CALLER };
29  
30 /* The one body behind every exported keyword. Which of the five shapes it
31 * takes is in the capture, so there is a single place where a DSL call becomes
32 * a registrar call. */
33 XS_INTERNAL(pki_kw_cb);
34 64242 XS_INTERNAL(pki_kw_cb) {
35 64242 dXSARGS;
36 64242 AV *cap = punk_clos_cap(aTHX_ cv);
37 SV *app, *name;
38 IV kind;
39 int i, count;
40 64242 I32 want = GIMME_V;
41  
42 /*
43 # uncoverable branch true
44 # uncoverable condition left count:1 class:ignore_covered_err */
45 64242 ▶ if (!cap) XSRETURN_EMPTY;
Branch: 1 branch
BranchTrueFalseTotal
if (!cap) XSRETURN_EMPTY; 0 64242 64242
46 64242 app = *av_fetch(cap, PKI_APP, 0);
47 64242 kind = SvIV(*av_fetch(cap, PKI_KIND, 0));
48 64242 name = *av_fetch(cap, PKI_NAME, 0);
49  
50 64242 ▶ if (kind == PKW_SELF) { /* punk_app: the registrar itself */
Branch: 1 branch
BranchTrueFalseTotal
if (kind == PKW_SELF) { /* punk_app: the registrar itself */ 312 63930 64242
51 312 ST(0) = sv_2mortal(newSVsv(app));
52 312 XSRETURN(1);
53 }
54  
55 63930 ▶ PUSHMARK(SP);
Branch: 1 branch
BranchTrueFalseTotal
PUSHMARK(SP); 0 63930 63930
56 63930 switch (kind) {
57 898 case PKW_NOARG:
58 898 ▶ EXTEND(SP, 1);
Branch: 1 branch
BranchTrueFalseTotal
EXTEND(SP, 1); 0 898 898
59 898 PUSHs(app);
60 898 break;
61  
62 61493 case PKW_ROUTE:
63 /* $app->route($METHOD, $path, $target, [], $opts?) - the empty
64 * guard list is what `under` fills in for a scoped route; the
65 * optional trailing hashref is the route options */
66 61493 ▶ if (items > 3)
Branch: 1 branch
BranchTrueFalseTotal
if (items > 3) 1 61492 61493
67 1 croak("Punk: a route takes a path, a target and at most "
68 "one options hashref");
69 61492 ▶ EXTEND(SP, 6);
Branch: 1 branch
BranchTrueFalseTotal
EXTEND(SP, 6); 0 61492 61492
70 61492 PUSHs(app);
71 61492 PUSHs(name);
72 61492 ▶ PUSHs(items > 0 ? ST(0) : &PL_sv_undef); /* # uncoverable condition right count:1 class:ignore_covered_err */
Branch: 1 branch
BranchTrueFalseTotal
PUSHs(items > 0 ? ST(0) : &PL_sv_undef); /* # uncoverable condition right count:1 class:ignore_covered_err */ 61492 0 61492
73 61492 ▶ PUSHs(items > 1 ? ST(1) : &PL_sv_undef); /* # uncoverable condition right count:1 class:ignore_covered_err */
Branch: 1 branch
BranchTrueFalseTotal
PUSHs(items > 1 ? ST(1) : &PL_sv_undef); /* # uncoverable condition right count:1 class:ignore_covered_err */ 61492 0 61492
74 61492 mPUSHs(newRV_noinc((SV *)newAV()));
75 61492 ▶ if (items > 2) PUSHs(ST(2));
Branch: 1 branch
BranchTrueFalseTotal
if (items > 2) PUSHs(ST(2)); 255 61237 61492
76 61492 break;
77  
78 6 case PKW_HELPER:
79 /* the owning class rides along so a collision can name both */
80 6 ▶ EXTEND(SP, items + 2);
Branch: 2 branches
BranchTrueFalseTotal
EXTEND(SP, items + 2); 6 0 6
EXTEND(SP, items + 2); 0 6 6
81 6 PUSHs(app);
82 18 ▶ for (i = 0; i < items; i++) PUSHs(ST(i));
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < items; i++) PUSHs(ST(i)); 12 6 18
83 6 PUSHs(*av_fetch(cap, PKI_CALLER, 0));
84 6 break;
85  
86 1533 default: /* PKW_FWD */
87 1533 ▶ EXTEND(SP, items + 1);
Branch: 2 branches
BranchTrueFalseTotal
EXTEND(SP, items + 1); 1533 0 1533
EXTEND(SP, items + 1); 0 1533 1533
88 1533 PUSHs(app);
89 5047 ▶ for (i = 0; i < items; i++) PUSHs(ST(i));
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < items; i++) PUSHs(ST(i)); 3514 1533 5047
90 1533 break;
91 }
92 63929 PUTBACK;
93  
94 /* the caller's context is propagated: `my $s = under ...` wants the scope
95 * object, and a chaining keyword wants its $self back */
96 66360 ▶ count = call_method(kind == PKW_ROUTE ? "route"
Branch: 2 branches
BranchTrueFalseTotal
count = call_method(kind == PKW_ROUTE ? "route" 2437 61492 63929
count = call_method(kind == PKW_ROUTE ? "route" 2431 6 2437
97 : kind == PKW_HELPER ? "helper"
98 : SvPV_nolen(name),
99 want == G_VOID ? G_VOID : want);
100 63456 SPAGAIN;
101 63456 ▶ if (want == G_VOID) XSRETURN_EMPTY;
Branch: 1 branch
BranchTrueFalseTotal
if (want == G_VOID) XSRETURN_EMPTY; 62654 802 63456
102  
103 /* The results sit above the arguments we were called with, but XSRETURN
104 * returns the slots at ax - so they have to be copied down. Into mortals
105 * first, and through a scratch vector, because the two regions can overlap
106 * and a direct move would clobber a value not yet read. */
107 /*
108 # uncoverable branch false
109 # uncoverable condition right count:1 class:ignore_covered_err */
110 802 ▶ if (count > 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (count > 0) { 802 0 802
111 SV **tmp;
112 int j;
113 802 Newx(tmp, count, SV *);
114 1604 ▶ for (j = 0; j < count; j++) tmp[j] = sv_2mortal(newSVsv(SP[j - count + 1]));
Branch: 1 branch
BranchTrueFalseTotal
for (j = 0; j < count; j++) tmp[j] = sv_2mortal(newSVsv(SP[j - count + 1])); 802 802 1604
115 1604 ▶ for (j = 0; j < count; j++) ST(j) = tmp[j];
Branch: 1 branch
BranchTrueFalseTotal
for (j = 0; j < count; j++) ST(j) = tmp[j]; 802 802 1604
116 802 Safefree(tmp);
117 }
118 802 XSRETURN(count);
119 }
120  
121 /* The DSL, as a table. A keyword is a row: its name, the registrar method it
122 * reaches, and which of the five shapes it takes. */
123 typedef struct pki_kw {
124 const char *kw; /* what the application writes */
125 const char *method; /* the Punk::App method behind it (or the HTTP verb) */
126 int kind;
127 } pki_kw;
128  
129 static const pki_kw PKI_KEYWORDS[] = {
130 /* the verbs: one route each, with the method they mean */
131 { "get", "GET", PKW_ROUTE },
132 { "post", "POST", PKW_ROUTE },
133 { "put", "PUT", PKW_ROUTE },
134 { "patch", "PATCH", PKW_ROUTE },
135 { "del", "DELETE", PKW_ROUTE },
136 { "any", "ANY", PKW_ROUTE },
137  
138 /* everything that forwards straight through */
139 { "under", "under", PKW_FWD },
140 { "api", "api", PKW_FWD },
141 { "websocket", "websocket", PKW_FWD },
142 { "sse", "sse", PKW_FWD },
143 { "session", "session", PKW_FWD },
144 { "ua", "ua", PKW_FWD },
145 { "csrf", "csrf", PKW_FWD },
146 { "cors", "cors", PKW_FWD },
147 { "headers", "headers", PKW_FWD },
148 { "proxy", "proxy", PKW_FWD },
149 { "max_body", "max_body", PKW_FWD },
150 { "auth", "auth", PKW_FWD },
151 { "auth_guard", "auth_guard", PKW_FWD },
152 { "logging", "logging", PKW_FWD },
153 { "docs", "docs", PKW_FWD },
154 { "static", "static", PKW_FWD },
155 { "markdown", "markdown", PKW_FWD },
156 { "mount", "mount", PKW_FWD },
157 { "views", "views", PKW_FWD },
158 { "cache", "cache", PKW_FWD },
159 { "config", "config", PKW_FWD },
160 { "secret", "secret", PKW_FWD },
161 { "database", "database", PKW_FWD },
162 { "model", "model_class", PKW_FWD },
163 { "hook", "hook", PKW_FWD },
164 { "rate_limit", "rate_limit", PKW_FWD },
165 { "middleware", "middleware", PKW_FWD },
166 { "on_error", "on_error", PKW_FWD },
167 { "on_not_found", "on_not_found", PKW_FWD },
168 { "plugin", "plugin", PKW_FWD },
169  
170 { "helper", "helper", PKW_HELPER },
171 { "to_app", "compile", PKW_NOARG },
172 { "upload_dir", "upload_dir", PKW_FWD },
173 { "host", "host", PKW_FWD },
174 { "favicon", "favicon", PKW_FWD },
175 { "punk_app", NULL, PKW_SELF },
176 { NULL, NULL, 0 }
177 };
178  
179 /* ---- plugin keywords ------------------------------------------------------
180 *
181 * A plugin that wants its own declaration keyword (`task`, `queue`, `cron`...)
182 * calls $app->install_kw($name => $code) rather than assigning to a glob in the
183 * application class. The keyword it gets is the same shape as the ones above -
184 * a magic CV, named for the class it lands in, installed from C - so a plugin
185 * never needs `no strict 'refs'` and every keyword in an application arrived
186 * through one door.
187 *
188 * They are ordinary CVs, not calls lifted into the BEGIN phase: lifting wants
189 * Devel::CallParser and perl 5.14, and Punk claims 5.10. A CV installed at
190 * import time is compile-time-visible to every later line on every perl, which
191 * is what a declaration keyword needs. */
192  
193 /* forward @_ to the plugin's code and return what it returns, in the caller's
194 * context - `my $q = queue();` is a keyword call too */
195 XS_INTERNAL(pki_pkw_cb);
196 19 XS_INTERNAL(pki_pkw_cb) {
197 19 dXSARGS;
198 19 AV *cap = punk_clos_cap(aTHX_ cv);
199 19 ▶ SV **code = cap ? av_fetch(cap, 0, 0) : NULL; /* # uncoverable condition right count:1 class:ignore_covered_err */
Branch: 1 branch
BranchTrueFalseTotal
SV **code = cap ? av_fetch(cap, 0, 0) : NULL; /* # uncoverable condition right count:1 class:ignore_covered_err */ 19 0 19
200 19 I32 want = GIMME_V;
201 int count, i;
202  
203 /*
204 # uncoverable branch true
205 # uncoverable condition left count:1 class:ignore_covered_err */
206 19 ▶ if (!code) XSRETURN_EMPTY;
Branch: 1 branch
BranchTrueFalseTotal
if (!code) XSRETURN_EMPTY; 0 19 19
207  
208 19 ▶ PUSHMARK(SP);
Branch: 1 branch
BranchTrueFalseTotal
PUSHMARK(SP); 0 19 19
209 19 ▶ EXTEND(SP, items);
Branch: 2 branches
BranchTrueFalseTotal
EXTEND(SP, items); 19 0 19
EXTEND(SP, items); 0 19 19
210 48 ▶ for (i = 0; i < items; i++) PUSHs(ST(i));
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; i < items; i++) PUSHs(ST(i)); 29 19 48
211 19 PUTBACK;
212 19 count = call_sv(*code, want == G_VOID ? G_VOID : want);
213 17 SPAGAIN;
214 17 ▶ if (want == G_VOID) XSRETURN_EMPTY;
Branch: 1 branch
BranchTrueFalseTotal
if (want == G_VOID) XSRETURN_EMPTY; 14 3 17
215  
216 /* the results sit above the arguments; copy them down to ax through a
217 * scratch vector, since the two regions can overlap (see pki_kw_cb) */
218 /*
219 # uncoverable branch false
220 # uncoverable condition right count:1 class:ignore_covered_err */
221 3 ▶ if (count > 0) {
Branch: 1 branch
BranchTrueFalseTotal
if (count > 0) { 3 0 3
222 SV **tmp;
223 int j;
224 3 Newx(tmp, count, SV *);
225 8 ▶ for (j = 0; j < count; j++) tmp[j] = sv_2mortal(newSVsv(SP[j - count + 1]));
Branch: 1 branch
BranchTrueFalseTotal
for (j = 0; j < count; j++) tmp[j] = sv_2mortal(newSVsv(SP[j - count + 1])); 5 3 8
226 8 ▶ for (j = 0; j < count; j++) ST(j) = tmp[j];
Branch: 1 branch
BranchTrueFalseTotal
for (j = 0; j < count; j++) ST(j) = tmp[j]; 5 3 8
227 3 Safefree(tmp);
228 }
229 3 XSRETURN(count);
230 }
231  
232 /* is this name part of the core DSL? installing over `get` or `plugin` would
233 * break the application in a way no error message would explain */
234 77 static int pki_is_dsl(const char *name) {
235 int i;
236 3227 ▶ for (i = 0; PKI_KEYWORDS[i].kw; i++)
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; PKI_KEYWORDS[i].kw; i++) 3152 75 3227
237 3152 ▶ if (strEQ(name, PKI_KEYWORDS[i].kw)) return 1;
Branch: 1 branch
BranchTrueFalseTotal
if (strEQ(name, PKI_KEYWORDS[i].kw)) return 1; 2 3150 3152
238 75 return 0;
239 }
240  
241 /* Install one plugin keyword into an application class. Idempotent by CV
242 * identity: a keyword already carrying this same code is left alone, which is
243 * what a plugin installing from both its import and its register does. */
244 50 static void pki_install_kw(pTHX_ SV *caller, SV *name, SV *code) {
245 STRLEN cl, nl;
246 50 ▶ const char *cs = SvPV_const(caller, cl);
Branch: 1 branch
BranchTrueFalseTotal
const char *cs = SvPV_const(caller, cl); 50 0 50
247 50 const char *ns = SvPV_const(name, nl);
248 50 const char *full = form("%.*s::%.*s", (int)cl, cs, (int)nl, ns);
249 50 CV *old = get_cv(full, 0);
250 AV *cap;
251  
252 /*
253 # uncoverable branch true
254 # uncoverable condition left count:1 class:ignore_covered_err */
255 50 ▶ if (old) {
Branch: 1 branch
BranchTrueFalseTotal
if (old) { 0 50 50
256 0 AV *ocap = punk_clos_cap(aTHX_ old); /* # uncoverable statement */
257 /*
258 # uncoverable statement
259 # uncoverable condition left count:1
260 # uncoverable condition right count:1 */
261 0 ▶ SV **oc = ocap ? av_fetch(ocap, 0, 0) : NULL;
Branch: 1 branch
BranchTrueFalseTotal
SV **oc = ocap ? av_fetch(ocap, 0, 0) : NULL; 0 0 0
262 /*
263 # uncoverable statement
264 # uncoverable branch true
265 # uncoverable branch false
266 # uncoverable condition left count:1
267 # uncoverable condition right count:1
268 # uncoverable condition left count:2
269 # uncoverable condition right count:2
270 # uncoverable condition left count:3
271 # uncoverable condition right count:3
272 # uncoverable condition left count:4
273 # uncoverable condition right count:4 */
274 0 ▶ if (oc && SvROK(*oc) && SvROK(code) && SvRV(*oc) == SvRV(code)) return;
Branch: 4 branches
BranchTrueFalseTotal
if (oc && SvROK(*oc) && SvROK(code) && SvRV(*oc) == SvRV(code)) return; 0 0 0
if (oc && SvROK(*oc) && SvROK(code) && SvRV(*oc) == SvRV(code)) return; 0 0 0
if (oc && SvROK(*oc) && SvROK(code) && SvRV(*oc) == SvRV(code)) return; 0 0 0
if (oc && SvROK(*oc) && SvROK(code) && SvRV(*oc) == SvRV(code)) return; 0 0 0
275 }
276 50 cap = newAV();
277 50 av_push(cap, newSVsv(code));
278 50 (void)punk_closure_named(aTHX_ full, pki_pkw_cb, cap);
279 }
280  
281 /* One application registrar per class, cached in %Punk::APPS the way the Perl
282 * import did - a second `use Punk` in the same package must not start a second
283 * application. */
284 1402 static SV *pki_app_for(pTHX_ SV *caller, int *fresh) {
285 1402 HV *apps = get_hv("Punk::APPS", GV_ADD);
286 1402 HE *he = hv_fetch_ent(apps, caller, 0, 0);
287 SV *app;
288 /*
289 # uncoverable branch false
290 # uncoverable condition right count:1 class:ignore_covered_err */
291 1402 ▶ if (fresh) *fresh = 0;
Branch: 1 branch
BranchTrueFalseTotal
if (fresh) *fresh = 0; 1402 0 1402
292 /*
293 # uncoverable condition right count:2 class:ignore_covered_err
294 # uncoverable condition right count:3 class:ignore_covered_err */
295 1402 ▶ if (he && HeVAL(he) && SvROK(HeVAL(he))) return HeVAL(he);
Branch: 3 branches
BranchTrueFalseTotal
if (he && HeVAL(he) && SvROK(HeVAL(he))) return HeVAL(he); 1 1401 1402
if (he && HeVAL(he) && SvROK(HeVAL(he))) return HeVAL(he); 1 0 1
if (he && HeVAL(he) && SvROK(HeVAL(he))) return HeVAL(he); 1 0 1
296 /*
297 # uncoverable branch false
298 # uncoverable condition right count:1 class:ignore_covered_err */
299 1401 ▶ if (fresh) *fresh = 1;
Branch: 1 branch
BranchTrueFalseTotal
if (fresh) *fresh = 1; 1401 0 1401
300  
301 {
302 1401 dSP;
303 int count;
304 1401 ENTER; SAVETMPS;
305 1401 ▶ PUSHMARK(SP);
Branch: 1 branch
BranchTrueFalseTotal
PUSHMARK(SP); 0 1401 1401
306 1401 ▶ EXTEND(SP, 3);
Branch: 1 branch
BranchTrueFalseTotal
EXTEND(SP, 3); 0 1401 1401
307 1401 mPUSHs(newSVpvs("Punk::App"));
308 1401 mPUSHs(newSVpvs("caller"));
309 1401 PUSHs(caller);
310 1401 PUTBACK;
311 1401 count = call_method("new", G_SCALAR);
312 1401 SPAGAIN;
313 1401 ▶ app = count > 0 ? newSVsv(POPs) : &PL_sv_undef; /* # uncoverable condition right count:1 class:ignore_covered_err */
Branch: 1 branch
BranchTrueFalseTotal
app = count > 0 ? newSVsv(POPs) : &PL_sv_undef; /* # uncoverable condition right count:1 class:ignore_covered_err */ 1401 0 1401
314 1401 ▶ PUTBACK; FREETMPS; LEAVE;
Branch: 1 branch
BranchTrueFalseTotal
PUTBACK; FREETMPS; LEAVE; 1401 0 1401
315 }
316 /*
317 # uncoverable branch true
318 # uncoverable condition left count:1 class:ignore_covered_err */
319 1401 ▶ if (!SvROK(app))
Branch: 1 branch
BranchTrueFalseTotal
if (!SvROK(app)) 0 1401 1401
320 0 croak("Punk: Punk::App->new returned no registrar"); /* # uncoverable statement */
321 1401 (void)hv_store_ent(apps, caller, app, 0);
322 1401 return app;
323 }
324  
325 /* strict and warnings, exactly as `use strict; use warnings;` would: both are
326 * plain import calls that set hint bits in the scope being compiled, and
327 * calling them from here reaches the same scope a Perl import would. */
328 2804 static void pki_pragma(pTHX_ const char *pragma) {
329 2804 dSP;
330 2804 ENTER; SAVETMPS;
331 2804 ▶ PUSHMARK(SP);
Branch: 1 branch
BranchTrueFalseTotal
PUSHMARK(SP); 0 2804 2804
332 2804 ▶ EXTEND(SP, 1);
Branch: 1 branch
BranchTrueFalseTotal
EXTEND(SP, 1); 0 2804 2804
333 2804 mPUSHs(newSVpv(pragma, 0));
334 2804 PUTBACK;
335 2804 (void)call_method("import", G_VOID | G_DISCARD);
336 2804 SPAGAIN;
337 2804 ▶ PUTBACK; FREETMPS; LEAVE;
Branch: 1 branch
BranchTrueFalseTotal
PUTBACK; FREETMPS; LEAVE; 2804 0 2804
338 2804 }
339  
340 /* Install the whole DSL into the calling package. */
341 1402 static void pki_export(pTHX_ SV *caller) {
342 1402 int fresh = 0;
343 1402 SV *app = pki_app_for(aTHX_ caller, &fresh);
344 STRLEN cl;
345 1402 const char *cs = SvPV_const(caller, cl);
346 int i;
347  
348 /* A second `use Punk` in the same package extends that application rather
349 * than starting another - so the keywords are already installed, and
350 * reinstalling them would only warn about redefining every one. */
351 1402 ▶ if (!fresh) return;
Branch: 1 branch
BranchTrueFalseTotal
if (!fresh) return; 1 1401 1402
352  
353 60243 ▶ for (i = 0; PKI_KEYWORDS[i].kw; i++) {
Branch: 1 branch
BranchTrueFalseTotal
for (i = 0; PKI_KEYWORDS[i].kw; i++) { 58842 1401 60243
354 58842 const pki_kw *k = &PKI_KEYWORDS[i];
355 58842 AV *cap = newAV();
356 SV *code;
357 58842 av_push(cap, newSVsv(app));
358 58842 av_push(cap, newSViv(k->kind));
359 58842 ▶ av_push(cap, k->method ? newSVpv(k->method, 0) : newSV(0));
Branch: 1 branch
BranchTrueFalseTotal
av_push(cap, k->method ? newSVpv(k->method, 0) : newSV(0)); 57441 1401 58842
360 58842 ▶ if (k->kind == PKW_HELPER) av_push(cap, newSVsv(caller));
Branch: 1 branch
BranchTrueFalseTotal
if (k->kind == PKW_HELPER) av_push(cap, newSVsv(caller)); 1401 57441 58842
361 58842 code = punk_closure(aTHX_ pki_kw_cb, cap);
362 {
363 58842 GV *gv = gv_fetchpvn_flags(form("%.*s::%s", (int)cl, cs, k->kw),
364 cl + 2 + strlen(k->kw), GV_ADD, SVt_PVCV);
365 58842 sv_setsv((SV *)gv, code);
366 }
367 58842 SvREFCNT_dec(code);
368 }
369 }
370  
371 #endif /* PUNK_IMPORT_H */
« include/punk/punk_serve.h ↑ Summary xs/sse.xs »