OpenCoverage

mbiter.h

Absolute File Name:

/home/opencoverage/opencoverage/guest-scripts/coreutils/src/gnulib/lib/mbiter.h

Source code

Switch to Preprocessed file

Line Source Count

1 /* Iterating through multibyte strings: macros for multi-byte encodings. -

3 -

4 This program is free software: you can redistribute it and/or modify -

5 it under the terms of the GNU General Public License as published by -

6 the Free Software Foundation; either version 3 of the License, or -

7 (at your option) any later version. -

8 -

9 This program is distributed in the hope that it will be useful, -

10 but WITHOUT ANY WARRANTY; without even the implied warranty of -

11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -

12 GNU General Public License for more details. -

13 -

14 You should have received a copy of the GNU General Public License -

15 along with this program. If not, see <https://www.gnu.org/licenses/>. */ -

16 -

17 /* Written by Bruno Haible <bruno@clisp.org>. */ -

18 -

19 /* The macros in this file implement forward iteration through a -

20 multi-byte string. -

21 -

22 With these macros, an iteration loop that looks like -

23 -

24 char *iter; -

25 for (iter = buf; iter < buf + buflen; iter++) -

26 { -

27 do_something (*iter); -

28 } -

29 -

30 becomes -

31 -

32 mbi_iterator_t iter; -

33 for (mbi_init (iter, buf, buflen); mbi_avail (iter); mbi_advance (iter)) -

34 { -

35 do_something (mbi_cur_ptr (iter), mb_len (mbi_cur (iter))); -

36 } -

37 -

38 The benefit of these macros over plain use of mbrtowc is: -

39 - Handling of invalid multibyte sequences is possible without -

40 making the code more complicated, while still preserving the -

41 invalid multibyte sequences. -

42 -

43 mbi_iterator_t -

44 is a type usable for variable declarations. -

45 -

46 mbi_init (iter, startptr, length) -

47 initializes the iterator, starting at startptr and crossing length bytes. -

48 -

49 mbi_avail (iter) -

50 returns true if there are more multibyte characters available before -

51 the end of string is reached. In this case, mbi_cur (iter) is -

52 initialized to the next multibyte character. -

53 -

54 mbi_advance (iter) -

55 advances the iterator by one multibyte character. -

56 -

57 mbi_cur (iter) -

58 returns the current multibyte character, of type mbchar_t. All the -

59 macros defined in mbchar.h can be used on it. -

60 -

61 mbi_cur_ptr (iter) -

62 return a pointer to the beginning of the current multibyte character. -

63 -

64 mbi_reloc (iter, ptrdiff) -

65 relocates iterator when the string is moved by ptrdiff bytes. -

66 -

67 mbi_copy (&destiter, &srciter) -

68 copies srciter to destiter. -

69 -

70 Here are the function prototypes of the macros. -

71 -

72 extern void mbi_init (mbi_iterator_t iter, -

73 const char *startptr, size_t length); -

74 extern bool mbi_avail (mbi_iterator_t iter); -

75 extern void mbi_advance (mbi_iterator_t iter); -

76 extern mbchar_t mbi_cur (mbi_iterator_t iter); -

77 extern const char * mbi_cur_ptr (mbi_iterator_t iter); -

78 extern void mbi_reloc (mbi_iterator_t iter, ptrdiff_t ptrdiff); -

79 extern void mbi_copy (mbi_iterator_t *new, const mbi_iterator_t *old); -

80 */ -

81 -

82 #ifndef _MBITER_H -

83 #define _MBITER_H 1 -

84 -

85 #include <assert.h> -

86 #include <stdbool.h> -

87 #include <stddef.h> -

88 #include <string.h> -

89 -

90 /* Tru64 with Desktop Toolkit C has a bug: <stdio.h> must be included before -

91 <wchar.h>. -

92 BSD/OS 4.1 has a bug: <stdio.h> and <time.h> must be included before -

93 <wchar.h>. */ -

94 #include <stdio.h> -

95 #include <time.h> -

96 #include <wchar.h> -

97 -

98 #include "mbchar.h" -

99 -

100 #ifndef _GL_INLINE_HEADER_BEGIN -

101 #error "Please include config.h first." -

102 #endif -

103 _GL_INLINE_HEADER_BEGIN -

104 #ifndef MBITER_INLINE -

105 # define MBITER_INLINE _GL_INLINE -

106 #endif -

107 -

108 struct mbiter_multi -

109 { -

110 const char *limit; /* pointer to end of string */ -

111 bool in_shift; /* true if next byte may not be interpreted as ASCII */ -

112 mbstate_t state; /* if in_shift: current shift state */ -

113 bool next_done; /* true if mbi_avail has already filled the following */ -

114 struct mbchar cur; /* the current character: -

115 const char *cur.ptr pointer to current character -

116 The following are only valid after mbi_avail. -

117 size_t cur.bytes number of bytes of current character -

118 bool cur.wc_valid true if wc is a valid wide character -

119 wchar_t cur.wc if wc_valid: the current character -

120 */ -

121 }; -

122 -

123 MBITER_INLINE void -

124 mbiter_multi_next (struct mbiter_multi *iter) -

125 { -

126

if (iter->next_done)

iter->next_done	Description
TRUE	never evaluated
FALSE	never evaluated

127

return;

never executed: return;

128

if (iter->in_shift)

iter->in_shift	Description
TRUE	never evaluated
FALSE	never evaluated

129

goto with_shift;

never executed: goto with_shift;

130 /* Handle most ASCII characters quickly, without calling mbrtowc(). */ -

131

if (is_basic (*iter->cur.ptr))

is_basic (*iter->cur.ptr)	Description
TRUE	never evaluated
FALSE	never evaluated

132 { -

133 /* These characters are part of the basic character set. ISO C 99 -

134 guarantees that their wide character code is identical to their -

135 char code. */ -

136 iter->cur.bytes = 1; -

137 iter->cur.wc = *iter->cur.ptr; -

138 iter->cur.wc_valid = true; -

139

}

never executed: end of block

140 else -

141 { -

142 assert (mbsinit (&iter->state)); -

143 iter->in_shift = true; -

144

with_shift:

code before this statement never executed: with_shift:

145 iter->cur.bytes = mbrtowc (&iter->cur.wc, iter->cur.ptr, -

146 iter->limit - iter->cur.ptr, &iter->state); -

147

if (iter->cur.bytes == (size_t) -1)

iter->cur.bytes == (size_t) -1	Description
TRUE	never evaluated
FALSE	never evaluated

148 { -

149 /* An invalid multibyte sequence was encountered. */ -

150 iter->cur.bytes = 1; -

151 iter->cur.wc_valid = false; -

152 /* Whether to set iter->in_shift = false and reset iter->state -

153 or not is not very important; the string is bogus anyway. */ -

154

}

never executed: end of block

155

else if (iter->cur.bytes == (size_t) -2)

iter->cur.bytes == (size_t) -2	Description
TRUE	never evaluated
FALSE	never evaluated

156 { -

157 /* An incomplete multibyte character at the end. */ -

158 iter->cur.bytes = iter->limit - iter->cur.ptr; -

159 iter->cur.wc_valid = false; -

160 /* Whether to set iter->in_shift = false and reset iter->state -

161 or not is not important; the string end is reached anyway. */ -

162

}

never executed: end of block

163 else -

164 { -

165

if (iter->cur.bytes == 0)

iter->cur.bytes == 0	Description
TRUE	never evaluated
FALSE	never evaluated

166 { -

167 /* A null wide character was encountered. */ -

168 iter->cur.bytes = 1; -

169 assert (*iter->cur.ptr == '\0'); -

170 assert (iter->cur.wc == 0); -

171

}

never executed: end of block

172 iter->cur.wc_valid = true; -

173 -

174 /* When in the initial state, we can go back treating ASCII -

175 characters more quickly. */ -

176

if (mbsinit (&iter->state))

mbsinit (&iter->state)	Description
TRUE	never evaluated
FALSE	never evaluated

177

iter->in_shift = false;

never executed: iter->in_shift = 0 ;

178

}

never executed: end of block

179 } -

180 iter->next_done = true; -

181

}

never executed: end of block

182 -

183 MBITER_INLINE void -

184 mbiter_multi_reloc (struct mbiter_multi *iter, ptrdiff_t ptrdiff) -

185 { -

186 iter->cur.ptr += ptrdiff; -

187 iter->limit += ptrdiff; -

188

}

never executed: end of block

189 -

190 MBITER_INLINE void -

191 mbiter_multi_copy (struct mbiter_multi *new_iter, const struct mbiter_multi *old_iter) -

192 { -

193 new_iter->limit = old_iter->limit; -

194

if ((new_iter->in_shift = old_iter->in_shift))

(new_iter->in_...ter->in_shift)	Description
TRUE	never evaluated
FALSE	never evaluated

195

memcpy (&new_iter->state, &old_iter->state, sizeof (mbstate_t));

never executed: memcpy (&new_iter->state, &old_iter->state, sizeof (mbstate_t));

196 else -

197

memset (&new_iter->state, 0, sizeof (mbstate_t));

never executed: memset (&new_iter->state, 0, sizeof (mbstate_t));

198 new_iter->next_done = old_iter->next_done; -

199 mb_copy (&new_iter->cur, &old_iter->cur); -

200

}

never executed: end of block

201 -

202 /* Iteration macros. */ -

203 typedef struct mbiter_multi mbi_iterator_t; -

204 #define mbi_init(iter, startptr, length) \ -

205 ((iter).cur.ptr = (startptr), (iter).limit = (iter).cur.ptr + (length), \ -

206 (iter).in_shift = false, memset (&(iter).state, '\0', sizeof (mbstate_t)), \ -

207 (iter).next_done = false) -

208 #define mbi_avail(iter) \ -

209 ((iter).cur.ptr < (iter).limit && (mbiter_multi_next (&(iter)), true)) -

210 #define mbi_advance(iter) \ -

211 ((iter).cur.ptr += (iter).cur.bytes, (iter).next_done = false) -

212 -

213 /* Access to the current character. */ -

214 #define mbi_cur(iter) (iter).cur -

215 #define mbi_cur_ptr(iter) (iter).cur.ptr -

216 -

217 /* Relocation. */ -

218 #define mbi_reloc(iter, ptrdiff) mbiter_multi_reloc (&iter, ptrdiff) -

219 -

220 /* Copying an iterator. */ -

221 #define mbi_copy mbiter_multi_copy -

222 -

223 _GL_INLINE_HEADER_END -

224 -

225 #endif /* _MBITER_H */ -

Source code

Switch to Preprocessed file

Generated by Squish Coco 4.1.2