← Back to branch summary

~ubuntu-branches/ubuntu/hardy/php5/hardy-updates

« back to all changes in this revision

Viewing changes to ext/mbstring/oniguruma/regenc.c

  • Committer: Bazaar Package Importer
  • Author(s): Adam Conrad
  • Date: 2005-10-09 03:14:32 UTC
  • Revision ID: james.westby@ubuntu.com-20051009031432-kspik3lobxstafv9
Tags: upstream-5.0.5
Import upstream version 5.0.5

Show diffs side-by-side

added added

removed removed

Lines of Context:
ext/mbstring/oniguruma/regenc.c
 
1
/**********************************************************************
 
2
  regenc.c -  Oniguruma (regular expression library)
 
3
**********************************************************************/
 
4
/*-
 
5
 * Copyright (c) 2002-2005  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()
 
36
{
 
37
  return 0;
 
38
}
 
39
 
 
40
extern OnigEncoding
 
41
onigenc_get_default_encoding()
 
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
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
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
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
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
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
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
                                       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
                                         OnigCompAmbigCodes** ccs)
 
492
{
 
493
  return 0;
 
494
}
 
495
 
 
496
extern int
 
497
onigenc_iso_8859_1_get_all_pair_ambig_codes(OnigAmbigType flag,
 
498
                                            OnigPairAmbigCodes** ccs)
 
499
{
 
500
  static 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
                                           OnigCompAmbigCodes** ccs)
 
581
{
 
582
  static 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
                             OnigCodePoint* sbr[], 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) {
 
834
    *p++ = (UChar )((code >> 16) & 0xff);
 
835
  }
 
836
  if ((code & 0xff00) != 0) {
 
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 ((ctype & ONIGENC_CTYPE_WORD) != 0) {
 
853
    if (code < 128)
 
854
      return ONIGENC_IS_ASCII_CODE_CTYPE(code, ctype);
 
855
    else
 
856
      return (ONIGENC_CODE_TO_MBCLEN(enc, code) > 1 ? TRUE : FALSE);
 
857
 
 
858
    ctype &= ~ONIGENC_CTYPE_WORD;
 
859
    if (ctype == 0) return FALSE;
 
860
  }
 
861
 
 
862
  if (code < 128)
 
863
    return ONIGENC_IS_ASCII_CODE_CTYPE(code, ctype);
 
864
  else
 
865
    return FALSE;
 
866
}
 
867
 
 
868
extern int
 
869
onigenc_mb4_is_code_ctype(OnigEncoding enc, OnigCodePoint code,
 
870
                          unsigned int ctype)
 
871
{
 
872
  if ((ctype & ONIGENC_CTYPE_WORD) != 0) {
 
873
    if (code < 128)
 
874
      return ONIGENC_IS_ASCII_CODE_CTYPE(code, ctype);
 
875
    else
 
876
      return (ONIGENC_CODE_TO_MBCLEN(enc, code) > 1 ? TRUE : FALSE);
 
877
 
 
878
    ctype &= ~ONIGENC_CTYPE_WORD;
 
879
    if (ctype == 0) return FALSE;
 
880
  }
 
881
 
 
882
  if (code < 128)
 
883
    return ONIGENC_IS_ASCII_CODE_CTYPE(code, ctype);
 
884
  else
 
885
    return FALSE;
 
886
}
 
887
 
 
888
extern int
 
889
onigenc_with_ascii_strncmp(OnigEncoding enc, const UChar* p, const UChar* end,
 
890
                           const UChar* sascii /* ascii */, int n)
 
891
{
 
892
  int x, c;
 
893
 
 
894
  while (n-- > 0) {
 
895
    if (p >= end) return (int )(*sascii);
 
896
 
 
897
    c = (int )ONIGENC_MBC_TO_CODE(enc, p, end);
 
898
    x = *sascii - c;
 
899
    if (x) return x;
 
900
 
 
901
    sascii++;
 
902
    p += enc_len(enc, p);
 
903
  }
 
904
  return 0;
 
905
}
 
906
 
 
907
#else /* ONIG_RUBY_M17N */
 
908
 
 
909
extern int
 
910
onigenc_is_code_ctype(OnigEncoding enc, OnigCodePoint code, int ctype)
 
911
{
 
912
  switch (ctype) {
 
913
  case ONIGENC_CTYPE_NEWLINE:
 
914
    if (code == 0x0a) return 1;
 
915
    break;
 
916
 
 
917
  case ONIGENC_CTYPE_ALPHA:
 
918
    return m17n_isalpha(enc, code);
 
919
    break;
 
920
  case ONIGENC_CTYPE_BLANK:
 
921
    return ONIGENC_IS_CODE_BLANK(enc, (int )(code));
 
922
    break;
 
923
  case ONIGENC_CTYPE_CNTRL:
 
924
    return m17n_iscntrl(enc, code);
 
925
    break;
 
926
  case ONIGENC_CTYPE_DIGIT:
 
927
    return m17n_isdigit(enc, code);
 
928
    break;
 
929
  case ONIGENC_CTYPE_GRAPH:
 
930
    return ONIGENC_IS_CODE_GRAPH(enc, (int )(code));
 
931
    break;
 
932
  case ONIGENC_CTYPE_LOWER:
 
933
    return m17n_islower(enc, code);
 
934
    break;
 
935
  case ONIGENC_CTYPE_PRINT:
 
936
    return m17n_isprint(enc, code);
 
937
    break;
 
938
  case ONIGENC_CTYPE_PUNCT:
 
939
    return m17n_ispunct(enc, code);
 
940
    break;
 
941
  case ONIGENC_CTYPE_SPACE:
 
942
    return m17n_isspace(enc, code);
 
943
    break;
 
944
  case ONIGENC_CTYPE_UPPER:
 
945
    return m17n_isupper(enc, code);
 
946
    break;
 
947
  case ONIGENC_CTYPE_XDIGIT:
 
948
    return m17n_isxdigit(enc, code);
 
949
    break;
 
950
  case ONIGENC_CTYPE_WORD:
 
951
    return m17n_iswchar(enc, code);
 
952
    break;
 
953
  case ONIGENC_CTYPE_ASCII:
 
954
    return (code < 128 ? TRUE : FALSE);
 
955
    break;
 
956
  case ONIGENC_CTYPE_ALNUM:
 
957
    return m17n_isalnum(enc, code);
 
958
    break;
 
959
  default:
 
960
    break;
 
961
  }
 
962
 
 
963
  return 0;
 
964
}
 
965
 
 
966
extern int
 
967
onigenc_code_to_mbc(OnigEncoding enc, OnigCodePoint code, UChar *buf)
 
968
{
 
969
  int c, len;
 
970
 
 
971
  m17n_mbcput(enc, code, buf);
 
972
  c = m17n_firstbyte(enc, code);
 
973
  len = enc_len(enc, c);
 
974
  return len;
 
975
}
 
976
 
 
977
extern int
 
978
onigenc_mbc_to_lower(OnigEncoding enc, UChar* p, UChar* buf)
 
979
{
 
980
  unsigned int c, low;
 
981
 
 
982
  c   = m17n_codepoint(enc, p, p + enc_len(enc, *p));
 
983
  low = m17n_tolower(enc, c);
 
984
  m17n_mbcput(enc, low, buf);
 
985
 
 
986
  return m17n_codelen(enc, low);
 
987
}
 
988
 
 
989
extern int
 
990
onigenc_is_mbc_ambiguous(OnigEncoding enc, OnigAmbigType flag,
 
991
                         UChar** pp, UChar* end)
 
992
{
 
993
  int len;
 
994
  unsigned int c;
 
995
  UChar* p = *pp;
 
996
 
 
997
  len = enc_len(enc, *p);
 
998
  (*pp) += len;
 
999
  c = m17n_codepoint(enc, p, p + len);
 
1000
 
 
1001
  if ((flag & ONIGENC_AMBIGUOUS_MATCH_ASCII_CASE) != 0) {
 
1002
    if (m17n_isupper(enc, c) || m17n_islower(enc, c))
 
1003
      return TRUE;
 
1004
  }
 
1005
 
 
1006
  return FALSE;
 
1007
}
 
1008
 
 
1009
extern UChar*
 
1010
onigenc_get_left_adjust_char_head(OnigEncoding enc, UChar* start, UChar* s)
 
1011
{
 
1012
  UChar *p;
 
1013
  int len;
 
1014
 
 
1015
  if (s <= start) return s;
 
1016
  p = s;
 
1017
 
 
1018
  while (!m17n_islead(enc, *p) && p > start) p--;
 
1019
  while (p + (len = enc_len(enc, *p)) < s) {
 
1020
    p += len;
 
1021
  }
 
1022
  if (p + len == s) return s;
 
1023
  return p;
 
1024
}
 
1025
 
 
1026
extern int
 
1027
onigenc_is_allowed_reverse_match(OnigEncoding enc,
 
1028
                                 const UChar* s, const UChar* end)
 
1029
{
 
1030
  return ONIGENC_IS_SINGLEBYTE(enc);
 
1031
}
 
1032
 
 
1033
extern void
 
1034
onigenc_set_default_caseconv_table(UChar* table) { }
 
1035
 
 
1036
#endif /* ONIG_RUBY_M17N */