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