Ruby 2.0.0p353(2013-11-22revision43784)

- Main Page
- Modules
- Data Structures
- Files

- File List
- Globals

regenc.c
Go to the documentation of this file.
1 /**********************************************************************
2 regenc.c - Onigmo (Oniguruma-mod) (regular expression library)
3 **********************************************************************/
4 /*-
5 * Copyright (c) 2002-2007 K.Kosako <sndgk393 AT ybb DOT ne DOT jp>
6 * Copyright (c) 2011 K.Takata <kentkt AT csc DOT jp>
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28 * SUCH DAMAGE.
29 */
30
31 #include "regint.h"
32
33 OnigEncoding OnigEncDefaultCharEncoding = ONIG_ENCODING_INIT_DEFAULT;
34
35 extern int
36 onigenc_init(void)
37 {
38 return 0;
39 }
40
41 extern OnigEncoding
42 onigenc_get_default_encoding(void)
43 {
44 return OnigEncDefaultCharEncoding;
45 }
46
47 extern int
48 onigenc_set_default_encoding(OnigEncoding enc)
49 {
50 OnigEncDefaultCharEncoding = enc;
51 return 0;
52 }
53
54 extern int
55 onigenc_mbclen_approximate(const OnigUChar* p,const OnigUChar* e, struct OnigEncodingTypeST* enc)
56 {
57 int ret = ONIGENC_PRECISE_MBC_ENC_LEN(enc,p,e);
58 if (ONIGENC_MBCLEN_CHARFOUND_P(ret))
59 return ONIGENC_MBCLEN_CHARFOUND_LEN(ret);
60 else if (ONIGENC_MBCLEN_NEEDMORE_P(ret))
61 return (int)(e-p)+ONIGENC_MBCLEN_NEEDMORE_LEN(ret);
62 return 1;
63 }
64
65 extern UChar*
66 onigenc_get_right_adjust_char_head(OnigEncoding enc, const UChar* start, const UChar* s, const UChar* end)
67 {
68 UChar* p = ONIGENC_LEFT_ADJUST_CHAR_HEAD(enc, start, s, end);
69 if (p < s) {
70 p += enclen(enc, p, end);
71 }
72 return p;
73 }
74
75 extern UChar*
76 onigenc_get_right_adjust_char_head_with_prev(OnigEncoding enc,
77 const UChar* start, const UChar* s, const UChar* end, const UChar** prev)
78 {
79 UChar* p = ONIGENC_LEFT_ADJUST_CHAR_HEAD(enc, start, s, end);
80
81 if (p < s) {
82 if (prev) *prev = (const UChar* )p;
83 p += enclen(enc, p, end);
84 }
85 else {
86 if (prev) *prev = (const UChar* )NULL; /* Sorry */
87 }
88 return p;
89 }
90
91 extern UChar*
92 onigenc_get_prev_char_head(OnigEncoding enc, const UChar* start, const UChar* s, const UChar* end)
93 {
94 if (s <= start)
95 return (UChar* )NULL;
96
97 return ONIGENC_LEFT_ADJUST_CHAR_HEAD(enc, start, s - 1, end);
98 }
99
100 extern UChar*
101 onigenc_step_back(OnigEncoding enc, const UChar* start, const UChar* s, const UChar* end, int n)
102 {
103 while (ONIG_IS_NOT_NULL(s) && n-- > 0) {
104 if (s <= start)
105 return (UChar* )NULL;
106
107 s = ONIGENC_LEFT_ADJUST_CHAR_HEAD(enc, start, s - 1, end);
108 }
109 return (UChar* )s;
110 }
111
112 extern UChar*
113 onigenc_step(OnigEncoding enc, const UChar* p, const UChar* end, int n)
114 {
115 UChar* q = (UChar* )p;
116 while (n-- > 0) {
117 q += ONIGENC_MBC_ENC_LEN(enc, q, end);
118 }
119 return (q <= end ? q : NULL);
120 }
121
122 extern int
123 onigenc_strlen(OnigEncoding enc, const UChar* p, const UChar* end)
124 {
125 int n = 0;
126 UChar* q = (UChar* )p;
127
128 while (q < end) {
129 q += ONIGENC_MBC_ENC_LEN(enc, q, end);
130 n++;
131 }
132 return n;
133 }
134
135 extern int
136 onigenc_strlen_null(OnigEncoding enc, const UChar* s)
137 {
138 int n = 0;
139 UChar* p = (UChar* )s;
140 UChar* e;
141
142 while (1) {
143 if (*p == '\0') {
144 UChar* q;
145 int len = ONIGENC_MBC_MINLEN(enc);
146
147 if (len == 1) return n;
148 q = p + 1;
149 while (len > 1) {
150 if (*q != '\0') break;
151 q++;
152 len--;
153 }
154 if (len == 1) return n;
155 }
156 e = p + ONIGENC_MBC_MAXLEN(enc);
157 p += ONIGENC_MBC_ENC_LEN(enc, p, e);
158 n++;
159 }
160 }
161
162 extern int
163 onigenc_str_bytelen_null(OnigEncoding enc, const UChar* s)
164 {
165 UChar* start = (UChar* )s;
166 UChar* p = (UChar* )s;
167 UChar* e;
168
169 while (1) {
170 if (*p == '\0') {
171 UChar* q;
172 int len = ONIGENC_MBC_MINLEN(enc);
173
174 if (len == 1) return (int )(p - start);
175 q = p + 1;
176 while (len > 1) {
177 if (*q != '\0') break;
178 q++;
179 len--;
180 }
181 if (len == 1) return (int )(p - start);
182 }
183 e = p + ONIGENC_MBC_MAXLEN(enc);
184 p += ONIGENC_MBC_ENC_LEN(enc, p, e);
185 }
186 }
187
188 const UChar OnigEncAsciiToLowerCaseTable[] = {
189 '\000', '\001', '\002', '\003', '\004', '\005', '\006', '\007',
190 '\010', '\011', '\012', '\013', '\014', '\015', '\016', '\017',
191 '\020', '\021', '\022', '\023', '\024', '\025', '\026', '\027',
192 '\030', '\031', '\032', '\033', '\034', '\035', '\036', '\037',
193 '\040', '\041', '\042', '\043', '\044', '\045', '\046', '\047',
194 '\050', '\051', '\052', '\053', '\054', '\055', '\056', '\057',
195 '\060', '\061', '\062', '\063', '\064', '\065', '\066', '\067',
196 '\070', '\071', '\072', '\073', '\074', '\075', '\076', '\077',
197 '\100', '\141', '\142', '\143', '\144', '\145', '\146', '\147',
198 '\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157',
199 '\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167',
200 '\170', '\171', '\172', '\133', '\134', '\135', '\136', '\137',
201 '\140', '\141', '\142', '\143', '\144', '\145', '\146', '\147',
202 '\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157',
203 '\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167',
204 '\170', '\171', '\172', '\173', '\174', '\175', '\176', '\177',
205 '\200', '\201', '\202', '\203', '\204', '\205', '\206', '\207',
206 '\210', '\211', '\212', '\213', '\214', '\215', '\216', '\217',
207 '\220', '\221', '\222', '\223', '\224', '\225', '\226', '\227',
208 '\230', '\231', '\232', '\233', '\234', '\235', '\236', '\237',
209 '\240', '\241', '\242', '\243', '\244', '\245', '\246', '\247',
210 '\250', '\251', '\252', '\253', '\254', '\255', '\256', '\257',
211 '\260', '\261', '\262', '\263', '\264', '\265', '\266', '\267',
212 '\270', '\271', '\272', '\273', '\274', '\275', '\276', '\277',
213 '\300', '\301', '\302', '\303', '\304', '\305', '\306', '\307',
214 '\310', '\311', '\312', '\313', '\314', '\315', '\316', '\317',
215 '\320', '\321', '\322', '\323', '\324', '\325', '\326', '\327',
216 '\330', '\331', '\332', '\333', '\334', '\335', '\336', '\337',
217 '\340', '\341', '\342', '\343', '\344', '\345', '\346', '\347',
218 '\350', '\351', '\352', '\353', '\354', '\355', '\356', '\357',
219 '\360', '\361', '\362', '\363', '\364', '\365', '\366', '\367',
220 '\370', '\371', '\372', '\373', '\374', '\375', '\376', '\377',
221 };
222
223 #ifdef USE_UPPER_CASE_TABLE
224 const UChar OnigEncAsciiToUpperCaseTable[256] = {
225 '\000', '\001', '\002', '\003', '\004', '\005', '\006', '\007',
226 '\010', '\011', '\012', '\013', '\014', '\015', '\016', '\017',
227 '\020', '\021', '\022', '\023', '\024', '\025', '\026', '\027',
228 '\030', '\031', '\032', '\033', '\034', '\035', '\036', '\037',
229 '\040', '\041', '\042', '\043', '\044', '\045', '\046', '\047',
230 '\050', '\051', '\052', '\053', '\054', '\055', '\056', '\057',
231 '\060', '\061', '\062', '\063', '\064', '\065', '\066', '\067',
232 '\070', '\071', '\072', '\073', '\074', '\075', '\076', '\077',
233 '\100', '\101', '\102', '\103', '\104', '\105', '\106', '\107',
234 '\110', '\111', '\112', '\113', '\114', '\115', '\116', '\117',
235 '\120', '\121', '\122', '\123', '\124', '\125', '\126', '\127',
236 '\130', '\131', '\132', '\133', '\134', '\135', '\136', '\137',
237 '\140', '\101', '\102', '\103', '\104', '\105', '\106', '\107',
238 '\110', '\111', '\112', '\113', '\114', '\115', '\116', '\117',
239 '\120', '\121', '\122', '\123', '\124', '\125', '\126', '\127',
240 '\130', '\131', '\132', '\173', '\174', '\175', '\176', '\177',
241 '\200', '\201', '\202', '\203', '\204', '\205', '\206', '\207',
242 '\210', '\211', '\212', '\213', '\214', '\215', '\216', '\217',
243 '\220', '\221', '\222', '\223', '\224', '\225', '\226', '\227',
244 '\230', '\231', '\232', '\233', '\234', '\235', '\236', '\237',
245 '\240', '\241', '\242', '\243', '\244', '\245', '\246', '\247',
246 '\250', '\251', '\252', '\253', '\254', '\255', '\256', '\257',
247 '\260', '\261', '\262', '\263', '\264', '\265', '\266', '\267',
248 '\270', '\271', '\272', '\273', '\274', '\275', '\276', '\277',
249 '\300', '\301', '\302', '\303', '\304', '\305', '\306', '\307',
250 '\310', '\311', '\312', '\313', '\314', '\315', '\316', '\317',
251 '\320', '\321', '\322', '\323', '\324', '\325', '\326', '\327',
252 '\330', '\331', '\332', '\333', '\334', '\335', '\336', '\337',
253 '\340', '\341', '\342', '\343', '\344', '\345', '\346', '\347',
254 '\350', '\351', '\352', '\353', '\354', '\355', '\356', '\357',
255 '\360', '\361', '\362', '\363', '\364', '\365', '\366', '\367',
256 '\370', '\371', '\372', '\373', '\374', '\375', '\376', '\377',
257 };
258 #endif
259
260 const unsigned short OnigEncAsciiCtypeTable[256] = {
261 0x4008, 0x4008, 0x4008, 0x4008, 0x4008, 0x4008, 0x4008, 0x4008,
262 0x4008, 0x420c, 0x4209, 0x4208, 0x4208, 0x4208, 0x4008, 0x4008,
263 0x4008, 0x4008, 0x4008, 0x4008, 0x4008, 0x4008, 0x4008, 0x4008,
264 0x4008, 0x4008, 0x4008, 0x4008, 0x4008, 0x4008, 0x4008, 0x4008,
265 0x4284, 0x41a0, 0x41a0, 0x41a0, 0x41a0, 0x41a0, 0x41a0, 0x41a0,
266 0x41a0, 0x41a0, 0x41a0, 0x41a0, 0x41a0, 0x41a0, 0x41a0, 0x41a0,
267 0x78b0, 0x78b0, 0x78b0, 0x78b0, 0x78b0, 0x78b0, 0x78b0, 0x78b0,
268 0x78b0, 0x78b0, 0x41a0, 0x41a0, 0x41a0, 0x41a0, 0x41a0, 0x41a0,
269 0x41a0, 0x7ca2, 0x7ca2, 0x7ca2, 0x7ca2, 0x7ca2, 0x7ca2, 0x74a2,
270 0x74a2, 0x74a2, 0x74a2, 0x74a2, 0x74a2, 0x74a2, 0x74a2, 0x74a2,
271 0x74a2, 0x74a2, 0x74a2, 0x74a2, 0x74a2, 0x74a2, 0x74a2, 0x74a2,
272 0x74a2, 0x74a2, 0x74a2, 0x41a0, 0x41a0, 0x41a0, 0x41a0, 0x51a0,
273 0x41a0, 0x78e2, 0x78e2, 0x78e2, 0x78e2, 0x78e2, 0x78e2, 0x70e2,
274 0x70e2, 0x70e2, 0x70e2, 0x70e2, 0x70e2, 0x70e2, 0x70e2, 0x70e2,
275 0x70e2, 0x70e2, 0x70e2, 0x70e2, 0x70e2, 0x70e2, 0x70e2, 0x70e2,
276 0x70e2, 0x70e2, 0x70e2, 0x41a0, 0x41a0, 0x41a0, 0x41a0, 0x4008,
277 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
278 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
279 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
280 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
281 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
282 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
283 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
284 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
285 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
286 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
287 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
288 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
289 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
290 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
291 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
292 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000
293 };
294
295 const UChar OnigEncISO_8859_1_ToLowerCaseTable[256] = {
296 '\000', '\001', '\002', '\003', '\004', '\005', '\006', '\007',
297 '\010', '\011', '\012', '\013', '\014', '\015', '\016', '\017',
298 '\020', '\021', '\022', '\023', '\024', '\025', '\026', '\027',
299 '\030', '\031', '\032', '\033', '\034', '\035', '\036', '\037',
300 '\040', '\041', '\042', '\043', '\044', '\045', '\046', '\047',
301 '\050', '\051', '\052', '\053', '\054', '\055', '\056', '\057',
302 '\060', '\061', '\062', '\063', '\064', '\065', '\066', '\067',
303 '\070', '\071', '\072', '\073', '\074', '\075', '\076', '\077',
304 '\100', '\141', '\142', '\143', '\144', '\145', '\146', '\147',
305 '\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157',
306 '\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167',
307 '\170', '\171', '\172', '\133', '\134', '\135', '\136', '\137',
308 '\140', '\141', '\142', '\143', '\144', '\145', '\146', '\147',
309 '\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157',
310 '\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167',
311 '\170', '\171', '\172', '\173', '\174', '\175', '\176', '\177',
312 '\200', '\201', '\202', '\203', '\204', '\205', '\206', '\207',
313 '\210', '\211', '\212', '\213', '\214', '\215', '\216', '\217',
314 '\220', '\221', '\222', '\223', '\224', '\225', '\226', '\227',
315 '\230', '\231', '\232', '\233', '\234', '\235', '\236', '\237',
316 '\240', '\241', '\242', '\243', '\244', '\245', '\246', '\247',
317 '\250', '\251', '\252', '\253', '\254', '\255', '\256', '\257',
318 '\260', '\261', '\262', '\263', '\264', '\265', '\266', '\267',
319 '\270', '\271', '\272', '\273', '\274', '\275', '\276', '\277',
320 '\340', '\341', '\342', '\343', '\344', '\345', '\346', '\347',
321 '\350', '\351', '\352', '\353', '\354', '\355', '\356', '\357',
322 '\360', '\361', '\362', '\363', '\364', '\365', '\366', '\327',
323 '\370', '\371', '\372', '\373', '\374', '\375', '\376', '\337',
324 '\340', '\341', '\342', '\343', '\344', '\345', '\346', '\347',
325 '\350', '\351', '\352', '\353', '\354', '\355', '\356', '\357',
326 '\360', '\361', '\362', '\363', '\364', '\365', '\366', '\367',
327 '\370', '\371', '\372', '\373', '\374', '\375', '\376', '\377'
328 };
329
330 #ifdef USE_UPPER_CASE_TABLE
331 const UChar OnigEncISO_8859_1_ToUpperCaseTable[256] = {
332 '\000', '\001', '\002', '\003', '\004', '\005', '\006', '\007',
333 '\010', '\011', '\012', '\013', '\014', '\015', '\016', '\017',
334 '\020', '\021', '\022', '\023', '\024', '\025', '\026', '\027',
335 '\030', '\031', '\032', '\033', '\034', '\035', '\036', '\037',
336 '\040', '\041', '\042', '\043', '\044', '\045', '\046', '\047',
337 '\050', '\051', '\052', '\053', '\054', '\055', '\056', '\057',
338 '\060', '\061', '\062', '\063', '\064', '\065', '\066', '\067',
339 '\070', '\071', '\072', '\073', '\074', '\075', '\076', '\077',
340 '\100', '\101', '\102', '\103', '\104', '\105', '\106', '\107',
341 '\110', '\111', '\112', '\113', '\114', '\115', '\116', '\117',
342 '\120', '\121', '\122', '\123', '\124', '\125', '\126', '\127',
343 '\130', '\131', '\132', '\133', '\134', '\135', '\136', '\137',
344 '\140', '\101', '\102', '\103', '\104', '\105', '\106', '\107',
345 '\110', '\111', '\112', '\113', '\114', '\115', '\116', '\117',
346 '\120', '\121', '\122', '\123', '\124', '\125', '\126', '\127',
347 '\130', '\131', '\132', '\173', '\174', '\175', '\176', '\177',
348 '\200', '\201', '\202', '\203', '\204', '\205', '\206', '\207',
349 '\210', '\211', '\212', '\213', '\214', '\215', '\216', '\217',
350 '\220', '\221', '\222', '\223', '\224', '\225', '\226', '\227',
351 '\230', '\231', '\232', '\233', '\234', '\235', '\236', '\237',
352 '\240', '\241', '\242', '\243', '\244', '\245', '\246', '\247',
353 '\250', '\251', '\252', '\253', '\254', '\255', '\256', '\257',
354 '\260', '\261', '\262', '\263', '\264', '\265', '\266', '\267',
355 '\270', '\271', '\272', '\273', '\274', '\275', '\276', '\277',
356 '\300', '\301', '\302', '\303', '\304', '\305', '\306', '\307',
357 '\310', '\311', '\312', '\313', '\314', '\315', '\316', '\317',
358 '\320', '\321', '\322', '\323', '\324', '\325', '\326', '\327',
359 '\330', '\331', '\332', '\333', '\334', '\335', '\336', '\337',
360 '\300', '\301', '\302', '\303', '\304', '\305', '\306', '\307',
361 '\310', '\311', '\312', '\313', '\314', '\315', '\316', '\317',
362 '\320', '\321', '\322', '\323', '\324', '\325', '\326', '\367',
363 '\330', '\331', '\332', '\333', '\334', '\335', '\336', '\377',
364 };
365 #endif
366
367 extern void
368 onigenc_set_default_caseconv_table(const UChar* table ARG_UNUSED)
369 {
370 /* nothing */
371 /* obsoleted. */
372 }
373
374 extern UChar*
375 onigenc_get_left_adjust_char_head(OnigEncoding enc, const UChar* start, const UChar* s, const UChar* end)
376 {
377 return ONIGENC_LEFT_ADJUST_CHAR_HEAD(enc, start, s, end);
378 }
379
380 const OnigPairCaseFoldCodes OnigAsciiLowerMap[] = {
381 { 0x41, 0x61 },
382 { 0x42, 0x62 },
383 { 0x43, 0x63 },
384 { 0x44, 0x64 },
385 { 0x45, 0x65 },
386 { 0x46, 0x66 },
387 { 0x47, 0x67 },
388 { 0x48, 0x68 },
389 { 0x49, 0x69 },
390 { 0x4a, 0x6a },
391 { 0x4b, 0x6b },
392 { 0x4c, 0x6c },
393 { 0x4d, 0x6d },
394 { 0x4e, 0x6e },
395 { 0x4f, 0x6f },
396 { 0x50, 0x70 },
397 { 0x51, 0x71 },
398 { 0x52, 0x72 },
399 { 0x53, 0x73 },
400 { 0x54, 0x74 },
401 { 0x55, 0x75 },
402 { 0x56, 0x76 },
403 { 0x57, 0x77 },
404 { 0x58, 0x78 },
405 { 0x59, 0x79 },
406 { 0x5a, 0x7a }
407 };
408
409 extern int
410 onigenc_ascii_apply_all_case_fold(OnigCaseFoldType flag ARG_UNUSED,
411 OnigApplyAllCaseFoldFunc f, void* arg,
412 OnigEncoding enc ARG_UNUSED)
413 {
414 OnigCodePoint code;
415 int i, r;
416
417 for (i = 0;
418 i < (int )(sizeof(OnigAsciiLowerMap)/sizeof(OnigPairCaseFoldCodes));
419 i++) {
420 code = OnigAsciiLowerMap[i].to;
421 r = (*f)(OnigAsciiLowerMap[i].from, &code, 1, arg);
422 if (r != 0) return r;
423
424 code = OnigAsciiLowerMap[i].from;
425 r = (*f)(OnigAsciiLowerMap[i].to, &code, 1, arg);
426 if (r != 0) return r;
427 }
428
429 return 0;
430 }
431
432 extern int
433 onigenc_ascii_get_case_fold_codes_by_str(OnigCaseFoldType flag ARG_UNUSED,
434 const OnigUChar* p, const OnigUChar* end ARG_UNUSED, OnigCaseFoldCodeItem items[],
435 OnigEncoding enc ARG_UNUSED)
436 {
437 if (0x41 <= *p && *p <= 0x5a) {
438 items[0].byte_len = 1;
439 items[0].code_len = 1;
440 items[0].code[0] = (OnigCodePoint )(*p + 0x20);
441 return 1;
442 }
443 else if (0x61 <= *p && *p <= 0x7a) {
444 items[0].byte_len = 1;
445 items[0].code_len = 1;
446 items[0].code[0] = (OnigCodePoint )(*p - 0x20);
447 return 1;
448 }
449 else
450 return 0;
451 }
452
453 static int
454 ss_apply_all_case_fold(OnigCaseFoldType flag ARG_UNUSED,
455 OnigApplyAllCaseFoldFunc f, void* arg)
456 {
457 OnigCodePoint ss[] = { 0x73, 0x73 };
458
459 return (*f)((OnigCodePoint )0xdf, ss, 2, arg);
460 }
461
462 extern int
463 onigenc_apply_all_case_fold_with_map(int map_size,
464 const OnigPairCaseFoldCodes map[],
465 int ess_tsett_flag, OnigCaseFoldType flag,
466 OnigApplyAllCaseFoldFunc f, void* arg)
467 {
468 OnigCodePoint code;
469 int i, r;
470
471 r = onigenc_ascii_apply_all_case_fold(flag, f, arg, 0);
472 if (r != 0) return r;
473
474 for (i = 0; i < map_size; i++) {
475 code = map[i].to;
476 r = (*f)(map[i].from, &code, 1, arg);
477 if (r != 0) return r;
478
479 code = map[i].from;
480 r = (*f)(map[i].to, &code, 1, arg);
481 if (r != 0) return r;
482 }
483
484 if (ess_tsett_flag != 0)
485 return ss_apply_all_case_fold(flag, f, arg);
486
487 return 0;
488 }
489
490 extern int
491 onigenc_get_case_fold_codes_by_str_with_map(int map_size,
492 const OnigPairCaseFoldCodes map[],
493 int ess_tsett_flag, OnigCaseFoldType flag ARG_UNUSED,
494 const OnigUChar* p, const OnigUChar* end, OnigCaseFoldCodeItem items[])
495 {
496 if (0x41 <= *p && *p <= 0x5a) {
497 items[0].byte_len = 1;
498 items[0].code_len = 1;
499 items[0].code[0] = (OnigCodePoint )(*p + 0x20);
500 if (*p == 0x53 && ess_tsett_flag != 0 && end > p + 1
501 && (*(p+1) == 0x53 || *(p+1) == 0x73)) {
502 /* SS */
503 items[1].byte_len = 2;
504 items[1].code_len = 1;
505 items[1].code[0] = (OnigCodePoint )0xdf;
506 return 2;
507 }
508 else
509 return 1;
510 }
511 else if (0x61 <= *p && *p <= 0x7a) {
512 items[0].byte_len = 1;
513 items[0].code_len = 1;
514 items[0].code[0] = (OnigCodePoint )(*p - 0x20);
515 if (*p == 0x73 && ess_tsett_flag != 0 && end > p + 1
516 && (*(p+1) == 0x73 || *(p+1) == 0x53)) {
517 /* ss */
518 items[1].byte_len = 2;
519 items[1].code_len = 1;
520 items[1].code[0] = (OnigCodePoint )0xdf;
521 return 2;
522 }
523 else
524 return 1;
525 }
526 else if (*p == 0xdf && ess_tsett_flag != 0) {
527 items[0].byte_len = 1;
528 items[0].code_len = 2;
529 items[0].code[0] = (OnigCodePoint )'s';
530 items[0].code[1] = (OnigCodePoint )'s';
531
532 items[1].byte_len = 1;
533 items[1].code_len = 2;
534 items[1].code[0] = (OnigCodePoint )'S';
535 items[1].code[1] = (OnigCodePoint )'S';
536
537 items[2].byte_len = 1;
538 items[2].code_len = 2;
539 items[2].code[0] = (OnigCodePoint )'s';
540 items[2].code[1] = (OnigCodePoint )'S';
541
542 items[3].byte_len = 1;
543 items[3].code_len = 2;
544 items[3].code[0] = (OnigCodePoint )'S';
545 items[3].code[1] = (OnigCodePoint )'s';
546
547 return 4;
548 }
549 else {
550 int i;
551
552 for (i = 0; i < map_size; i++) {
553 if (*p == map[i].from) {
554 items[0].byte_len = 1;
555 items[0].code_len = 1;
556 items[0].code[0] = map[i].to;
557 return 1;
558 }
559 else if (*p == map[i].to) {
560 items[0].byte_len = 1;
561 items[0].code_len = 1;
562 items[0].code[0] = map[i].from;
563 return 1;
564 }
565 }
566 }
567
568 return 0;
569 }
570
571
572 extern int
573 onigenc_not_support_get_ctype_code_range(OnigCtype ctype,
574 OnigCodePoint* sb_out, const OnigCodePoint* ranges[],
575 OnigEncoding enc)
576 {
577 return ONIG_NO_SUPPORT_CONFIG;
578 }
579
580 extern int
581 onigenc_is_mbc_newline_0x0a(const UChar* p, const UChar* end, OnigEncoding enc ARG_UNUSED)
582 {
583 if (p < end) {
584 if (*p == 0x0a) return 1;
585 }
586 return 0;
587 }
588
589 /* for single byte encodings */
590 extern int
591 onigenc_ascii_mbc_case_fold(OnigCaseFoldType flag ARG_UNUSED, const UChar** p,
592 const UChar*end, UChar* lower, OnigEncoding enc ARG_UNUSED)
593 {
594 *lower = ONIGENC_ASCII_CODE_TO_LOWER_CASE(**p);
595
596 (*p)++;
597 return 1; /* return byte length of converted char to lower */
598 }
599
600 #if 0
601 extern int
602 onigenc_ascii_is_mbc_ambiguous(OnigCaseFoldType flag ARG_UNUSED,
603 const UChar** pp, const UChar* end ARG_UNUSED)
604 {
605 const UChar* p = *pp;
606
607 (*pp)++;
608 return ONIGENC_IS_ASCII_CODE_CASE_AMBIG(*p);
609 }
610 #endif
611
612 extern int
613 onigenc_single_byte_mbc_enc_len(const UChar* p ARG_UNUSED, const UChar* e ARG_UNUSED,
614 OnigEncoding enc ARG_UNUSED)
615 {
616 return 1;
617 }
618
619 extern OnigCodePoint
620 onigenc_single_byte_mbc_to_code(const UChar* p, const UChar* end ARG_UNUSED,
621 OnigEncoding enc ARG_UNUSED)
622 {
623 return (OnigCodePoint )(*p);
624 }
625
626 extern int
627 onigenc_single_byte_code_to_mbclen(OnigCodePoint code ARG_UNUSED, OnigEncoding enc ARG_UNUSED)
628 {
629 return 1;
630 }
631
632 extern int
633 onigenc_single_byte_code_to_mbc(OnigCodePoint code, UChar *buf, OnigEncoding enc ARG_UNUSED)
634 {
635 if (code > 0xff)
636 rb_raise(rb_eRangeError, "%u out of char range", code);
637 *buf = (UChar )(code & 0xff);
638 return 1;
639 }
640
641 extern UChar*
642 onigenc_single_byte_left_adjust_char_head(const UChar* start ARG_UNUSED, const UChar* s,
643 const UChar* end,
644 OnigEncoding enc ARG_UNUSED)
645 {
646 return (UChar* )s;
647 }
648
649 extern int
650 onigenc_always_true_is_allowed_reverse_match(const UChar* s ARG_UNUSED, const UChar* end ARG_UNUSED,
651 OnigEncoding enc ARG_UNUSED)
652 {
653 return TRUE;
654 }
655
656 extern int
657 onigenc_always_false_is_allowed_reverse_match(const UChar* s ARG_UNUSED, const UChar* end ARG_UNUSED,
658 OnigEncoding enc ARG_UNUSED)
659 {
660 return FALSE;
661 }
662
663 extern int
664 onigenc_ascii_is_code_ctype(OnigCodePoint code, unsigned int ctype,
665 OnigEncoding enc ARG_UNUSED)
666 {
667 if (code < 128)
668 return ONIGENC_IS_ASCII_CODE_CTYPE(code, ctype);
669 else
670 return FALSE;
671 }
672
673 extern OnigCodePoint
674 onigenc_mbn_mbc_to_code(OnigEncoding enc, const UChar* p, const UChar* end)
675 {
676 int c, i, len;
677 OnigCodePoint n;
678
679 len = enclen(enc, p, end);
680 n = (OnigCodePoint )(*p++);
681 if (len == 1) return n;
682
683 for (i = 1; i < len; i++) {
684 if (p >= end) break;
685 c = *p++;
686 n <<= 8; n += c;
687 }
688 return n;
689 }
690
691 extern int
692 onigenc_mbn_mbc_case_fold(OnigEncoding enc, OnigCaseFoldType flag ARG_UNUSED,
693 const UChar** pp, const UChar* end ARG_UNUSED,
694 UChar* lower)
695 {
696 int len;
697 const UChar *p = *pp;
698
699 if (ONIGENC_IS_MBC_ASCII(p)) {
700 *lower = ONIGENC_ASCII_CODE_TO_LOWER_CASE(*p);
701 (*pp)++;
702 return 1;
703 }
704 else {
705 int i;
706
707 len = enclen(enc, p, end);
708 for (i = 0; i < len; i++) {
709 *lower++ = *p++;
710 }
711 (*pp) += len;
712 return len; /* return byte length of converted to lower char */
713 }
714 }
715
716 #if 0
717 extern int
718 onigenc_mbn_is_mbc_ambiguous(OnigEncoding enc, OnigCaseFoldType flag,
719 const UChar** pp ARG_UNUSED, const UChar* end ARG_UNUSED)
720 {
721 const UChar* p = *pp;
722
723 if (ONIGENC_IS_MBC_ASCII(p)) {
724 (*pp)++;
725 return ONIGENC_IS_ASCII_CODE_CASE_AMBIG(*p);
726 }
727
728 (*pp) += enclen(enc, p);
729 return FALSE;
730 }
731 #endif
732
733 extern int
734 onigenc_mb2_code_to_mbclen(OnigCodePoint code, OnigEncoding enc ARG_UNUSED)
735 {
736 if (code <= 0xff) return 1;
737 if (code <= 0xffff) return 2;
738 return ONIGERR_TOO_BIG_WIDE_CHAR_VALUE;
739 }
740
741 extern int
742 onigenc_mb4_code_to_mbclen(OnigCodePoint code, OnigEncoding enc ARG_UNUSED)
743 {
744 if ((code & 0xff000000) != 0) return 4;
745 else if ((code & 0xff0000) != 0) return 3;
746 else if ((code & 0xff00) != 0) return 2;
747 else return 1;
748 }
749
750 extern int
751 onigenc_mb2_code_to_mbc(OnigEncoding enc, OnigCodePoint code, UChar *buf)
752 {
753 UChar *p = buf;
754
755 if ((code & 0xff00) != 0) {
756 *p++ = (UChar )((code >> 8) & 0xff);
757 }
758 *p++ = (UChar )(code & 0xff);
759
760 #if 1
761 if (enclen(enc, buf, p) != (p - buf))
762 return ONIGERR_INVALID_CODE_POINT_VALUE;
763 #endif
764 return (int )(p - buf);
765 }
766
767 extern int
768 onigenc_mb4_code_to_mbc(OnigEncoding enc, OnigCodePoint code, UChar *buf)
769 {
770 UChar *p = buf;
771
772 if ((code & 0xff000000) != 0) {
773 *p++ = (UChar )((code >> 24) & 0xff);
774 }
775 if ((code & 0xff0000) != 0 || p != buf) {
776 *p++ = (UChar )((code >> 16) & 0xff);
777 }
778 if ((code & 0xff00) != 0 || p != buf) {
779 *p++ = (UChar )((code >> 8) & 0xff);
780 }
781 *p++ = (UChar )(code & 0xff);
782
783 #if 1
784 if (enclen(enc, buf, p) != (p - buf))
785 return ONIGERR_INVALID_CODE_POINT_VALUE;
786 #endif
787 return (int )(p - buf);
788 }
789
790 extern int
791 onigenc_minimum_property_name_to_ctype(OnigEncoding enc, UChar* p, UChar* end)
792 {
793 static const PosixBracketEntryType PBS[] = {
794 PosixBracketEntryInit("Alnum", ONIGENC_CTYPE_ALNUM),
795 PosixBracketEntryInit("Alpha", ONIGENC_CTYPE_ALPHA),
796 PosixBracketEntryInit("Blank", ONIGENC_CTYPE_BLANK),
797 PosixBracketEntryInit("Cntrl", ONIGENC_CTYPE_CNTRL),
798 PosixBracketEntryInit("Digit", ONIGENC_CTYPE_DIGIT),
799 PosixBracketEntryInit("Graph", ONIGENC_CTYPE_GRAPH),
800 PosixBracketEntryInit("Lower", ONIGENC_CTYPE_LOWER),
801 PosixBracketEntryInit("Print", ONIGENC_CTYPE_PRINT),
802 PosixBracketEntryInit("Punct", ONIGENC_CTYPE_PUNCT),
803 PosixBracketEntryInit("Space", ONIGENC_CTYPE_SPACE),
804 PosixBracketEntryInit("Upper", ONIGENC_CTYPE_UPPER),
805 PosixBracketEntryInit("XDigit", ONIGENC_CTYPE_XDIGIT),
806 PosixBracketEntryInit("ASCII", ONIGENC_CTYPE_ASCII),
807 PosixBracketEntryInit("Word", ONIGENC_CTYPE_WORD),
808 };
809
810 const PosixBracketEntryType *pb, *pbe;
811 int len;
812
813 len = onigenc_strlen(enc, p, end);
814 for (pbe = (pb = PBS) + sizeof(PBS)/sizeof(PBS[0]); pb < pbe; ++pb) {
815 if (len == pb->len &&
816 onigenc_with_ascii_strnicmp(enc, p, end, pb->name, pb->len) == 0)
817 return pb->ctype;
818 }
819
820 return ONIGERR_INVALID_CHAR_PROPERTY_NAME;
821 }
822
823 extern int
824 onigenc_mb2_is_code_ctype(OnigEncoding enc, OnigCodePoint code,
825 unsigned int ctype)
826 {
827 if (code < 128)
828 return ONIGENC_IS_ASCII_CODE_CTYPE(code, ctype);
829 else {
830 if (CTYPE_IS_WORD_GRAPH_PRINT(ctype)) {
831 return (ONIGENC_CODE_TO_MBCLEN(enc, code) > 1 ? TRUE : FALSE);
832 }
833 }
834
835 return FALSE;
836 }
837
838 extern int
839 onigenc_mb4_is_code_ctype(OnigEncoding enc, OnigCodePoint code,
840 unsigned int ctype)
841 {
842 if (code < 128)
843 return ONIGENC_IS_ASCII_CODE_CTYPE(code, ctype);
844 else {
845 if (CTYPE_IS_WORD_GRAPH_PRINT(ctype)) {
846 return (ONIGENC_CODE_TO_MBCLEN(enc, code) > 1 ? TRUE : FALSE);
847 }
848 }
849
850 return FALSE;
851 }
852
853 extern int
854 onigenc_with_ascii_strncmp(OnigEncoding enc, const UChar* p, const UChar* end,
855 const UChar* sascii /* ascii */, int n)
856 {
857 int x, c;
858
859 while (n-- > 0) {
860 if (p >= end) return (int )(*sascii);
861
862 c = (int )ONIGENC_MBC_TO_CODE(enc, p, end);
863 x = *sascii - c;
864 if (x) return x;
865
866 sascii++;
867 p += enclen(enc, p, end);
868 }
869 return 0;
870 }
871
872 extern int
873 onigenc_with_ascii_strnicmp(OnigEncoding enc, const UChar* p, const UChar* end,
874 const UChar* sascii /* ascii */, int n)
875 {
876 int x, c;
877
878 while (n-- > 0) {
879 if (p >= end) return (int )(*sascii);
880
881 c = (int )ONIGENC_MBC_TO_CODE(enc, p, end);
882 if (ONIGENC_IS_ASCII_CODE(c))
883 c = ONIGENC_ASCII_CODE_TO_LOWER_CASE(c);
884 x = ONIGENC_ASCII_CODE_TO_LOWER_CASE(*sascii) - c;
885 if (x) return x;
886
887 sascii++;
888 p += enclen(enc, p, end);
889 }
890 return 0;
891 }
892
893 /* Property management */
894 static int
895 resize_property_list(int new_size, const OnigCodePoint*** plist, int* psize)
896 {
897 size_t size;
898 const OnigCodePoint **list = *plist;
899
900 size = sizeof(OnigCodePoint*) * new_size;
901 if (IS_NULL(list)) {
902 list = (const OnigCodePoint** )xmalloc(size);
903 }
904 else {
905 list = (const OnigCodePoint** )xrealloc((void* )list, size);
906 }
907
908 if (IS_NULL(list)) return ONIGERR_MEMORY;
909
910 *plist = list;
911 *psize = new_size;
912
913 return 0;
914 }
915
916 extern int
917 onigenc_property_list_add_property(UChar* name, const OnigCodePoint* prop,
918 hash_table_type **table, const OnigCodePoint*** plist, int *pnum,
919 int *psize)
920 {
921 #define PROP_INIT_SIZE 16
922
923 int r;
924
925 if (*psize <= *pnum) {
926 int new_size = (*psize == 0 ? PROP_INIT_SIZE : *psize * 2);
927 r = resize_property_list(new_size, plist, psize);
928 if (r != 0) return r;
929 }
930
931 (*plist)[*pnum] = prop;
932
933 if (ONIG_IS_NULL(*table)) {
934 *table = onig_st_init_strend_table_with_size(PROP_INIT_SIZE);
935 if (ONIG_IS_NULL(*table)) return ONIGERR_MEMORY;
936 }
937
938 *pnum = *pnum + 1;
939 onig_st_insert_strend(*table, name, name + strlen((char* )name),
940 (hash_data_type )(*pnum + ONIGENC_MAX_STD_CTYPE));
941 return 0;
942 }
943
944 extern int
945 onigenc_property_list_init(int (*f)(void))
946 {
947 int r;
948
949 THREAD_ATOMIC_START;
950
951 r = f();
952
953 THREAD_ATOMIC_END;
954 return r;
955 }
resize_property_list
static int resize_property_list(int new_size, const OnigCodePoint ***plist, int *psize)
Definition: regenc.c:895
PosixBracketEntryType::name
const UChar * name
Definition: ripper.y:104
onigenc_step_back
UChar * onigenc_step_back(OnigEncoding enc, const UChar *start, const UChar *s, const UChar *end, int n)
Definition: regenc.c:101
OnigEncAsciiCtypeTable
ONIG_EXTERN const unsigned short OnigEncAsciiCtypeTable[]
Definition: ripper.y:185
new_size
static st_index_t new_size(st_index_t size)
Definition: st.c:184
ONIGERR_TOO_BIG_WIDE_CHAR_VALUE
#define ONIGERR_TOO_BIG_WIDE_CHAR_VALUE
IS_NULL
#define IS_NULL(p)
Definition: regint.h:278
n
ssize_t n
Definition: bigdecimal.c:5655
ONIGENC_CTYPE_GRAPH
#define ONIGENC_CTYPE_GRAPH
int
VP_EXPORT int
Definition: bigdecimal.c:5050
onigenc_always_true_is_allowed_reverse_match
int onigenc_always_true_is_allowed_reverse_match(const UChar *s ARG_UNUSED, const UChar *end ARG_UNUSED, OnigEncoding enc ARG_UNUSED)
Definition: regenc.c:650
FALSE
#define FALSE
Definition: nkf.h:174
OnigCaseFoldCodeItem::byte_len
int byte_len
Definition: ripper.y:145
OnigAsciiLowerMap
const OnigPairCaseFoldCodes OnigAsciiLowerMap[]
Definition: regenc.c:380
OnigPairCaseFoldCodes::from
OnigCodePoint from
Definition: ripper.y:48
code
code
Definition: tcltklib.c:3381
onigenc_mbclen_approximate
int onigenc_mbclen_approximate(const OnigUChar *p, const OnigUChar *e, struct OnigEncodingTypeST *enc)
Definition: regenc.c:55
strlen
size_t strlen(const char *)
onigenc_single_byte_mbc_to_code
OnigCodePoint onigenc_single_byte_mbc_to_code(const UChar *p, const UChar *end ARG_UNUSED, OnigEncoding enc ARG_UNUSED)
Definition: regenc.c:620
OnigEncAsciiToLowerCaseTable
ONIG_EXTERN const UChar OnigEncAsciiToLowerCaseTable[]
Definition: ripper.y:183
p
Win32OLEIDispatch * p
Definition: win32ole.c:786
ONIGENC_MBC_MINLEN
#define ONIGENC_MBC_MINLEN(enc)
ONIGENC_CTYPE_PUNCT
#define ONIGENC_CTYPE_PUNCT
ONIGENC_CTYPE_XDIGIT
#define ONIGENC_CTYPE_XDIGIT
onigenc_get_right_adjust_char_head
UChar * onigenc_get_right_adjust_char_head(OnigEncoding enc, const UChar *start, const UChar *s, const UChar *end)
Definition: regenc.c:66
OnigCodePoint
unsigned int OnigCodePoint
Definition: ripper.y:115
onigenc_set_default_encoding
int onigenc_set_default_encoding(OnigEncoding enc)
Definition: regenc.c:48
ONIG_IS_NULL
#define ONIG_IS_NULL(p)
onigenc_ascii_is_code_ctype
int onigenc_ascii_is_code_ctype(OnigCodePoint code, unsigned int ctype, OnigEncoding enc ARG_UNUSED)
Definition: regenc.c:664
table
static int VALUE table
Definition: tcltklib.c:10138
onigenc_mbn_mbc_case_fold
int onigenc_mbn_mbc_case_fold(OnigEncoding enc, OnigCaseFoldType flag ARG_UNUSED, const UChar **pp, const UChar *end ARG_UNUSED, UChar *lower)
Definition: regenc.c:692
i
ssize_t i
Definition: bigdecimal.c:5655
UChar
#define UChar
onigenc_mb2_code_to_mbclen
int onigenc_mb2_code_to_mbclen(OnigCodePoint code, OnigEncoding enc ARG_UNUSED)
Definition: regenc.c:734
ONIGENC_CTYPE_ALNUM
#define ONIGENC_CTYPE_ALNUM
ONIGENC_MBC_MAXLEN
#define ONIGENC_MBC_MAXLEN(enc)
ret
int ret
Definition: tcltklib.c:280
enc
VALUE enc
Definition: tcltklib.c:10311
ONIGENC_CTYPE_LOWER
#define ONIGENC_CTYPE_LOWER
onigenc_get_left_adjust_char_head
UChar * onigenc_get_left_adjust_char_head(OnigEncoding enc, const UChar *start, const UChar *s, const UChar *end)
Definition: regenc.c:375
onig_st_init_strend_table_with_size
hash_table_type * onig_st_init_strend_table_with_size(st_index_t size)
Definition: regparse.c:367
onigenc_strlen
int onigenc_strlen(OnigEncoding enc, const UChar *p, const UChar *end)
Definition: regenc.c:123
rb_raise
void rb_raise(VALUE exc, const char *fmt,...)
Definition: error.c:1780
ONIGENC_CTYPE_SPACE
#define ONIGENC_CTYPE_SPACE
onigenc_mb2_code_to_mbc
int onigenc_mb2_code_to_mbc(OnigEncoding enc, OnigCodePoint code, UChar *buf)
Definition: regenc.c:751
onig_st_insert_strend
int onig_st_insert_strend(hash_table_type *table, const UChar *str_key, const UChar *end_key, hash_data_type value)
Definition: regparse.c:391
onigenc_ascii_apply_all_case_fold
int onigenc_ascii_apply_all_case_fold(OnigCaseFoldType flag ARG_UNUSED, OnigApplyAllCaseFoldFunc f, void *arg, OnigEncoding enc ARG_UNUSED)
Definition: regenc.c:410
r
r
Definition: bigdecimal.c:1196
onigenc_get_right_adjust_char_head_with_prev
UChar * onigenc_get_right_adjust_char_head_with_prev(OnigEncoding enc, const UChar *start, const UChar *s, const UChar *end, const UChar **prev)
Definition: regenc.c:76
ONIGENC_PRECISE_MBC_ENC_LEN
#define ONIGENC_PRECISE_MBC_ENC_LEN(enc, p, e)
ONIGENC_IS_ASCII_CODE
#define ONIGENC_IS_ASCII_CODE(code)
ONIGENC_CTYPE_CNTRL
#define ONIGENC_CTYPE_CNTRL
OnigCaseFoldType
unsigned int OnigCaseFoldType
Definition: ripper.y:122
ONIGENC_MBCLEN_NEEDMORE_P
#define ONIGENC_MBCLEN_NEEDMORE_P(r)
PosixBracketEntryInit
#define PosixBracketEntryInit(name, ctype)
onigenc_get_default_encoding
OnigEncoding onigenc_get_default_encoding(void)
Definition: regenc.c:42
ONIGENC_IS_ASCII_CODE_CTYPE
#define ONIGENC_IS_ASCII_CODE_CTYPE(code, ctype)
flag
flag
Definition: tcltklib.c:2048
rb_eRangeError
VALUE rb_eRangeError
Definition: error.c:515
OnigEncISO_8859_1_ToUpperCaseTable
ONIG_EXTERN const UChar OnigEncISO_8859_1_ToUpperCaseTable[]
Definition: ripper.y:170
onigenc_mb2_is_code_ctype
int onigenc_mb2_is_code_ctype(OnigEncoding enc, OnigCodePoint code, unsigned int ctype)
Definition: regenc.c:824
onigenc_get_prev_char_head
UChar * onigenc_get_prev_char_head(OnigEncoding enc, const UChar *start, const UChar *s, const UChar *end)
Definition: regenc.c:92
ss_apply_all_case_fold
static int ss_apply_all_case_fold(OnigCaseFoldType flag ARG_UNUSED, OnigApplyAllCaseFoldFunc f, void *arg)
Definition: regenc.c:454
OnigCaseFoldCodeItem::code
OnigCodePoint code[ONIGENC_MAX_COMP_CASE_FOLD_CODE_LEN]
Definition: ripper.y:147
OnigEncDefaultCharEncoding
ONIG_EXTERN OnigEncoding OnigEncDefaultCharEncoding
Definition: ripper.y:182
enclen
#define enclen(enc, p, e)
THREAD_ATOMIC_END
#define THREAD_ATOMIC_END
Definition: regint.h:119
ONIGENC_MBCLEN_CHARFOUND_LEN
#define ONIGENC_MBCLEN_CHARFOUND_LEN(r)
OnigCaseFoldCodeItem
Definition: ripper.y:144
onigenc_set_default_caseconv_table
void onigenc_set_default_caseconv_table(const UChar *table ARG_UNUSED)
Definition: regenc.c:368
OnigCaseFoldCodeItem::code_len
int code_len
Definition: ripper.y:146
onigenc_always_false_is_allowed_reverse_match
int onigenc_always_false_is_allowed_reverse_match(const UChar *s ARG_UNUSED, const UChar *end ARG_UNUSED, OnigEncoding enc ARG_UNUSED)
Definition: regenc.c:657
onigenc_init
int onigenc_init(void)
Definition: regenc.c:36
onigenc_with_ascii_strnicmp
int onigenc_with_ascii_strnicmp(OnigEncoding enc, const UChar *p, const UChar *end, const UChar *sascii, int n)
Definition: regenc.c:873
ARG_UNUSED
#define ARG_UNUSED
Definition: nkf.h:181
ONIG_IS_NOT_NULL
#define ONIG_IS_NOT_NULL(p)
ONIGENC_CTYPE_UPPER
#define ONIGENC_CTYPE_UPPER
ONIGENC_CTYPE_ALPHA
#define ONIGENC_CTYPE_ALPHA
PROP_INIT_SIZE
#define PROP_INIT_SIZE
OnigUChar
unsigned char OnigUChar
Definition: ripper.y:114
ONIGENC_LEFT_ADJUST_CHAR_HEAD
#define ONIGENC_LEFT_ADJUST_CHAR_HEAD(enc, start, s, end)
xmalloc
#define xmalloc
xrealloc
#define xrealloc
onigenc_apply_all_case_fold_with_map
int onigenc_apply_all_case_fold_with_map(int map_size, const OnigPairCaseFoldCodes map[], int ess_tsett_flag, OnigCaseFoldType flag, OnigApplyAllCaseFoldFunc f, void *arg)
Definition: regenc.c:463
onigenc_single_byte_code_to_mbclen
int onigenc_single_byte_code_to_mbclen(OnigCodePoint code ARG_UNUSED, OnigEncoding enc ARG_UNUSED)
Definition: regenc.c:627
ONIGENC_IS_MBC_ASCII
#define ONIGENC_IS_MBC_ASCII(p)
ONIGENC_MBCLEN_NEEDMORE_LEN
#define ONIGENC_MBCLEN_NEEDMORE_LEN(r)
buf
unsigned char buf[MIME_BUF_SIZE]
Definition: nkf.c:4308
onigenc_single_byte_left_adjust_char_head
UChar * onigenc_single_byte_left_adjust_char_head(const UChar *start ARG_UNUSED, const UChar *s, const UChar *end, OnigEncoding enc ARG_UNUSED)
Definition: regenc.c:642
ONIGENC_CTYPE_BLANK
#define ONIGENC_CTYPE_BLANK
onigenc_is_mbc_newline_0x0a
int onigenc_is_mbc_newline_0x0a(const UChar *p, const UChar *end, OnigEncoding enc ARG_UNUSED)
Definition: regenc.c:581
ONIGENC_CTYPE_ASCII
#define ONIGENC_CTYPE_ASCII
THREAD_ATOMIC_START
#define THREAD_ATOMIC_START
Definition: regint.h:118
TRUE
#define TRUE
Definition: nkf.h:175
OnigPairCaseFoldCodes
Definition: ripper.y:47
s
register char * s
Definition: os2.c:56
onigenc_mb4_is_code_ctype
int onigenc_mb4_is_code_ctype(OnigEncoding enc, OnigCodePoint code, unsigned int ctype)
Definition: regenc.c:839
PosixBracketEntryType::ctype
int ctype
Definition: ripper.y:105
onigenc_property_list_init
int onigenc_property_list_init(int(*f)(void))
Definition: regenc.c:945
onigenc_single_byte_mbc_enc_len
int onigenc_single_byte_mbc_enc_len(const UChar *p ARG_UNUSED, const UChar *e ARG_UNUSED, OnigEncoding enc ARG_UNUSED)
Definition: regenc.c:613
hash_data_type
st_data_t hash_data_type
Definition: regint.h:879
ONIG_NO_SUPPORT_CONFIG
#define ONIG_NO_SUPPORT_CONFIG
onigenc_not_support_get_ctype_code_range
int onigenc_not_support_get_ctype_code_range(OnigCtype ctype, OnigCodePoint *sb_out, const OnigCodePoint *ranges[], OnigEncoding enc)
Definition: regenc.c:573
onigenc_str_bytelen_null
int onigenc_str_bytelen_null(OnigEncoding enc, const UChar *s)
Definition: regenc.c:163
onigenc_strlen_null
int onigenc_strlen_null(OnigEncoding enc, const UChar *s)
Definition: regenc.c:136
onigenc_ascii_get_case_fold_codes_by_str
int onigenc_ascii_get_case_fold_codes_by_str(OnigCaseFoldType flag ARG_UNUSED, const OnigUChar *p, const OnigUChar *end ARG_UNUSED, OnigCaseFoldCodeItem items[], OnigEncoding enc ARG_UNUSED)
Definition: regenc.c:433
c
VpDivd * c
Definition: bigdecimal.c:1205
onigenc_step
UChar * onigenc_step(OnigEncoding enc, const UChar *p, const UChar *end, int n)
Definition: regenc.c:113
end
gz end
Definition: zlib.c:2272
OnigEncISO_8859_1_ToLowerCaseTable
ONIG_EXTERN const UChar OnigEncISO_8859_1_ToLowerCaseTable[]
Definition: ripper.y:169
arg
arg
Definition: ripper.y:1315
OnigCtype
unsigned int OnigCtype
Definition: ripper.y:116
size
int size
Definition: encoding.c:52
onigenc_mb4_code_to_mbc
int onigenc_mb4_code_to_mbc(OnigEncoding enc, OnigCodePoint code, UChar *buf)
Definition: regenc.c:768
f
#define f
ONIGENC_CTYPE_WORD
#define ONIGENC_CTYPE_WORD
ONIGENC_CODE_TO_MBCLEN
#define ONIGENC_CODE_TO_MBCLEN(enc, code)
ONIGENC_MBC_TO_CODE
#define ONIGENC_MBC_TO_CODE(enc, p, end)
ONIGENC_MBC_ENC_LEN
#define ONIGENC_MBC_ENC_LEN(enc, p, e)
ONIGERR_MEMORY
#define ONIGERR_MEMORY
ONIGENC_CTYPE_DIGIT
#define ONIGENC_CTYPE_DIGIT
hash_table_type
void hash_table_type
Definition: regint.h:876
list
struct rb_encoding_entry * list
Definition: encoding.c:50
onigenc_mb4_code_to_mbclen
int onigenc_mb4_code_to_mbclen(OnigCodePoint code, OnigEncoding enc ARG_UNUSED)
Definition: regenc.c:742
onigenc_single_byte_code_to_mbc
int onigenc_single_byte_code_to_mbc(OnigCodePoint code, UChar *buf, OnigEncoding enc ARG_UNUSED)
Definition: regenc.c:633
ONIGENC_IS_ASCII_CODE_CASE_AMBIG
#define ONIGENC_IS_ASCII_CODE_CASE_AMBIG(code)
PosixBracketEntryType
Definition: ripper.y:103
ONIGENC_ASCII_CODE_TO_LOWER_CASE
#define ONIGENC_ASCII_CODE_TO_LOWER_CASE(c)
onigenc_with_ascii_strncmp
int onigenc_with_ascii_strncmp(OnigEncoding enc, const UChar *p, const UChar *end, const UChar *sascii, int n)
Definition: regenc.c:854
e
BDIGIT e
Definition: bigdecimal.c:5085
onigenc_mbn_mbc_to_code
OnigCodePoint onigenc_mbn_mbc_to_code(OnigEncoding enc, const UChar *p, const UChar *end)
Definition: regenc.c:674
PosixBracketEntryType::len
short int len
Definition: ripper.y:106
ONIGERR_INVALID_CODE_POINT_VALUE
#define ONIGERR_INVALID_CODE_POINT_VALUE
regint.h
ONIGENC_CTYPE_PRINT
#define ONIGENC_CTYPE_PRINT
OnigEncAsciiToUpperCaseTable
ONIG_EXTERN const UChar OnigEncAsciiToUpperCaseTable[]
Definition: ripper.y:184
NULL
#define NULL
Definition: _sdbm.c:103
q
q
Definition: tcltklib.c:2968
onigenc_property_list_add_property
int onigenc_property_list_add_property(UChar *name, const OnigCodePoint *prop, hash_table_type **table, const OnigCodePoint ***plist, int *pnum, int *psize)
Definition: regenc.c:917
name
const char * name
Definition: nkf.c:208
OnigPairCaseFoldCodes::to
OnigCodePoint to
Definition: ripper.y:49
CTYPE_IS_WORD_GRAPH_PRINT
#define CTYPE_IS_WORD_GRAPH_PRINT(ctype)
OnigApplyAllCaseFoldFunc
int(* OnigApplyAllCaseFoldFunc)(OnigCodePoint from, OnigCodePoint *to, int to_len, void *arg)
Definition: ripper.y:159
onigenc_minimum_property_name_to_ctype
int onigenc_minimum_property_name_to_ctype(OnigEncoding enc, UChar *p, UChar *end)
Definition: regenc.c:791
ONIG_ENCODING_INIT_DEFAULT
#define ONIG_ENCODING_INIT_DEFAULT
ONIGENC_MAX_STD_CTYPE
#define ONIGENC_MAX_STD_CTYPE
onigenc_ascii_mbc_case_fold
int onigenc_ascii_mbc_case_fold(OnigCaseFoldType flag ARG_UNUSED, const UChar **p, const UChar *end, UChar *lower, OnigEncoding enc ARG_UNUSED)
Definition: regenc.c:591
onigenc_get_case_fold_codes_by_str_with_map
int onigenc_get_case_fold_codes_by_str_with_map(int map_size, const OnigPairCaseFoldCodes map[], int ess_tsett_flag, OnigCaseFoldType flag ARG_UNUSED, const OnigUChar *p, const OnigUChar *end, OnigCaseFoldCodeItem items[])
Definition: regenc.c:491
ONIGERR_INVALID_CHAR_PROPERTY_NAME
#define ONIGERR_INVALID_CHAR_PROPERTY_NAME
OnigEncodingTypeST
Definition: ripper.y:161
ONIGENC_MBCLEN_CHARFOUND_P
#define ONIGENC_MBCLEN_CHARFOUND_P(r)
len
size_t len
Definition: tcltklib.c:3568