← Back to branch summary

~ubuntu-branches/ubuntu/lucid/w3m/lucid-proposed

« back to all changes in this revision

Viewing changes to regex.c

  • Committer: Bazaar Package Importer
  • Author(s): Fumitoshi UKAI
  • Date: 2004-04-29 03:28:41 UTC
  • Revision ID: james.westby@ubuntu.com-20040429032841-uo4mu7a813aqrua8
Tags: upstream-0.5.1
Import upstream version 0.5.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
regex.c
 
1
/* $Id: regex.c,v 1.22 2003/09/24 18:49:00 ukai Exp $ */
 
2
/* 
 
3
 * regex: Regular expression pattern match library
 
4
 * 
 
5
 * by A.ITO, December 1989
 
6
 * Revised by A.ITO, January 2002
 
7
 */
 
8
 
 
9
#ifdef REGEX_DEBUG
 
10
#include <sys/types.h>
 
11
#include <malloc.h>
 
12
#endif                          /* REGEX_DEBUG */
 
13
#include <stdio.h>
 
14
#include <stdlib.h>
 
15
#include <string.h>
 
16
#include <gc.h>
 
17
#include "config.h"
 
18
#ifdef USE_M17N
 
19
#include "wc.h"
 
20
#include "wtf.h"
 
21
#ifdef USE_UNICODE
 
22
#include "ucs.h"
 
23
#endif
 
24
#endif
 
25
#include "regex.h"
 
26
#include "config.h"
 
27
#include "myctype.h"
 
28
 
 
29
#ifndef NULL
 
30
#define NULL    0
 
31
#endif                          /* not NULL */
 
32
 
 
33
#define RE_ITER_LIMIT   65535
 
34
 
 
35
#define RE_MATCHMODE    0x07
 
36
#define RE_NORMAL       0x00
 
37
#define RE_ANY          0x01
 
38
#define RE_WHICH        0x02
 
39
#define RE_EXCEPT       0x03
 
40
#define RE_SUBREGEX     0x04
 
41
#define RE_BEGIN        0x05
 
42
#define RE_END          0x06
 
43
#define RE_ENDMARK      0x07
 
44
 
 
45
#define RE_OPT          0x08
 
46
#define RE_ANYTIME      0x10
 
47
#define RE_IGNCASE      0x40
 
48
 
 
49
#define RE_MODE(x)      ((x)->mode&RE_MATCHMODE)
 
50
#define RE_SET_MODE(x,v) ((x)->mode = (((x)->mode&~RE_MATCHMODE)|((v)&RE_MATCHMODE)))
 
51
 
 
52
#ifdef REGEX_DEBUG
 
53
void debugre(regexchar *);
 
54
char *lc2c(longchar *, int);
 
55
int verbose;
 
56
#endif                          /* REGEX_DEBUG */
 
57
 
 
58
#ifdef USE_M17N
 
59
#define get_mclen(c) wtf_len1((wc_uchar *)(c))
 
60
#else
 
61
#define get_mclen(c) 1
 
62
#endif
 
63
 
 
64
#ifndef TOLOWER
 
65
#include <ctype.h>
 
66
#define TOLOWER(x) tolower(x)
 
67
#define TOUPPER(x) toupper(x)
 
68
#endif
 
69
 
 
70
#define RE_TYPE_END     0
 
71
#define RE_TYPE_CHAR    1
 
72
#define RE_TYPE_WCHAR_T 2
 
73
#define RE_WHICH_RANGE  3
 
74
#define RE_TYPE_SYMBOL  4
 
75
 
 
76
static longchar
 
77
set_longchar(char *str)
 
78
{
 
79
    unsigned char *p = (unsigned char *)str;
 
80
    longchar r;
 
81
 
 
82
#ifdef USE_M17N
 
83
    if (*p & 0x80) {
 
84
        r.wch = wtf_parse1(&p);
 
85
        if (r.wch.ccs == WC_CCS_SPECIAL || r.wch.ccs == WC_CCS_SPECIAL_W) {
 
86
            r.type = RE_TYPE_SYMBOL;
 
87
            return r;
 
88
        }
 
89
#ifdef USE_UNICODE
 
90
        if (WC_CCS_IS_UNICODE(r.wch.ccs)) {
 
91
            if (WC_CCS_SET(r.wch.ccs) == WC_CCS_UCS_TAG)
 
92
                r.wch.code = wc_ucs_tag_to_ucs(r.wch.code);
 
93
            r.wch.ccs = WC_CCS_UCS4;
 
94
        }
 
95
        else
 
96
#endif
 
97
            r.wch.ccs = WC_CCS_SET(r.wch.ccs);
 
98
        r.type = RE_TYPE_WCHAR_T;
 
99
        return r;
 
100
    }
 
101
#endif
 
102
    r.ch = *p;
 
103
    r.type = RE_TYPE_CHAR;
 
104
    return r;
 
105
}
 
106
 
 
107
static Regex DefaultRegex;
 
108
#define CompiledRegex DefaultRegex.re
 
109
#define Cstorage DefaultRegex.storage
 
110
 
 
111
static int regmatch(regexchar *, char *, char *, int, char **);
 
112
static int regmatch1(regexchar *, longchar *);
 
113
static int matchWhich(longchar *, longchar *, int);
 
114
static int match_longchar(longchar *, longchar *, int);
 
115
static int match_range_longchar(longchar *, longchar *, longchar *, int);
 
116
 
 
117
/* 
 
118
 * regexCompile: compile regular expression
 
119
 */
 
120
char *
 
121
regexCompile(char *ex, int igncase)
 
122
{
 
123
    char *msg;
 
124
    newRegex(ex, igncase, &DefaultRegex, &msg);
 
125
    return msg;
 
126
}
 
127
 
 
128
static Regex *
 
129
newRegex0(char **ex, int igncase, Regex *regex, char **msg, int level)
 
130
{
 
131
    char *p;
 
132
    longchar *r;
 
133
    regexchar *re;
 
134
    int m;
 
135
    longchar *st_ptr;
 
136
 
 
137
    if (regex == NULL)
 
138
        regex = (Regex *)GC_malloc(sizeof(Regex));
 
139
    regex->alt_regex = NULL;
 
140
    re = regex->re;
 
141
    st_ptr = regex->storage;
 
142
    for (p = *ex; *p != '\0'; p++) {
 
143
        re->mode = 0;
 
144
        switch (*p) {
 
145
        case '.':
 
146
            re->p.pattern = NULL;
 
147
            RE_SET_MODE(re, RE_ANY);
 
148
            re++;
 
149
            break;
 
150
        case '$':
 
151
            re->p.pattern = NULL;
 
152
            RE_SET_MODE(re, RE_END);
 
153
            re++;
 
154
            break;
 
155
        case '^':
 
156
            re->p.pattern = NULL;
 
157
            RE_SET_MODE(re, RE_BEGIN);
 
158
            re++;
 
159
            break;
 
160
        case '+':
 
161
            if (re == regex->re ||
 
162
                (RE_MODE(re - 1) != RE_ANY && (re - 1)->p.pattern == NULL)) {
 
163
                if (msg)
 
164
                    *msg = "Invalid regular expression";
 
165
                return NULL;
 
166
            }
 
167
            *re = *(re - 1);
 
168
            re->mode |= RE_ANYTIME;
 
169
            re++;
 
170
            break;
 
171
        case '*':
 
172
            if (re == regex->re ||
 
173
                (RE_MODE(re - 1) != RE_ANY && (re - 1)->p.pattern == NULL)) {
 
174
                if (msg)
 
175
                    *msg = "Invalid regular expression";
 
176
                return NULL;
 
177
            }
 
178
            (re - 1)->mode |= RE_ANYTIME;
 
179
            break;
 
180
        case '?':
 
181
            if (re == regex->re ||
 
182
                (RE_MODE(re - 1) != RE_ANY && (re - 1)->p.pattern == NULL)) {
 
183
                if (msg)
 
184
                    *msg = "Invalid regular expression";
 
185
                return NULL;
 
186
            }
 
187
            (re - 1)->mode |= RE_OPT;
 
188
            break;
 
189
        case '[':
 
190
            r = st_ptr;
 
191
            if (*++p == '^') {
 
192
                p++;
 
193
                m = RE_EXCEPT;
 
194
            }
 
195
            else
 
196
                m = RE_WHICH;
 
197
            if (*p == '-' || *p == ']')
 
198
                *(st_ptr++) = set_longchar(p);
 
199
            while (*p != ']') {
 
200
                if (*p == '\\') {
 
201
                    p++;
 
202
                    *(st_ptr++) = set_longchar(p);
 
203
                    p += get_mclen(p);
 
204
                }
 
205
                else if (*p == '-' && *(p + 1) != ']') {
 
206
                    (st_ptr++)->type = RE_WHICH_RANGE;
 
207
                    p++;
 
208
                }
 
209
                else if (*p == '\0') {
 
210
                    if (msg)
 
211
                        *msg = "Missing ]";
 
212
                    return NULL;
 
213
                }
 
214
                else {
 
215
                    *(st_ptr++) = set_longchar(p);
 
216
                    p += get_mclen(p);
 
217
                }
 
218
                if (st_ptr >= &regex->storage[STORAGE_MAX]) {
 
219
                    if (msg)
 
220
                        *msg = "Regular expression too long";
 
221
                    return NULL;
 
222
                }
 
223
            }
 
224
            (st_ptr++)->type = RE_TYPE_END;
 
225
            re->p.pattern = r;
 
226
            RE_SET_MODE(re, m);
 
227
            if (igncase)
 
228
                re->mode |= RE_IGNCASE;
 
229
            re++;
 
230
            break;
 
231
        case '|':
 
232
            RE_SET_MODE(re, RE_ENDMARK);
 
233
            re++;
 
234
            p++;
 
235
            regex->alt_regex = newRegex0(&p, igncase, NULL, msg, level);
 
236
            if (regex->alt_regex == NULL)
 
237
                return NULL;
 
238
            *ex = p;
 
239
            return regex;
 
240
        case '(':
 
241
            RE_SET_MODE(re, RE_SUBREGEX);
 
242
            p++;
 
243
            re->p.sub = newRegex0(&p, igncase, NULL, msg, level + 1);
 
244
            if (re->p.sub == NULL)
 
245
                return NULL;
 
246
            re++;
 
247
            break;
 
248
        case ')':
 
249
            if (level == 0) {
 
250
                if (msg)
 
251
                    *msg = "Too many ')'";
 
252
                return NULL;
 
253
            }
 
254
            RE_SET_MODE(re, RE_ENDMARK);
 
255
            re++;
 
256
            *ex = p;
 
257
            return regex;
 
258
        case '\\':
 
259
            p++;
 
260
        default:
 
261
            *(st_ptr) = set_longchar(p);
 
262
            p += get_mclen(p) - 1;
 
263
            re->p.pattern = st_ptr;
 
264
            st_ptr++;
 
265
            RE_SET_MODE(re, RE_NORMAL);
 
266
            if (igncase)
 
267
                re->mode |= RE_IGNCASE;
 
268
            re++;
 
269
        }
 
270
        if (st_ptr >= &regex->storage[STORAGE_MAX] ||
 
271
            re >= &regex->re[REGEX_MAX]) {
 
272
            if (msg)
 
273
                *msg = "Regular expression too long";
 
274
            return NULL;
 
275
        }
 
276
    }
 
277
    RE_SET_MODE(re, RE_ENDMARK);
 
278
    if (msg)
 
279
        *msg = NULL;
 
280
    *ex = p;
 
281
    return regex;
 
282
}
 
283
 
 
284
Regex *
 
285
newRegex(char *ex, int igncase, Regex *regex, char **msg)
 
286
{
 
287
    return newRegex0(&ex, igncase, regex, msg, 0);
 
288
}
 
289
 
 
290
/* 
 
291
 * regexMatch: match regular expression
 
292
 */
 
293
int
 
294
regexMatch(char *str, int len, int firstp)
 
295
{
 
296
    return RegexMatch(&DefaultRegex, str, len, firstp);
 
297
}
 
298
 
 
299
int
 
300
RegexMatch(Regex *re, char *str, int len, int firstp)
 
301
{
 
302
    char *p, *ep;
 
303
    char *lpos;
 
304
    Regex *r;
 
305
 
 
306
    if (str == NULL)
 
307
        return 0;
 
308
    if (len < 0)
 
309
        len = strlen(str);
 
310
    re->position = NULL;
 
311
    ep = str + len;
 
312
    for (p = str; p <= ep; p++) {
 
313
        lpos = NULL;
 
314
        re->lposition = NULL;
 
315
        for (r = re; r != NULL; r = r->alt_regex) {
 
316
            switch (regmatch(r->re, p, ep, firstp && (p == str), &lpos)) {
 
317
            case 1:             /* matched */
 
318
                re->position = p;
 
319
                if (re->lposition == NULL || re->lposition < lpos)
 
320
                    re->lposition = lpos;
 
321
                break;
 
322
            case -1:            /* error */
 
323
                re->position = NULL;
 
324
                return -1;
 
325
            }
 
326
        }
 
327
        if (re->lposition != NULL) {
 
328
            /* matched */
 
329
            return 1;
 
330
        }
 
331
        p += get_mclen(p) - 1;
 
332
    }
 
333
    return 0;
 
334
}
 
335
 
 
336
/* 
 
337
 * matchedPosition: last matched position
 
338
 */
 
339
void
 
340
MatchedPosition(Regex *re, char **first, char **last)
 
341
{
 
342
    *first = re->position;
 
343
    *last = re->lposition;
 
344
}
 
345
 
 
346
void
 
347
matchedPosition(char **first, char **last)
 
348
{
 
349
    *first = DefaultRegex.position;
 
350
    *last = DefaultRegex.lposition;
 
351
}
 
352
 
 
353
/* 
 
354
 * Intermal routines
 
355
 */
 
356
 
 
357
struct MatchingContext1 {
 
358
    int label;
 
359
    regexchar *re;
 
360
    char *lastpos;
 
361
    char *str;
 
362
    int iter_limit;
 
363
    int n_any;
 
364
    int firstp;
 
365
    char *end_p;
 
366
    Regex *sub_regex;
 
367
    struct MatchingContext1 *sub_ctx;
 
368
    struct MatchingContext2 *ctx2;
 
369
};
 
370
 
 
371
struct MatchingContext2 {
 
372
    int label;
 
373
    Regex *regex;
 
374
    char *lastpos;
 
375
    struct MatchingContext1 *ctx;
 
376
    struct MatchingContext2 *ctx2;
 
377
    char *str;
 
378
    int n_any;
 
379
    int firstp;
 
380
};
 
381
 
 
382
 
 
383
#define YIELD(retval,context,lnum) (context)->label = lnum; return (retval); label##lnum:
 
384
 
 
385
static int regmatch_iter(struct MatchingContext1 *,
 
386
                         regexchar *, char *, char *, int);
 
387
 
 
388
static int
 
389
regmatch_sub_anytime(struct MatchingContext2 *c, Regex *regex,
 
390
                     regexchar * pat2,
 
391
                     char *str, char *end_p, int iter_limit, int firstp)
 
392
{
 
393
    switch (c->label) {
 
394
    case 1:
 
395
        goto label1;
 
396
    case 2:
 
397
        goto label2;
 
398
    case 3:
 
399
        goto label3;
 
400
    }
 
401
    c->ctx = GC_malloc(sizeof(struct MatchingContext1));
 
402
    c->ctx2 = GC_malloc(sizeof(struct MatchingContext2));
 
403
    c->ctx->label = 0;
 
404
    c->regex = regex;
 
405
    c->n_any = 0;
 
406
    c->str = str;
 
407
    c->firstp = firstp;
 
408
    for (;;) {
 
409
        c->ctx->label = 0;
 
410
        while (regmatch_iter(c->ctx, c->regex->re, c->str, end_p, c->firstp)) {
 
411
            c->n_any = c->ctx->lastpos - c->str;
 
412
            if (c->n_any <= 0)
 
413
                continue;
 
414
            c->firstp = 0;
 
415
            if (RE_MODE(pat2) == RE_ENDMARK) {
 
416
                c->lastpos = c->str + c->n_any;
 
417
                YIELD(1, c, 1);
 
418
            }
 
419
            else if (regmatch(pat2, c->str + c->n_any, end_p,
 
420
                              c->firstp, &c->lastpos) == 1) {
 
421
                YIELD(1, c, 2);
 
422
            }
 
423
            if (iter_limit == 1)
 
424
                continue;
 
425
            c->ctx2->label = 0;
 
426
            while (regmatch_sub_anytime(c->ctx2, regex, pat2,
 
427
                                        c->str + c->n_any, end_p,
 
428
                                        iter_limit - 1, c->firstp)) {
 
429
 
 
430
                c->lastpos = c->ctx2->lastpos;
 
431
                YIELD(1, c, 3);
 
432
            }
 
433
        }
 
434
        if (c->regex->alt_regex == NULL)
 
435
            break;
 
436
        c->regex = c->regex->alt_regex;
 
437
    }
 
438
    return 0;
 
439
}
 
440
 
 
441
static int
 
442
regmatch_iter(struct MatchingContext1 *c,
 
443
              regexchar * re, char *str, char *end_p, int firstp)
 
444
{
 
445
    switch (c->label) {
 
446
    case 1:
 
447
        goto label1;
 
448
    case 2:
 
449
        goto label2;
 
450
    case 3:
 
451
        goto label3;
 
452
    case 4:
 
453
        goto label4;
 
454
    case 5:
 
455
        goto label5;
 
456
    case 6:
 
457
        goto label6;
 
458
    case 7:
 
459
        goto label7;
 
460
    }
 
461
    if (RE_MODE(re) == RE_ENDMARK)
 
462
        return 0;
 
463
    c->re = re;
 
464
    c->firstp = firstp;
 
465
    c->str = str;
 
466
    c->end_p = end_p;
 
467
    c->sub_ctx = NULL;
 
468
    c->lastpos = NULL;
 
469
    while (RE_MODE(c->re) != RE_ENDMARK) {
 
470
        if (c->re->mode & (RE_ANYTIME | RE_OPT)) {
 
471
            if (c->re->mode & RE_ANYTIME)
 
472
                c->iter_limit = RE_ITER_LIMIT;
 
473
            else
 
474
                c->iter_limit = 1;
 
475
            c->n_any = -1;
 
476
            while (c->n_any < c->iter_limit) {
 
477
                if (c->str + c->n_any >= c->end_p) {
 
478
                    return 0;
 
479
                }
 
480
                if (c->n_any >= 0) {
 
481
                    if (RE_MODE(c->re) == RE_SUBREGEX) {
 
482
                        c->ctx2 = GC_malloc(sizeof(struct MatchingContext2));
 
483
                        c->ctx2->label = 0;
 
484
                        while (regmatch_sub_anytime(c->ctx2,
 
485
                                                    c->re->p.sub,
 
486
                                                    c->re + 1,
 
487
                                                    c->str + c->n_any,
 
488
                                                    c->end_p,
 
489
                                                    c->iter_limit,
 
490
                                                    c->firstp)) {
 
491
                            c->n_any = c->ctx2->lastpos - c->str;
 
492
                            c->lastpos = c->ctx2->lastpos;
 
493
                            YIELD(1, c, 1);
 
494
                        }
 
495
                        return 0;
 
496
                    }
 
497
                    else {
 
498
                        longchar k;
 
499
                        k = set_longchar(c->str + c->n_any);
 
500
                        if (regmatch1(c->re, &k)) {
 
501
                            c->n_any += get_mclen(c->str + c->n_any);
 
502
                        }
 
503
                        else {
 
504
                            return 0;
 
505
                        }
 
506
                        c->firstp = 0;
 
507
                    }
 
508
                }
 
509
                else
 
510
                    c->n_any++;
 
511
                if (RE_MODE(c->re + 1) == RE_ENDMARK) {
 
512
                    c->lastpos = c->str + c->n_any;
 
513
                    YIELD(1, c, 2);
 
514
                }
 
515
                else if (regmatch(c->re + 1, c->str + c->n_any, c->end_p,
 
516
                                  c->firstp, &c->lastpos) == 1) {
 
517
                    YIELD(1, c, 3);
 
518
                }
 
519
            }
 
520
            return 0;
 
521
        }
 
522
        /* regexp other than pat*, pat+ and pat? */
 
523
        switch (RE_MODE(c->re)) {
 
524
        case RE_BEGIN:
 
525
            if (!c->firstp)
 
526
                return 0;
 
527
            c->re++;
 
528
            break;
 
529
        case RE_END:
 
530
            if (c->str >= c->end_p) {
 
531
                c->lastpos = c->str;
 
532
                c->re++;
 
533
                YIELD(1, c, 4);
 
534
            }
 
535
            else {
 
536
                c->lastpos = NULL;
 
537
                return 0;
 
538
            }
 
539
            break;
 
540
        case RE_SUBREGEX:
 
541
            if (c->sub_ctx == NULL) {
 
542
                c->sub_ctx = GC_malloc(sizeof(struct MatchingContext1));
 
543
            }
 
544
            c->sub_regex = c->re->p.sub;
 
545
            for (;;) {
 
546
                c->sub_ctx->label = 0;
 
547
                while (regmatch_iter(c->sub_ctx, c->sub_regex->re,
 
548
                                     c->str, c->end_p, c->firstp)) {
 
549
                    if (c->sub_ctx->lastpos != c->str)
 
550
                        c->firstp = 0;
 
551
                    if (RE_MODE(c->re + 1) == RE_ENDMARK) {
 
552
                        c->lastpos = c->sub_ctx->lastpos;
 
553
                        YIELD(1, c, 5);
 
554
                    }
 
555
                    else if (regmatch(c->re + 1, c->sub_ctx->lastpos, c->end_p,
 
556
                                      c->firstp, &c->lastpos) == 1) {
 
557
                        YIELD(1, c, 6);
 
558
                    }
 
559
                }
 
560
                if (c->sub_regex->alt_regex == NULL)
 
561
                    break;
 
562
                c->sub_regex = c->sub_regex->alt_regex;
 
563
            }
 
564
            return 0;
 
565
        default:
 
566
            {
 
567
                longchar k;
 
568
                k = set_longchar(c->str);
 
569
                c->str += get_mclen(c->str);
 
570
                if (!regmatch1(c->re, &k))
 
571
                    return 0;
 
572
            }
 
573
            c->re++;
 
574
            c->firstp = 0;
 
575
        }
 
576
        if (c->str > c->end_p) {
 
577
            return 0;
 
578
        }
 
579
    }
 
580
    c->lastpos = c->str;
 
581
#ifdef REGEX_DEBUG
 
582
    if (verbose)
 
583
        printf("Succeed: %s %d\n", c->str, c->lastpos - c->str);
 
584
#endif
 
585
    YIELD(1, c, 7);
 
586
    return 0;
 
587
}
 
588
 
 
589
static int
 
590
regmatch(regexchar * re, char *str, char *end_p, int firstp, char **lastpos)
 
591
{
 
592
    struct MatchingContext1 contx;
 
593
 
 
594
    *lastpos = NULL;
 
595
 
 
596
    contx.label = 0;
 
597
    while (regmatch_iter(&contx, re, str, end_p, firstp)) {
 
598
#ifdef REGEX_DEBUG
 
599
        char *p;
 
600
        if (verbose) {
 
601
            printf("regmatch: matched <");
 
602
            for (p = str; p < contx.lastpos; p++)
 
603
                putchar(*p);
 
604
            printf(">\n");
 
605
        }
 
606
#endif
 
607
        if (*lastpos == NULL || *lastpos < contx.lastpos)
 
608
            *lastpos = contx.lastpos;
 
609
    }
 
610
    if (*lastpos == NULL)
 
611
        return 0;
 
612
    return 1;
 
613
}
 
614
 
 
615
 
 
616
static int
 
617
regmatch1(regexchar * re, longchar * c)
 
618
{
 
619
    int ans;
 
620
 
 
621
#ifdef USE_M17N
 
622
    if (c->type == RE_TYPE_SYMBOL)
 
623
        return 0;
 
624
#endif
 
625
    switch (RE_MODE(re)) {
 
626
    case RE_ANY:
 
627
#ifdef REGEX_DEBUG
 
628
        if (verbose)
 
629
            printf("%s vs any. -> 1\n", lc2c(c, 1));
 
630
#endif                          /* REGEX_DEBUG */
 
631
        return 1;
 
632
    case RE_NORMAL:
 
633
        ans = match_longchar(re->p.pattern, c, re->mode & RE_IGNCASE);
 
634
#ifdef REGEX_DEBUG
 
635
        if (verbose)
 
636
            printf("RE=%s vs %s -> %d\n", lc2c(re->p.pattern, 1), lc2c(c, 1),
 
637
                   ans);
 
638
#endif                          /* REGEX_DEBUG */
 
639
        return ans;
 
640
    case RE_WHICH:
 
641
        return matchWhich(re->p.pattern, c, re->mode & RE_IGNCASE);
 
642
    case RE_EXCEPT:
 
643
        return !matchWhich(re->p.pattern, c, re->mode & RE_IGNCASE);
 
644
    }
 
645
    return 0;
 
646
}
 
647
 
 
648
static int
 
649
matchWhich(longchar * pattern, longchar * c, int igncase)
 
650
{
 
651
    longchar *p = pattern;
 
652
    int ans = 0;
 
653
 
 
654
#ifdef REGEX_DEBUG
 
655
    if (verbose)
 
656
        printf("RE pattern = %s char=%s", lc2c(pattern, 10000), lc2c(c, 1));
 
657
#endif                          /* REGEX_DEBUG */
 
658
    while (p->type != RE_TYPE_END) {
 
659
        if ((p + 1)->type == RE_WHICH_RANGE && (p + 2)->type != RE_TYPE_END) {
 
660
            if (match_range_longchar(p, p + 2, c, igncase)) {
 
661
                ans = 1;
 
662
                break;
 
663
            }
 
664
            p += 3;
 
665
        }
 
666
        else {
 
667
            if (match_longchar(p, c, igncase)) {
 
668
                ans = 1;
 
669
                break;
 
670
            }
 
671
            p++;
 
672
        }
 
673
    }
 
674
#ifdef REGEX_DEBUG
 
675
    if (verbose)
 
676
        printf(" -> %d\n", ans);
 
677
#endif                          /* REGEX_DEBUG */
 
678
    return ans;
 
679
}
 
680
 
 
681
static int
 
682
match_longchar(longchar * a, longchar * b, int ignore)
 
683
{
 
684
#ifdef USE_M17N
 
685
    if (a->type != b->type)
 
686
        return 0;
 
687
    if (a->type == RE_TYPE_WCHAR_T)
 
688
        return (a->wch.ccs == b->wch.ccs) && (a->wch.code == b->wch.code);
 
689
#endif
 
690
    if (ignore && IS_ALPHA(b->ch))
 
691
        return (a->ch == TOLOWER(b->ch) || a->ch == TOUPPER(b->ch));
 
692
    else
 
693
        return a->ch == b->ch;
 
694
}
 
695
 
 
696
static int
 
697
match_range_longchar(longchar * a, longchar * b, longchar * c, int ignore)
 
698
{
 
699
#ifdef USE_M17N
 
700
    if (a->type != b->type || a->type != c->type)
 
701
        return 0;
 
702
    if (a->type == RE_TYPE_WCHAR_T)
 
703
        return ((a->wch.ccs == c->wch.ccs && c->wch.ccs == b->wch.ccs) &&
 
704
                (a->wch.code <= c->wch.code && c->wch.code <= b->wch.code));
 
705
#endif
 
706
    if (ignore && IS_ALPHA(c->ch))
 
707
        return ((a->ch <= TOLOWER(c->ch) && TOLOWER(c->ch) <= b->ch) ||
 
708
                (a->ch <= TOUPPER(c->ch) && TOUPPER(c->ch) <= b->ch));
 
709
    else
 
710
        return (a->ch <= c->ch && c->ch <= b->ch);
 
711
}
 
712
 
 
713
#ifdef REGEX_DEBUG
 
714
char *
 
715
lc2c(longchar * x, int len)
 
716
{
 
717
    static char y[100];
 
718
    int i = 0, j = 0;
 
719
    char *r;
 
720
 
 
721
    while (x[j].type != RE_TYPE_END && j < len) {
 
722
        if (x[j].type == RE_WHICH_RANGE)
 
723
            y[i++] = '-';
 
724
#ifdef USE_M17N
 
725
        else if (x[j].type == RE_TYPE_WCHAR_T) {
 
726
            char buf[20];
 
727
            sprintf(buf, "[%x-%x]", x[j].wch.ccs, x[j].wch.code);
 
728
            strcpy(&y[i], buf);
 
729
            i += strlen(buf);
 
730
        }
 
731
#endif
 
732
        else
 
733
            y[i++] = x[j].ch;
 
734
        j++;
 
735
    }
 
736
    y[i] = '\0';
 
737
    r = GC_malloc_atomic(i + 1);
 
738
    strcpy(r, y);
 
739
    return r;
 
740
}
 
741
 
 
742
void
 
743
debugre(regexchar * re)
 
744
{
 
745
    for (; RE_MODE(re) != RE_ENDMARK; re++) {
 
746
        switch (RE_MODE(re)) {
 
747
        case RE_BEGIN:
 
748
            printf("Begin ");
 
749
            continue;
 
750
        case RE_END:
 
751
            printf("End ");
 
752
            continue;
 
753
        }
 
754
        if (re->mode & RE_ANYTIME)
 
755
            printf("Anytime-");
 
756
        if (re->mode & RE_OPT)
 
757
            printf("Opt-");
 
758
 
 
759
        switch (RE_MODE(re)) {
 
760
        case RE_ANY:
 
761
            printf("Any ");
 
762
            break;
 
763
        case RE_NORMAL:
 
764
            printf("Match-to'%c' ", *re->p.pattern);
 
765
            break;
 
766
        case RE_WHICH:
 
767
            printf("One-of\"%s\" ", lc2c(re->p.pattern, 10000));
 
768
            break;
 
769
        case RE_EXCEPT:
 
770
            printf("Other-than\"%s\" ", lc2c(re->p.pattern, 10000));
 
771
            break;
 
772
        case RE_SUBREGEX:
 
773
            {
 
774
                Regex *r = re->p.sub;
 
775
                printf("(");
 
776
                while (r) {
 
777
                    debugre(r->re);
 
778
                    if (r->alt_regex)
 
779
                        printf(" | ");
 
780
                    r = r->alt_regex;
 
781
                }
 
782
                printf(")");
 
783
                break;
 
784
            }
 
785
        default:
 
786
            printf("Unknown ");
 
787
        }
 
788
    }
 
789
}
 
790
 
 
791
#endif                          /* REGEX_DEBUG */
 
792
 
 
793
#ifdef REGEXTEST
 
794
int
 
795
main(int argc, char **argv)
 
796
{
 
797
    char buf[128], buf2[128];
 
798
    char *msg;
 
799
    Regex *re;
 
800
    char *fpos, *epos;
 
801
    FILE *f = stdin;
 
802
    int i = 1;
 
803
 
 
804
#ifdef USE_M17N
 
805
    wtf_init(WC_CES_EUC_JP, WC_CES_EUC_JP);
 
806
#endif
 
807
#ifdef REGEX_DEBUG
 
808
    for (i = 1; i < argc; i++) {
 
809
        if (strcmp(argv[i], "-v") == 0)
 
810
            verbose = 1;
 
811
        else
 
812
            break;
 
813
    }
 
814
#endif
 
815
 
 
816
    if (argc > i)
 
817
        f = fopen(argv[i], "r");
 
818
    if (f == NULL) {
 
819
        fprintf(stderr, "Can't open %s\n", argv[i]);
 
820
        exit(1);
 
821
    }
 
822
    while (fscanf(f, "%s%s", buf, buf2) == 2) {
 
823
        re = newRegex(buf, 0, NULL, &msg);
 
824
        if (re == NULL) {
 
825
            printf("Error on regexp /%s/: %s\n", buf, msg);
 
826
            exit(1);
 
827
        }
 
828
        if (RegexMatch(re, buf2, -1, 1)) {
 
829
            printf("/%s/\t\"%s\"\t\"", buf, buf2);
 
830
            MatchedPosition(re, &fpos, &epos);
 
831
            while (fpos < epos)
 
832
                putchar(*(fpos++));
 
833
            putchar('"');
 
834
        }
 
835
        else
 
836
            printf("/%s/\t\"%s\"\tno_match", buf, buf2);
 
837
        putchar('\n');
 
838
    }
 
839
    /* notreatched */
 
840
    return 0;
 
841
}
 
842
#endif