This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Use PADNAME rather than SV in the source
[perl5.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
31 struct padlist {
32     SSize_t     xpadl_max;      /* max index for which array has space */
33     PAD **      xpadl_alloc;    /* pointer to beginning of array of AVs */
34     PADNAMELIST*xpadl_outid;    /* Padnamelist of outer pad; used as ID */
35 };
36
37
38 /* a value that PL_cop_seqmax is guaranteed never to be,
39  * flagging that a lexical is being introduced, or has not yet left scope
40  */
41 #define PERL_PADSEQ_INTRO  U32_MAX
42 #define COP_SEQMAX_INC \
43         (PL_cop_seqmax++, \
44          (void)(PL_cop_seqmax == PERL_PADSEQ_INTRO && PL_cop_seqmax++))
45
46
47 /* B.xs needs these for the benefit of B::Deparse */
48 /* Low range end is exclusive (valid from the cop seq after this one) */
49 /* High range end is inclusive (valid up to this cop seq) */
50
51 #if defined (DEBUGGING) && defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
52 #  define COP_SEQ_RANGE_LOW(sv)                                         \
53         (({ const SV *const _sv_cop_seq_range_low = (const SV *) (sv);  \
54           assert(SvTYPE(_sv_cop_seq_range_low) == SVt_NV                \
55                  || SvTYPE(_sv_cop_seq_range_low) >= SVt_PVNV);         \
56           assert(SvTYPE(_sv_cop_seq_range_low) != SVt_PVAV);            \
57           assert(SvTYPE(_sv_cop_seq_range_low) != SVt_PVHV);            \
58           assert(SvTYPE(_sv_cop_seq_range_low) != SVt_PVCV);            \
59           assert(SvTYPE(_sv_cop_seq_range_low) != SVt_PVFM);            \
60           assert(!isGV_with_GP(_sv_cop_seq_range_low));                 \
61           ((XPVNV*) MUTABLE_PTR(SvANY(_sv_cop_seq_range_low)))->xnv_u.xpad_cop_seq.xlow; \
62          }))
63 #  define COP_SEQ_RANGE_HIGH(sv)                                        \
64         (({ const SV *const _sv_cop_seq_range_high = (const SV *) (sv); \
65           assert(SvTYPE(_sv_cop_seq_range_high) == SVt_NV               \
66                  || SvTYPE(_sv_cop_seq_range_high) >= SVt_PVNV);        \
67           assert(SvTYPE(_sv_cop_seq_range_high) != SVt_PVAV);           \
68           assert(SvTYPE(_sv_cop_seq_range_high) != SVt_PVHV);           \
69           assert(SvTYPE(_sv_cop_seq_range_high) != SVt_PVCV);           \
70           assert(SvTYPE(_sv_cop_seq_range_high) != SVt_PVFM);           \
71           assert(!isGV_with_GP(_sv_cop_seq_range_high));                \
72           ((XPVNV*) MUTABLE_PTR(SvANY(_sv_cop_seq_range_high)))->xnv_u.xpad_cop_seq.xhigh; \
73          }))
74 #  define PARENT_PAD_INDEX(sv)                                          \
75         (({ const SV *const _sv_parent_pad_index = (const SV *) (sv);   \
76           assert(SvTYPE(_sv_parent_pad_index) == SVt_NV                 \
77                  || SvTYPE(_sv_parent_pad_index) >= SVt_PVNV);          \
78           assert(SvTYPE(_sv_parent_pad_index) != SVt_PVAV);             \
79           assert(SvTYPE(_sv_parent_pad_index) != SVt_PVHV);             \
80           assert(SvTYPE(_sv_parent_pad_index) != SVt_PVCV);             \
81           assert(SvTYPE(_sv_parent_pad_index) != SVt_PVFM);             \
82           assert(!isGV_with_GP(_sv_parent_pad_index));                  \
83           ((XPVNV*) MUTABLE_PTR(SvANY(_sv_parent_pad_index)))->xnv_u.xpad_cop_seq.xlow; \
84          }))
85 #  define PARENT_FAKELEX_FLAGS(sv)                                      \
86         (({ const SV *const _sv_parent_fakelex_flags = (const SV *) (sv); \
87           assert(SvTYPE(_sv_parent_fakelex_flags) == SVt_NV             \
88                  || SvTYPE(_sv_parent_fakelex_flags) >= SVt_PVNV);      \
89           assert(SvTYPE(_sv_parent_fakelex_flags) != SVt_PVAV);         \
90           assert(SvTYPE(_sv_parent_fakelex_flags) != SVt_PVHV);         \
91           assert(SvTYPE(_sv_parent_fakelex_flags) != SVt_PVCV);         \
92           assert(SvTYPE(_sv_parent_fakelex_flags) != SVt_PVFM);         \
93           assert(!isGV_with_GP(_sv_parent_fakelex_flags));              \
94           ((XPVNV*) MUTABLE_PTR(SvANY(_sv_parent_fakelex_flags)))->xnv_u.xpad_cop_seq.xhigh; \
95          }))
96 #else
97 #  define COP_SEQ_RANGE_LOW(sv)         \
98         (0 + (((XPVNV*) SvANY(sv))->xnv_u.xpad_cop_seq.xlow))
99 #  define COP_SEQ_RANGE_HIGH(sv)        \
100         (0 + (((XPVNV*) SvANY(sv))->xnv_u.xpad_cop_seq.xhigh))
101
102
103 #  define PARENT_PAD_INDEX(sv)          \
104         (0 + (((XPVNV*) SvANY(sv))->xnv_u.xpad_cop_seq.xlow))
105 #  define PARENT_FAKELEX_FLAGS(sv)      \
106         (0 + (((XPVNV*) SvANY(sv))->xnv_u.xpad_cop_seq.xhigh))
107 #endif
108
109 /* Flags set in the SvIVX field of FAKE namesvs */
110
111 #define PAD_FAKELEX_ANON   1 /* the lex is declared in an ANON, or ... */
112 #define PAD_FAKELEX_MULTI  2 /* the lex can be instantiated multiple times */
113
114 /* flags for the pad_new() function */
115
116 #define padnew_CLONE    1       /* this pad is for a cloned CV */
117 #define padnew_SAVE     2       /* save old globals */
118 #define padnew_SAVESUB  4       /* also save extra stuff for start of sub */
119
120 /* values for the pad_tidy() function */
121
122 typedef enum {
123         padtidy_SUB,            /* tidy up a pad for a sub, */
124         padtidy_SUBCLONE,       /* a cloned sub, */
125         padtidy_FORMAT          /* or a format */
126 } padtidy_type;
127
128 /* flags for pad_add_name_pvn. */
129
130 #define padadd_OUR              0x01       /* our declaration. */
131 #define padadd_STATE            0x02       /* state declaration. */
132 #define padadd_NO_DUP_CHECK     0x04       /* skip warning on dups. */
133 #define padadd_STALEOK          0x08       /* allow stale lexical in active
134                                             * sub, but only one level up */
135 #define padadd_UTF8_NAME        SVf_UTF8   /* name is UTF-8 encoded. */
136
137 /* ASSERT_CURPAD_LEGAL and ASSERT_CURPAD_ACTIVE respectively determine
138  * whether PL_comppad and PL_curpad are consistent and whether they have
139  * active values */
140
141 #  define pad_peg(label)
142
143 #ifdef DEBUGGING
144 #  define ASSERT_CURPAD_LEGAL(label) \
145     pad_peg(label); \
146     if (PL_comppad ? (AvARRAY(PL_comppad) != PL_curpad) : (PL_curpad != 0))  \
147         Perl_croak(aTHX_ "panic: illegal pad in %s: 0x%" UVxf "[0x%" UVxf "]",\
148             label, PTR2UV(PL_comppad), PTR2UV(PL_curpad));
149
150
151 #  define ASSERT_CURPAD_ACTIVE(label) \
152     pad_peg(label); \
153     if (!PL_comppad || (AvARRAY(PL_comppad) != PL_curpad))                \
154         Perl_croak(aTHX_ "panic: invalid pad in %s: 0x%" UVxf "[0x%" UVxf "]",\
155             label, PTR2UV(PL_comppad), PTR2UV(PL_curpad));
156 #else
157 #  define ASSERT_CURPAD_LEGAL(label)
158 #  define ASSERT_CURPAD_ACTIVE(label)
159 #endif
160
161
162
163 /* Note: the following three macros are actually defined in scope.h, but
164  * they are documented here for completeness, since they directly or
165  * indirectly affect pads.
166
167 =for apidoc m|void|SAVEPADSV    |PADOFFSET po
168 Save a pad slot (used to restore after an iteration)
169
170 XXX DAPM it would make more sense to make the arg a PADOFFSET
171 =for apidoc m|void|SAVECLEARSV  |SV **svp
172 Clear the pointed to pad value on scope exit.  (i.e. the runtime action of
173 'my')
174
175 =for apidoc m|void|SAVECOMPPAD
176 save PL_comppad and PL_curpad
177
178
179 =for apidoc Amx|PAD **|PadlistARRAY|PADLIST padlist
180 The C array of a padlist, containing the pads.  Only subscript it with
181 numbers >= 1, as the 0th entry is not guaranteed to remain usable.
182
183 =for apidoc Amx|SSize_t|PadlistMAX|PADLIST padlist
184 The index of the last allocated space in the padlist.  Note that the last
185 pad may be in an earlier slot.  Any entries following it will be NULL in
186 that case.
187
188 =for apidoc Amx|PADNAMELIST *|PadlistNAMES|PADLIST padlist
189 The names associated with pad entries.
190
191 =for apidoc Amx|PADNAME **|PadlistNAMESARRAY|PADLIST padlist
192 The C array of pad names.
193
194 =for apidoc Amx|SSize_t|PadlistNAMESMAX|PADLIST padlist
195 The index of the last pad name.
196
197 =for apidoc Amx|U32|PadlistREFCNT|PADLIST padlist
198 The reference count of the padlist.  Currently this is always 1.
199
200 =for apidoc Amx|PADNAME **|PadnamelistARRAY|PADNAMELIST pnl
201 The C array of pad names.
202
203 =for apidoc Amx|SSize_t|PadnamelistMAX|PADNAMELIST pnl
204 The index of the last pad name.
205
206 =for apidoc Amx|SV **|PadARRAY|PAD pad
207 The C array of pad entries.
208
209 =for apidoc Amx|SSize_t|PadMAX|PAD pad
210 The index of the last pad entry.
211
212 =for apidoc Amx|char *|PadnamePV|PADNAME pn     
213 The name stored in the pad name struct.  This returns NULL for a target or
214 GV slot.
215
216 =for apidoc Amx|STRLEN|PadnameLEN|PADNAME pn    
217 The length of the name.
218
219 =for apidoc Amx|bool|PadnameUTF8|PADNAME pn
220 Whether PadnamePV is in UTF8.
221
222 =for apidoc Amx|SV *|PadnameSV|PADNAME pn
223 Returns the pad name as an SV.  This is currently just C<pn>.  It will
224 begin returning a new mortal SV if pad names ever stop being SVs.
225
226 =for apidoc m|bool|PadnameIsOUR|PADNAME pn
227 Whether this is an "our" variable.
228
229 =for apidoc m|HV *|PadnameOURSTASH
230 The stash in which this "our" variable was declared.
231
232 =for apidoc m|bool|PadnameOUTER|PADNAME pn
233 Whether this entry belongs to an outer pad.
234
235 =for apidoc m|bool|PadnameIsSTATE|PADNAME pn
236 Whether this is a "state" variable.
237
238 =for apidoc m|HV *|PadnameTYPE|PADNAME pn
239 The stash associated with a typed lexical.  This returns the %Foo:: hash
240 for C<my Foo $bar>.
241
242
243 =for apidoc m|SV *|PAD_SETSV    |PADOFFSET po|SV* sv
244 Set the slot at offset C<po> in the current pad to C<sv>
245
246 =for apidoc m|SV *|PAD_SV       |PADOFFSET po
247 Get the value at offset C<po> in the current pad
248
249 =for apidoc m|SV *|PAD_SVl      |PADOFFSET po
250 Lightweight and lvalue version of C<PAD_SV>.
251 Get or set the value at offset C<po> in the current pad.
252 Unlike C<PAD_SV>, does not print diagnostics with -DX.
253 For internal use only.
254
255 =for apidoc m|SV *|PAD_BASE_SV  |PADLIST padlist|PADOFFSET po
256 Get the value from slot C<po> in the base (DEPTH=1) pad of a padlist
257
258 =for apidoc m|void|PAD_SET_CUR  |PADLIST padlist|I32 n
259 Set the current pad to be pad C<n> in the padlist, saving
260 the previous current pad.  NB currently this macro expands to a string too
261 long for some compilers, so it's best to replace it with
262
263     SAVECOMPPAD();
264     PAD_SET_CUR_NOSAVE(padlist,n);
265
266
267 =for apidoc m|void|PAD_SET_CUR_NOSAVE   |PADLIST padlist|I32 n
268 like PAD_SET_CUR, but without the save
269
270 =for apidoc m|void|PAD_SAVE_SETNULLPAD
271 Save the current pad then set it to null.
272
273 =for apidoc m|void|PAD_SAVE_LOCAL|PAD *opad|PAD *npad
274 Save the current pad to the local variable opad, then make the
275 current pad equal to npad
276
277 =for apidoc m|void|PAD_RESTORE_LOCAL|PAD *opad
278 Restore the old pad saved into the local variable opad by PAD_SAVE_LOCAL()
279
280 =cut
281 */
282
283 #define PadlistARRAY(pl)        (pl)->xpadl_alloc
284 #define PadlistMAX(pl)          (pl)->xpadl_max
285 #define PadlistNAMES(pl)        (*PadlistARRAY(pl))
286 #define PadlistNAMESARRAY(pl)   PadnamelistARRAY(PadlistNAMES(pl))
287 #define PadlistNAMESMAX(pl)     PadnamelistMAX(PadlistNAMES(pl))
288 #define PadlistREFCNT(pl)       1       /* reserved for future use */
289
290 #define PadnamelistARRAY(pnl)   ((PADNAME **)AvARRAY(pnl))
291 #define PadnamelistMAX(pnl)     AvFILLp(pnl)
292 #define PadnamelistMAXNAMED(pnl) \
293         ((XPVAV*) SvANY(pnl))->xmg_u.xmg_hash_index
294
295 #define PadARRAY(pad)           AvARRAY(pad)
296 #define PadMAX(pad)             AvFILLp(pad)
297
298 #define PadnamePV(pn)           (SvPOKp(pn) ? SvPVX_const(pn) : NULL)
299 #define PadnameLEN(pn)          ((SV*)(pn) == &PL_sv_undef ? 0 : SvCUR(pn))
300 #define PadnameUTF8(pn)         !!SvUTF8(pn)
301 #define PadnameSV(pn)           pn
302 #define PadnameIsOUR(pn)        !!SvPAD_OUR(pn)
303 #define PadnameOURSTASH(pn)     SvOURSTASH(pn)
304 #define PadnameOUTER(pn)        !!SvFAKE(pn)
305 #define PadnameIsSTATE(pn)      !!SvPAD_STATE(pn)
306 #define PadnameTYPE(pn)         (SvPAD_TYPED(pn) ? SvSTASH(pn) : NULL)
307 #define PadnameLVALUE(pn) \
308     ((SvFLAGS(pn) & (SVpad_NAME|SVpad_LVALUE))==(SVpad_NAME|SVpad_LVALUE))
309
310 #define PadnameLVALUE_on(pn)    (SvFLAGS(pn) |= SVpad_NAME|SVpad_LVALUE)
311
312 #ifdef DEBUGGING
313 #  define PAD_SV(po)       pad_sv(po)
314 #  define PAD_SETSV(po,sv) pad_setsv(po,sv)
315 #else
316 #  define PAD_SV(po)       (PL_curpad[po])
317 #  define PAD_SETSV(po,sv) PL_curpad[po] = (sv)
318 #endif
319
320 #define PAD_SVl(po)       (PL_curpad[po])
321
322 #define PAD_BASE_SV(padlist, po) \
323         (PadlistARRAY(padlist)[1])                                      \
324             ? AvARRAY(MUTABLE_AV((PadlistARRAY(padlist)[1])))[po] \
325             : NULL;
326
327
328 #define PAD_SET_CUR_NOSAVE(padlist,nth) \
329         PL_comppad = (PAD*) (PadlistARRAY(padlist)[nth]);       \
330         PL_curpad = AvARRAY(PL_comppad);                        \
331         DEBUG_Xv(PerlIO_printf(Perl_debug_log,                  \
332               "Pad 0x%" UVxf "[0x%" UVxf "] set_cur    depth=%d\n",     \
333               PTR2UV(PL_comppad), PTR2UV(PL_curpad), (int)(nth)));
334
335
336 #define PAD_SET_CUR(padlist,nth) \
337         SAVECOMPPAD();                                          \
338         PAD_SET_CUR_NOSAVE(padlist,nth);
339
340
341 #define PAD_SAVE_SETNULLPAD()   SAVECOMPPAD(); \
342         PL_comppad = NULL; PL_curpad = NULL;    \
343         DEBUG_Xv(PerlIO_printf(Perl_debug_log, "Pad set_null\n"));
344
345 #define PAD_SAVE_LOCAL(opad,npad) \
346         opad = PL_comppad;                                      \
347         PL_comppad = (npad);                                    \
348         PL_curpad =  PL_comppad ? AvARRAY(PL_comppad) : NULL;   \
349         DEBUG_Xv(PerlIO_printf(Perl_debug_log,                  \
350               "Pad 0x%" UVxf "[0x%" UVxf "] save_local\n",              \
351               PTR2UV(PL_comppad), PTR2UV(PL_curpad)));
352
353 #define PAD_RESTORE_LOCAL(opad) \
354         assert(!opad || !SvIS_FREED(opad));                                     \
355         PL_comppad = opad;                                              \
356         PL_curpad =  PL_comppad ? AvARRAY(PL_comppad) : NULL;   \
357         DEBUG_Xv(PerlIO_printf(Perl_debug_log,                  \
358               "Pad 0x%" UVxf "[0x%" UVxf "] restore_local\n",   \
359               PTR2UV(PL_comppad), PTR2UV(PL_curpad)));
360
361
362 /*
363 =for apidoc m|void|CX_CURPAD_SAVE|struct context
364 Save the current pad in the given context block structure.
365
366 =for apidoc m|SV *|CX_CURPAD_SV|struct context|PADOFFSET po
367 Access the SV at offset po in the saved current pad in the given
368 context block structure (can be used as an lvalue).
369
370 =cut
371 */
372
373 #define CX_CURPAD_SAVE(block)  (block).oldcomppad = PL_comppad
374 #define CX_CURPAD_SV(block,po) (AvARRAY(MUTABLE_AV(((block).oldcomppad)))[po])
375
376
377 /*
378 =for apidoc m|U32|PAD_COMPNAME_FLAGS|PADOFFSET po
379 Return the flags for the current compiling pad name
380 at offset C<po>.  Assumes a valid slot entry.
381
382 =for apidoc m|char *|PAD_COMPNAME_PV|PADOFFSET po
383 Return the name of the current compiling pad name
384 at offset C<po>.  Assumes a valid slot entry.
385
386 =for apidoc m|HV *|PAD_COMPNAME_TYPE|PADOFFSET po
387 Return the type (stash) of the current compiling pad name at offset
388 C<po>.  Must be a valid name.  Returns null if not typed.
389
390 =for apidoc m|HV *|PAD_COMPNAME_OURSTASH|PADOFFSET po
391 Return the stash associated with an C<our> variable.
392 Assumes the slot entry is a valid C<our> lexical.
393
394 =for apidoc m|STRLEN|PAD_COMPNAME_GEN|PADOFFSET po
395 The generation number of the name at offset C<po> in the current
396 compiling pad (lvalue).  Note that C<SvUVX> is hijacked for this purpose.
397
398 =for apidoc m|STRLEN|PAD_COMPNAME_GEN_set|PADOFFSET po|int gen
399 Sets the generation number of the name at offset C<po> in the current
400 ling pad (lvalue) to C<gen>.  Note that C<SvUV_set> is hijacked for this purpose.
401
402 =cut
403
404 */
405
406 #define PAD_COMPNAME(po)        PAD_COMPNAME_SV(po)
407 #define PAD_COMPNAME_SV(po)     ((PADNAME *)AvARRAY(PL_comppad_name)[(po)])
408 #define PAD_COMPNAME_FLAGS(po) SvFLAGS(PAD_COMPNAME_SV(po))
409 #define PAD_COMPNAME_FLAGS_isOUR(po) SvPAD_OUR(PAD_COMPNAME_SV(po))
410 #define PAD_COMPNAME_PV(po)     PadnamePV(PAD_COMPNAME(po))
411
412 #define PAD_COMPNAME_TYPE(po) pad_compname_type(po)
413
414 #define PAD_COMPNAME_OURSTASH(po) \
415     (SvOURSTASH(PAD_COMPNAME_SV(po)))
416
417 #define PAD_COMPNAME_GEN(po) ((STRLEN)SvUVX(AvARRAY(PL_comppad_name)[po]))
418
419 #define PAD_COMPNAME_GEN_set(po, gen) SvUV_set(AvARRAY(PL_comppad_name)[po], (UV)(gen))
420
421
422 /*
423 =for apidoc m|void|PAD_CLONE_VARS|PerlInterpreter *proto_perl|CLONE_PARAMS* param
424 Clone the state variables associated with running and compiling pads.
425
426 =cut
427 */
428
429 /* NB - we set PL_comppad to null unless it points at a value that
430  * has already been dup'ed, ie it points to part of an active padlist.
431  * Otherwise PL_comppad ends up being a leaked scalar in code like
432  * the following:
433  *     threads->create(sub { threads->create(sub {...} ) } );
434  * where the second thread dups the outer sub's comppad but not the
435  * sub's CV or padlist. */
436
437 #define PAD_CLONE_VARS(proto_perl, param)                               \
438     PL_comppad                  = av_dup(proto_perl->Icomppad, param);  \
439     PL_curpad = PL_comppad ?  AvARRAY(PL_comppad) : NULL;               \
440     PL_comppad_name             = av_dup(proto_perl->Icomppad_name, param); \
441     PL_comppad_name_fill        = proto_perl->Icomppad_name_fill;       \
442     PL_comppad_name_floor       = proto_perl->Icomppad_name_floor;      \
443     PL_min_intro_pending        = proto_perl->Imin_intro_pending;       \
444     PL_max_intro_pending        = proto_perl->Imax_intro_pending;       \
445     PL_padix                    = proto_perl->Ipadix;                   \
446     PL_padix_floor              = proto_perl->Ipadix_floor;             \
447     PL_pad_reset_pending        = proto_perl->Ipad_reset_pending;       \
448     PL_cop_seqmax               = proto_perl->Icop_seqmax;
449
450 /*
451 =for apidoc Am|PADOFFSET|pad_add_name_pvs|const char *name|U32 flags|HV *typestash|HV *ourstash
452
453 Exactly like L</pad_add_name_pvn>, but takes a literal string instead
454 of a string/length pair.
455
456 =cut
457 */
458
459 #define pad_add_name_pvs(name,flags,typestash,ourstash) \
460     Perl_pad_add_name_pvn(aTHX_ STR_WITH_LEN(name), flags, typestash, ourstash)
461
462 /*
463 =for apidoc Am|PADOFFSET|pad_findmy_pvs|const char *name|U32 flags
464
465 Exactly like L</pad_findmy_pvn>, but takes a literal string instead
466 of a string/length pair.
467
468 =cut
469 */
470
471 #define pad_findmy_pvs(name,flags) \
472     Perl_pad_findmy_pvn(aTHX_ STR_WITH_LEN(name), flags)
473
474 /*
475  * Local variables:
476  * c-indentation-style: bsd
477  * c-basic-offset: 4
478  * indent-tabs-mode: nil
479  * End:
480  *
481  * ex: set ts=8 sts=4 sw=4 et:
482  */