Annotation of embedaddon/php/ext/mbstring/oniguruma/regenc.c, revision 1.1.1.1
1.1 misho 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
35: onigenc_init(void)
36: {
37: return 0;
38: }
39:
40: extern OnigEncoding
41: onigenc_get_default_encoding(void)
42: {
43: return OnigEncDefaultCharEncoding;
44: }
45:
46: extern int
47: onigenc_set_default_encoding(OnigEncoding enc)
48: {
49: OnigEncDefaultCharEncoding = enc;
50: return 0;
51: }
52:
53: extern UChar*
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 += enc_len(enc, p);
59: }
60: return p;
61: }
62:
63: extern UChar*
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 += enc_len(enc, p);
72: }
73: else {
74: if (prev) *prev = (const UChar* )NULL; /* Sorry */
75: }
76: return p;
77: }
78:
79: extern UChar*
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*
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*
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
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
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
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: #ifndef ONIG_RUBY_M17N
173:
174: #ifndef NOT_RUBY
175:
176: #define USE_APPLICATION_TO_LOWER_CASE_TABLE
177:
178: const unsigned short OnigEnc_Unicode_ISO_8859_1_CtypeTable[256] = {
179: 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008,
180: 0x2008, 0x228c, 0x2289, 0x2288, 0x2288, 0x2288, 0x2008, 0x2008,
181: 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008,
182: 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008,
183: 0x2284, 0x21a0, 0x21a0, 0x21a0, 0x21a0, 0x21a0, 0x21a0, 0x21a0,
184: 0x21a0, 0x21a0, 0x21a0, 0x21a0, 0x21a0, 0x21a0, 0x21a0, 0x21a0,
185: 0x38b0, 0x38b0, 0x38b0, 0x38b0, 0x38b0, 0x38b0, 0x38b0, 0x38b0,
186: 0x38b0, 0x38b0, 0x21a0, 0x21a0, 0x21a0, 0x21a0, 0x21a0, 0x21a0,
187: 0x21a0, 0x3ca2, 0x3ca2, 0x3ca2, 0x3ca2, 0x3ca2, 0x3ca2, 0x34a2,
188: 0x34a2, 0x34a2, 0x34a2, 0x34a2, 0x34a2, 0x34a2, 0x34a2, 0x34a2,
189: 0x34a2, 0x34a2, 0x34a2, 0x34a2, 0x34a2, 0x34a2, 0x34a2, 0x34a2,
190: 0x34a2, 0x34a2, 0x34a2, 0x21a0, 0x21a0, 0x21a0, 0x21a0, 0x31a0,
191: 0x21a0, 0x38e2, 0x38e2, 0x38e2, 0x38e2, 0x38e2, 0x38e2, 0x30e2,
192: 0x30e2, 0x30e2, 0x30e2, 0x30e2, 0x30e2, 0x30e2, 0x30e2, 0x30e2,
193: 0x30e2, 0x30e2, 0x30e2, 0x30e2, 0x30e2, 0x30e2, 0x30e2, 0x30e2,
194: 0x30e2, 0x30e2, 0x30e2, 0x21a0, 0x21a0, 0x21a0, 0x21a0, 0x2008,
195: 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0288, 0x0008, 0x0008,
196: 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008,
197: 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008,
198: 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008, 0x0008,
199: 0x0284, 0x01a0, 0x00a0, 0x00a0, 0x00a0, 0x00a0, 0x00a0, 0x00a0,
200: 0x00a0, 0x00a0, 0x10e2, 0x01a0, 0x00a0, 0x00a8, 0x00a0, 0x00a0,
201: 0x00a0, 0x00a0, 0x10a0, 0x10a0, 0x00a0, 0x10e2, 0x00a0, 0x01a0,
202: 0x00a0, 0x10a0, 0x10e2, 0x01a0, 0x10a0, 0x10a0, 0x10a0, 0x01a0,
203: 0x14a2, 0x14a2, 0x14a2, 0x14a2, 0x14a2, 0x14a2, 0x14a2, 0x14a2,
204: 0x14a2, 0x14a2, 0x14a2, 0x14a2, 0x14a2, 0x14a2, 0x14a2, 0x14a2,
205: 0x14a2, 0x14a2, 0x14a2, 0x14a2, 0x14a2, 0x14a2, 0x14a2, 0x00a0,
206: 0x14a2, 0x14a2, 0x14a2, 0x14a2, 0x14a2, 0x14a2, 0x14a2, 0x10e2,
207: 0x10e2, 0x10e2, 0x10e2, 0x10e2, 0x10e2, 0x10e2, 0x10e2, 0x10e2,
208: 0x10e2, 0x10e2, 0x10e2, 0x10e2, 0x10e2, 0x10e2, 0x10e2, 0x10e2,
209: 0x10e2, 0x10e2, 0x10e2, 0x10e2, 0x10e2, 0x10e2, 0x10e2, 0x00a0,
210: 0x10e2, 0x10e2, 0x10e2, 0x10e2, 0x10e2, 0x10e2, 0x10e2, 0x10e2
211: };
212: #endif
213:
214: const UChar* OnigEncAsciiToLowerCaseTable = (const UChar* )0;
215:
216: #ifndef USE_APPLICATION_TO_LOWER_CASE_TABLE
217: static const UChar BuiltInAsciiToLowerCaseTable[] = {
218: '\000', '\001', '\002', '\003', '\004', '\005', '\006', '\007',
219: '\010', '\011', '\012', '\013', '\014', '\015', '\016', '\017',
220: '\020', '\021', '\022', '\023', '\024', '\025', '\026', '\027',
221: '\030', '\031', '\032', '\033', '\034', '\035', '\036', '\037',
222: '\040', '\041', '\042', '\043', '\044', '\045', '\046', '\047',
223: '\050', '\051', '\052', '\053', '\054', '\055', '\056', '\057',
224: '\060', '\061', '\062', '\063', '\064', '\065', '\066', '\067',
225: '\070', '\071', '\072', '\073', '\074', '\075', '\076', '\077',
226: '\100', '\141', '\142', '\143', '\144', '\145', '\146', '\147',
227: '\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157',
228: '\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167',
229: '\170', '\171', '\172', '\133', '\134', '\135', '\136', '\137',
230: '\140', '\141', '\142', '\143', '\144', '\145', '\146', '\147',
231: '\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157',
232: '\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167',
233: '\170', '\171', '\172', '\173', '\174', '\175', '\176', '\177',
234: '\200', '\201', '\202', '\203', '\204', '\205', '\206', '\207',
235: '\210', '\211', '\212', '\213', '\214', '\215', '\216', '\217',
236: '\220', '\221', '\222', '\223', '\224', '\225', '\226', '\227',
237: '\230', '\231', '\232', '\233', '\234', '\235', '\236', '\237',
238: '\240', '\241', '\242', '\243', '\244', '\245', '\246', '\247',
239: '\250', '\251', '\252', '\253', '\254', '\255', '\256', '\257',
240: '\260', '\261', '\262', '\263', '\264', '\265', '\266', '\267',
241: '\270', '\271', '\272', '\273', '\274', '\275', '\276', '\277',
242: '\300', '\301', '\302', '\303', '\304', '\305', '\306', '\307',
243: '\310', '\311', '\312', '\313', '\314', '\315', '\316', '\317',
244: '\320', '\321', '\322', '\323', '\324', '\325', '\326', '\327',
245: '\330', '\331', '\332', '\333', '\334', '\335', '\336', '\337',
246: '\340', '\341', '\342', '\343', '\344', '\345', '\346', '\347',
247: '\350', '\351', '\352', '\353', '\354', '\355', '\356', '\357',
248: '\360', '\361', '\362', '\363', '\364', '\365', '\366', '\367',
249: '\370', '\371', '\372', '\373', '\374', '\375', '\376', '\377',
250: };
251: #endif /* not USE_APPLICATION_TO_LOWER_CASE_TABLE */
252:
253: #ifdef USE_UPPER_CASE_TABLE
254: const UChar OnigEncAsciiToUpperCaseTable[256] = {
255: '\000', '\001', '\002', '\003', '\004', '\005', '\006', '\007',
256: '\010', '\011', '\012', '\013', '\014', '\015', '\016', '\017',
257: '\020', '\021', '\022', '\023', '\024', '\025', '\026', '\027',
258: '\030', '\031', '\032', '\033', '\034', '\035', '\036', '\037',
259: '\040', '\041', '\042', '\043', '\044', '\045', '\046', '\047',
260: '\050', '\051', '\052', '\053', '\054', '\055', '\056', '\057',
261: '\060', '\061', '\062', '\063', '\064', '\065', '\066', '\067',
262: '\070', '\071', '\072', '\073', '\074', '\075', '\076', '\077',
263: '\100', '\101', '\102', '\103', '\104', '\105', '\106', '\107',
264: '\110', '\111', '\112', '\113', '\114', '\115', '\116', '\117',
265: '\120', '\121', '\122', '\123', '\124', '\125', '\126', '\127',
266: '\130', '\131', '\132', '\133', '\134', '\135', '\136', '\137',
267: '\140', '\101', '\102', '\103', '\104', '\105', '\106', '\107',
268: '\110', '\111', '\112', '\113', '\114', '\115', '\116', '\117',
269: '\120', '\121', '\122', '\123', '\124', '\125', '\126', '\127',
270: '\130', '\131', '\132', '\173', '\174', '\175', '\176', '\177',
271: '\200', '\201', '\202', '\203', '\204', '\205', '\206', '\207',
272: '\210', '\211', '\212', '\213', '\214', '\215', '\216', '\217',
273: '\220', '\221', '\222', '\223', '\224', '\225', '\226', '\227',
274: '\230', '\231', '\232', '\233', '\234', '\235', '\236', '\237',
275: '\240', '\241', '\242', '\243', '\244', '\245', '\246', '\247',
276: '\250', '\251', '\252', '\253', '\254', '\255', '\256', '\257',
277: '\260', '\261', '\262', '\263', '\264', '\265', '\266', '\267',
278: '\270', '\271', '\272', '\273', '\274', '\275', '\276', '\277',
279: '\300', '\301', '\302', '\303', '\304', '\305', '\306', '\307',
280: '\310', '\311', '\312', '\313', '\314', '\315', '\316', '\317',
281: '\320', '\321', '\322', '\323', '\324', '\325', '\326', '\327',
282: '\330', '\331', '\332', '\333', '\334', '\335', '\336', '\337',
283: '\340', '\341', '\342', '\343', '\344', '\345', '\346', '\347',
284: '\350', '\351', '\352', '\353', '\354', '\355', '\356', '\357',
285: '\360', '\361', '\362', '\363', '\364', '\365', '\366', '\367',
286: '\370', '\371', '\372', '\373', '\374', '\375', '\376', '\377',
287: };
288: #endif
289:
290: const unsigned short OnigEncAsciiCtypeTable[256] = {
291: 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008,
292: 0x2008, 0x220c, 0x2209, 0x2208, 0x2208, 0x2208, 0x2008, 0x2008,
293: 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008,
294: 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008, 0x2008,
295: 0x2284, 0x21a0, 0x21a0, 0x21a0, 0x21a0, 0x21a0, 0x21a0, 0x21a0,
296: 0x21a0, 0x21a0, 0x21a0, 0x21a0, 0x21a0, 0x21a0, 0x21a0, 0x21a0,
297: 0x38b0, 0x38b0, 0x38b0, 0x38b0, 0x38b0, 0x38b0, 0x38b0, 0x38b0,
298: 0x38b0, 0x38b0, 0x21a0, 0x21a0, 0x21a0, 0x21a0, 0x21a0, 0x21a0,
299: 0x21a0, 0x3ca2, 0x3ca2, 0x3ca2, 0x3ca2, 0x3ca2, 0x3ca2, 0x34a2,
300: 0x34a2, 0x34a2, 0x34a2, 0x34a2, 0x34a2, 0x34a2, 0x34a2, 0x34a2,
301: 0x34a2, 0x34a2, 0x34a2, 0x34a2, 0x34a2, 0x34a2, 0x34a2, 0x34a2,
302: 0x34a2, 0x34a2, 0x34a2, 0x21a0, 0x21a0, 0x21a0, 0x21a0, 0x31a0,
303: 0x21a0, 0x38e2, 0x38e2, 0x38e2, 0x38e2, 0x38e2, 0x38e2, 0x30e2,
304: 0x30e2, 0x30e2, 0x30e2, 0x30e2, 0x30e2, 0x30e2, 0x30e2, 0x30e2,
305: 0x30e2, 0x30e2, 0x30e2, 0x30e2, 0x30e2, 0x30e2, 0x30e2, 0x30e2,
306: 0x30e2, 0x30e2, 0x30e2, 0x21a0, 0x21a0, 0x21a0, 0x21a0, 0x2008,
307:
308: 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
309: 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
310: 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
311: 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
312: 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
313: 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
314: 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
315: 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
316: 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
317: 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
318: 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
319: 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
320: 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
321: 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
322: 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
323: 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000
324: };
325:
326: const UChar OnigEncISO_8859_1_ToLowerCaseTable[256] = {
327: '\000', '\001', '\002', '\003', '\004', '\005', '\006', '\007',
328: '\010', '\011', '\012', '\013', '\014', '\015', '\016', '\017',
329: '\020', '\021', '\022', '\023', '\024', '\025', '\026', '\027',
330: '\030', '\031', '\032', '\033', '\034', '\035', '\036', '\037',
331: '\040', '\041', '\042', '\043', '\044', '\045', '\046', '\047',
332: '\050', '\051', '\052', '\053', '\054', '\055', '\056', '\057',
333: '\060', '\061', '\062', '\063', '\064', '\065', '\066', '\067',
334: '\070', '\071', '\072', '\073', '\074', '\075', '\076', '\077',
335: '\100', '\141', '\142', '\143', '\144', '\145', '\146', '\147',
336: '\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157',
337: '\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167',
338: '\170', '\171', '\172', '\133', '\134', '\135', '\136', '\137',
339: '\140', '\141', '\142', '\143', '\144', '\145', '\146', '\147',
340: '\150', '\151', '\152', '\153', '\154', '\155', '\156', '\157',
341: '\160', '\161', '\162', '\163', '\164', '\165', '\166', '\167',
342: '\170', '\171', '\172', '\173', '\174', '\175', '\176', '\177',
343: '\200', '\201', '\202', '\203', '\204', '\205', '\206', '\207',
344: '\210', '\211', '\212', '\213', '\214', '\215', '\216', '\217',
345: '\220', '\221', '\222', '\223', '\224', '\225', '\226', '\227',
346: '\230', '\231', '\232', '\233', '\234', '\235', '\236', '\237',
347: '\240', '\241', '\242', '\243', '\244', '\245', '\246', '\247',
348: '\250', '\251', '\252', '\253', '\254', '\255', '\256', '\257',
349: '\260', '\261', '\262', '\263', '\264', '\265', '\266', '\267',
350: '\270', '\271', '\272', '\273', '\274', '\275', '\276', '\277',
351: '\340', '\341', '\342', '\343', '\344', '\345', '\346', '\347',
352: '\350', '\351', '\352', '\353', '\354', '\355', '\356', '\357',
353: '\360', '\361', '\362', '\363', '\364', '\365', '\366', '\327',
354: '\370', '\371', '\372', '\373', '\374', '\375', '\376', '\337',
355: '\340', '\341', '\342', '\343', '\344', '\345', '\346', '\347',
356: '\350', '\351', '\352', '\353', '\354', '\355', '\356', '\357',
357: '\360', '\361', '\362', '\363', '\364', '\365', '\366', '\367',
358: '\370', '\371', '\372', '\373', '\374', '\375', '\376', '\377'
359: };
360:
361: #ifdef USE_UPPER_CASE_TABLE
362: const UChar OnigEncISO_8859_1_ToUpperCaseTable[256] = {
363: '\000', '\001', '\002', '\003', '\004', '\005', '\006', '\007',
364: '\010', '\011', '\012', '\013', '\014', '\015', '\016', '\017',
365: '\020', '\021', '\022', '\023', '\024', '\025', '\026', '\027',
366: '\030', '\031', '\032', '\033', '\034', '\035', '\036', '\037',
367: '\040', '\041', '\042', '\043', '\044', '\045', '\046', '\047',
368: '\050', '\051', '\052', '\053', '\054', '\055', '\056', '\057',
369: '\060', '\061', '\062', '\063', '\064', '\065', '\066', '\067',
370: '\070', '\071', '\072', '\073', '\074', '\075', '\076', '\077',
371: '\100', '\101', '\102', '\103', '\104', '\105', '\106', '\107',
372: '\110', '\111', '\112', '\113', '\114', '\115', '\116', '\117',
373: '\120', '\121', '\122', '\123', '\124', '\125', '\126', '\127',
374: '\130', '\131', '\132', '\133', '\134', '\135', '\136', '\137',
375: '\140', '\101', '\102', '\103', '\104', '\105', '\106', '\107',
376: '\110', '\111', '\112', '\113', '\114', '\115', '\116', '\117',
377: '\120', '\121', '\122', '\123', '\124', '\125', '\126', '\127',
378: '\130', '\131', '\132', '\173', '\174', '\175', '\176', '\177',
379: '\200', '\201', '\202', '\203', '\204', '\205', '\206', '\207',
380: '\210', '\211', '\212', '\213', '\214', '\215', '\216', '\217',
381: '\220', '\221', '\222', '\223', '\224', '\225', '\226', '\227',
382: '\230', '\231', '\232', '\233', '\234', '\235', '\236', '\237',
383: '\240', '\241', '\242', '\243', '\244', '\245', '\246', '\247',
384: '\250', '\251', '\252', '\253', '\254', '\255', '\256', '\257',
385: '\260', '\261', '\262', '\263', '\264', '\265', '\266', '\267',
386: '\270', '\271', '\272', '\273', '\274', '\275', '\276', '\277',
387: '\300', '\301', '\302', '\303', '\304', '\305', '\306', '\307',
388: '\310', '\311', '\312', '\313', '\314', '\315', '\316', '\317',
389: '\320', '\321', '\322', '\323', '\324', '\325', '\326', '\327',
390: '\330', '\331', '\332', '\333', '\334', '\335', '\336', '\337',
391: '\300', '\301', '\302', '\303', '\304', '\305', '\306', '\307',
392: '\310', '\311', '\312', '\313', '\314', '\315', '\316', '\317',
393: '\320', '\321', '\322', '\323', '\324', '\325', '\326', '\367',
394: '\330', '\331', '\332', '\333', '\334', '\335', '\336', '\377',
395: };
396: #endif
397:
398: extern void
399: onigenc_set_default_caseconv_table(const UChar* table)
400: {
401: if (table == (const UChar* )0) {
402: #ifndef USE_APPLICATION_TO_LOWER_CASE_TABLE
403: table = BuiltInAsciiToLowerCaseTable;
404: #else
405: return ;
406: #endif
407: }
408:
409: if (table != OnigEncAsciiToLowerCaseTable) {
410: OnigEncAsciiToLowerCaseTable = table;
411: }
412: }
413:
414: extern UChar*
415: onigenc_get_left_adjust_char_head(OnigEncoding enc, const UChar* start, const UChar* s)
416: {
417: return ONIGENC_LEFT_ADJUST_CHAR_HEAD(enc, start, s);
418: }
419:
420: const OnigPairAmbigCodes OnigAsciiPairAmbigCodes[] = {
421: { 0x41, 0x61 },
422: { 0x42, 0x62 },
423: { 0x43, 0x63 },
424: { 0x44, 0x64 },
425: { 0x45, 0x65 },
426: { 0x46, 0x66 },
427: { 0x47, 0x67 },
428: { 0x48, 0x68 },
429: { 0x49, 0x69 },
430: { 0x4a, 0x6a },
431: { 0x4b, 0x6b },
432: { 0x4c, 0x6c },
433: { 0x4d, 0x6d },
434: { 0x4e, 0x6e },
435: { 0x4f, 0x6f },
436: { 0x50, 0x70 },
437: { 0x51, 0x71 },
438: { 0x52, 0x72 },
439: { 0x53, 0x73 },
440: { 0x54, 0x74 },
441: { 0x55, 0x75 },
442: { 0x56, 0x76 },
443: { 0x57, 0x77 },
444: { 0x58, 0x78 },
445: { 0x59, 0x79 },
446: { 0x5a, 0x7a },
447:
448: { 0x61, 0x41 },
449: { 0x62, 0x42 },
450: { 0x63, 0x43 },
451: { 0x64, 0x44 },
452: { 0x65, 0x45 },
453: { 0x66, 0x46 },
454: { 0x67, 0x47 },
455: { 0x68, 0x48 },
456: { 0x69, 0x49 },
457: { 0x6a, 0x4a },
458: { 0x6b, 0x4b },
459: { 0x6c, 0x4c },
460: { 0x6d, 0x4d },
461: { 0x6e, 0x4e },
462: { 0x6f, 0x4f },
463: { 0x70, 0x50 },
464: { 0x71, 0x51 },
465: { 0x72, 0x52 },
466: { 0x73, 0x53 },
467: { 0x74, 0x54 },
468: { 0x75, 0x55 },
469: { 0x76, 0x56 },
470: { 0x77, 0x57 },
471: { 0x78, 0x58 },
472: { 0x79, 0x59 },
473: { 0x7a, 0x5a }
474: };
475:
476: extern int
477: onigenc_ascii_get_all_pair_ambig_codes(OnigAmbigType flag,
478: const OnigPairAmbigCodes** ccs)
479: {
480: if (flag == ONIGENC_AMBIGUOUS_MATCH_ASCII_CASE) {
481: *ccs = OnigAsciiPairAmbigCodes;
482: return (sizeof(OnigAsciiPairAmbigCodes) / sizeof(OnigPairAmbigCodes));
483: }
484: else {
485: return 0;
486: }
487: }
488:
489: extern int
490: onigenc_nothing_get_all_comp_ambig_codes(OnigAmbigType flag,
491: const OnigCompAmbigCodes** ccs)
492: {
493: return 0;
494: }
495:
496: extern int
497: onigenc_iso_8859_1_get_all_pair_ambig_codes(OnigAmbigType flag,
498: const OnigPairAmbigCodes** ccs)
499: {
500: static const OnigPairAmbigCodes cc[] = {
501: { 0xc0, 0xe0 },
502: { 0xc1, 0xe1 },
503: { 0xc2, 0xe2 },
504: { 0xc3, 0xe3 },
505: { 0xc4, 0xe4 },
506: { 0xc5, 0xe5 },
507: { 0xc6, 0xe6 },
508: { 0xc7, 0xe7 },
509: { 0xc8, 0xe8 },
510: { 0xc9, 0xe9 },
511: { 0xca, 0xea },
512: { 0xcb, 0xeb },
513: { 0xcc, 0xec },
514: { 0xcd, 0xed },
515: { 0xce, 0xee },
516: { 0xcf, 0xef },
517:
518: { 0xd0, 0xf0 },
519: { 0xd1, 0xf1 },
520: { 0xd2, 0xf2 },
521: { 0xd3, 0xf3 },
522: { 0xd4, 0xf4 },
523: { 0xd5, 0xf5 },
524: { 0xd6, 0xf6 },
525: { 0xd8, 0xf8 },
526: { 0xd9, 0xf9 },
527: { 0xda, 0xfa },
528: { 0xdb, 0xfb },
529: { 0xdc, 0xfc },
530: { 0xdd, 0xfd },
531: { 0xde, 0xfe },
532:
533: { 0xe0, 0xc0 },
534: { 0xe1, 0xc1 },
535: { 0xe2, 0xc2 },
536: { 0xe3, 0xc3 },
537: { 0xe4, 0xc4 },
538: { 0xe5, 0xc5 },
539: { 0xe6, 0xc6 },
540: { 0xe7, 0xc7 },
541: { 0xe8, 0xc8 },
542: { 0xe9, 0xc9 },
543: { 0xea, 0xca },
544: { 0xeb, 0xcb },
545: { 0xec, 0xcc },
546: { 0xed, 0xcd },
547: { 0xee, 0xce },
548: { 0xef, 0xcf },
549:
550: { 0xf0, 0xd0 },
551: { 0xf1, 0xd1 },
552: { 0xf2, 0xd2 },
553: { 0xf3, 0xd3 },
554: { 0xf4, 0xd4 },
555: { 0xf5, 0xd5 },
556: { 0xf6, 0xd6 },
557: { 0xf8, 0xd8 },
558: { 0xf9, 0xd9 },
559: { 0xfa, 0xda },
560: { 0xfb, 0xdb },
561: { 0xfc, 0xdc },
562: { 0xfd, 0xdd },
563: { 0xfe, 0xde }
564: };
565:
566: if (flag == ONIGENC_AMBIGUOUS_MATCH_ASCII_CASE) {
567: *ccs = OnigAsciiPairAmbigCodes;
568: return (sizeof(OnigAsciiPairAmbigCodes) / sizeof(OnigPairAmbigCodes));
569: }
570: else if (flag == ONIGENC_AMBIGUOUS_MATCH_NONASCII_CASE) {
571: *ccs = cc;
572: return sizeof(cc) / sizeof(OnigPairAmbigCodes);
573: }
574: else
575: return 0;
576: }
577:
578: extern int
579: onigenc_ess_tsett_get_all_comp_ambig_codes(OnigAmbigType flag,
580: const OnigCompAmbigCodes** ccs)
581: {
582: static const OnigCompAmbigCodes folds[] = {
583: { 2, 0xdf, {{ 2, { 0x53, 0x53 } }, { 2, { 0x73, 0x73} } } }
584: };
585:
586: if (flag == ONIGENC_AMBIGUOUS_MATCH_NONASCII_CASE) {
587: *ccs = folds;
588: return sizeof(folds) / sizeof(OnigCompAmbigCodes);
589: }
590: else
591: return 0;
592: }
593:
594: extern int
595: onigenc_not_support_get_ctype_code_range(int ctype,
596: const OnigCodePoint* sbr[], const OnigCodePoint* mbr[])
597: {
598: return ONIG_NO_SUPPORT_CONFIG;
599: }
600:
601: extern int
602: onigenc_is_mbc_newline_0x0a(const UChar* p, const UChar* end)
603: {
604: if (p < end) {
605: if (*p == 0x0a) return 1;
606: }
607: return 0;
608: }
609:
610: /* for single byte encodings */
611: extern int
612: onigenc_ascii_mbc_to_normalize(OnigAmbigType flag, const UChar** p, const UChar*end,
613: UChar* lower)
614: {
615: if ((flag & ONIGENC_AMBIGUOUS_MATCH_ASCII_CASE) != 0) {
616: *lower = ONIGENC_ASCII_CODE_TO_LOWER_CASE(**p);
617: }
618: else {
619: *lower = **p;
620: }
621:
622: (*p)++;
623: return 1; /* return byte length of converted char to lower */
624: }
625:
626: extern int
627: onigenc_ascii_is_mbc_ambiguous(OnigAmbigType flag,
628: const UChar** pp, const UChar* end)
629: {
630: const UChar* p = *pp;
631:
632: (*pp)++;
633: if ((flag & ONIGENC_AMBIGUOUS_MATCH_ASCII_CASE) != 0) {
634: return ONIGENC_IS_ASCII_CODE_CASE_AMBIG(*p);
635: }
636: else {
637: return FALSE;
638: }
639: }
640:
641: extern int
642: onigenc_single_byte_mbc_enc_len(const UChar* p)
643: {
644: return 1;
645: }
646:
647: extern OnigCodePoint
648: onigenc_single_byte_mbc_to_code(const UChar* p, const UChar* end)
649: {
650: return (OnigCodePoint )(*p);
651: }
652:
653: extern int
654: onigenc_single_byte_code_to_mbclen(OnigCodePoint code)
655: {
656: return 1;
657: }
658:
659: extern int
660: onigenc_single_byte_code_to_mbc_first(OnigCodePoint code)
661: {
662: return (code & 0xff);
663: }
664:
665: extern int
666: onigenc_single_byte_code_to_mbc(OnigCodePoint code, UChar *buf)
667: {
668: *buf = (UChar )(code & 0xff);
669: return 1;
670: }
671:
672: extern UChar*
673: onigenc_single_byte_left_adjust_char_head(const UChar* start, const UChar* s)
674: {
675: return (UChar* )s;
676: }
677:
678: extern int
679: onigenc_always_true_is_allowed_reverse_match(const UChar* s, const UChar* end)
680: {
681: return TRUE;
682: }
683:
684: extern int
685: onigenc_always_false_is_allowed_reverse_match(const UChar* s, const UChar* end)
686: {
687: return FALSE;
688: }
689:
690: extern OnigCodePoint
691: onigenc_mbn_mbc_to_code(OnigEncoding enc, const UChar* p, const UChar* end)
692: {
693: int c, i, len;
694: OnigCodePoint n;
695:
696: len = enc_len(enc, p);
697: n = (OnigCodePoint )(*p++);
698: if (len == 1) return n;
699:
700: for (i = 1; i < len; i++) {
701: if (p >= end) break;
702: c = *p++;
703: n <<= 8; n += c;
704: }
705: return n;
706: }
707:
708: extern int
709: onigenc_mbn_mbc_to_normalize(OnigEncoding enc, OnigAmbigType flag,
710: const UChar** pp, const UChar* end, UChar* lower)
711: {
712: int len;
713: const UChar *p = *pp;
714:
715: if (ONIGENC_IS_MBC_ASCII(p)) {
716: if ((flag & ONIGENC_AMBIGUOUS_MATCH_ASCII_CASE) != 0) {
717: *lower = ONIGENC_ASCII_CODE_TO_LOWER_CASE(*p);
718: }
719: else {
720: *lower = *p;
721: }
722: (*pp)++;
723: return 1;
724: }
725: else {
726: len = enc_len(enc, p);
727: if (lower != p) {
728: int i;
729: for (i = 0; i < len; i++) {
730: *lower++ = *p++;
731: }
732: }
733: (*pp) += len;
734: return len; /* return byte length of converted to lower char */
735: }
736: }
737:
738: extern int
739: onigenc_mbn_is_mbc_ambiguous(OnigEncoding enc, OnigAmbigType flag,
740: const UChar** pp, const UChar* end)
741: {
742: const UChar* p = *pp;
743:
744: if (ONIGENC_IS_MBC_ASCII(p)) {
745: (*pp)++;
746: if ((flag & ONIGENC_AMBIGUOUS_MATCH_ASCII_CASE) != 0) {
747: return ONIGENC_IS_ASCII_CODE_CASE_AMBIG(*p);
748: }
749: else {
750: return FALSE;
751: }
752: }
753:
754: (*pp) += enc_len(enc, p);
755: return FALSE;
756: }
757:
758: extern int
759: onigenc_mb2_code_to_mbclen(OnigCodePoint code)
760: {
761: if ((code & 0xff00) != 0) return 2;
762: else return 1;
763: }
764:
765: extern int
766: onigenc_mb4_code_to_mbclen(OnigCodePoint code)
767: {
768: if ((code & 0xff000000) != 0) return 4;
769: else if ((code & 0xff0000) != 0) return 3;
770: else if ((code & 0xff00) != 0) return 2;
771: else return 1;
772: }
773:
774: extern int
775: onigenc_mb2_code_to_mbc_first(OnigCodePoint code)
776: {
777: int first;
778:
779: if ((code & 0xff00) != 0) {
780: first = (code >> 8) & 0xff;
781: }
782: else {
783: return (int )code;
784: }
785: return first;
786: }
787:
788: extern int
789: onigenc_mb4_code_to_mbc_first(OnigCodePoint code)
790: {
791: int first;
792:
793: if ((code & 0xff000000) != 0) {
794: first = (code >> 24) & 0xff;
795: }
796: else if ((code & 0xff0000) != 0) {
797: first = (code >> 16) & 0xff;
798: }
799: else if ((code & 0xff00) != 0) {
800: first = (code >> 8) & 0xff;
801: }
802: else {
803: return (int )code;
804: }
805: return first;
806: }
807:
808: extern int
809: onigenc_mb2_code_to_mbc(OnigEncoding enc, OnigCodePoint code, UChar *buf)
810: {
811: UChar *p = buf;
812:
813: if ((code & 0xff00) != 0) {
814: *p++ = (UChar )((code >> 8) & 0xff);
815: }
816: *p++ = (UChar )(code & 0xff);
817:
818: #if 1
819: if (enc_len(enc, buf) != (p - buf))
820: return ONIGENCERR_INVALID_WIDE_CHAR_VALUE;
821: #endif
822: return p - buf;
823: }
824:
825: extern int
826: onigenc_mb4_code_to_mbc(OnigEncoding enc, OnigCodePoint code, UChar *buf)
827: {
828: UChar *p = buf;
829:
830: if ((code & 0xff000000) != 0) {
831: *p++ = (UChar )((code >> 24) & 0xff);
832: }
833: if ((code & 0xff0000) != 0 || p != buf) {
834: *p++ = (UChar )((code >> 16) & 0xff);
835: }
836: if ((code & 0xff00) != 0 || p != buf) {
837: *p++ = (UChar )((code >> 8) & 0xff);
838: }
839: *p++ = (UChar )(code & 0xff);
840:
841: #if 1
842: if (enc_len(enc, buf) != (p - buf))
843: return ONIGENCERR_INVALID_WIDE_CHAR_VALUE;
844: #endif
845: return p - buf;
846: }
847:
848: extern int
849: onigenc_mb2_is_code_ctype(OnigEncoding enc, OnigCodePoint code,
850: unsigned int ctype)
851: {
852: if (code < 128)
853: return ONIGENC_IS_ASCII_CODE_CTYPE(code, ctype);
854: else {
855: if ((ctype & (ONIGENC_CTYPE_WORD |
856: ONIGENC_CTYPE_GRAPH | ONIGENC_CTYPE_PRINT)) != 0) {
857: return (ONIGENC_CODE_TO_MBCLEN(enc, code) > 1 ? TRUE : FALSE);
858: }
859: }
860:
861: return FALSE;
862: }
863:
864: extern int
865: onigenc_mb4_is_code_ctype(OnigEncoding enc, OnigCodePoint code,
866: unsigned int ctype)
867: {
868: if (code < 128)
869: return ONIGENC_IS_ASCII_CODE_CTYPE(code, ctype);
870: else {
871: if ((ctype & (ONIGENC_CTYPE_WORD |
872: ONIGENC_CTYPE_GRAPH | ONIGENC_CTYPE_PRINT)) != 0) {
873: return (ONIGENC_CODE_TO_MBCLEN(enc, code) > 1 ? TRUE : FALSE);
874: }
875: }
876:
877: return FALSE;
878: }
879:
880: extern int
881: onigenc_with_ascii_strncmp(OnigEncoding enc, const UChar* p, const UChar* end,
882: const UChar* sascii /* ascii */, int n)
883: {
884: int x, c;
885:
886: while (n-- > 0) {
887: if (p >= end) return (int )(*sascii);
888:
889: c = (int )ONIGENC_MBC_TO_CODE(enc, p, end);
890: x = *sascii - c;
891: if (x) return x;
892:
893: sascii++;
894: p += enc_len(enc, p);
895: }
896: return 0;
897: }
898:
899: #else /* ONIG_RUBY_M17N */
900:
901: extern int
902: onigenc_is_code_ctype(OnigEncoding enc, OnigCodePoint code, int ctype)
903: {
904: switch (ctype) {
905: case ONIGENC_CTYPE_NEWLINE:
906: if (code == 0x0a) return 1;
907: break;
908:
909: case ONIGENC_CTYPE_ALPHA:
910: return m17n_isalpha(enc, code);
911: break;
912: case ONIGENC_CTYPE_BLANK:
913: return ONIGENC_IS_CODE_BLANK(enc, (int )(code));
914: break;
915: case ONIGENC_CTYPE_CNTRL:
916: return m17n_iscntrl(enc, code);
917: break;
918: case ONIGENC_CTYPE_DIGIT:
919: return m17n_isdigit(enc, code);
920: break;
921: case ONIGENC_CTYPE_GRAPH:
922: return ONIGENC_IS_CODE_GRAPH(enc, (int )(code));
923: break;
924: case ONIGENC_CTYPE_LOWER:
925: return m17n_islower(enc, code);
926: break;
927: case ONIGENC_CTYPE_PRINT:
928: return m17n_isprint(enc, code);
929: break;
930: case ONIGENC_CTYPE_PUNCT:
931: return m17n_ispunct(enc, code);
932: break;
933: case ONIGENC_CTYPE_SPACE:
934: return m17n_isspace(enc, code);
935: break;
936: case ONIGENC_CTYPE_UPPER:
937: return m17n_isupper(enc, code);
938: break;
939: case ONIGENC_CTYPE_XDIGIT:
940: return m17n_isxdigit(enc, code);
941: break;
942: case ONIGENC_CTYPE_WORD:
943: return m17n_iswchar(enc, code);
944: break;
945: case ONIGENC_CTYPE_ASCII:
946: return (code < 128 ? TRUE : FALSE);
947: break;
948: case ONIGENC_CTYPE_ALNUM:
949: return m17n_isalnum(enc, code);
950: break;
951: default:
952: break;
953: }
954:
955: return 0;
956: }
957:
958: extern int
959: onigenc_code_to_mbc(OnigEncoding enc, OnigCodePoint code, UChar *buf)
960: {
961: int c, len;
962:
963: m17n_mbcput(enc, code, buf);
964: c = m17n_firstbyte(enc, code);
965: len = enc_len(enc, c);
966: return len;
967: }
968:
969: extern int
970: onigenc_mbc_to_lower(OnigEncoding enc, UChar* p, UChar* buf)
971: {
972: unsigned int c, low;
973:
974: c = m17n_codepoint(enc, p, p + enc_len(enc, *p));
975: low = m17n_tolower(enc, c);
976: m17n_mbcput(enc, low, buf);
977:
978: return m17n_codelen(enc, low);
979: }
980:
981: extern int
982: onigenc_is_mbc_ambiguous(OnigEncoding enc, OnigAmbigType flag,
983: UChar** pp, UChar* end)
984: {
985: int len;
986: unsigned int c;
987: UChar* p = *pp;
988:
989: len = enc_len(enc, *p);
990: (*pp) += len;
991: c = m17n_codepoint(enc, p, p + len);
992:
993: if ((flag & ONIGENC_AMBIGUOUS_MATCH_ASCII_CASE) != 0) {
994: if (m17n_isupper(enc, c) || m17n_islower(enc, c))
995: return TRUE;
996: }
997:
998: return FALSE;
999: }
1000:
1001: extern UChar*
1002: onigenc_get_left_adjust_char_head(OnigEncoding enc, UChar* start, UChar* s)
1003: {
1004: UChar *p;
1005: int len;
1006:
1007: if (s <= start) return s;
1008: p = s;
1009:
1010: while (!m17n_islead(enc, *p) && p > start) p--;
1011: while (p + (len = enc_len(enc, *p)) < s) {
1012: p += len;
1013: }
1014: if (p + len == s) return s;
1015: return p;
1016: }
1017:
1018: extern int
1019: onigenc_is_allowed_reverse_match(OnigEncoding enc,
1020: const UChar* s, const UChar* end)
1021: {
1022: return ONIGENC_IS_SINGLEBYTE(enc);
1023: }
1024:
1025: extern void
1026: onigenc_set_default_caseconv_table(UChar* table) { }
1027:
1028: #endif /* ONIG_RUBY_M17N */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to regenc.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / mbstring / oniguruma