]>
git.saurik.com Git - apple/libc.git/blob - gen/glob-fbsd.c
30df8a7dfa34631f68b4d88f75b98d922dea4182
2 * Copyright (c) 1989, 1993
3 * The Regents of the University of California. All rights reserved.
5 * This code is derived from software contributed to Berkeley by
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. All advertising materials mentioning features or use of this software
17 * must display the following acknowledgement:
18 * This product includes software developed by the University of
19 * California, Berkeley and its contributors.
20 * 4. Neither the name of the University nor the names of its contributors
21 * may be used to endorse or promote products derived from this software
22 * without specific prior written permission.
24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
37 #if defined(LIBC_SCCS) && !defined(lint)
38 static char sccsid
[] = "@(#)glob.c 8.3 (Berkeley) 10/13/93";
39 #endif /* LIBC_SCCS and not lint */
40 #include <sys/cdefs.h>
41 __FBSDID("$FreeBSD: src/lib/libc/gen/glob.c,v 1.22 2004/07/29 03:48:52 tjr Exp $");
43 #include "xlocale_private.h"
46 * glob(3) -- a superset of the one defined in POSIX 1003.2.
48 * The [!...] convention to negate a range is supported (SysV, Posix, ksh).
50 * Optional extra services, controlled by flags not defined by POSIX:
53 * Escaping convention: \ inhibits any special meaning the following
54 * character might have (except \ at end of string is retained).
56 * Set in gl_flags if pattern contained a globbing character.
58 * Same as GLOB_NOCHECK, but it will only append pattern if it did
59 * not contain any magic characters. [Used in csh style globbing]
61 * Use alternately specified directory access functions.
63 * expand ~user/foo to the /home/dir/of/user/foo
65 * expand {1,2}{a,b} to 1a 1b 2a 2b
67 * Number of matches in the current invocation of glob.
71 * Some notes on multibyte character support:
72 * 1. Patterns with illegal byte sequences match nothing - even if
73 * GLOB_NOCHECK is specified.
74 * 2. Illegal byte sequences in filenames are handled by treating them as
75 * single-byte characters with a value of the first byte of the sequence
77 * 3. State-dependent encodings are not currently supported.
80 #include <sys/param.h>
110 #define UNDERSCORE '_'
118 #define M_QUOTE 0x8000000000ULL
119 #define M_PROTECT 0x4000000000ULL
120 #define M_MASK 0xffffffffffULL
121 #define M_CHAR 0x00ffffffffULL
123 typedef uint_fast64_t Char
;
128 #define M_PROTECT 0x40
137 #define CHAR(c) ((Char)((c)&M_CHAR))
138 #define META(c) ((Char)((c)|M_QUOTE))
139 #define M_ALL META('*')
140 #define M_END META(']')
141 #define M_NOT META('!')
142 #define M_ONE META('?')
143 #define M_RNG META('-')
144 #define M_SET META('[')
145 #define ismeta(c) (((c)&M_QUOTE) != 0)
148 #define compare __gl_compare
149 #define g_Ctoc __gl_g_Ctoc
150 #define g_strchr __gl_g_strchr
151 #define globextend __gl_globextend
152 #define globtilde __gl_globtilde
153 #define match __gl_match
154 __private_extern__
int compare(const void *, const void *);
155 __private_extern__
int g_Ctoc(const Char
*, char *, u_int
, locale_t
);
156 __private_extern__ Char
*g_strchr(Char
*, wchar_t);
157 __private_extern__
int globextend(const Char
*, glob_t
*, int *, locale_t
);
158 __private_extern__
const Char
*
159 globtilde(const Char
*, Char
*, size_t, glob_t
*);
160 __private_extern__
int match(Char
*, Char
*, Char
*, locale_t
);
163 static int g_lstat(Char
*, struct stat
*, glob_t
*, locale_t
);
164 static DIR *g_opendir(Char
*, glob_t
*, locale_t
);
166 static Char
*g_strcat(Char
*, const Char
*);
168 static int g_stat(Char
*, struct stat
*, glob_t
*, locale_t
);
169 static int glob0(const Char
*, glob_t
*, int *, locale_t
);
170 static int glob1(Char
*, glob_t
*, int *, locale_t
);
171 static int glob2(Char
*, Char
*, Char
*, Char
*, glob_t
*, int *, locale_t
);
172 static int glob3(Char
*, Char
*, Char
*, Char
*, Char
*, glob_t
*, int *, locale_t
);
173 static int globexp1(const Char
*, glob_t
*, int *, locale_t
);
174 static int globexp2(const Char
*, const Char
*, glob_t
*, int *, int *, locale_t
);
176 static void qprintf(const char *, Char
*);
180 glob(pattern
, flags
, errfunc
, pglob
)
182 int flags
, (*errfunc
)(const char *, int);
185 const u_char
*patnext
;
187 Char
*bufnext
, *bufend
, patbuf
[MAXPATHLEN
], prot
;
191 locale_t loc
= __current_locale();
192 int mb_cur_max
= MB_CUR_MAX_L(loc
);
194 patnext
= (u_char
*) pattern
;
195 if (!(flags
& GLOB_APPEND
)) {
197 pglob
->gl_pathv
= NULL
;
198 if (!(flags
& GLOB_DOOFFS
))
201 if (flags
& GLOB_LIMIT
) {
202 limit
= pglob
->gl_matchc
;
207 pglob
->gl_flags
= flags
& ~GLOB_MAGCHAR
;
208 pglob
->gl_errfunc
= errfunc
;
209 pglob
->gl_matchc
= 0;
212 bufend
= bufnext
+ MAXPATHLEN
- 1;
213 if (flags
& GLOB_NOESCAPE
) {
214 memset(&mbs
, 0, sizeof(mbs
));
215 while (bufend
- bufnext
>= mb_cur_max
) {
216 clen
= mbrtowc_l(&wc
, (const char *)patnext
, MB_LEN_MAX
, &mbs
, loc
);
217 if (clen
== (size_t)-1 || clen
== (size_t)-2)
218 return (GLOB_NOMATCH
);
225 /* Protect the quoted characters. */
226 memset(&mbs
, 0, sizeof(mbs
));
227 while (bufend
- bufnext
>= mb_cur_max
) {
228 if (*patnext
== QUOTE
) {
229 if (*++patnext
== EOS
) {
230 *bufnext
++ = QUOTE
| M_PROTECT
;
236 clen
= mbrtowc_l(&wc
, (const char *)patnext
, MB_LEN_MAX
, &mbs
, loc
);
237 if (clen
== (size_t)-1 || clen
== (size_t)-2)
238 return (GLOB_NOMATCH
);
241 *bufnext
++ = wc
| prot
;
247 if (flags
& GLOB_BRACE
)
248 return globexp1(patbuf
, pglob
, &limit
, loc
);
250 return glob0(patbuf
, pglob
, &limit
, loc
);
254 * Expand recursively a glob {} pattern. When there is no more expansion
255 * invoke the standard globbing routine to glob the rest of the magic
259 globexp1(pattern
, pglob
, limit
, loc
)
265 const Char
* ptr
= pattern
;
268 /* Protect a single {}, for find(1), like csh */
269 if (pattern
[0] == LBRACE
&& pattern
[1] == RBRACE
&& pattern
[2] == EOS
)
270 return glob0(pattern
, pglob
, limit
, loc
);
272 while ((ptr
= (const Char
*) g_strchr((Char
*) ptr
, LBRACE
)) != NULL
)
273 if (!globexp2(ptr
, pattern
, pglob
, &rv
, limit
, loc
))
276 return glob0(pattern
, pglob
, limit
, loc
);
281 * Recursive brace globbing helper. Tries to expand a single brace.
282 * If it succeeds then it invokes globexp1 with the new pattern.
283 * If it fails then it tries to glob the rest of the pattern and returns.
286 globexp2(ptr
, pattern
, pglob
, rv
, limit
, loc
)
287 const Char
*ptr
, *pattern
;
294 const Char
*pe
, *pm
, *pl
;
295 Char patbuf
[MAXPATHLEN
];
297 /* copy part up to the brace */
298 for (lm
= patbuf
, pm
= pattern
; pm
!= ptr
; *lm
++ = *pm
++)
303 /* Find the balanced brace */
304 for (i
= 0, pe
= ++ptr
; *pe
; pe
++)
305 if (*pe
== LBRACKET
) {
306 /* Ignore everything between [] */
307 for (pm
= pe
++; *pe
!= RBRACKET
&& *pe
!= EOS
; pe
++)
311 * We could not find a matching RBRACKET.
312 * Ignore and just look for RBRACE
317 else if (*pe
== LBRACE
)
319 else if (*pe
== RBRACE
) {
325 /* Non matching braces; just glob the pattern */
326 if (i
!= 0 || *pe
== EOS
) {
327 *rv
= glob0(patbuf
, pglob
, limit
, loc
);
331 for (i
= 0, pl
= pm
= ptr
; pm
<= pe
; pm
++)
334 /* Ignore everything between [] */
335 for (pl
= pm
++; *pm
!= RBRACKET
&& *pm
!= EOS
; pm
++)
339 * We could not find a matching RBRACKET.
340 * Ignore and just look for RBRACE
357 if (i
&& *pm
== COMMA
)
360 /* Append the current string */
361 for (lm
= ls
; (pl
< pm
); *lm
++ = *pl
++)
364 * Append the rest of the pattern after the
367 for (pl
= pe
+ 1; (*lm
++ = *pl
++) != EOS
;)
370 /* Expand the current pattern */
372 qprintf("globexp2:", patbuf
);
374 *rv
= globexp1(patbuf
, pglob
, limit
, loc
);
376 /* move after the comma, to the next string */
390 #ifndef BUILDING_VARIANT
392 * expand tilde from the passwd file.
394 __private_extern__
const Char
*
395 globtilde(pattern
, patbuf
, patbuf_len
, pglob
)
406 if (*pattern
!= TILDE
|| !(pglob
->gl_flags
& GLOB_TILDE
))
410 * Copy up to the end of the string or /
412 eb
= &patbuf
[patbuf_len
- 1];
413 for (p
= pattern
+ 1, h
= (char *) patbuf
;
414 h
< (char *)eb
&& *p
&& *p
!= SLASH
; *h
++ = *p
++)
419 if (((char *) patbuf
)[0] == EOS
) {
421 * handle a plain ~ or ~/ by expanding $HOME first (iff
422 * we're not running setuid or setgid) and then trying
425 if (issetugid() != 0 ||
426 (h
= getenv("HOME")) == NULL
) {
427 if (((h
= getlogin()) != NULL
&&
428 (pwd
= getpwnam(h
)) != NULL
) ||
429 (pwd
= getpwuid(getuid())) != NULL
)
439 if ((pwd
= getpwnam((char*) patbuf
)) == NULL
)
445 /* Copy the home directory */
446 for (b
= patbuf
; b
< eb
&& *h
; *b
++ = *h
++)
449 /* Append the rest of the pattern */
450 while (b
< eb
&& (*b
++ = *p
++) != EOS
)
456 #endif /* BUILDING_VARIANT */
460 * The main glob() routine: compiles the pattern (optionally processing
461 * quotes), calls glob1() to do the real pattern matching, and finally
462 * sorts the list (unless unsorted operation is requested). Returns 0
463 * if things went well, nonzero if errors occurred.
466 glob0(pattern
, pglob
, limit
, loc
)
472 const Char
*qpatnext
;
475 Char
*bufnext
, patbuf
[MAXPATHLEN
];
477 qpatnext
= globtilde(pattern
, patbuf
, MAXPATHLEN
, pglob
);
478 oldpathc
= pglob
->gl_pathc
;
481 /* We don't need to check for buffer overflow any more. */
482 while ((c
= *qpatnext
++) != EOS
) {
484 *bufnext
++ = CHAR(c
);
492 if (*qpatnext
== EOS
||
493 g_strchr((Char
*) qpatnext
+1, RBRACKET
) == NULL
) {
494 *bufnext
++ = LBRACKET
;
504 *bufnext
++ = CHAR(c
);
505 if (*qpatnext
== RANGE
&&
506 (c
= qpatnext
[1]) != RBRACKET
) {
508 *bufnext
++ = CHAR(c
);
511 } while ((c
= *qpatnext
++) != RBRACKET
);
512 pglob
->gl_flags
|= GLOB_MAGCHAR
;
516 pglob
->gl_flags
|= GLOB_MAGCHAR
;
520 pglob
->gl_flags
|= GLOB_MAGCHAR
;
521 /* collapse adjacent stars to one,
522 * to avoid exponential behavior
524 if (bufnext
== patbuf
|| bufnext
[-1] != M_ALL
)
528 *bufnext
++ = CHAR(c
);
534 qprintf("glob0:", patbuf
);
537 if ((err
= glob1(patbuf
, pglob
, limit
, loc
)) != 0)
541 * If there was no match we are going to append the pattern
542 * if GLOB_NOCHECK was specified or if GLOB_NOMAGIC was specified
543 * and the pattern did not contain any magic characters
544 * GLOB_NOMAGIC is there just for compatibility with csh.
546 if (pglob
->gl_pathc
== oldpathc
) {
547 if (((pglob
->gl_flags
& GLOB_NOCHECK
) ||
548 ((pglob
->gl_flags
& GLOB_NOMAGIC
) &&
549 !(pglob
->gl_flags
& GLOB_MAGCHAR
))))
550 return(globextend(pattern
, pglob
, limit
, loc
));
552 return(GLOB_NOMATCH
);
554 if (!(pglob
->gl_flags
& GLOB_NOSORT
))
555 qsort(pglob
->gl_pathv
+ pglob
->gl_offs
+ oldpathc
,
556 pglob
->gl_pathc
- oldpathc
, sizeof(char *), compare
);
560 #ifndef BUILDING_VARIANT
561 __private_extern__
int
565 return(strcoll(*(char **)p
, *(char **)q
));
567 #endif /* BUILDING_VARIANT */
570 glob1(pattern
, pglob
, limit
, loc
)
576 Char pathbuf
[MAXPATHLEN
];
578 /* A null pathname is invalid -- POSIX 1003.1 sect. 2.4. */
581 return(glob2(pathbuf
, pathbuf
, pathbuf
+ MAXPATHLEN
- 1,
582 pattern
, pglob
, limit
, loc
));
586 * The functions glob2 and glob3 are mutually recursive; there is one level
587 * of recursion for each segment in the pattern that contains one or more
591 glob2(pathbuf
, pathend
, pathend_last
, pattern
, pglob
, limit
, loc
)
592 Char
*pathbuf
, *pathend
, *pathend_last
, *pattern
;
602 * Loop over pattern segments until end of pattern or until
603 * segment with meta character found.
605 for (anymeta
= 0;;) {
606 if (*pattern
== EOS
) { /* End of pattern? */
608 if (g_lstat(pathbuf
, &sb
, pglob
, loc
))
611 if (((pglob
->gl_flags
& GLOB_MARK
) &&
612 pathend
[-1] != SEP
) && (S_ISDIR(sb
.st_mode
)
613 || (S_ISLNK(sb
.st_mode
) &&
614 (g_stat(pathbuf
, &sb
, pglob
, loc
) == 0) &&
615 S_ISDIR(sb
.st_mode
)))) {
616 if (pathend
+ 1 > pathend_last
)
617 return (GLOB_ABORTED
);
622 return(globextend(pathbuf
, pglob
, limit
, loc
));
625 /* Find end of next segment, copy tentatively to pathend. */
628 while (*p
!= EOS
&& *p
!= SEP
) {
631 if (q
+ 1 > pathend_last
)
632 return (GLOB_ABORTED
);
636 if (!anymeta
) { /* No expansion, do next segment. */
639 while (*pattern
== SEP
) {
640 if (pathend
+ 1 > pathend_last
)
641 return (GLOB_ABORTED
);
642 *pathend
++ = *pattern
++;
644 } else /* Need expansion, recurse. */
645 return(glob3(pathbuf
, pathend
, pathend_last
, pattern
, p
,
652 glob3(pathbuf
, pathend
, pathend_last
, pattern
, restpattern
, pglob
, limit
, loc
)
653 Char
*pathbuf
, *pathend
, *pathend_last
, *pattern
, *restpattern
;
661 char buf
[MAXPATHLEN
];
664 * The readdirfunc declaration can't be prototyped, because it is
665 * assigned, below, to two functions which are prototyped in glob.h
666 * and dirent.h as taking pointers to differently typed opaque
669 struct dirent
*(*readdirfunc
)();
671 if (pathend
> pathend_last
)
672 return (GLOB_ABORTED
);
676 if ((dirp
= g_opendir(pathbuf
, pglob
, loc
)) == NULL
) {
677 /* TODO: don't call for ENOENT or ENOTDIR? */
678 if (pglob
->gl_errfunc
) {
679 if (g_Ctoc(pathbuf
, buf
, sizeof(buf
), loc
))
680 return (GLOB_ABORTED
);
681 if (pglob
->gl_errfunc(buf
, errno
))
682 return (GLOB_ABORTED
);
684 if (pglob
->gl_flags
& GLOB_ERR
)
685 return (GLOB_ABORTED
);
691 /* Search directory for matching names. */
692 if (pglob
->gl_flags
& GLOB_ALTDIRFUNC
)
693 readdirfunc
= pglob
->gl_readdir
;
695 readdirfunc
= readdir
;
696 while ((dp
= (*readdirfunc
)(dirp
))) {
703 /* Initial DOT must be matched literally. */
704 if (dp
->d_name
[0] == DOT
&& *pattern
!= DOT
)
706 memset(&mbs
, 0, sizeof(mbs
));
708 sc
= (u_char
*) dp
->d_name
;
709 while (dc
< pathend_last
) {
710 clen
= mbrtowc_l(&wc
, (const char *)sc
, MB_LEN_MAX
, &mbs
, loc
);
711 if (clen
== (size_t)-1 || clen
== (size_t)-2) {
714 memset(&mbs
, 0, sizeof(mbs
));
716 if ((*dc
++ = wc
) == EOS
)
720 if (!match(pathend
, pattern
, restpattern
, loc
)) {
724 err
= glob2(pathbuf
, --dc
, pathend_last
, restpattern
,
730 if (pglob
->gl_flags
& GLOB_ALTDIRFUNC
)
731 (*pglob
->gl_closedir
)(dirp
);
738 #ifndef BUILDING_VARIANT
740 * Extend the gl_pathv member of a glob_t structure to accomodate a new item,
741 * add the new item, and update gl_pathc.
743 * This assumes the BSD realloc, which only copies the block when its size
744 * crosses a power-of-two boundary; for v7 realloc, this would cause quadratic
747 * Return 0 if new item added, error code if memory couldn't be allocated.
749 * Invariant of the glob_t structure:
750 * Either gl_pathc is zero and gl_pathv is NULL; or gl_pathc > 0 and
751 * gl_pathv points to (gl_offs + gl_pathc + 1) items.
753 __private_extern__
int
754 globextend(path
, pglob
, limit
, loc
)
766 if (*limit
&& pglob
->gl_pathc
> *limit
) {
768 return (GLOB_NOSPACE
);
771 newsize
= sizeof(*pathv
) * (2 + pglob
->gl_pathc
+ pglob
->gl_offs
);
772 pathv
= pglob
->gl_pathv
?
773 realloc((char *)pglob
->gl_pathv
, newsize
) :
776 if (pglob
->gl_pathv
) {
777 free(pglob
->gl_pathv
);
778 pglob
->gl_pathv
= NULL
;
780 return(GLOB_NOSPACE
);
783 if (pglob
->gl_pathv
== NULL
&& pglob
->gl_offs
> 0) {
784 /* first time around -- clear initial gl_offs items */
785 pathv
+= pglob
->gl_offs
;
786 for (i
= pglob
->gl_offs
; --i
>= 0; )
789 pglob
->gl_pathv
= pathv
;
791 for (p
= path
; *p
++;)
793 len
= MB_CUR_MAX_L(loc
) * (size_t)(p
- path
); /* XXX overallocation */
794 if ((copy
= malloc(len
)) != NULL
) {
795 if (g_Ctoc(path
, copy
, len
, loc
)) {
797 return (GLOB_NOSPACE
);
799 pathv
[pglob
->gl_offs
+ pglob
->gl_pathc
++] = copy
;
801 pathv
[pglob
->gl_offs
+ pglob
->gl_pathc
] = NULL
;
802 return(copy
== NULL
? GLOB_NOSPACE
: 0);
806 * pattern matching function for filenames. Each occurrence of the *
807 * pattern causes a recursion level.
809 __private_extern__
int
810 match(name
, pat
, patend
, loc
)
811 Char
*name
, *pat
, *patend
;
814 int ok
, negate_range
;
817 while (pat
< patend
) {
819 switch (c
& M_MASK
) {
824 if (match(name
, pat
, patend
, loc
))
826 while (*name
++ != EOS
);
834 if ((k
= *name
++) == EOS
)
836 if ((negate_range
= ((*pat
& M_MASK
) == M_NOT
)) != EOS
)
838 while (((c
= *pat
++) & M_MASK
) != M_END
)
839 if ((*pat
& M_MASK
) == M_RNG
) {
840 if (loc
->__collate_load_error
?
841 CHAR(c
) <= CHAR(k
) && CHAR(k
) <= CHAR(pat
[1]) :
842 __collate_range_cmp(CHAR(c
), CHAR(k
), loc
) <= 0
843 && __collate_range_cmp(CHAR(k
), CHAR(pat
[1]), loc
) <= 0
849 if (ok
== negate_range
)
858 return(*name
== EOS
);
861 /* Free allocated data belonging to a glob_t structure. */
869 if (pglob
->gl_pathv
!= NULL
) {
870 pp
= pglob
->gl_pathv
+ pglob
->gl_offs
;
871 for (i
= pglob
->gl_pathc
; i
--; ++pp
)
874 free(pglob
->gl_pathv
);
875 pglob
->gl_pathv
= NULL
;
878 #endif /* !BUILDING_VARIANT */
881 g_opendir(str
, pglob
, loc
)
886 char buf
[MAXPATHLEN
];
891 if (g_Ctoc(str
, buf
, sizeof(buf
), loc
))
895 if (pglob
->gl_flags
& GLOB_ALTDIRFUNC
)
896 return((*pglob
->gl_opendir
)(buf
));
898 return(opendir(buf
));
902 g_lstat(fn
, sb
, pglob
, loc
)
908 char buf
[MAXPATHLEN
];
910 if (g_Ctoc(fn
, buf
, sizeof(buf
), loc
)) {
911 errno
= ENAMETOOLONG
;
914 if (pglob
->gl_flags
& GLOB_ALTDIRFUNC
)
915 return((*pglob
->gl_lstat
)(buf
, sb
));
916 return(lstat(buf
, sb
));
920 g_stat(fn
, sb
, pglob
, loc
)
926 char buf
[MAXPATHLEN
];
928 if (g_Ctoc(fn
, buf
, sizeof(buf
), loc
)) {
929 errno
= ENAMETOOLONG
;
932 if (pglob
->gl_flags
& GLOB_ALTDIRFUNC
)
933 return((*pglob
->gl_stat
)(buf
, sb
));
934 return(stat(buf
, sb
));
937 #ifndef BUILDING_VARIANT
938 __private_extern__ Char
*
950 __private_extern__
int
951 g_Ctoc(str
, buf
, len
, loc
)
959 int mb_cur_max
= MB_CUR_MAX_L(loc
);
961 memset(&mbs
, 0, sizeof(mbs
));
962 while (len
>= mb_cur_max
) {
963 clen
= wcrtomb_l(buf
, *str
, &mbs
, loc
);
964 if (clen
== (size_t)-1)
983 (void)printf("%s:\n", str
);
985 (void)printf("%c", CHAR(*p
));
988 (void)printf("%c", *p
& M_PROTECT
? '"' : ' ');
991 (void)printf("%c", ismeta(*p
) ? '_' : ' ');
995 #endif /* !BUILDING_VARIANT */