Fix where we look for the Sun Studio compiler
[perl.git] / pad.h
1 /*    pad.h
2  *
3  *    Copyright (C) 2002, 2003, 2005, 2006, 2007, 2008,
4  *    2009, 2010, 2011 by Larry Wall and others
5  *
6  *    You may distribute under the terms of either the GNU General Public
7  *    License or the Artistic License, as specified in the README file.
8  *
9  * This file defines the types and macros associated with the API for
10  * manipulating scratchpads, which are used by perl to store lexical
11  * variables, op targets and constants.
12  */
13
14 /*
15 =head1 Pad Data Structures
16 */
17
18
19 /* offsets within a pad */
20
21 #if PTRSIZE == 4
22 typedef U32TYPE PADOFFSET;
23 #else
24 #   if PTRSIZE == 8
25 typedef U64TYPE PADOFFSET;
26 #   endif
27 #endif
28 #define NOT_IN_PAD ((PADOFFSET) -1)
29
30 /* B.xs expects the first members of these two structs to line up
31    (xpadl_max with xpadnl_fill).
32  */
33
34 struct padlist {
35     SSize_t     xpadl_max;      /* max index for which array has space */
36     PAD **      xpadl_alloc;    /* pointer to beginning of array of AVs */
37     U32         xpadl_id;       /* Semi-unique ID, shared between clones */
38     U32         xpadl_outid;    /* ID of outer pad */
39 };
40
41 struct padnamelist {
42     SSize_t     xpadnl_fill;    /* max index in use */
43     PADNAME **  xpadnl_alloc;   /* pointer to beginning of array */
44     SSize_t     xpadnl_max;     /* max index for which array has space */
45     PADOFFSET   xpadnl_max_named; /* highest index with len > 0 */
46     U32         xpadnl_refcnt;
47 };
48
49 /* PERL_PADNAME_MINIMAL uses less memory, but on some platforms
50    PERL_PADNAME_ALIGNED may be faster, so platform-specific hints can
51    define one or the other.  */
52 #if defined(PERL_PADNAME_MINIMAL) && defined (PERL_PADNAME_ALIGNED)
53 #  error PERL_PADNAME_MINIMAL and PERL_PADNAME_ALIGNED are exclusive
54 #endif
55
56 #if !defined(PERL_PADNAME_MINIMAL) && !defined(PERL_PADNAME_ALIGNED)
57 #  define PERL_PADNAME_MINIMAL
58 #endif
59
60 #define _PADNAME_BASE \
61     char *      xpadn_pv;               \
62     HV *        xpadn_ourstash;         \
63     union {                             \
64         HV *    xpadn_typestash;        \
65         CV *    xpadn_protocv;          \
66     } xpadn_type_u;                     \
67     U32         xpadn_low;              \
68     U32         xpadn_high;             \
69     U32         xpadn_refcnt;           \
70     int         xpadn_gen;              \
71     U8          xpadn_len;              \
72     U8          xpadn_flags
73
74 struct padname {
75     _PADNAME_BASE;
76 };
77
78 struct padname_with_str {
79 #ifdef PERL_PADNAME_MINIMAL
80     _PADNAME_BASE;
81 #else
82     struct padname      xpadn_padname;
83 #endif
84     char                xpadn_str[1];
85 };
86
87 #undef _PADNAME_BASE
88
89 #define PADNAME_FROM_PV(s) \
90     ((PADNAME *)((s) - STRUCT_OFFSET(struct padname_with_str, xpadn_str)))
91
92
93 /* a value that PL_cop_seqmax is guaranteed never to be,
94  * flagging that a lexical is being introduced, or has not yet left scope
95  */
96 #define PERL_PADSEQ_INTRO  U32_MAX
97 #define COP_SEQMAX_INC \
98         (PL_cop_seqmax++, \
99          (void)(PL_cop_seqmax == PERL_PADSEQ_INTRO && PL_cop_seqmax++))
100
101
102 /* B.xs needs these for the benefit of B::Deparse */
103 /* Low range end is exclusive (valid from the cop seq after this one) */
104 /* High range end is inclusive (valid up to this cop seq) */
105
106 #define COP_SEQ_RANGE_LOW(pn)           (pn)->xpadn_low
107 #define COP_SEQ_RANGE_HIGH(pn)          (pn)->xpadn_high
108 #define PARENT_PAD_INDEX(pn)            (pn)->xpadn_low
109 #define PARENT_FAKELEX_FLAGS(pn)        (pn)->xpadn_high
110
111 /* Flags set in the SvIVX field of FAKE namesvs */
112
113 #define PAD_FAKELEX_ANON   1 /* the lex is declared in an ANON, or ... */
114 #define PAD_FAKELEX_MULTI  2 /* the lex can be instantiated multiple times */
115
116 /* flags for the pad_new() function */
117
118 #define padnew_CLONE    1       /* this pad is for a cloned CV */
119 #define padnew_SAVE     2       /* save old globals */
120 #define padnew_SAVESUB  4       /* also save extra stuff for start of sub */
121
122 /* values for the pad_tidy() function */
123
124 typedef enum {
125         padtidy_SUB,            /* tidy up a pad for a sub, */
126         padtidy_SUBCLONE,       /* a cloned sub, */
127         padtidy_FORMAT          /* or a format */
128 } padtidy_type;
129
130 /* flags for pad_add_name_pvn. */
131
132 #define padadd_OUR              0x01       /* our declaration. */
133 #define padadd_STATE            0x02       /* state declaration. */
134 #define padadd_NO_DUP_CHECK     0x04       /* skip warning on dups. */
135 #define padadd_STALEOK          0x08       /* allow stale lexical in active
136                                             * sub, but only one level up */
137
138 /* ASSERT_CURPAD_LEGAL and ASSERT_CURPAD_ACTIVE respectively determine
139  * whether PL_comppad and PL_curpad are consistent and whether they have
140  * active values */
141
142 #  define pad_peg(label)
143
144 #ifdef DEBUGGING
145 #  define ASSERT_CURPAD_LEGAL(label) \
146     pad_peg(label); \
147     if (PL_comppad ? (AvARRAY(PL_comppad) != PL_curpad) : (PL_curpad != 0))  \
148         Perl_croak(aTHX_ "panic: illegal pad in %s: 0x%" UVxf "[0x%" UVxf "]",\
149             label, PTR2UV(PL_comppad), PTR2UV(PL_curpad));
150
151
152 #  define ASSERT_CURPAD_ACTIVE(label) \
153     pad_peg(label); \
154     if (!PL_comppad || (AvARRAY(PL_comppad) != PL_curpad))                \
155         Perl_croak(aTHX_ "panic: invalid pad in %s: 0x%" UVxf "[0x%" UVxf "]",\
156             label, PTR2UV(PL_comppad), PTR2UV(PL_curpad));
157 #else
158 #  define ASSERT_CURPAD_LEGAL(label)
159 #  define ASSERT_CURPAD_ACTIVE(label)
160 #endif
161
162
163
164 /* Note: the following three macros are actually defined in scope.h, but
165  * they are documented here for completeness, since they directly or
166  * indirectly affect pads.
167
168 =for apidoc m|void|SAVEPADSV    |PADOFFSET po
169 Save a pad slot (used to restore after an iteration)
170
171 XXX DAPM it would make more sense to make the arg a PADOFFSET
172 =for apidoc m|void|SAVECLEARSV  |SV **svp
173 Clear the pointed to pad value on scope exit.  (i.e. the runtime action of
174 'my')
175
176 =for apidoc m|void|SAVECOMPPAD
177 save PL_comppad and PL_curpad
178
179
180 =for apidoc Amx|PAD **|PadlistARRAY|PADLIST padlist
181 The C array of a padlist, containing the pads.  Only subscript it with
182 numbers >= 1, as the 0th entry is not guaranteed to remain usable.
183
184 =for apidoc Amx|SSize_t|PadlistMAX|PADLIST padlist
185 The index of the last allocated space in the padlist.  Note that the last
186 pad may be in an earlier slot.  Any entries following it will be NULL in
187 that case.
188
189 =for apidoc Amx|PADNAMELIST *|PadlistNAMES|PADLIST padlist
190 The names associated with pad entries.
191
192 =for apidoc Amx|PADNAME **|PadlistNAMESARRAY|PADLIST padlist
193 The C array of pad names.
194
195 =for apidoc Amx|SSize_t|PadlistNAMESMAX|PADLIST padlist
196 The index of the last pad name.
197
198 =for apidoc Amx|U32|PadlistREFCNT|PADLIST padlist
199 The reference count of the padlist.  Currently this is always 1.
200
201 =for apidoc Amx|PADNAME **|PadnamelistARRAY|PADNAMELIST pnl
202 The C array of pad names.
203
204 =for apidoc Amx|SSize_t|PadnamelistMAX|PADNAMELIST pnl
205 The index of the last pad name.
206
207 =for apidoc Amx|SSize_t|PadnamelistREFCNT|PADNAMELIST pnl
208 The reference count of the pad name list.
209
210 =for apidoc Amx|void|PadnamelistREFCNT_dec|PADNAMELIST pnl
211 Lowers the reference count of the pad name list.
212
213 =for apidoc Amx|SV **|PadARRAY|PAD pad
214 The C array of pad entries.
215
216 =for apidoc Amx|SSize_t|PadMAX|PAD pad
217 The index of the last pad entry.
218
219 =for apidoc Amx|char *|PadnamePV|PADNAME pn     
220 The name stored in the pad name struct.  This returns NULL for a target
221 slot.
222
223 =for apidoc Amx|STRLEN|PadnameLEN|PADNAME pn    
224 The length of the name.
225
226 =for apidoc Amx|bool|PadnameUTF8|PADNAME pn
227 Whether PadnamePV is in UTF8.  Currently, this is always true.
228
229 =for apidoc Amx|SV *|PadnameSV|PADNAME pn
230 Returns the pad name as a mortal SV.
231
232 =for apidoc m|bool|PadnameIsOUR|PADNAME pn
233 Whether this is an "our" variable.
234
235 =for apidoc m|HV *|PadnameOURSTASH
236 The stash in which this "our" variable was declared.
237
238 =for apidoc m|bool|PadnameOUTER|PADNAME pn
239 Whether this entry belongs to an outer pad.  Entries for which this is true
240 are often referred to as 'fake'.
241
242 =for apidoc m|bool|PadnameIsSTATE|PADNAME pn
243 Whether this is a "state" variable.
244
245 =for apidoc m|HV *|PadnameTYPE|PADNAME pn
246 The stash associated with a typed lexical.  This returns the %Foo:: hash
247 for C<my Foo $bar>.
248
249 =for apidoc Amx|SSize_t|PadnameREFCNT|PADNAME pn
250 The reference count of the pad name.
251
252 =for apidoc Amx|void|PadnameREFCNT_dec|PADNAME pn
253 Lowers the reference count of the pad name.
254
255
256 =for apidoc m|SV *|PAD_SETSV    |PADOFFSET po|SV* sv
257 Set the slot at offset C<po> in the current pad to C<sv>
258
259 =for apidoc m|SV *|PAD_SV       |PADOFFSET po
260 Get the value at offset C<po> in the current pad
261
262 =for apidoc m|SV *|PAD_SVl      |PADOFFSET po
263 Lightweight and lvalue version of C<PAD_SV>.
264 Get or set the value at offset C<po> in the current pad.
265 Unlike C<PAD_SV>, does not print diagnostics with -DX.
266 For internal use only.
267
268 =for apidoc m|SV *|PAD_BASE_SV  |PADLIST padlist|PADOFFSET po
269 Get the value from slot C<po> in the base (DEPTH=1) pad of a padlist
270
271 =for apidoc m|void|PAD_SET_CUR  |PADLIST padlist|I32 n
272 Set the current pad to be pad C<n> in the padlist, saving
273 the previous current pad.  NB currently this macro expands to a string too
274 long for some compilers, so it's best to replace it with
275
276     SAVECOMPPAD();
277     PAD_SET_CUR_NOSAVE(padlist,n);
278
279
280 =for apidoc m|void|PAD_SET_CUR_NOSAVE   |PADLIST padlist|I32 n
281 like PAD_SET_CUR, but without the save
282
283 =for apidoc m|void|PAD_SAVE_SETNULLPAD
284 Save the current pad then set it to null.
285
286 =for apidoc m|void|PAD_SAVE_LOCAL|PAD *opad|PAD *npad
287 Save the current pad to the local variable opad, then make the
288 current pad equal to npad
289
290 =for apidoc m|void|PAD_RESTORE_LOCAL|PAD *opad
291 Restore the old pad saved into the local variable opad by PAD_SAVE_LOCAL()
292
293 =cut
294 */
295
296 #define PadlistARRAY(pl)        (pl)->xpadl_alloc
297 #define PadlistMAX(pl)          (pl)->xpadl_max
298 #define PadlistNAMES(pl)        ((PADNAMELIST *)*PadlistARRAY(pl))
299 #define PadlistNAMESARRAY(pl)   PadnamelistARRAY(PadlistNAMES(pl))
300 #define PadlistNAMESMAX(pl)     PadnamelistMAX(PadlistNAMES(pl))
301 #define PadlistREFCNT(pl)       1       /* reserved for future use */
302
303 #define PadnamelistARRAY(pnl)           (pnl)->xpadnl_alloc
304 #define PadnamelistMAX(pnl)             (pnl)->xpadnl_fill
305 #define PadnamelistMAXNAMED(pnl)        (pnl)->xpadnl_max_named
306 #define PadnamelistREFCNT(pnl)          (pnl)->xpadnl_refcnt
307 #define PadnamelistREFCNT_dec(pnl)      Perl_padnamelist_free(aTHX_ pnl)
308
309 #define PadARRAY(pad)           AvARRAY(pad)
310 #define PadMAX(pad)             AvFILLp(pad)
311
312 #define PadnamePV(pn)           (pn)->xpadn_pv
313 #define PadnameLEN(pn)          (pn)->xpadn_len
314 #define PadnameUTF8(pn)         1
315 #define PadnameSV(pn) \
316         newSVpvn_flags(PadnamePV(pn), PadnameLEN(pn), SVs_TEMP|SVf_UTF8)
317 #define PadnameFLAGS(pn)        (pn)->xpadn_flags
318 #define PadnameIsOUR(pn)        (!!(pn)->xpadn_ourstash)
319 #define PadnameOURSTASH(pn)     (pn)->xpadn_ourstash
320 #define PadnameTYPE(pn)         (pn)->xpadn_type_u.xpadn_typestash
321 #define PadnamePROTOCV(pn)      (pn)->xpadn_type_u.xpadn_protocv
322 #define PadnameREFCNT(pn)       (pn)->xpadn_refcnt
323 #define PadnameREFCNT_dec(pn)   Perl_padname_free(aTHX_ pn)
324 #define PadnameOURSTASH_set(pn,s) (PadnameOURSTASH(pn) = (s))
325 #define PadnameTYPE_set(pn,s)     (PadnameTYPE(pn) = (s))
326 #define PadnameOUTER(pn)        (PadnameFLAGS(pn) & PADNAMEt_OUTER)
327 #define PadnameIsSTATE(pn)      (PadnameFLAGS(pn) & PADNAMEt_STATE)
328 #define PadnameLVALUE(pn)       (PadnameFLAGS(pn) & PADNAMEt_LVALUE)
329
330 #define PadnameLVALUE_on(pn)    (PadnameFLAGS(pn) |= PADNAMEt_LVALUE)
331 #define PadnameIsSTATE_on(pn)   (PadnameFLAGS(pn) |= PADNAMEt_STATE)
332
333 #define PADNAMEt_OUTER  1       /* outer lexical var */
334 #define PADNAMEt_STATE  2       /* state var */
335 #define PADNAMEt_LVALUE 4       /* used as lvalue */
336 #define PADNAMEt_TYPED  8       /* for B; unused by core */
337 #define PADNAMEt_OUR    16      /* for B; unused by core */
338
339 /* backward compatibility */
340 #define SvPAD_STATE             PadnameIsSTATE
341 #define SvPAD_TYPED(pn)         (!!PadnameTYPE(pn))
342 #define SvPAD_OUR(pn)           (!!PadnameOURSTASH(pn))
343 #define SvPAD_STATE_on          PadnameIsSTATE_on
344 #define SvPAD_TYPED_on(pn)      (PadnameFLAGS(pn) |= PADNAMEt_TYPED)
345 #define SvPAD_OUR_on(pn)        (PadnameFLAGS(pn) |= PADNAMEt_OUR)
346 #define SvOURSTASH              PadnameOURSTASH
347 #define SvOURSTASH_set          PadnameOURSTASH_set
348 #define SVpad_STATE             PADNAMEt_STATE
349 #define SVpad_TYPED             PADNAMEt_TYPED
350 #define SVpad_OUR               PADNAMEt_OUR
351
352 #ifdef DEBUGGING
353 #  define PAD_SV(po)       pad_sv(po)
354 #  define PAD_SETSV(po,sv) pad_setsv(po,sv)
355 #else
356 #  define PAD_SV(po)       (PL_curpad[po])
357 #  define PAD_SETSV(po,sv) PL_curpad[po] = (sv)
358 #endif
359
360 #define PAD_SVl(po)       (PL_curpad[po])
361
362 #define PAD_BASE_SV(padlist, po) \
363         (PadlistARRAY(padlist)[1])                                      \
364             ? AvARRAY(MUTABLE_AV((PadlistARRAY(padlist)[1])))[po] \
365             : NULL;
366
367
368 #define PAD_SET_CUR_NOSAVE(padlist,nth) \
369         PL_comppad = (PAD*) (PadlistARRAY(padlist)[nth]);       \
370         PL_curpad = AvARRAY(PL_comppad);                        \
371         DEBUG_Xv(PerlIO_printf(Perl_debug_log,                  \
372               "Pad 0x%" UVxf "[0x%" UVxf "] set_cur    depth=%d\n",     \
373               PTR2UV(PL_comppad), PTR2UV(PL_curpad), (int)(nth)));
374
375
376 #define PAD_SET_CUR(padlist,nth) \
377         SAVECOMPPAD();                                          \
378         PAD_SET_CUR_NOSAVE(padlist,nth);
379
380
381 #define PAD_SAVE_SETNULLPAD()   SAVECOMPPAD(); \
382         PL_comppad = NULL; PL_curpad = NULL;    \
383         DEBUG_Xv(PerlIO_printf(Perl_debug_log, "Pad set_null\n"));
384
385 #define PAD_SAVE_LOCAL(opad,npad) \
386         opad = PL_comppad;                                      \
387         PL_comppad = (npad);                                    \
388         PL_curpad =  PL_comppad ? AvARRAY(PL_comppad) : NULL;   \
389         DEBUG_Xv(PerlIO_printf(Perl_debug_log,                  \
390               "Pad 0x%" UVxf "[0x%" UVxf "] save_local\n",              \
391               PTR2UV(PL_comppad), PTR2UV(PL_curpad)));
392
393 #define PAD_RESTORE_LOCAL(opad) \
394         assert(!opad || !SvIS_FREED(opad));                                     \
395         PL_comppad = opad;                                              \
396         PL_curpad =  PL_comppad ? AvARRAY(PL_comppad) : NULL;   \
397         DEBUG_Xv(PerlIO_printf(Perl_debug_log,                  \
398               "Pad 0x%" UVxf "[0x%" UVxf "] restore_local\n",   \
399               PTR2UV(PL_comppad), PTR2UV(PL_curpad)));
400
401
402 /*
403 =for apidoc m|void|CX_CURPAD_SAVE|struct context
404 Save the current pad in the given context block structure.
405
406 =for apidoc m|SV *|CX_CURPAD_SV|struct context|PADOFFSET po
407 Access the SV at offset po in the saved current pad in the given
408 context block structure (can be used as an lvalue).
409
410 =cut
411 */
412
413 #define CX_CURPAD_SAVE(block)  (block).oldcomppad = PL_comppad
414 #define CX_CURPAD_SV(block,po) (AvARRAY(MUTABLE_AV(((block).oldcomppad)))[po])
415
416
417 /*
418 =for apidoc m|U32|PAD_COMPNAME_FLAGS|PADOFFSET po
419 Return the flags for the current compiling pad name
420 at offset C<po>.  Assumes a valid slot entry.
421
422 =for apidoc m|char *|PAD_COMPNAME_PV|PADOFFSET po
423 Return the name of the current compiling pad name
424 at offset C<po>.  Assumes a valid slot entry.
425
426 =for apidoc m|HV *|PAD_COMPNAME_TYPE|PADOFFSET po
427 Return the type (stash) of the current compiling pad name at offset
428 C<po>.  Must be a valid name.  Returns null if not typed.
429
430 =for apidoc m|HV *|PAD_COMPNAME_OURSTASH|PADOFFSET po
431 Return the stash associated with an C<our> variable.
432 Assumes the slot entry is a valid C<our> lexical.
433
434 =for apidoc m|STRLEN|PAD_COMPNAME_GEN|PADOFFSET po
435 The generation number of the name at offset C<po> in the current
436 compiling pad (lvalue).  Note that C<SvUVX> is hijacked for this purpose.
437
438 =for apidoc m|STRLEN|PAD_COMPNAME_GEN_set|PADOFFSET po|int gen
439 Sets the generation number of the name at offset C<po> in the current
440 ling pad (lvalue) to C<gen>.  Note that C<SvUV_set> is hijacked for this purpose.
441
442 =cut
443
444 */
445
446 #define PAD_COMPNAME(po)        PAD_COMPNAME_SV(po)
447 #define PAD_COMPNAME_SV(po)     (PadnamelistARRAY(PL_comppad_name)[(po)])
448 #define PAD_COMPNAME_FLAGS(po)  PadnameFLAGS(PAD_COMPNAME(po))
449 #define PAD_COMPNAME_FLAGS_isOUR(po) SvPAD_OUR(PAD_COMPNAME_SV(po))
450 #define PAD_COMPNAME_PV(po)     PadnamePV(PAD_COMPNAME(po))
451
452 #define PAD_COMPNAME_TYPE(po)   PadnameTYPE(PAD_COMPNAME(po))
453
454 #define PAD_COMPNAME_OURSTASH(po) \
455     (SvOURSTASH(PAD_COMPNAME_SV(po)))
456
457 #define PAD_COMPNAME_GEN(po) \
458     ((STRLEN)PadnamelistARRAY(PL_comppad_name)[po]->xpadn_gen)
459
460 #define PAD_COMPNAME_GEN_set(po, gen) \
461     (PadnamelistARRAY(PL_comppad_name)[po]->xpadn_gen = (gen))
462
463
464 /*
465 =for apidoc m|void|PAD_CLONE_VARS|PerlInterpreter *proto_perl|CLONE_PARAMS* param
466 Clone the state variables associated with running and compiling pads.
467
468 =cut
469 */
470
471 /* NB - we set PL_comppad to null unless it points at a value that
472  * has already been dup'ed, ie it points to part of an active padlist.
473  * Otherwise PL_comppad ends up being a leaked scalar in code like
474  * the following:
475  *     threads->create(sub { threads->create(sub {...} ) } );
476  * where the second thread dups the outer sub's comppad but not the
477  * sub's CV or padlist. */
478
479 #define PAD_CLONE_VARS(proto_perl, param)                               \
480     PL_comppad                  = av_dup(proto_perl->Icomppad, param);  \
481     PL_curpad = PL_comppad ?  AvARRAY(PL_comppad) : NULL;               \
482     PL_comppad_name             =                                       \
483                   padnamelist_dup(proto_perl->Icomppad_name, param);    \
484     PL_comppad_name_fill        = proto_perl->Icomppad_name_fill;       \
485     PL_comppad_name_floor       = proto_perl->Icomppad_name_floor;      \
486     PL_min_intro_pending        = proto_perl->Imin_intro_pending;       \
487     PL_max_intro_pending        = proto_perl->Imax_intro_pending;       \
488     PL_padix                    = proto_perl->Ipadix;                   \
489     PL_padix_floor              = proto_perl->Ipadix_floor;             \
490     PL_pad_reset_pending        = proto_perl->Ipad_reset_pending;       \
491     PL_cop_seqmax               = proto_perl->Icop_seqmax;
492
493 /*
494 =for apidoc Am|PADOFFSET|pad_add_name_pvs|const char *name|U32 flags|HV *typestash|HV *ourstash
495
496 Exactly like L</pad_add_name_pvn>, but takes a literal string instead
497 of a string/length pair.
498
499 =cut
500 */
501
502 #define pad_add_name_pvs(name,flags,typestash,ourstash) \
503     Perl_pad_add_name_pvn(aTHX_ STR_WITH_LEN(name), flags, typestash, ourstash)
504
505 /*
506 =for apidoc Am|PADOFFSET|pad_findmy_pvs|const char *name|U32 flags
507
508 Exactly like L</pad_findmy_pvn>, but takes a literal string instead
509 of a string/length pair.
510
511 =cut
512 */
513
514 #define pad_findmy_pvs(name,flags) \
515     Perl_pad_findmy_pvn(aTHX_ STR_WITH_LEN(name), flags)
516
517 /*
518  * Local variables:
519  * c-indentation-style: bsd
520  * c-basic-offset: 4
521  * indent-tabs-mode: nil
522  * End:
523  *
524  * ex: set ts=8 sts=4 sw=4 et:
525  */