3 * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
4 * 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by Larry Wall and others
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.
12 * '...for the Entwives desired order, and plenty, and peace (by which they
13 * meant that things should remain where they had set them).' --Treebeard
15 * [p.476 of _The Lord of the Rings_, III/iv: "Treebeard"]
19 =head1 Array Manipulation Functions
27 Perl_av_reify(pTHX_ AV *av)
32 PERL_ARGS_ASSERT_AV_REIFY;
33 assert(SvTYPE(av) == SVt_PVAV);
38 if (SvTIED_mg((const SV *)av, PERL_MAGIC_tied))
39 Perl_ck_warner_d(aTHX_ packWARN(WARN_DEBUGGING), "av_reify called on tied array");
42 while (key > AvFILLp(av) + 1)
43 AvARRAY(av)[--key] = &PL_sv_undef;
45 SV * const sv = AvARRAY(av)[--key];
47 if (sv != &PL_sv_undef)
48 SvREFCNT_inc_simple_void_NN(sv);
50 key = AvARRAY(av) - AvALLOC(av);
52 AvALLOC(av)[--key] = &PL_sv_undef;
60 Pre-extend an array. The C<key> is the index to which the array should be
67 Perl_av_extend(pTHX_ AV *av, I32 key)
72 PERL_ARGS_ASSERT_AV_EXTEND;
73 assert(SvTYPE(av) == SVt_PVAV);
75 mg = SvTIED_mg((const SV *)av, PERL_MAGIC_tied);
77 SV *arg1 = sv_newmortal();
78 sv_setiv(arg1, (IV)(key + 1));
79 Perl_magic_methcall(aTHX_ MUTABLE_SV(av), mg, "EXTEND", G_DISCARD, 1,
83 if (key > AvMAX(av)) {
88 if (AvALLOC(av) != AvARRAY(av)) {
89 ary = AvALLOC(av) + AvFILLp(av) + 1;
90 tmp = AvARRAY(av) - AvALLOC(av);
91 Move(AvARRAY(av), AvALLOC(av), AvFILLp(av)+1, SV*);
93 AvARRAY(av) = AvALLOC(av);
96 ary[--tmp] = &PL_sv_undef;
98 if (key > AvMAX(av) - 10) {
99 newmax = key + AvMAX(av);
104 #ifdef PERL_MALLOC_WRAP
105 static const char oom_array_extend[] =
106 "Out of memory during array extend"; /* Duplicated in pp_hot.c */
110 #if !defined(STRANGE_MALLOC) && !defined(MYMALLOC)
115 #ifdef Perl_safesysmalloc_size
116 /* Whilst it would be quite possible to move this logic around
117 (as I did in the SV code), so as to set AvMAX(av) early,
118 based on calling Perl_safesysmalloc_size() immediately after
119 allocation, I'm not convinced that it is a great idea here.
120 In an array we have to loop round setting everything to
121 &PL_sv_undef, which means writing to memory, potentially lots
122 of it, whereas for the SV buffer case we don't touch the
123 "bonus" memory. So there there is no cost in telling the
124 world about it, whereas here we have to do work before we can
125 tell the world about it, and that work involves writing to
126 memory that might never be read. So, I feel, better to keep
127 the current lazy system of only writing to it if our caller
128 has a need for more space. NWC */
129 newmax = Perl_safesysmalloc_size((void*)AvALLOC(av)) /
130 sizeof(const SV *) - 1;
135 newmax = key + AvMAX(av) / 5;
137 MEM_WRAP_CHECK_1(newmax+1, SV*, oom_array_extend);
138 #if defined(STRANGE_MALLOC) || defined(MYMALLOC)
139 Renew(AvALLOC(av),newmax+1, SV*);
141 bytes = (newmax + 1) * sizeof(const SV *);
142 #define MALLOC_OVERHEAD 16
143 itmp = MALLOC_OVERHEAD;
144 while ((MEM_SIZE)(itmp - MALLOC_OVERHEAD) < bytes)
146 itmp -= MALLOC_OVERHEAD;
147 itmp /= sizeof(const SV *);
148 assert(itmp > newmax);
150 assert(newmax >= AvMAX(av));
151 Newx(ary, newmax+1, SV*);
152 Copy(AvALLOC(av), ary, AvMAX(av)+1, SV*);
153 Safefree(AvALLOC(av));
156 #ifdef Perl_safesysmalloc_size
159 ary = AvALLOC(av) + AvMAX(av) + 1;
160 tmp = newmax - AvMAX(av);
161 if (av == PL_curstack) { /* Oops, grew stack (via av_store()?) */
162 PL_stack_sp = AvALLOC(av) + (PL_stack_sp - PL_stack_base);
163 PL_stack_base = AvALLOC(av);
164 PL_stack_max = PL_stack_base + newmax;
168 newmax = key < 3 ? 3 : key;
169 MEM_WRAP_CHECK_1(newmax+1, SV*, oom_array_extend);
170 Newx(AvALLOC(av), newmax+1, SV*);
171 ary = AvALLOC(av) + 1;
173 AvALLOC(av)[0] = &PL_sv_undef; /* For the stacks */
177 ary[--tmp] = &PL_sv_undef;
180 AvARRAY(av) = AvALLOC(av);
189 Returns the SV at the specified index in the array. The C<key> is the
190 index. If lval is true, you are guaranteed to get a real SV back (in case
191 it wasn't real before), which you can then modify. Check that the return
192 value is non-null before dereferencing it to a C<SV*>.
194 See L<perlguts/"Understanding the Magic of Tied Hashes and Arrays"> for
195 more information on how to use this function on tied arrays.
197 The rough perl equivalent is C<$myarray[$idx]>.
203 Perl_av_fetch(pTHX_ register AV *av, I32 key, I32 lval)
207 PERL_ARGS_ASSERT_AV_FETCH;
208 assert(SvTYPE(av) == SVt_PVAV);
210 if (SvRMAGICAL(av)) {
211 const MAGIC * const tied_magic
212 = mg_find((const SV *)av, PERL_MAGIC_tied);
213 if (tied_magic || mg_find((const SV *)av, PERL_MAGIC_regdata)) {
216 I32 adjust_index = 1;
218 /* Handle negative array indices 20020222 MJD */
219 SV * const * const negative_indices_glob =
220 hv_fetch(SvSTASH(SvRV(SvTIED_obj(MUTABLE_SV(av),
222 NEGATIVE_INDICES_VAR, 16, 0);
224 if (negative_indices_glob && SvTRUE(GvSV(*negative_indices_glob)))
229 key += AvFILL(av) + 1;
236 sv_upgrade(sv, SVt_PVLV);
237 mg_copy(MUTABLE_SV(av), sv, 0, key);
238 if (!tied_magic) /* for regdata, force leavesub to make copies */
241 LvTARG(sv) = sv; /* fake (SV**) */
242 return &(LvTARG(sv));
247 key += AvFILL(av) + 1;
252 if (key > AvFILLp(av) || AvARRAY(av)[key] == &PL_sv_undef) {
254 return lval ? av_store(av,key,newSV(0)) : NULL;
258 && (!AvARRAY(av)[key] /* eg. @_ could have freed elts */
259 || SvIS_FREED(AvARRAY(av)[key]))) {
260 AvARRAY(av)[key] = &PL_sv_undef; /* 1/2 reify */
263 return &AvARRAY(av)[key];
269 Stores an SV in an array. The array index is specified as C<key>. The
270 return value will be NULL if the operation failed or if the value did not
271 need to be actually stored within the array (as in the case of tied
272 arrays). Otherwise, it can be dereferenced
273 to get the C<SV*> that was stored
276 Note that the caller is responsible for suitably incrementing the reference
277 count of C<val> before the call, and decrementing it if the function
280 Approximate Perl equivalent: C<$myarray[$key] = $val;>.
282 See L<perlguts/"Understanding the Magic of Tied Hashes and Arrays"> for
283 more information on how to use this function on tied arrays.
289 Perl_av_store(pTHX_ register AV *av, I32 key, SV *val)
294 PERL_ARGS_ASSERT_AV_STORE;
295 assert(SvTYPE(av) == SVt_PVAV);
297 /* S_regclass relies on being able to pass in a NULL sv
298 (unicode_alternate may be NULL).
304 if (SvRMAGICAL(av)) {
305 const MAGIC * const tied_magic = mg_find((const SV *)av, PERL_MAGIC_tied);
307 /* Handle negative array indices 20020222 MJD */
309 bool adjust_index = 1;
310 SV * const * const negative_indices_glob =
311 hv_fetch(SvSTASH(SvRV(SvTIED_obj(MUTABLE_SV(av),
313 NEGATIVE_INDICES_VAR, 16, 0);
314 if (negative_indices_glob
315 && SvTRUE(GvSV(*negative_indices_glob)))
318 key += AvFILL(av) + 1;
323 if (val != &PL_sv_undef) {
324 mg_copy(MUTABLE_SV(av), val, 0, key);
332 key += AvFILL(av) + 1;
337 if (SvREADONLY(av) && key >= AvFILL(av))
338 Perl_croak_no_modify(aTHX);
340 if (!AvREAL(av) && AvREIFY(av))
345 if (AvFILLp(av) < key) {
347 if (av == PL_curstack && key > PL_stack_sp - PL_stack_base)
348 PL_stack_sp = PL_stack_base + key; /* XPUSH in disguise */
350 ary[++AvFILLp(av)] = &PL_sv_undef;
351 } while (AvFILLp(av) < key);
356 SvREFCNT_dec(ary[key]);
358 if (SvSMAGICAL(av)) {
359 const MAGIC *mg = SvMAGIC(av);
361 for (; mg; mg = mg->mg_moremagic) {
362 if (!isUPPER(mg->mg_type)) continue;
363 if (val != &PL_sv_undef) {
364 sv_magic(val, MUTABLE_SV(av), toLOWER(mg->mg_type), 0, key);
366 if (PL_delaymagic && mg->mg_type == PERL_MAGIC_isa) {
367 PL_delaymagic |= DM_ARRAY_ISA;
372 mg_set(MUTABLE_SV(av));
380 Creates a new AV and populates it with a list of SVs. The SVs are copied
381 into the array, so they may be freed after the call to av_make. The new AV
382 will have a reference count of 1.
384 Perl equivalent: C<my @new_array = ($scalar1, $scalar2, $scalar3...);>
390 Perl_av_make(pTHX_ register I32 size, register SV **strp)
392 register AV * const av = MUTABLE_AV(newSV_type(SVt_PVAV));
393 /* sv_upgrade does AvREAL_only() */
394 PERL_ARGS_ASSERT_AV_MAKE;
395 assert(SvTYPE(av) == SVt_PVAV);
397 if (size) { /* "defined" was returning undef for size==0 anyway. */
403 AvFILLp(av) = AvMAX(av) = size - 1;
404 for (i = 0; i < size; i++) {
407 /* Don't let sv_setsv swipe, since our source array might
408 have multiple references to the same temp scalar (e.g.
409 from a list slice) */
412 sv_setsv_flags(ary[i], *strp,
413 SV_GMAGIC|SV_DO_COW_SVSETSV|SV_NOSTEAL);
423 Clears an array, making it empty. Does not free the memory the av uses to
424 store its list of scalars. If any destructors are triggered as a result,
425 the av itself may be freed when this function returns.
427 Perl equivalent: C<@myarray = ();>.
433 Perl_av_clear(pTHX_ register AV *av)
439 PERL_ARGS_ASSERT_AV_CLEAR;
440 assert(SvTYPE(av) == SVt_PVAV);
443 if (SvREFCNT(av) == 0) {
444 Perl_ck_warner_d(aTHX_ packWARN(WARN_DEBUGGING), "Attempt to clear deleted array");
449 Perl_croak_no_modify(aTHX);
451 /* Give any tie a chance to cleanup first */
452 if (SvRMAGICAL(av)) {
453 const MAGIC* const mg = SvMAGIC(av);
454 if (PL_delaymagic && mg && mg->mg_type == PERL_MAGIC_isa)
455 PL_delaymagic |= DM_ARRAY_ISA;
457 mg_clear(MUTABLE_SV(av));
463 if ((real = !!AvREAL(av))) {
464 SV** const ary = AvARRAY(av);
465 I32 index = AvFILLp(av) + 1;
467 SAVEFREESV(SvREFCNT_inc_simple_NN(av));
469 SV * const sv = ary[--index];
470 /* undef the slot before freeing the value, because a
471 * destructor might try to modify this array */
472 ary[index] = &PL_sv_undef;
476 extra = AvARRAY(av) - AvALLOC(av);
479 AvARRAY(av) = AvALLOC(av);
488 Undefines the array. Frees the memory used by the av to store its list of
489 scalars. If any destructors are triggered as a result, the av itself may
496 Perl_av_undef(pTHX_ register AV *av)
500 PERL_ARGS_ASSERT_AV_UNDEF;
501 assert(SvTYPE(av) == SVt_PVAV);
503 /* Give any tie a chance to cleanup first */
504 if (SvTIED_mg((const SV *)av, PERL_MAGIC_tied))
507 if ((real = !!AvREAL(av))) {
508 register I32 key = AvFILLp(av) + 1;
510 SAVEFREESV(SvREFCNT_inc_simple_NN(av));
512 SvREFCNT_dec(AvARRAY(av)[--key]);
515 Safefree(AvALLOC(av));
518 AvMAX(av) = AvFILLp(av) = -1;
520 if(SvRMAGICAL(av)) mg_clear(MUTABLE_SV(av));
526 =for apidoc av_create_and_push
528 Push an SV onto the end of the array, creating the array if necessary.
529 A small internal helper function to remove a commonly duplicated idiom.
535 Perl_av_create_and_push(pTHX_ AV **const avp, SV *const val)
537 PERL_ARGS_ASSERT_AV_CREATE_AND_PUSH;
547 Pushes an SV onto the end of the array. The array will grow automatically
548 to accommodate the addition. This takes ownership of one reference count.
550 Perl equivalent: C<push @myarray, $elem;>.
556 Perl_av_push(pTHX_ register AV *av, SV *val)
561 PERL_ARGS_ASSERT_AV_PUSH;
562 assert(SvTYPE(av) == SVt_PVAV);
565 Perl_croak_no_modify(aTHX);
567 if ((mg = SvTIED_mg((const SV *)av, PERL_MAGIC_tied))) {
568 Perl_magic_methcall(aTHX_ MUTABLE_SV(av), mg, "PUSH", G_DISCARD, 1,
572 av_store(av,AvFILLp(av)+1,val);
578 Pops an SV off the end of the array. Returns C<&PL_sv_undef> if the array
581 Perl equivalent: C<pop(@myarray);>
587 Perl_av_pop(pTHX_ register AV *av)
593 PERL_ARGS_ASSERT_AV_POP;
594 assert(SvTYPE(av) == SVt_PVAV);
597 Perl_croak_no_modify(aTHX);
598 if ((mg = SvTIED_mg((const SV *)av, PERL_MAGIC_tied))) {
599 retval = Perl_magic_methcall(aTHX_ MUTABLE_SV(av), mg, "POP", 0, 0);
601 retval = newSVsv(retval);
606 retval = AvARRAY(av)[AvFILLp(av)];
607 AvARRAY(av)[AvFILLp(av)--] = &PL_sv_undef;
609 mg_set(MUTABLE_SV(av));
615 =for apidoc av_create_and_unshift_one
617 Unshifts an SV onto the beginning of the array, creating the array if
619 A small internal helper function to remove a commonly duplicated idiom.
625 Perl_av_create_and_unshift_one(pTHX_ AV **const avp, SV *const val)
627 PERL_ARGS_ASSERT_AV_CREATE_AND_UNSHIFT_ONE;
632 return av_store(*avp, 0, val);
636 =for apidoc av_unshift
638 Unshift the given number of C<undef> values onto the beginning of the
639 array. The array will grow automatically to accommodate the addition. You
640 must then use C<av_store> to assign values to these new elements.
642 Perl equivalent: C<unshift @myarray, ( (undef) x $n );>
648 Perl_av_unshift(pTHX_ register AV *av, register I32 num)
654 PERL_ARGS_ASSERT_AV_UNSHIFT;
655 assert(SvTYPE(av) == SVt_PVAV);
658 Perl_croak_no_modify(aTHX);
660 if ((mg = SvTIED_mg((const SV *)av, PERL_MAGIC_tied))) {
661 Perl_magic_methcall(aTHX_ MUTABLE_SV(av), mg, "UNSHIFT",
662 G_DISCARD | G_UNDEF_FILL, num);
668 if (!AvREAL(av) && AvREIFY(av))
670 i = AvARRAY(av) - AvALLOC(av);
678 AvARRAY(av) = AvARRAY(av) - i;
682 const I32 i = AvFILLp(av);
683 /* Create extra elements */
684 const I32 slide = i > 0 ? i : 0;
686 av_extend(av, i + num);
689 Move(ary, ary + num, i + 1, SV*);
691 ary[--num] = &PL_sv_undef;
693 /* Make extra elements into a buffer */
695 AvFILLp(av) -= slide;
696 AvARRAY(av) = AvARRAY(av) + slide;
703 Shifts an SV off the beginning of the
704 array. Returns C<&PL_sv_undef> if the
707 Perl equivalent: C<shift(@myarray);>
713 Perl_av_shift(pTHX_ register AV *av)
719 PERL_ARGS_ASSERT_AV_SHIFT;
720 assert(SvTYPE(av) == SVt_PVAV);
723 Perl_croak_no_modify(aTHX);
724 if ((mg = SvTIED_mg((const SV *)av, PERL_MAGIC_tied))) {
725 retval = Perl_magic_methcall(aTHX_ MUTABLE_SV(av), mg, "SHIFT", 0, 0);
727 retval = newSVsv(retval);
732 retval = *AvARRAY(av);
734 *AvARRAY(av) = &PL_sv_undef;
735 AvARRAY(av) = AvARRAY(av) + 1;
739 mg_set(MUTABLE_SV(av));
746 Returns the highest index in the array. The number of elements in the
747 array is C<av_len(av) + 1>. Returns -1 if the array is empty.
749 The Perl equivalent for this is C<$#myarray>.
755 Perl_av_len(pTHX_ AV *av)
757 PERL_ARGS_ASSERT_AV_LEN;
758 assert(SvTYPE(av) == SVt_PVAV);
766 Set the highest index in the array to the given number, equivalent to
767 Perl's C<$#array = $fill;>.
769 The number of elements in the an array will be C<fill + 1> after
770 av_fill() returns. If the array was previously shorter, then the
771 additional elements appended are set to C<PL_sv_undef>. If the array
772 was longer, then the excess elements are freed. C<av_fill(av, -1)> is
773 the same as C<av_clear(av)>.
778 Perl_av_fill(pTHX_ register AV *av, I32 fill)
783 PERL_ARGS_ASSERT_AV_FILL;
784 assert(SvTYPE(av) == SVt_PVAV);
788 if ((mg = SvTIED_mg((const SV *)av, PERL_MAGIC_tied))) {
789 SV *arg1 = sv_newmortal();
790 sv_setiv(arg1, (IV)(fill + 1));
791 Perl_magic_methcall(aTHX_ MUTABLE_SV(av), mg, "STORESIZE", G_DISCARD,
795 if (fill <= AvMAX(av)) {
796 I32 key = AvFILLp(av);
797 SV** const ary = AvARRAY(av);
801 SvREFCNT_dec(ary[key]);
802 ary[key--] = &PL_sv_undef;
807 ary[++key] = &PL_sv_undef;
812 mg_set(MUTABLE_SV(av));
815 (void)av_store(av,fill,&PL_sv_undef);
819 =for apidoc av_delete
821 Deletes the element indexed by C<key> from the array, makes the element mortal,
822 and returns it. If C<flags> equals C<G_DISCARD>, the element is freed and null
823 is returned. Perl equivalent: C<my $elem = delete($myarray[$idx]);> for the
824 non-C<G_DISCARD> version and a void-context C<delete($myarray[$idx]);> for the
825 C<G_DISCARD> version.
830 Perl_av_delete(pTHX_ AV *av, I32 key, I32 flags)
835 PERL_ARGS_ASSERT_AV_DELETE;
836 assert(SvTYPE(av) == SVt_PVAV);
839 Perl_croak_no_modify(aTHX);
841 if (SvRMAGICAL(av)) {
842 const MAGIC * const tied_magic
843 = mg_find((const SV *)av, PERL_MAGIC_tied);
844 if ((tied_magic || mg_find((const SV *)av, PERL_MAGIC_regdata))) {
845 /* Handle negative array indices 20020222 MJD */
848 unsigned adjust_index = 1;
850 SV * const * const negative_indices_glob =
851 hv_fetch(SvSTASH(SvRV(SvTIED_obj(MUTABLE_SV(av),
853 NEGATIVE_INDICES_VAR, 16, 0);
854 if (negative_indices_glob
855 && SvTRUE(GvSV(*negative_indices_glob)))
859 key += AvFILL(av) + 1;
864 svp = av_fetch(av, key, TRUE);
868 if (mg_find(sv, PERL_MAGIC_tiedelem)) {
869 sv_unmagic(sv, PERL_MAGIC_tiedelem); /* No longer an element */
878 key += AvFILL(av) + 1;
883 if (key > AvFILLp(av))
886 if (!AvREAL(av) && AvREIFY(av))
888 sv = AvARRAY(av)[key];
889 if (key == AvFILLp(av)) {
890 AvARRAY(av)[key] = &PL_sv_undef;
893 } while (--key >= 0 && AvARRAY(av)[key] == &PL_sv_undef);
896 AvARRAY(av)[key] = &PL_sv_undef;
898 mg_set(MUTABLE_SV(av));
900 if (flags & G_DISCARD) {
910 =for apidoc av_exists
912 Returns true if the element indexed by C<key> has been initialized.
914 This relies on the fact that uninitialized array elements are set to
917 Perl equivalent: C<exists($myarray[$key])>.
922 Perl_av_exists(pTHX_ AV *av, I32 key)
925 PERL_ARGS_ASSERT_AV_EXISTS;
926 assert(SvTYPE(av) == SVt_PVAV);
928 if (SvRMAGICAL(av)) {
929 const MAGIC * const tied_magic
930 = mg_find((const SV *)av, PERL_MAGIC_tied);
931 const MAGIC * const regdata_magic
932 = mg_find((const SV *)av, PERL_MAGIC_regdata);
933 if (tied_magic || regdata_magic) {
934 SV * const sv = sv_newmortal();
936 /* Handle negative array indices 20020222 MJD */
938 unsigned adjust_index = 1;
940 SV * const * const negative_indices_glob =
941 hv_fetch(SvSTASH(SvRV(SvTIED_obj(MUTABLE_SV(av),
943 NEGATIVE_INDICES_VAR, 16, 0);
944 if (negative_indices_glob
945 && SvTRUE(GvSV(*negative_indices_glob)))
949 key += AvFILL(av) + 1;
957 if(key >= 0 && regdata_magic) {
958 if (key <= AvFILL(av))
964 mg_copy(MUTABLE_SV(av), sv, 0, key);
965 mg = mg_find(sv, PERL_MAGIC_tiedelem);
967 magic_existspack(sv, mg);
968 return cBOOL(SvTRUE(sv));
975 key += AvFILL(av) + 1;
980 if (key <= AvFILLp(av) && AvARRAY(av)[key] != &PL_sv_undef
990 S_get_aux_mg(pTHX_ AV *av) {
994 PERL_ARGS_ASSERT_GET_AUX_MG;
995 assert(SvTYPE(av) == SVt_PVAV);
997 mg = mg_find((const SV *)av, PERL_MAGIC_arylen_p);
1000 mg = sv_magicext(MUTABLE_SV(av), 0, PERL_MAGIC_arylen_p,
1001 &PL_vtbl_arylen_p, 0, 0);
1003 /* sv_magicext won't set this for us because we pass in a NULL obj */
1004 mg->mg_flags |= MGf_REFCOUNTED;
1010 Perl_av_arylen_p(pTHX_ AV *av) {
1011 MAGIC *const mg = get_aux_mg(av);
1013 PERL_ARGS_ASSERT_AV_ARYLEN_P;
1014 assert(SvTYPE(av) == SVt_PVAV);
1016 return &(mg->mg_obj);
1020 Perl_av_iter_p(pTHX_ AV *av) {
1021 MAGIC *const mg = get_aux_mg(av);
1023 PERL_ARGS_ASSERT_AV_ITER_P;
1024 assert(SvTYPE(av) == SVt_PVAV);
1026 #if IVSIZE == I32SIZE
1027 return (IV *)&(mg->mg_len);
1031 mg->mg_len = IVSIZE;
1033 mg->mg_ptr = (char *) temp;
1035 return (IV *)mg->mg_ptr;
1041 * c-indentation-style: bsd
1043 * indent-tabs-mode: nil
1046 * ex: set ts=8 sts=4 sw=4 et: