Annotation of embedaddon/php/ext/mbstring/oniguruma/regparse.c, revision 1.1
1.1 ! misho 1: /**********************************************************************
! 2: regparse.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 "regparse.h"
! 31:
! 32: #define WARN_BUFSIZE 256
! 33:
! 34: OnigSyntaxType OnigSyntaxRuby = {
! 35: (( SYN_GNU_REGEX_OP | ONIG_SYN_OP_QMARK_NON_GREEDY |
! 36: ONIG_SYN_OP_ESC_OCTAL3 | ONIG_SYN_OP_ESC_X_HEX2 |
! 37: ONIG_SYN_OP_ESC_X_BRACE_HEX8 | ONIG_SYN_OP_ESC_CONTROL_CHARS |
! 38: ONIG_SYN_OP_ESC_C_CONTROL )
! 39: & ~ONIG_SYN_OP_ESC_LTGT_WORD_BEGIN_END )
! 40: , ( ONIG_SYN_OP2_QMARK_GROUP_EFFECT |
! 41: ONIG_SYN_OP2_OPTION_RUBY |
! 42: ONIG_SYN_OP2_QMARK_LT_NAMED_GROUP | ONIG_SYN_OP2_ESC_K_NAMED_BACKREF |
! 43: ONIG_SYN_OP2_ESC_G_SUBEXP_CALL |
! 44: ONIG_SYN_OP2_PLUS_POSSESSIVE_REPEAT |
! 45: ONIG_SYN_OP2_CCLASS_SET_OP | ONIG_SYN_OP2_ESC_CAPITAL_C_BAR_CONTROL |
! 46: ONIG_SYN_OP2_ESC_CAPITAL_M_BAR_META | ONIG_SYN_OP2_ESC_V_VTAB |
! 47: ONIG_SYN_OP2_ESC_H_XDIGIT )
! 48: , ( SYN_GNU_REGEX_BV |
! 49: ONIG_SYN_ALLOW_INTERVAL_LOW_ABBREV |
! 50: ONIG_SYN_DIFFERENT_LEN_ALT_LOOK_BEHIND |
! 51: ONIG_SYN_CAPTURE_ONLY_NAMED_GROUP |
! 52: ONIG_SYN_ALLOW_MULTIPLEX_DEFINITION_NAME |
! 53: ONIG_SYN_FIXED_INTERVAL_IS_GREEDY_ONLY |
! 54: ONIG_SYN_WARN_CC_OP_NOT_ESCAPED |
! 55: ONIG_SYN_WARN_REDUNDANT_NESTED_REPEAT )
! 56: , ONIG_OPTION_NONE
! 57: };
! 58:
! 59: OnigSyntaxType* OnigDefaultSyntax = ONIG_SYNTAX_RUBY;
! 60:
! 61: extern void onig_null_warn(const char* s) { }
! 62:
! 63: #ifdef RUBY_PLATFORM
! 64: extern void
! 65: onig_rb_warn(const char* s)
! 66: {
! 67: rb_warn("%s", s);
! 68: }
! 69:
! 70: extern void
! 71: onig_rb_warning(const char* s)
! 72: {
! 73: rb_warning("%s", s);
! 74: }
! 75: #endif
! 76:
! 77: #ifdef DEFAULT_WARN_FUNCTION
! 78: static OnigWarnFunc onig_warn = (OnigWarnFunc )DEFAULT_WARN_FUNCTION;
! 79: #else
! 80: static OnigWarnFunc onig_warn = onig_null_warn;
! 81: #endif
! 82:
! 83: #ifdef DEFAULT_VERB_WARN_FUNCTION
! 84: static OnigWarnFunc onig_verb_warn = (OnigWarnFunc )DEFAULT_VERB_WARN_FUNCTION;
! 85: #else
! 86: static OnigWarnFunc onig_verb_warn = onig_null_warn;
! 87: #endif
! 88:
! 89: extern void onig_set_warn_func(OnigWarnFunc f)
! 90: {
! 91: onig_warn = f;
! 92: }
! 93:
! 94: extern void onig_set_verb_warn_func(OnigWarnFunc f)
! 95: {
! 96: onig_verb_warn = f;
! 97: }
! 98:
! 99: static void
! 100: bbuf_free(BBuf* bbuf)
! 101: {
! 102: if (IS_NOT_NULL(bbuf)) {
! 103: if (IS_NOT_NULL(bbuf->p)) xfree(bbuf->p);
! 104: xfree(bbuf);
! 105: }
! 106: }
! 107:
! 108: static int
! 109: bbuf_clone(BBuf** rto, BBuf* from)
! 110: {
! 111: int r;
! 112: BBuf *to;
! 113:
! 114: *rto = to = (BBuf* )xmalloc(sizeof(BBuf));
! 115: CHECK_NULL_RETURN_VAL(to, ONIGERR_MEMORY);
! 116: r = BBUF_INIT(to, from->alloc);
! 117: if (r != 0) return r;
! 118: to->used = from->used;
! 119: xmemcpy(to->p, from->p, from->used);
! 120: return 0;
! 121: }
! 122:
! 123: #define ONOFF(v,f,negative) (negative) ? ((v) &= ~(f)) : ((v) |= (f))
! 124:
! 125: #define MBCODE_START_POS(enc) \
! 126: (OnigCodePoint )(ONIGENC_MBC_MINLEN(enc) > 1 ? 0 : 0x80)
! 127:
! 128: #define SET_ALL_MULTI_BYTE_RANGE(enc, pbuf) \
! 129: add_code_range_to_buf(pbuf, MBCODE_START_POS(enc), ~((OnigCodePoint )0))
! 130:
! 131: #define ADD_ALL_MULTI_BYTE_RANGE(enc, mbuf) do {\
! 132: if (! ONIGENC_IS_SINGLEBYTE(enc)) {\
! 133: r = SET_ALL_MULTI_BYTE_RANGE(enc, &(mbuf));\
! 134: if (r) return r;\
! 135: }\
! 136: } while (0)
! 137:
! 138:
! 139: #define BITSET_IS_EMPTY(bs,empty) do {\
! 140: int i;\
! 141: empty = 1;\
! 142: for (i = 0; i < BITSET_SIZE; i++) {\
! 143: if ((bs)[i] != 0) {\
! 144: empty = 0; break;\
! 145: }\
! 146: }\
! 147: } while (0)
! 148:
! 149: static void
! 150: bitset_set_range(BitSetRef bs, int from, int to)
! 151: {
! 152: int i;
! 153: for (i = from; i <= to && i < SINGLE_BYTE_SIZE; i++) {
! 154: BITSET_SET_BIT(bs, i);
! 155: }
! 156: }
! 157:
! 158: #if 0
! 159: static void
! 160: bitset_set_all(BitSetRef bs)
! 161: {
! 162: int i;
! 163: for (i = 0; i < BITSET_SIZE; i++) {
! 164: bs[i] = ~((Bits )0);
! 165: }
! 166: }
! 167: #endif
! 168:
! 169: static void
! 170: bitset_invert(BitSetRef bs)
! 171: {
! 172: int i;
! 173: for (i = 0; i < BITSET_SIZE; i++) {
! 174: bs[i] = ~(bs[i]);
! 175: }
! 176: }
! 177:
! 178: static void
! 179: bitset_invert_to(BitSetRef from, BitSetRef to)
! 180: {
! 181: int i;
! 182: for (i = 0; i < BITSET_SIZE; i++) {
! 183: to[i] = ~(from[i]);
! 184: }
! 185: }
! 186:
! 187: static void
! 188: bitset_and(BitSetRef dest, BitSetRef bs)
! 189: {
! 190: int i;
! 191: for (i = 0; i < BITSET_SIZE; i++) {
! 192: dest[i] &= bs[i];
! 193: }
! 194: }
! 195:
! 196: static void
! 197: bitset_or(BitSetRef dest, BitSetRef bs)
! 198: {
! 199: int i;
! 200: for (i = 0; i < BITSET_SIZE; i++) {
! 201: dest[i] |= bs[i];
! 202: }
! 203: }
! 204:
! 205: static void
! 206: bitset_copy(BitSetRef dest, BitSetRef bs)
! 207: {
! 208: int i;
! 209: for (i = 0; i < BITSET_SIZE; i++) {
! 210: dest[i] = bs[i];
! 211: }
! 212: }
! 213:
! 214: extern int
! 215: onig_strncmp(const UChar* s1, const UChar* s2, int n)
! 216: {
! 217: int x;
! 218:
! 219: while (n-- > 0) {
! 220: x = *s2++ - *s1++;
! 221: if (x) return x;
! 222: }
! 223: return 0;
! 224: }
! 225:
! 226: static void
! 227: k_strcpy(UChar* dest, const UChar* src, const UChar* end)
! 228: {
! 229: int len = end - src;
! 230: if (len > 0) {
! 231: xmemcpy(dest, src, len);
! 232: dest[len] = (UChar )0;
! 233: }
! 234: }
! 235:
! 236: static UChar*
! 237: strdup_with_null(OnigEncoding enc, UChar* s, UChar* end)
! 238: {
! 239: int slen, term_len, i;
! 240: UChar *r;
! 241:
! 242: slen = end - s;
! 243: term_len = ONIGENC_MBC_MINLEN(enc);
! 244:
! 245: r = (UChar* )xmalloc(slen + term_len);
! 246: CHECK_NULL_RETURN(r);
! 247: xmemcpy(r, s, slen);
! 248:
! 249: for (i = 0; i < term_len; i++)
! 250: r[slen + i] = (UChar )0;
! 251:
! 252: return r;
! 253: }
! 254:
! 255:
! 256: /* scan pattern methods */
! 257: #define PEND_VALUE 0
! 258:
! 259: #define PFETCH_READY UChar* pfetch_prev
! 260: #define PEND (p < end ? 0 : 1)
! 261: #define PUNFETCH p = pfetch_prev
! 262: #define PINC do { \
! 263: pfetch_prev = p; \
! 264: p += ONIGENC_MBC_ENC_LEN(enc, p); \
! 265: } while (0)
! 266: #define PFETCH(c) do { \
! 267: c = ONIGENC_MBC_TO_CODE(enc, p, end); \
! 268: pfetch_prev = p; \
! 269: p += ONIGENC_MBC_ENC_LEN(enc, p); \
! 270: } while (0)
! 271:
! 272: #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE)
! 273: #define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c)
! 274:
! 275: static UChar*
! 276: k_strcat_capa(UChar* dest, UChar* dest_end, const UChar* src, const UChar* src_end,
! 277: int capa)
! 278: {
! 279: UChar* r;
! 280:
! 281: if (dest)
! 282: r = (UChar* )xrealloc(dest, capa + 1);
! 283: else
! 284: r = (UChar* )xmalloc(capa + 1);
! 285:
! 286: CHECK_NULL_RETURN(r);
! 287: k_strcpy(r + (dest_end - dest), src, src_end);
! 288: return r;
! 289: }
! 290:
! 291: /* dest on static area */
! 292: static UChar*
! 293: strcat_capa_from_static(UChar* dest, UChar* dest_end,
! 294: const UChar* src, const UChar* src_end, int capa)
! 295: {
! 296: UChar* r;
! 297:
! 298: r = (UChar* )xmalloc(capa + 1);
! 299: CHECK_NULL_RETURN(r);
! 300: k_strcpy(r, dest, dest_end);
! 301: k_strcpy(r + (dest_end - dest), src, src_end);
! 302: return r;
! 303: }
! 304:
! 305: #ifdef USE_NAMED_GROUP
! 306:
! 307: #define INIT_NAME_BACKREFS_ALLOC_NUM 8
! 308:
! 309: typedef struct {
! 310: UChar* name;
! 311: int name_len; /* byte length */
! 312: int back_num; /* number of backrefs */
! 313: int back_alloc;
! 314: int back_ref1;
! 315: int* back_refs;
! 316: } NameEntry;
! 317:
! 318: #ifdef USE_ST_HASH_TABLE
! 319:
! 320: #include "st.h"
! 321:
! 322: typedef struct {
! 323: unsigned char* s;
! 324: unsigned char* end;
! 325: } st_strend_key;
! 326:
! 327: static int strend_cmp(st_strend_key*, st_strend_key*);
! 328: static int strend_hash(st_strend_key*);
! 329:
! 330: static struct st_hash_type type_strend_hash = {
! 331: strend_cmp,
! 332: strend_hash,
! 333: };
! 334:
! 335: static st_table*
! 336: onig_st_init_strend_table_with_size(int size)
! 337: {
! 338: return onig_st_init_table_with_size(&type_strend_hash, size);
! 339: }
! 340:
! 341: static int
! 342: onig_st_lookup_strend(st_table *table, const UChar* str_key, const UChar* end_key, st_data_t *value)
! 343: {
! 344: st_strend_key key;
! 345:
! 346: key.s = (unsigned char* )str_key;
! 347: key.end = (unsigned char* )end_key;
! 348:
! 349: return onig_st_lookup(table, (st_data_t )(&key), value);
! 350: }
! 351:
! 352: static int
! 353: onig_st_insert_strend(st_table *table, const UChar* str_key, const UChar* end_key, st_data_t value)
! 354: {
! 355: st_strend_key* key;
! 356: int result;
! 357:
! 358: key = (st_strend_key* )xmalloc(sizeof(st_strend_key));
! 359: key->s = (unsigned char* )str_key;
! 360: key->end = (unsigned char* )end_key;
! 361: result = onig_st_insert(table, (st_data_t )key, value);
! 362: if (result) {
! 363: xfree(key);
! 364: }
! 365: return result;
! 366: }
! 367:
! 368: static int
! 369: strend_cmp(st_strend_key* x, st_strend_key* y)
! 370: {
! 371: unsigned char *p, *q;
! 372: int c;
! 373:
! 374: if ((x->end - x->s) != (y->end - y->s))
! 375: return 1;
! 376:
! 377: p = x->s;
! 378: q = y->s;
! 379: while (p < x->end) {
! 380: c = (int )*p - (int )*q;
! 381: if (c != 0) return c;
! 382:
! 383: p++; q++;
! 384: }
! 385:
! 386: return 0;
! 387: }
! 388:
! 389: static int
! 390: strend_hash(st_strend_key* x)
! 391: {
! 392: int val;
! 393: unsigned char *p;
! 394:
! 395: val = 0;
! 396: p = x->s;
! 397: while (p < x->end) {
! 398: val = val * 997 + (int )*p++;
! 399: }
! 400:
! 401: return val + (val >> 5);
! 402: }
! 403:
! 404: typedef st_table NameTable;
! 405: typedef st_data_t HashDataType; /* 1.6 st.h doesn't define st_data_t type */
! 406:
! 407: #define NAMEBUF_SIZE 24
! 408: #define NAMEBUF_SIZE_1 25
! 409:
! 410: #ifdef ONIG_DEBUG
! 411: static int
! 412: i_print_name_entry(UChar* key, NameEntry* e, void* arg)
! 413: {
! 414: int i;
! 415: FILE* fp = (FILE* )arg;
! 416:
! 417: fprintf(fp, "%s: ", e->name);
! 418: if (e->back_num == 0)
! 419: fputs("-", fp);
! 420: else if (e->back_num == 1)
! 421: fprintf(fp, "%d", e->back_ref1);
! 422: else {
! 423: for (i = 0; i < e->back_num; i++) {
! 424: if (i > 0) fprintf(fp, ", ");
! 425: fprintf(fp, "%d", e->back_refs[i]);
! 426: }
! 427: }
! 428: fputs("\n", fp);
! 429: return ST_CONTINUE;
! 430: }
! 431:
! 432: extern int
! 433: onig_print_names(FILE* fp, regex_t* reg)
! 434: {
! 435: NameTable* t = (NameTable* )reg->name_table;
! 436:
! 437: if (IS_NOT_NULL(t)) {
! 438: fprintf(fp, "name table\n");
! 439: onig_st_foreach(t, i_print_name_entry, (HashDataType )fp);
! 440: fputs("\n", fp);
! 441: }
! 442: return 0;
! 443: }
! 444: #endif
! 445:
! 446: static int
! 447: i_free_name_entry(UChar* key, NameEntry* e, void* arg)
! 448: {
! 449: xfree(e->name);
! 450: if (IS_NOT_NULL(e->back_refs)) xfree(e->back_refs);
! 451: xfree(key);
! 452: xfree(e);
! 453: return ST_DELETE;
! 454: }
! 455:
! 456: static int
! 457: names_clear(regex_t* reg)
! 458: {
! 459: NameTable* t = (NameTable* )reg->name_table;
! 460:
! 461: if (IS_NOT_NULL(t)) {
! 462: onig_st_foreach(t, i_free_name_entry, 0);
! 463: }
! 464: return 0;
! 465: }
! 466:
! 467: extern int
! 468: onig_names_free(regex_t* reg)
! 469: {
! 470: int r;
! 471: NameTable* t;
! 472:
! 473: r = names_clear(reg);
! 474: if (r) return r;
! 475:
! 476: t = (NameTable* )reg->name_table;
! 477: if (IS_NOT_NULL(t)) onig_st_free_table(t);
! 478: reg->name_table = (void* )NULL;
! 479: return 0;
! 480: }
! 481:
! 482: static NameEntry*
! 483: name_find(regex_t* reg, const UChar* name, const UChar* name_end)
! 484: {
! 485: NameEntry* e;
! 486: NameTable* t = (NameTable* )reg->name_table;
! 487:
! 488: e = (NameEntry* )NULL;
! 489: if (IS_NOT_NULL(t)) {
! 490: onig_st_lookup_strend(t, name, name_end, (HashDataType* )((void* )(&e)));
! 491: }
! 492: return e;
! 493: }
! 494:
! 495: typedef struct {
! 496: int (*func)(const UChar*, const UChar*,int,int*,regex_t*,void*);
! 497: regex_t* reg;
! 498: void* arg;
! 499: int ret;
! 500: OnigEncoding enc;
! 501: } INamesArg;
! 502:
! 503: static int
! 504: i_names(UChar* key, NameEntry* e, INamesArg* arg)
! 505: {
! 506: int r = (*(arg->func))(e->name,
! 507: /*e->name + onigenc_str_bytelen_null(arg->enc, e->name), */
! 508: e->name + e->name_len,
! 509: e->back_num,
! 510: (e->back_num > 1 ? e->back_refs : &(e->back_ref1)),
! 511: arg->reg, arg->arg);
! 512: if (r != 0) {
! 513: arg->ret = r;
! 514: return ST_STOP;
! 515: }
! 516: return ST_CONTINUE;
! 517: }
! 518:
! 519: extern int
! 520: onig_foreach_name(regex_t* reg,
! 521: int (*func)(const UChar*, const UChar*,int,int*,regex_t*,void*),
! 522: void* arg)
! 523: {
! 524: INamesArg narg;
! 525: NameTable* t = (NameTable* )reg->name_table;
! 526:
! 527: narg.ret = 0;
! 528: if (IS_NOT_NULL(t)) {
! 529: narg.func = func;
! 530: narg.reg = reg;
! 531: narg.arg = arg;
! 532: narg.enc = reg->enc; /* should be pattern encoding. */
! 533: onig_st_foreach(t, i_names, (HashDataType )&narg);
! 534: }
! 535: return narg.ret;
! 536: }
! 537:
! 538: static int
! 539: i_renumber_name(UChar* key, NameEntry* e, GroupNumRemap* map)
! 540: {
! 541: int i;
! 542:
! 543: if (e->back_num > 1) {
! 544: for (i = 0; i < e->back_num; i++) {
! 545: e->back_refs[i] = map[e->back_refs[i]].new_val;
! 546: }
! 547: }
! 548: else if (e->back_num == 1) {
! 549: e->back_ref1 = map[e->back_ref1].new_val;
! 550: }
! 551:
! 552: return ST_CONTINUE;
! 553: }
! 554:
! 555: extern int
! 556: onig_renumber_name_table(regex_t* reg, GroupNumRemap* map)
! 557: {
! 558: NameTable* t = (NameTable* )reg->name_table;
! 559:
! 560: if (IS_NOT_NULL(t)) {
! 561: onig_st_foreach(t, i_renumber_name, (HashDataType )map);
! 562: }
! 563: return 0;
! 564: }
! 565:
! 566:
! 567: extern int
! 568: onig_number_of_names(regex_t* reg)
! 569: {
! 570: NameTable* t = (NameTable* )reg->name_table;
! 571:
! 572: if (IS_NOT_NULL(t))
! 573: return t->num_entries;
! 574: else
! 575: return 0;
! 576: }
! 577:
! 578: #else /* USE_ST_HASH_TABLE */
! 579:
! 580: #define INIT_NAMES_ALLOC_NUM 8
! 581:
! 582: typedef struct {
! 583: NameEntry* e;
! 584: int num;
! 585: int alloc;
! 586: } NameTable;
! 587:
! 588:
! 589: #ifdef ONIG_DEBUG
! 590: extern int
! 591: onig_print_names(FILE* fp, regex_t* reg)
! 592: {
! 593: int i, j;
! 594: NameEntry* e;
! 595: NameTable* t = (NameTable* )reg->name_table;
! 596:
! 597: if (IS_NOT_NULL(t) && t->num > 0) {
! 598: fprintf(fp, "name table\n");
! 599: for (i = 0; i < t->num; i++) {
! 600: e = &(t->e[i]);
! 601: fprintf(fp, "%s: ", e->name);
! 602: if (e->back_num == 0) {
! 603: fputs("-", fp);
! 604: }
! 605: else if (e->back_num == 1) {
! 606: fprintf(fp, "%d", e->back_ref1);
! 607: }
! 608: else {
! 609: for (j = 0; j < e->back_num; j++) {
! 610: if (j > 0) fprintf(fp, ", ");
! 611: fprintf(fp, "%d", e->back_refs[j]);
! 612: }
! 613: }
! 614: fputs("\n", fp);
! 615: }
! 616: fputs("\n", fp);
! 617: }
! 618: return 0;
! 619: }
! 620: #endif
! 621:
! 622: static int
! 623: names_clear(regex_t* reg)
! 624: {
! 625: int i;
! 626: NameEntry* e;
! 627: NameTable* t = (NameTable* )reg->name_table;
! 628:
! 629: if (IS_NOT_NULL(t)) {
! 630: for (i = 0; i < t->num; i++) {
! 631: e = &(t->e[i]);
! 632: if (IS_NOT_NULL(e->name)) {
! 633: xfree(e->name);
! 634: e->name = NULL;
! 635: e->name_len = 0;
! 636: e->back_num = 0;
! 637: e->back_alloc = 0;
! 638: if (IS_NOT_NULL(e->back_refs)) xfree(e->back_refs);
! 639: e->back_refs = (int* )NULL;
! 640: }
! 641: }
! 642: if (IS_NOT_NULL(t->e)) {
! 643: xfree(t->e);
! 644: t->e = NULL;
! 645: }
! 646: t->num = 0;
! 647: }
! 648: return 0;
! 649: }
! 650:
! 651: extern int
! 652: onig_names_free(regex_t* reg)
! 653: {
! 654: int r;
! 655: NameTable* t;
! 656:
! 657: r = names_clear(reg);
! 658: if (r) return r;
! 659:
! 660: t = (NameTable* )reg->name_table;
! 661: if (IS_NOT_NULL(t)) xfree(t);
! 662: reg->name_table = NULL;
! 663: return 0;
! 664: }
! 665:
! 666: static NameEntry*
! 667: name_find(regex_t* reg, UChar* name, UChar* name_end)
! 668: {
! 669: int i, len;
! 670: NameEntry* e;
! 671: NameTable* t = (NameTable* )reg->name_table;
! 672:
! 673: if (IS_NOT_NULL(t)) {
! 674: len = name_end - name;
! 675: for (i = 0; i < t->num; i++) {
! 676: e = &(t->e[i]);
! 677: if (len == e->name_len && onig_strncmp(name, e->name, len) == 0)
! 678: return e;
! 679: }
! 680: }
! 681: return (NameEntry* )NULL;
! 682: }
! 683:
! 684: extern int
! 685: onig_foreach_name(regex_t* reg,
! 686: int (*func)(const UChar*, const UChar*,int,int*,regex_t*,void*),
! 687: void* arg)
! 688: {
! 689: int i, r;
! 690: NameEntry* e;
! 691: NameTable* t = (NameTable* )reg->name_table;
! 692:
! 693: if (IS_NOT_NULL(t)) {
! 694: for (i = 0; i < t->num; i++) {
! 695: e = &(t->e[i]);
! 696: r = (*func)(e->name, e->name + e->name_len, e->back_num,
! 697: (e->back_num > 1 ? e->back_refs : &(e->back_ref1)),
! 698: reg, arg);
! 699: if (r != 0) return r;
! 700: }
! 701: }
! 702: return 0;
! 703: }
! 704:
! 705: extern int
! 706: onig_number_of_names(regex_t* reg)
! 707: {
! 708: NameTable* t = (NameTable* )reg->name_table;
! 709:
! 710: if (IS_NOT_NULL(t))
! 711: return t->num;
! 712: else
! 713: return 0;
! 714: }
! 715:
! 716: #endif /* else USE_ST_HASH_TABLE */
! 717:
! 718: static int
! 719: name_add(regex_t* reg, UChar* name, UChar* name_end, int backref, ScanEnv* env)
! 720: {
! 721: int alloc;
! 722: NameEntry* e;
! 723: NameTable* t = (NameTable* )reg->name_table;
! 724:
! 725: if (name_end - name <= 0)
! 726: return ONIGERR_EMPTY_GROUP_NAME;
! 727:
! 728: e = name_find(reg, name, name_end);
! 729: if (IS_NULL(e)) {
! 730: #ifdef USE_ST_HASH_TABLE
! 731: if (IS_NULL(t)) {
! 732: t = onig_st_init_strend_table_with_size(5);
! 733: reg->name_table = (void* )t;
! 734: }
! 735: e = (NameEntry* )xmalloc(sizeof(NameEntry));
! 736: CHECK_NULL_RETURN_VAL(e, ONIGERR_MEMORY);
! 737:
! 738: e->name = strdup_with_null(reg->enc, name, name_end);
! 739: if (IS_NULL(e->name)) return ONIGERR_MEMORY;
! 740: onig_st_insert_strend(t, e->name, (e->name + (name_end - name)),
! 741: (HashDataType )e);
! 742:
! 743: e->name_len = name_end - name;
! 744: e->back_num = 0;
! 745: e->back_alloc = 0;
! 746: e->back_refs = (int* )NULL;
! 747:
! 748: #else
! 749:
! 750: if (IS_NULL(t)) {
! 751: alloc = INIT_NAMES_ALLOC_NUM;
! 752: t = (NameTable* )xmalloc(sizeof(NameTable));
! 753: CHECK_NULL_RETURN_VAL(t, ONIGERR_MEMORY);
! 754: t->e = NULL;
! 755: t->alloc = 0;
! 756: t->num = 0;
! 757:
! 758: t->e = (NameEntry* )xmalloc(sizeof(NameEntry) * alloc);
! 759: if (IS_NULL(t->e)) {
! 760: xfree(t);
! 761: return ONIGERR_MEMORY;
! 762: }
! 763: t->alloc = alloc;
! 764: reg->name_table = t;
! 765: goto clear;
! 766: }
! 767: else if (t->num == t->alloc) {
! 768: int i;
! 769:
! 770: alloc = t->alloc * 2;
! 771: t->e = (NameEntry* )xrealloc(t->e, sizeof(NameEntry) * alloc);
! 772: CHECK_NULL_RETURN_VAL(t->e, ONIGERR_MEMORY);
! 773: t->alloc = alloc;
! 774:
! 775: clear:
! 776: for (i = t->num; i < t->alloc; i++) {
! 777: t->e[i].name = NULL;
! 778: t->e[i].name_len = 0;
! 779: t->e[i].back_num = 0;
! 780: t->e[i].back_alloc = 0;
! 781: t->e[i].back_refs = (int* )NULL;
! 782: }
! 783: }
! 784: e = &(t->e[t->num]);
! 785: t->num++;
! 786: e->name = strdup_with_null(reg->enc, name, name_end);
! 787: e->name_len = name_end - name;
! 788: #endif
! 789: }
! 790:
! 791: if (e->back_num >= 1 &&
! 792: ! IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_MULTIPLEX_DEFINITION_NAME)) {
! 793: onig_scan_env_set_error_string(env, ONIGERR_MULTIPLEX_DEFINED_NAME,
! 794: name, name_end);
! 795: return ONIGERR_MULTIPLEX_DEFINED_NAME;
! 796: }
! 797:
! 798: e->back_num++;
! 799: if (e->back_num == 1) {
! 800: e->back_ref1 = backref;
! 801: }
! 802: else {
! 803: if (e->back_num == 2) {
! 804: alloc = INIT_NAME_BACKREFS_ALLOC_NUM;
! 805: e->back_refs = (int* )xmalloc(sizeof(int) * alloc);
! 806: CHECK_NULL_RETURN_VAL(e->back_refs, ONIGERR_MEMORY);
! 807: e->back_alloc = alloc;
! 808: e->back_refs[0] = e->back_ref1;
! 809: e->back_refs[1] = backref;
! 810: }
! 811: else {
! 812: if (e->back_num > e->back_alloc) {
! 813: alloc = e->back_alloc * 2;
! 814: e->back_refs = (int* )xrealloc(e->back_refs, sizeof(int) * alloc);
! 815: CHECK_NULL_RETURN_VAL(e->back_refs, ONIGERR_MEMORY);
! 816: e->back_alloc = alloc;
! 817: }
! 818: e->back_refs[e->back_num - 1] = backref;
! 819: }
! 820: }
! 821:
! 822: return 0;
! 823: }
! 824:
! 825: extern int
! 826: onig_name_to_group_numbers(regex_t* reg, const UChar* name,
! 827: const UChar* name_end, int** nums)
! 828: {
! 829: NameEntry* e;
! 830:
! 831: e = name_find(reg, name, name_end);
! 832: if (IS_NULL(e)) return ONIGERR_UNDEFINED_NAME_REFERENCE;
! 833:
! 834: switch (e->back_num) {
! 835: case 0:
! 836: break;
! 837: case 1:
! 838: *nums = &(e->back_ref1);
! 839: break;
! 840: default:
! 841: *nums = e->back_refs;
! 842: break;
! 843: }
! 844: return e->back_num;
! 845: }
! 846:
! 847: extern int
! 848: onig_name_to_backref_number(regex_t* reg, const UChar* name,
! 849: const UChar* name_end, OnigRegion *region)
! 850: {
! 851: int i, n, *nums;
! 852:
! 853: n = onig_name_to_group_numbers(reg, name, name_end, &nums);
! 854: if (n < 0)
! 855: return n;
! 856: else if (n == 0)
! 857: return ONIGERR_PARSER_BUG;
! 858: else if (n == 1)
! 859: return nums[0];
! 860: else {
! 861: if (IS_NOT_NULL(region)) {
! 862: for (i = n - 1; i >= 0; i--) {
! 863: if (region->beg[nums[i]] != ONIG_REGION_NOTPOS)
! 864: return nums[i];
! 865: }
! 866: }
! 867: return nums[n - 1];
! 868: }
! 869: }
! 870:
! 871: #else /* USE_NAMED_GROUP */
! 872:
! 873: extern int
! 874: onig_name_to_group_numbers(regex_t* reg, const UChar* name,
! 875: const UChar* name_end, int** nums)
! 876: {
! 877: return ONIG_NO_SUPPORT_CONFIG;
! 878: }
! 879:
! 880: extern int
! 881: onig_name_to_backref_number(regex_t* reg, const UChar* name,
! 882: const UChar* name_end, OnigRegion* region)
! 883: {
! 884: return ONIG_NO_SUPPORT_CONFIG;
! 885: }
! 886:
! 887: extern int
! 888: onig_foreach_name(regex_t* reg,
! 889: int (*func)(const UChar*, const UChar*,int,int*,regex_t*,void*),
! 890: void* arg)
! 891: {
! 892: return ONIG_NO_SUPPORT_CONFIG;
! 893: }
! 894:
! 895: extern int
! 896: onig_number_of_names(regex_t* reg)
! 897: {
! 898: return 0;
! 899: }
! 900: #endif /* else USE_NAMED_GROUP */
! 901:
! 902: extern int
! 903: onig_noname_group_capture_is_active(regex_t* reg)
! 904: {
! 905: if (ONIG_IS_OPTION_ON(reg->options, ONIG_OPTION_DONT_CAPTURE_GROUP))
! 906: return 0;
! 907:
! 908: #ifdef USE_NAMED_GROUP
! 909: if (onig_number_of_names(reg) > 0 &&
! 910: IS_SYNTAX_BV(reg->syntax, ONIG_SYN_CAPTURE_ONLY_NAMED_GROUP) &&
! 911: !ONIG_IS_OPTION_ON(reg->options, ONIG_OPTION_CAPTURE_GROUP)) {
! 912: return 0;
! 913: }
! 914: #endif
! 915:
! 916: return 1;
! 917: }
! 918:
! 919:
! 920: #define INIT_SCANENV_MEMNODES_ALLOC_SIZE 16
! 921:
! 922: static void
! 923: scan_env_clear(ScanEnv* env)
! 924: {
! 925: int i;
! 926:
! 927: BIT_STATUS_CLEAR(env->capture_history);
! 928: BIT_STATUS_CLEAR(env->bt_mem_start);
! 929: BIT_STATUS_CLEAR(env->bt_mem_end);
! 930: BIT_STATUS_CLEAR(env->backrefed_mem);
! 931: env->error = (UChar* )NULL;
! 932: env->error_end = (UChar* )NULL;
! 933: env->num_call = 0;
! 934: env->num_mem = 0;
! 935: #ifdef USE_NAMED_GROUP
! 936: env->num_named = 0;
! 937: #endif
! 938: env->mem_alloc = 0;
! 939: env->mem_nodes_dynamic = (Node** )NULL;
! 940:
! 941: for (i = 0; i < SCANENV_MEMNODES_SIZE; i++)
! 942: env->mem_nodes_static[i] = NULL_NODE;
! 943:
! 944: #ifdef USE_COMBINATION_EXPLOSION_CHECK
! 945: env->num_comb_exp_check = 0;
! 946: env->comb_exp_max_regnum = 0;
! 947: env->curr_max_regnum = 0;
! 948: env->has_recursion = 0;
! 949: #endif
! 950: }
! 951:
! 952: static int
! 953: scan_env_add_mem_entry(ScanEnv* env)
! 954: {
! 955: int i, need, alloc;
! 956: Node** p;
! 957:
! 958: need = env->num_mem + 1;
! 959: if (need >= SCANENV_MEMNODES_SIZE) {
! 960: if (env->mem_alloc <= need) {
! 961: if (IS_NULL(env->mem_nodes_dynamic)) {
! 962: alloc = INIT_SCANENV_MEMNODES_ALLOC_SIZE;
! 963: p = (Node** )xmalloc(sizeof(Node*) * alloc);
! 964: xmemcpy(p, env->mem_nodes_static,
! 965: sizeof(Node*) * SCANENV_MEMNODES_SIZE);
! 966: }
! 967: else {
! 968: alloc = env->mem_alloc * 2;
! 969: p = (Node** )xrealloc(env->mem_nodes_dynamic, sizeof(Node*) * alloc);
! 970: }
! 971: CHECK_NULL_RETURN_VAL(p, ONIGERR_MEMORY);
! 972:
! 973: for (i = env->num_mem + 1; i < alloc; i++)
! 974: p[i] = NULL_NODE;
! 975:
! 976: env->mem_nodes_dynamic = p;
! 977: env->mem_alloc = alloc;
! 978: }
! 979: }
! 980:
! 981: env->num_mem++;
! 982: return env->num_mem;
! 983: }
! 984:
! 985: static int
! 986: scan_env_set_mem_node(ScanEnv* env, int num, Node* node)
! 987: {
! 988: if (env->num_mem >= num)
! 989: SCANENV_MEM_NODES(env)[num] = node;
! 990: else
! 991: return ONIGERR_PARSER_BUG;
! 992: return 0;
! 993: }
! 994:
! 995:
! 996: #ifdef USE_RECYCLE_NODE
! 997: typedef struct _FreeNode {
! 998: struct _FreeNode* next;
! 999: } FreeNode;
! 1000:
! 1001: static FreeNode* FreeNodeList = (FreeNode* )NULL;
! 1002: #endif
! 1003:
! 1004: extern void
! 1005: onig_node_free(Node* node)
! 1006: {
! 1007: start:
! 1008: if (IS_NULL(node)) return ;
! 1009:
! 1010: switch (NTYPE(node)) {
! 1011: case N_STRING:
! 1012: if (IS_NOT_NULL(NSTRING(node).s) && NSTRING(node).s != NSTRING(node).buf) {
! 1013: xfree(NSTRING(node).s);
! 1014: }
! 1015: break;
! 1016:
! 1017: case N_LIST:
! 1018: case N_ALT:
! 1019: onig_node_free(NCONS(node).left);
! 1020: /* onig_node_free(NCONS(node).right); */
! 1021: {
! 1022: Node* next_node = NCONS(node).right;
! 1023:
! 1024: #ifdef USE_RECYCLE_NODE
! 1025: {
! 1026: FreeNode* n = (FreeNode* )node;
! 1027:
! 1028: THREAD_ATOMIC_START;
! 1029: n->next = FreeNodeList;
! 1030: FreeNodeList = n;
! 1031: THREAD_ATOMIC_END;
! 1032: }
! 1033: #else
! 1034: xfree(node);
! 1035: #endif
! 1036:
! 1037: node = next_node;
! 1038: goto start;
! 1039: }
! 1040: break;
! 1041:
! 1042: case N_CCLASS:
! 1043: {
! 1044: CClassNode* cc = &(NCCLASS(node));
! 1045:
! 1046: if (IS_CCLASS_SHARE(cc))
! 1047: return ;
! 1048:
! 1049: if (cc->mbuf)
! 1050: bbuf_free(cc->mbuf);
! 1051: }
! 1052: break;
! 1053:
! 1054: case N_QUANTIFIER:
! 1055: if (NQUANTIFIER(node).target)
! 1056: onig_node_free(NQUANTIFIER(node).target);
! 1057: break;
! 1058:
! 1059: case N_EFFECT:
! 1060: if (NEFFECT(node).target)
! 1061: onig_node_free(NEFFECT(node).target);
! 1062: break;
! 1063:
! 1064: case N_BACKREF:
! 1065: if (IS_NOT_NULL(NBACKREF(node).back_dynamic))
! 1066: xfree(NBACKREF(node).back_dynamic);
! 1067: break;
! 1068:
! 1069: case N_ANCHOR:
! 1070: if (NANCHOR(node).target)
! 1071: onig_node_free(NANCHOR(node).target);
! 1072: break;
! 1073: }
! 1074:
! 1075: #ifdef USE_RECYCLE_NODE
! 1076: {
! 1077: FreeNode* n = (FreeNode* )node;
! 1078:
! 1079: THREAD_ATOMIC_START;
! 1080: n->next = FreeNodeList;
! 1081: FreeNodeList = n;
! 1082: THREAD_ATOMIC_END;
! 1083: }
! 1084: #else
! 1085: xfree(node);
! 1086: #endif
! 1087: }
! 1088:
! 1089: #ifdef USE_RECYCLE_NODE
! 1090: extern int
! 1091: onig_free_node_list(void)
! 1092: {
! 1093: FreeNode* n;
! 1094:
! 1095: /* THREAD_ATOMIC_START; */
! 1096: while (IS_NOT_NULL(FreeNodeList)) {
! 1097: n = FreeNodeList;
! 1098: FreeNodeList = FreeNodeList->next;
! 1099: xfree(n);
! 1100: }
! 1101: /* THREAD_ATOMIC_END; */
! 1102: return 0;
! 1103: }
! 1104: #endif
! 1105:
! 1106: static Node*
! 1107: node_new(void)
! 1108: {
! 1109: Node* node;
! 1110:
! 1111: #ifdef USE_RECYCLE_NODE
! 1112: THREAD_ATOMIC_START;
! 1113: if (IS_NOT_NULL(FreeNodeList)) {
! 1114: node = (Node* )FreeNodeList;
! 1115: FreeNodeList = FreeNodeList->next;
! 1116: THREAD_ATOMIC_END;
! 1117: return node;
! 1118: }
! 1119: THREAD_ATOMIC_END;
! 1120: #endif
! 1121:
! 1122: node = (Node* )xmalloc(sizeof(Node));
! 1123: return node;
! 1124: }
! 1125:
! 1126:
! 1127: static void
! 1128: initialize_cclass(CClassNode* cc)
! 1129: {
! 1130: BITSET_CLEAR(cc->bs);
! 1131: cc->flags = 0;
! 1132: cc->mbuf = NULL;
! 1133: }
! 1134:
! 1135: static Node*
! 1136: node_new_cclass(void)
! 1137: {
! 1138: Node* node = node_new();
! 1139: CHECK_NULL_RETURN(node);
! 1140: node->type = N_CCLASS;
! 1141:
! 1142: initialize_cclass(&(NCCLASS(node)));
! 1143: return node;
! 1144: }
! 1145:
! 1146: static Node*
! 1147: node_new_cclass_by_codepoint_range(int not,
! 1148: const OnigCodePoint sbr[], const OnigCodePoint mbr[])
! 1149: {
! 1150: CClassNode* cc;
! 1151: int n, i, j;
! 1152:
! 1153: Node* node = node_new();
! 1154: CHECK_NULL_RETURN(node);
! 1155: node->type = N_CCLASS;
! 1156:
! 1157: cc = &(NCCLASS(node));
! 1158: cc->flags = 0;
! 1159: if (not != 0) CCLASS_SET_NOT(cc);
! 1160:
! 1161: BITSET_CLEAR(cc->bs);
! 1162: if (IS_NOT_NULL(sbr)) {
! 1163: n = ONIGENC_CODE_RANGE_NUM(sbr);
! 1164: for (i = 0; i < n; i++) {
! 1165: for (j = ONIGENC_CODE_RANGE_FROM(sbr, i);
! 1166: j <= (int )ONIGENC_CODE_RANGE_TO(sbr, i); j++) {
! 1167: BITSET_SET_BIT(cc->bs, j);
! 1168: }
! 1169: }
! 1170: }
! 1171:
! 1172: if (IS_NULL(mbr)) {
! 1173: is_null:
! 1174: cc->mbuf = NULL;
! 1175: }
! 1176: else {
! 1177: BBuf* bbuf;
! 1178:
! 1179: n = ONIGENC_CODE_RANGE_NUM(mbr);
! 1180: if (n == 0) goto is_null;
! 1181:
! 1182: bbuf = (BBuf* )xmalloc(sizeof(BBuf));
! 1183: CHECK_NULL_RETURN_VAL(bbuf, NULL);
! 1184: bbuf->alloc = n + 1;
! 1185: bbuf->used = n + 1;
! 1186: bbuf->p = (UChar* )((void* )mbr);
! 1187:
! 1188: cc->mbuf = bbuf;
! 1189: }
! 1190:
! 1191: return node;
! 1192: }
! 1193:
! 1194: static Node*
! 1195: node_new_ctype(int type)
! 1196: {
! 1197: Node* node = node_new();
! 1198: CHECK_NULL_RETURN(node);
! 1199: node->type = N_CTYPE;
! 1200: NCTYPE(node).type = type;
! 1201: return node;
! 1202: }
! 1203:
! 1204: static Node*
! 1205: node_new_anychar(void)
! 1206: {
! 1207: Node* node = node_new();
! 1208: CHECK_NULL_RETURN(node);
! 1209: node->type = N_ANYCHAR;
! 1210: return node;
! 1211: }
! 1212:
! 1213: static Node*
! 1214: node_new_list(Node* left, Node* right)
! 1215: {
! 1216: Node* node = node_new();
! 1217: CHECK_NULL_RETURN(node);
! 1218: node->type = N_LIST;
! 1219: NCONS(node).left = left;
! 1220: NCONS(node).right = right;
! 1221: return node;
! 1222: }
! 1223:
! 1224: extern Node*
! 1225: onig_node_new_list(Node* left, Node* right)
! 1226: {
! 1227: return node_new_list(left, right);
! 1228: }
! 1229:
! 1230: static Node*
! 1231: node_new_alt(Node* left, Node* right)
! 1232: {
! 1233: Node* node = node_new();
! 1234: CHECK_NULL_RETURN(node);
! 1235: node->type = N_ALT;
! 1236: NCONS(node).left = left;
! 1237: NCONS(node).right = right;
! 1238: return node;
! 1239: }
! 1240:
! 1241: extern Node*
! 1242: onig_node_new_anchor(int type)
! 1243: {
! 1244: Node* node = node_new();
! 1245: CHECK_NULL_RETURN(node);
! 1246: node->type = N_ANCHOR;
! 1247: NANCHOR(node).type = type;
! 1248: NANCHOR(node).target = NULL;
! 1249: NANCHOR(node).char_len = -1;
! 1250: return node;
! 1251: }
! 1252:
! 1253: static Node*
! 1254: node_new_backref(int back_num, int* backrefs, int by_name,
! 1255: #ifdef USE_BACKREF_AT_LEVEL
! 1256: int exist_level, int nest_level,
! 1257: #endif
! 1258: ScanEnv* env)
! 1259: {
! 1260: int i;
! 1261: Node* node = node_new();
! 1262:
! 1263: CHECK_NULL_RETURN(node);
! 1264: node->type = N_BACKREF;
! 1265: NBACKREF(node).state = 0;
! 1266: NBACKREF(node).back_num = back_num;
! 1267: NBACKREF(node).back_dynamic = (int* )NULL;
! 1268: if (by_name != 0)
! 1269: NBACKREF(node).state |= NST_NAME_REF;
! 1270:
! 1271: #ifdef USE_BACKREF_AT_LEVEL
! 1272: if (exist_level != 0) {
! 1273: NBACKREF(node).state |= NST_NEST_LEVEL;
! 1274: NBACKREF(node).nest_level = nest_level;
! 1275: }
! 1276: #endif
! 1277:
! 1278: for (i = 0; i < back_num; i++) {
! 1279: if (backrefs[i] <= env->num_mem &&
! 1280: IS_NULL(SCANENV_MEM_NODES(env)[backrefs[i]])) {
! 1281: NBACKREF(node).state |= NST_RECURSION; /* /...(\1).../ */
! 1282: break;
! 1283: }
! 1284: }
! 1285:
! 1286: if (back_num <= NODE_BACKREFS_SIZE) {
! 1287: for (i = 0; i < back_num; i++)
! 1288: NBACKREF(node).back_static[i] = backrefs[i];
! 1289: }
! 1290: else {
! 1291: int* p = (int* )xmalloc(sizeof(int) * back_num);
! 1292: if (IS_NULL(p)) {
! 1293: onig_node_free(node);
! 1294: return NULL;
! 1295: }
! 1296: NBACKREF(node).back_dynamic = p;
! 1297: for (i = 0; i < back_num; i++)
! 1298: p[i] = backrefs[i];
! 1299: }
! 1300: return node;
! 1301: }
! 1302:
! 1303: #ifdef USE_SUBEXP_CALL
! 1304: static Node*
! 1305: node_new_call(UChar* name, UChar* name_end)
! 1306: {
! 1307: Node* node = node_new();
! 1308: CHECK_NULL_RETURN(node);
! 1309:
! 1310: node->type = N_CALL;
! 1311: NCALL(node).state = 0;
! 1312: NCALL(node).ref_num = CALLNODE_REFNUM_UNDEF;
! 1313: NCALL(node).target = NULL_NODE;
! 1314: NCALL(node).name = name;
! 1315: NCALL(node).name_end = name_end;
! 1316: return node;
! 1317: }
! 1318: #endif
! 1319:
! 1320: static Node*
! 1321: node_new_quantifier(int lower, int upper, int by_number)
! 1322: {
! 1323: Node* node = node_new();
! 1324: CHECK_NULL_RETURN(node);
! 1325: node->type = N_QUANTIFIER;
! 1326: NQUANTIFIER(node).state = 0;
! 1327: NQUANTIFIER(node).target = NULL;
! 1328: NQUANTIFIER(node).lower = lower;
! 1329: NQUANTIFIER(node).upper = upper;
! 1330: NQUANTIFIER(node).greedy = 1;
! 1331: NQUANTIFIER(node).target_empty_info = NQ_TARGET_ISNOT_EMPTY;
! 1332: NQUANTIFIER(node).head_exact = NULL_NODE;
! 1333: NQUANTIFIER(node).next_head_exact = NULL_NODE;
! 1334: NQUANTIFIER(node).is_refered = 0;
! 1335: if (by_number != 0)
! 1336: NQUANTIFIER(node).state |= NST_BY_NUMBER;
! 1337:
! 1338: #ifdef USE_COMBINATION_EXPLOSION_CHECK
! 1339: NQUANTIFIER(node).comb_exp_check_num = 0;
! 1340: #endif
! 1341:
! 1342: return node;
! 1343: }
! 1344:
! 1345: static Node*
! 1346: node_new_effect(int type)
! 1347: {
! 1348: Node* node = node_new();
! 1349: CHECK_NULL_RETURN(node);
! 1350: node->type = N_EFFECT;
! 1351: NEFFECT(node).type = type;
! 1352: NEFFECT(node).state = 0;
! 1353: NEFFECT(node).regnum = 0;
! 1354: NEFFECT(node).option = 0;
! 1355: NEFFECT(node).target = NULL;
! 1356: NEFFECT(node).call_addr = -1;
! 1357: NEFFECT(node).opt_count = 0;
! 1358: return node;
! 1359: }
! 1360:
! 1361: extern Node*
! 1362: onig_node_new_effect(int type)
! 1363: {
! 1364: return node_new_effect(type);
! 1365: }
! 1366:
! 1367: static Node*
! 1368: node_new_effect_memory(OnigOptionType option, int is_named)
! 1369: {
! 1370: Node* node = node_new_effect(EFFECT_MEMORY);
! 1371: CHECK_NULL_RETURN(node);
! 1372: if (is_named != 0)
! 1373: SET_EFFECT_STATUS(node, NST_NAMED_GROUP);
! 1374:
! 1375: #ifdef USE_SUBEXP_CALL
! 1376: NEFFECT(node).option = option;
! 1377: #endif
! 1378: return node;
! 1379: }
! 1380:
! 1381: static Node*
! 1382: node_new_option(OnigOptionType option)
! 1383: {
! 1384: Node* node = node_new_effect(EFFECT_OPTION);
! 1385: CHECK_NULL_RETURN(node);
! 1386: NEFFECT(node).option = option;
! 1387: return node;
! 1388: }
! 1389:
! 1390: extern int
! 1391: onig_node_str_cat(Node* node, const UChar* s, const UChar* end)
! 1392: {
! 1393: int addlen = end - s;
! 1394:
! 1395: if (addlen > 0) {
! 1396: int len = NSTRING(node).end - NSTRING(node).s;
! 1397:
! 1398: if (NSTRING(node).capa > 0 || (len + addlen > NODE_STR_BUF_SIZE - 1)) {
! 1399: UChar* p;
! 1400: int capa = len + addlen + NODE_STR_MARGIN;
! 1401:
! 1402: if (capa <= NSTRING(node).capa) {
! 1403: k_strcpy(NSTRING(node).s + len, s, end);
! 1404: }
! 1405: else {
! 1406: if (NSTRING(node).s == NSTRING(node).buf)
! 1407: p = strcat_capa_from_static(NSTRING(node).s, NSTRING(node).end,
! 1408: s, end, capa);
! 1409: else
! 1410: p = k_strcat_capa(NSTRING(node).s, NSTRING(node).end, s, end, capa);
! 1411:
! 1412: CHECK_NULL_RETURN_VAL(p, ONIGERR_MEMORY);
! 1413: NSTRING(node).s = p;
! 1414: NSTRING(node).capa = capa;
! 1415: }
! 1416: }
! 1417: else {
! 1418: k_strcpy(NSTRING(node).s + len, s, end);
! 1419: }
! 1420: NSTRING(node).end = NSTRING(node).s + len + addlen;
! 1421: }
! 1422:
! 1423: return 0;
! 1424: }
! 1425:
! 1426: static int
! 1427: node_str_cat_char(Node* node, UChar c)
! 1428: {
! 1429: UChar s[1];
! 1430:
! 1431: s[0] = c;
! 1432: return onig_node_str_cat(node, s, s + 1);
! 1433: }
! 1434:
! 1435: extern void
! 1436: onig_node_conv_to_str_node(Node* node, int flag)
! 1437: {
! 1438: node->type = N_STRING;
! 1439:
! 1440: NSTRING(node).flag = flag;
! 1441: NSTRING(node).capa = 0;
! 1442: NSTRING(node).s = NSTRING(node).buf;
! 1443: NSTRING(node).end = NSTRING(node).buf;
! 1444: }
! 1445:
! 1446: extern void
! 1447: onig_node_str_clear(Node* node)
! 1448: {
! 1449: if (NSTRING(node).capa != 0 &&
! 1450: IS_NOT_NULL(NSTRING(node).s) && NSTRING(node).s != NSTRING(node).buf) {
! 1451: xfree(NSTRING(node).s);
! 1452: }
! 1453:
! 1454: NSTRING(node).capa = 0;
! 1455: NSTRING(node).flag = 0;
! 1456: NSTRING(node).s = NSTRING(node).buf;
! 1457: NSTRING(node).end = NSTRING(node).buf;
! 1458: }
! 1459:
! 1460: static Node*
! 1461: node_new_str(const UChar* s, const UChar* end)
! 1462: {
! 1463: Node* node = node_new();
! 1464: CHECK_NULL_RETURN(node);
! 1465:
! 1466: node->type = N_STRING;
! 1467: NSTRING(node).capa = 0;
! 1468: NSTRING(node).flag = 0;
! 1469: NSTRING(node).s = NSTRING(node).buf;
! 1470: NSTRING(node).end = NSTRING(node).buf;
! 1471: if (onig_node_str_cat(node, s, end)) {
! 1472: onig_node_free(node);
! 1473: return NULL;
! 1474: }
! 1475: return node;
! 1476: }
! 1477:
! 1478: extern Node*
! 1479: onig_node_new_str(const UChar* s, const UChar* end)
! 1480: {
! 1481: return node_new_str(s, end);
! 1482: }
! 1483:
! 1484: #ifdef NUMBERED_CHAR_IS_NOT_CASE_AMBIG
! 1485: static Node*
! 1486: node_new_str_raw(UChar* s, UChar* end)
! 1487: {
! 1488: Node* node = node_new_str(s, end);
! 1489: NSTRING_SET_RAW(node);
! 1490: return node;
! 1491: }
! 1492: #endif
! 1493:
! 1494: static Node*
! 1495: node_new_empty(void)
! 1496: {
! 1497: return node_new_str(NULL, NULL);
! 1498: }
! 1499:
! 1500: static Node*
! 1501: node_new_str_char(UChar c)
! 1502: {
! 1503: UChar p[1];
! 1504:
! 1505: p[0] = c;
! 1506: return node_new_str(p, p + 1);
! 1507: }
! 1508:
! 1509: static Node*
! 1510: str_node_split_last_char(StrNode* sn, OnigEncoding enc)
! 1511: {
! 1512: const UChar *p;
! 1513: Node* n = NULL_NODE;
! 1514:
! 1515: if (sn->end > sn->s) {
! 1516: p = onigenc_get_prev_char_head(enc, sn->s, sn->end);
! 1517: if (p && p > sn->s) { /* can be splitted. */
! 1518: n = node_new_str(p, sn->end);
! 1519: if ((sn->flag & NSTR_RAW) != 0)
! 1520: NSTRING_SET_RAW(n);
! 1521: sn->end = (UChar* )p;
! 1522: }
! 1523: }
! 1524: return n;
! 1525: }
! 1526:
! 1527: static int
! 1528: str_node_can_be_split(StrNode* sn, OnigEncoding enc)
! 1529: {
! 1530: if (sn->end > sn->s) {
! 1531: return ((enc_len(enc, sn->s) < sn->end - sn->s) ? 1 : 0);
! 1532: }
! 1533: return 0;
! 1534: }
! 1535:
! 1536: #ifdef USE_PAD_TO_SHORT_BYTE_CHAR
! 1537: static int
! 1538: node_str_head_pad(StrNode* sn, int num, UChar val)
! 1539: {
! 1540: UChar buf[NODE_STR_BUF_SIZE];
! 1541: int i, len;
! 1542:
! 1543: len = sn->end - sn->s;
! 1544: onig_strcpy(buf, sn->s, sn->end);
! 1545: onig_strcpy(&(sn->s[num]), buf, buf + len);
! 1546: sn->end += num;
! 1547:
! 1548: for (i = 0; i < num; i++) {
! 1549: sn->s[i] = val;
! 1550: }
! 1551: }
! 1552: #endif
! 1553:
! 1554: extern int
! 1555: onig_scan_unsigned_number(UChar** src, const UChar* end, OnigEncoding enc)
! 1556: {
! 1557: unsigned int num, val;
! 1558: OnigCodePoint c;
! 1559: UChar* p = *src;
! 1560: PFETCH_READY;
! 1561:
! 1562: num = 0;
! 1563: while (!PEND) {
! 1564: PFETCH(c);
! 1565: if (ONIGENC_IS_CODE_DIGIT(enc, c)) {
! 1566: val = (unsigned int )DIGITVAL(c);
! 1567: if ((INT_MAX_LIMIT - val) / 10UL < num)
! 1568: return -1; /* overflow */
! 1569:
! 1570: num = num * 10 + val;
! 1571: }
! 1572: else {
! 1573: PUNFETCH;
! 1574: break;
! 1575: }
! 1576: }
! 1577: *src = p;
! 1578: return num;
! 1579: }
! 1580:
! 1581: static int
! 1582: scan_unsigned_hexadecimal_number(UChar** src, UChar* end, int maxlen,
! 1583: OnigEncoding enc)
! 1584: {
! 1585: OnigCodePoint c;
! 1586: unsigned int num, val;
! 1587: UChar* p = *src;
! 1588: PFETCH_READY;
! 1589:
! 1590: num = 0;
! 1591: while (!PEND && maxlen-- != 0) {
! 1592: PFETCH(c);
! 1593: if (ONIGENC_IS_CODE_XDIGIT(enc, c)) {
! 1594: val = (unsigned int )XDIGITVAL(enc,c);
! 1595: if ((INT_MAX_LIMIT - val) / 16UL < num)
! 1596: return -1; /* overflow */
! 1597:
! 1598: num = (num << 4) + XDIGITVAL(enc,c);
! 1599: }
! 1600: else {
! 1601: PUNFETCH;
! 1602: break;
! 1603: }
! 1604: }
! 1605: *src = p;
! 1606: return num;
! 1607: }
! 1608:
! 1609: static int
! 1610: scan_unsigned_octal_number(UChar** src, UChar* end, int maxlen,
! 1611: OnigEncoding enc)
! 1612: {
! 1613: OnigCodePoint c;
! 1614: unsigned int num, val;
! 1615: UChar* p = *src;
! 1616: PFETCH_READY;
! 1617:
! 1618: num = 0;
! 1619: while (!PEND && maxlen-- != 0) {
! 1620: PFETCH(c);
! 1621: if (ONIGENC_IS_CODE_DIGIT(enc, c) && c < '8') {
! 1622: val = ODIGITVAL(c);
! 1623: if ((INT_MAX_LIMIT - val) / 8UL < num)
! 1624: return -1; /* overflow */
! 1625:
! 1626: num = (num << 3) + val;
! 1627: }
! 1628: else {
! 1629: PUNFETCH;
! 1630: break;
! 1631: }
! 1632: }
! 1633: *src = p;
! 1634: return num;
! 1635: }
! 1636:
! 1637:
! 1638: #define BBUF_WRITE_CODE_POINT(bbuf,pos,code) \
! 1639: BBUF_WRITE(bbuf, pos, &(code), SIZE_CODE_POINT)
! 1640:
! 1641: /* data format:
! 1642: [n][from-1][to-1][from-2][to-2] ... [from-n][to-n]
! 1643: (all data size is OnigCodePoint)
! 1644: */
! 1645: static int
! 1646: new_code_range(BBuf** pbuf)
! 1647: {
! 1648: #define INIT_MULTI_BYTE_RANGE_SIZE (SIZE_CODE_POINT * 5)
! 1649: int r;
! 1650: OnigCodePoint n;
! 1651: BBuf* bbuf;
! 1652:
! 1653: bbuf = *pbuf = (BBuf* )xmalloc(sizeof(BBuf));
! 1654: CHECK_NULL_RETURN_VAL(*pbuf, ONIGERR_MEMORY);
! 1655: r = BBUF_INIT(*pbuf, INIT_MULTI_BYTE_RANGE_SIZE);
! 1656: if (r) return r;
! 1657:
! 1658: n = 0;
! 1659: BBUF_WRITE_CODE_POINT(bbuf, 0, n);
! 1660: return 0;
! 1661: }
! 1662:
! 1663: static int
! 1664: add_code_range_to_buf(BBuf** pbuf, OnigCodePoint from, OnigCodePoint to)
! 1665: {
! 1666: int r, inc_n, pos;
! 1667: int low, high, bound, x;
! 1668: OnigCodePoint n, *data;
! 1669: BBuf* bbuf;
! 1670:
! 1671: if (from > to) {
! 1672: n = from; from = to; to = n;
! 1673: }
! 1674:
! 1675: if (IS_NULL(*pbuf)) {
! 1676: r = new_code_range(pbuf);
! 1677: if (r) return r;
! 1678: bbuf = *pbuf;
! 1679: n = 0;
! 1680: }
! 1681: else {
! 1682: bbuf = *pbuf;
! 1683: GET_CODE_POINT(n, bbuf->p);
! 1684: }
! 1685: data = (OnigCodePoint* )(bbuf->p);
! 1686: data++;
! 1687:
! 1688: for (low = 0, bound = n; low < bound; ) {
! 1689: x = (low + bound) >> 1;
! 1690: if (from > data[x*2 + 1])
! 1691: low = x + 1;
! 1692: else
! 1693: bound = x;
! 1694: }
! 1695:
! 1696: for (high = low, bound = n; high < bound; ) {
! 1697: x = (high + bound) >> 1;
! 1698: if (to >= data[x*2] - 1)
! 1699: high = x + 1;
! 1700: else
! 1701: bound = x;
! 1702: }
! 1703:
! 1704: inc_n = low + 1 - high;
! 1705: if (n + inc_n > ONIG_MAX_MULTI_BYTE_RANGES_NUM)
! 1706: return ONIGERR_TOO_MANY_MULTI_BYTE_RANGES;
! 1707:
! 1708: if (inc_n != 1) {
! 1709: if (from > data[low*2])
! 1710: from = data[low*2];
! 1711: if (to < data[(high - 1)*2 + 1])
! 1712: to = data[(high - 1)*2 + 1];
! 1713: }
! 1714:
! 1715: if (inc_n != 0 && (OnigCodePoint )high < n) {
! 1716: int from_pos = SIZE_CODE_POINT * (1 + high * 2);
! 1717: int to_pos = SIZE_CODE_POINT * (1 + (low + 1) * 2);
! 1718: int size = (n - high) * 2 * SIZE_CODE_POINT;
! 1719:
! 1720: if (inc_n > 0) {
! 1721: BBUF_MOVE_RIGHT(bbuf, from_pos, to_pos, size);
! 1722: }
! 1723: else {
! 1724: BBUF_MOVE_LEFT_REDUCE(bbuf, from_pos, to_pos);
! 1725: }
! 1726: }
! 1727:
! 1728: pos = SIZE_CODE_POINT * (1 + low * 2);
! 1729: BBUF_ENSURE_SIZE(bbuf, pos + SIZE_CODE_POINT * 2);
! 1730: BBUF_WRITE_CODE_POINT(bbuf, pos, from);
! 1731: BBUF_WRITE_CODE_POINT(bbuf, pos + SIZE_CODE_POINT, to);
! 1732: n += inc_n;
! 1733: BBUF_WRITE_CODE_POINT(bbuf, 0, n);
! 1734:
! 1735: return 0;
! 1736: }
! 1737:
! 1738: static int
! 1739: add_code_range(BBuf** pbuf, ScanEnv* env, OnigCodePoint from, OnigCodePoint to)
! 1740: {
! 1741: if (from > to) {
! 1742: if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_EMPTY_RANGE_IN_CC))
! 1743: return 0;
! 1744: else
! 1745: return ONIGERR_EMPTY_RANGE_IN_CHAR_CLASS;
! 1746: }
! 1747:
! 1748: return add_code_range_to_buf(pbuf, from, to);
! 1749: }
! 1750:
! 1751: static int
! 1752: not_code_range_buf(OnigEncoding enc, BBuf* bbuf, BBuf** pbuf)
! 1753: {
! 1754: int r, i, n;
! 1755: OnigCodePoint pre, from, *data, to = 0;
! 1756:
! 1757: *pbuf = (BBuf* )NULL;
! 1758: if (IS_NULL(bbuf)) {
! 1759: set_all:
! 1760: return SET_ALL_MULTI_BYTE_RANGE(enc, pbuf);
! 1761: }
! 1762:
! 1763: data = (OnigCodePoint* )(bbuf->p);
! 1764: GET_CODE_POINT(n, data);
! 1765: data++;
! 1766: if (n <= 0) goto set_all;
! 1767:
! 1768: r = 0;
! 1769: pre = MBCODE_START_POS(enc);
! 1770: for (i = 0; i < n; i++) {
! 1771: from = data[i*2];
! 1772: to = data[i*2+1];
! 1773: if (pre <= from - 1) {
! 1774: r = add_code_range_to_buf(pbuf, pre, from - 1);
! 1775: if (r != 0) return r;
! 1776: }
! 1777: if (to == ~((OnigCodePoint )0)) break;
! 1778: pre = to + 1;
! 1779: }
! 1780: if (to < ~((OnigCodePoint )0)) {
! 1781: r = add_code_range_to_buf(pbuf, to + 1, ~((OnigCodePoint )0));
! 1782: }
! 1783: return r;
! 1784: }
! 1785:
! 1786: #define SWAP_BBUF_NOT(bbuf1, not1, bbuf2, not2) do {\
! 1787: BBuf *tbuf; \
! 1788: int tnot; \
! 1789: tnot = not1; not1 = not2; not2 = tnot; \
! 1790: tbuf = bbuf1; bbuf1 = bbuf2; bbuf2 = tbuf; \
! 1791: } while (0)
! 1792:
! 1793: static int
! 1794: or_code_range_buf(OnigEncoding enc, BBuf* bbuf1, int not1,
! 1795: BBuf* bbuf2, int not2, BBuf** pbuf)
! 1796: {
! 1797: int r;
! 1798: OnigCodePoint i, n1, *data1;
! 1799: OnigCodePoint from, to;
! 1800:
! 1801: *pbuf = (BBuf* )NULL;
! 1802: if (IS_NULL(bbuf1) && IS_NULL(bbuf2)) {
! 1803: if (not1 != 0 || not2 != 0)
! 1804: return SET_ALL_MULTI_BYTE_RANGE(enc, pbuf);
! 1805: return 0;
! 1806: }
! 1807:
! 1808: r = 0;
! 1809: if (IS_NULL(bbuf2))
! 1810: SWAP_BBUF_NOT(bbuf1, not1, bbuf2, not2);
! 1811:
! 1812: if (IS_NULL(bbuf1)) {
! 1813: if (not1 != 0) {
! 1814: return SET_ALL_MULTI_BYTE_RANGE(enc, pbuf);
! 1815: }
! 1816: else {
! 1817: if (not2 == 0) {
! 1818: return bbuf_clone(pbuf, bbuf2);
! 1819: }
! 1820: else {
! 1821: return not_code_range_buf(enc, bbuf2, pbuf);
! 1822: }
! 1823: }
! 1824: }
! 1825:
! 1826: if (not1 != 0)
! 1827: SWAP_BBUF_NOT(bbuf1, not1, bbuf2, not2);
! 1828:
! 1829: data1 = (OnigCodePoint* )(bbuf1->p);
! 1830: GET_CODE_POINT(n1, data1);
! 1831: data1++;
! 1832:
! 1833: if (not2 == 0 && not1 == 0) { /* 1 OR 2 */
! 1834: r = bbuf_clone(pbuf, bbuf2);
! 1835: }
! 1836: else if (not1 == 0) { /* 1 OR (not 2) */
! 1837: r = not_code_range_buf(enc, bbuf2, pbuf);
! 1838: }
! 1839: if (r != 0) return r;
! 1840:
! 1841: for (i = 0; i < n1; i++) {
! 1842: from = data1[i*2];
! 1843: to = data1[i*2+1];
! 1844: r = add_code_range_to_buf(pbuf, from, to);
! 1845: if (r != 0) return r;
! 1846: }
! 1847: return 0;
! 1848: }
! 1849:
! 1850: static int
! 1851: and_code_range1(BBuf** pbuf, OnigCodePoint from1, OnigCodePoint to1,
! 1852: OnigCodePoint* data, int n)
! 1853: {
! 1854: int i, r;
! 1855: OnigCodePoint from2, to2;
! 1856:
! 1857: for (i = 0; i < n; i++) {
! 1858: from2 = data[i*2];
! 1859: to2 = data[i*2+1];
! 1860: if (from2 < from1) {
! 1861: if (to2 < from1) continue;
! 1862: else {
! 1863: from1 = to2 + 1;
! 1864: }
! 1865: }
! 1866: else if (from2 <= to1) {
! 1867: if (to2 < to1) {
! 1868: if (from1 <= from2 - 1) {
! 1869: r = add_code_range_to_buf(pbuf, from1, from2-1);
! 1870: if (r != 0) return r;
! 1871: }
! 1872: from1 = to2 + 1;
! 1873: }
! 1874: else {
! 1875: to1 = from2 - 1;
! 1876: }
! 1877: }
! 1878: else {
! 1879: from1 = from2;
! 1880: }
! 1881: if (from1 > to1) break;
! 1882: }
! 1883: if (from1 <= to1) {
! 1884: r = add_code_range_to_buf(pbuf, from1, to1);
! 1885: if (r != 0) return r;
! 1886: }
! 1887: return 0;
! 1888: }
! 1889:
! 1890: static int
! 1891: and_code_range_buf(BBuf* bbuf1, int not1, BBuf* bbuf2, int not2, BBuf** pbuf)
! 1892: {
! 1893: int r;
! 1894: OnigCodePoint i, j, n1, n2, *data1, *data2;
! 1895: OnigCodePoint from, to, from1, to1, from2, to2;
! 1896:
! 1897: *pbuf = (BBuf* )NULL;
! 1898: if (IS_NULL(bbuf1)) {
! 1899: if (not1 != 0 && IS_NOT_NULL(bbuf2)) /* not1 != 0 -> not2 == 0 */
! 1900: return bbuf_clone(pbuf, bbuf2);
! 1901: return 0;
! 1902: }
! 1903: else if (IS_NULL(bbuf2)) {
! 1904: if (not2 != 0)
! 1905: return bbuf_clone(pbuf, bbuf1);
! 1906: return 0;
! 1907: }
! 1908:
! 1909: if (not1 != 0)
! 1910: SWAP_BBUF_NOT(bbuf1, not1, bbuf2, not2);
! 1911:
! 1912: data1 = (OnigCodePoint* )(bbuf1->p);
! 1913: data2 = (OnigCodePoint* )(bbuf2->p);
! 1914: GET_CODE_POINT(n1, data1);
! 1915: GET_CODE_POINT(n2, data2);
! 1916: data1++;
! 1917: data2++;
! 1918:
! 1919: if (not2 == 0 && not1 == 0) { /* 1 AND 2 */
! 1920: for (i = 0; i < n1; i++) {
! 1921: from1 = data1[i*2];
! 1922: to1 = data1[i*2+1];
! 1923: for (j = 0; j < n2; j++) {
! 1924: from2 = data2[j*2];
! 1925: to2 = data2[j*2+1];
! 1926: if (from2 > to1) break;
! 1927: if (to2 < from1) continue;
! 1928: from = MAX(from1, from2);
! 1929: to = MIN(to1, to2);
! 1930: r = add_code_range_to_buf(pbuf, from, to);
! 1931: if (r != 0) return r;
! 1932: }
! 1933: }
! 1934: }
! 1935: else if (not1 == 0) { /* 1 AND (not 2) */
! 1936: for (i = 0; i < n1; i++) {
! 1937: from1 = data1[i*2];
! 1938: to1 = data1[i*2+1];
! 1939: r = and_code_range1(pbuf, from1, to1, data2, n2);
! 1940: if (r != 0) return r;
! 1941: }
! 1942: }
! 1943:
! 1944: return 0;
! 1945: }
! 1946:
! 1947: static int
! 1948: and_cclass(CClassNode* dest, CClassNode* cc, OnigEncoding enc)
! 1949: {
! 1950: int r, not1, not2;
! 1951: BBuf *buf1, *buf2, *pbuf;
! 1952: BitSetRef bsr1, bsr2;
! 1953: BitSet bs1, bs2;
! 1954:
! 1955: not1 = IS_CCLASS_NOT(dest);
! 1956: bsr1 = dest->bs;
! 1957: buf1 = dest->mbuf;
! 1958: not2 = IS_CCLASS_NOT(cc);
! 1959: bsr2 = cc->bs;
! 1960: buf2 = cc->mbuf;
! 1961:
! 1962: if (not1 != 0) {
! 1963: bitset_invert_to(bsr1, bs1);
! 1964: bsr1 = bs1;
! 1965: }
! 1966: if (not2 != 0) {
! 1967: bitset_invert_to(bsr2, bs2);
! 1968: bsr2 = bs2;
! 1969: }
! 1970: bitset_and(bsr1, bsr2);
! 1971: if (bsr1 != dest->bs) {
! 1972: bitset_copy(dest->bs, bsr1);
! 1973: bsr1 = dest->bs;
! 1974: }
! 1975: if (not1 != 0) {
! 1976: bitset_invert(dest->bs);
! 1977: }
! 1978:
! 1979: if (! ONIGENC_IS_SINGLEBYTE(enc)) {
! 1980: if (not1 != 0 && not2 != 0) {
! 1981: r = or_code_range_buf(enc, buf1, 0, buf2, 0, &pbuf);
! 1982: }
! 1983: else {
! 1984: r = and_code_range_buf(buf1, not1, buf2, not2, &pbuf);
! 1985: if (r == 0 && not1 != 0) {
! 1986: BBuf *tbuf;
! 1987: r = not_code_range_buf(enc, pbuf, &tbuf);
! 1988: if (r != 0) {
! 1989: bbuf_free(pbuf);
! 1990: return r;
! 1991: }
! 1992: bbuf_free(pbuf);
! 1993: pbuf = tbuf;
! 1994: }
! 1995: }
! 1996: if (r != 0) return r;
! 1997:
! 1998: dest->mbuf = pbuf;
! 1999: bbuf_free(buf1);
! 2000: return r;
! 2001: }
! 2002: return 0;
! 2003: }
! 2004:
! 2005: static int
! 2006: or_cclass(CClassNode* dest, CClassNode* cc, OnigEncoding enc)
! 2007: {
! 2008: int r, not1, not2;
! 2009: BBuf *buf1, *buf2, *pbuf;
! 2010: BitSetRef bsr1, bsr2;
! 2011: BitSet bs1, bs2;
! 2012:
! 2013: not1 = IS_CCLASS_NOT(dest);
! 2014: bsr1 = dest->bs;
! 2015: buf1 = dest->mbuf;
! 2016: not2 = IS_CCLASS_NOT(cc);
! 2017: bsr2 = cc->bs;
! 2018: buf2 = cc->mbuf;
! 2019:
! 2020: if (not1 != 0) {
! 2021: bitset_invert_to(bsr1, bs1);
! 2022: bsr1 = bs1;
! 2023: }
! 2024: if (not2 != 0) {
! 2025: bitset_invert_to(bsr2, bs2);
! 2026: bsr2 = bs2;
! 2027: }
! 2028: bitset_or(bsr1, bsr2);
! 2029: if (bsr1 != dest->bs) {
! 2030: bitset_copy(dest->bs, bsr1);
! 2031: bsr1 = dest->bs;
! 2032: }
! 2033: if (not1 != 0) {
! 2034: bitset_invert(dest->bs);
! 2035: }
! 2036:
! 2037: if (! ONIGENC_IS_SINGLEBYTE(enc)) {
! 2038: if (not1 != 0 && not2 != 0) {
! 2039: r = and_code_range_buf(buf1, 0, buf2, 0, &pbuf);
! 2040: }
! 2041: else {
! 2042: r = or_code_range_buf(enc, buf1, not1, buf2, not2, &pbuf);
! 2043: if (r == 0 && not1 != 0) {
! 2044: BBuf *tbuf;
! 2045: r = not_code_range_buf(enc, pbuf, &tbuf);
! 2046: if (r != 0) {
! 2047: bbuf_free(pbuf);
! 2048: return r;
! 2049: }
! 2050: bbuf_free(pbuf);
! 2051: pbuf = tbuf;
! 2052: }
! 2053: }
! 2054: if (r != 0) return r;
! 2055:
! 2056: dest->mbuf = pbuf;
! 2057: bbuf_free(buf1);
! 2058: return r;
! 2059: }
! 2060: else
! 2061: return 0;
! 2062: }
! 2063:
! 2064: static int
! 2065: conv_backslash_value(int c, ScanEnv* env)
! 2066: {
! 2067: if (IS_SYNTAX_OP(env->syntax, ONIG_SYN_OP_ESC_CONTROL_CHARS)) {
! 2068: switch (c) {
! 2069: case 'n': return '\n';
! 2070: case 't': return '\t';
! 2071: case 'r': return '\r';
! 2072: case 'f': return '\f';
! 2073: case 'a': return '\007';
! 2074: case 'b': return '\010';
! 2075: case 'e': return '\033';
! 2076: case 'v':
! 2077: if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_ESC_V_VTAB))
! 2078: return '\v';
! 2079: break;
! 2080:
! 2081: default:
! 2082: break;
! 2083: }
! 2084: }
! 2085: return c;
! 2086: }
! 2087:
! 2088: static int
! 2089: is_invalid_quantifier_target(Node* node)
! 2090: {
! 2091: switch (NTYPE(node)) {
! 2092: case N_ANCHOR:
! 2093: return 1;
! 2094: break;
! 2095:
! 2096: case N_EFFECT:
! 2097: if (NEFFECT(node).type == EFFECT_OPTION)
! 2098: return is_invalid_quantifier_target(NEFFECT(node).target);
! 2099: break;
! 2100:
! 2101: case N_LIST: /* ex. (?:\G\A)* */
! 2102: do {
! 2103: if (! is_invalid_quantifier_target(NCONS(node).left)) return 0;
! 2104: } while (IS_NOT_NULL(node = NCONS(node).right));
! 2105: return 0;
! 2106: break;
! 2107:
! 2108: case N_ALT: /* ex. (?:abc|\A)* */
! 2109: do {
! 2110: if (is_invalid_quantifier_target(NCONS(node).left)) return 1;
! 2111: } while (IS_NOT_NULL(node = NCONS(node).right));
! 2112: break;
! 2113:
! 2114: default:
! 2115: break;
! 2116: }
! 2117: return 0;
! 2118: }
! 2119:
! 2120: /* ?:0, *:1, +:2, ??:3, *?:4, +?:5 */
! 2121: static int
! 2122: popular_quantifier_num(QuantifierNode* qf)
! 2123: {
! 2124: if (qf->greedy) {
! 2125: if (qf->lower == 0) {
! 2126: if (qf->upper == 1) return 0;
! 2127: else if (IS_REPEAT_INFINITE(qf->upper)) return 1;
! 2128: }
! 2129: else if (qf->lower == 1) {
! 2130: if (IS_REPEAT_INFINITE(qf->upper)) return 2;
! 2131: }
! 2132: }
! 2133: else {
! 2134: if (qf->lower == 0) {
! 2135: if (qf->upper == 1) return 3;
! 2136: else if (IS_REPEAT_INFINITE(qf->upper)) return 4;
! 2137: }
! 2138: else if (qf->lower == 1) {
! 2139: if (IS_REPEAT_INFINITE(qf->upper)) return 5;
! 2140: }
! 2141: }
! 2142: return -1;
! 2143: }
! 2144:
! 2145:
! 2146: enum ReduceType {
! 2147: RQ_ASIS = 0, /* as is */
! 2148: RQ_DEL = 1, /* delete parent */
! 2149: RQ_A, /* to '*' */
! 2150: RQ_AQ, /* to '*?' */
! 2151: RQ_QQ, /* to '??' */
! 2152: RQ_P_QQ, /* to '+)??' */
! 2153: RQ_PQ_Q /* to '+?)?' */
! 2154: };
! 2155:
! 2156: static enum ReduceType ReduceTypeTable[6][6] = {
! 2157: {RQ_DEL, RQ_A, RQ_A, RQ_QQ, RQ_AQ, RQ_ASIS}, /* '?' */
! 2158: {RQ_DEL, RQ_DEL, RQ_DEL, RQ_P_QQ, RQ_P_QQ, RQ_DEL}, /* '*' */
! 2159: {RQ_A, RQ_A, RQ_DEL, RQ_ASIS, RQ_P_QQ, RQ_DEL}, /* '+' */
! 2160: {RQ_DEL, RQ_AQ, RQ_AQ, RQ_DEL, RQ_AQ, RQ_AQ}, /* '??' */
! 2161: {RQ_DEL, RQ_DEL, RQ_DEL, RQ_DEL, RQ_DEL, RQ_DEL}, /* '*?' */
! 2162: {RQ_ASIS, RQ_PQ_Q, RQ_DEL, RQ_AQ, RQ_AQ, RQ_DEL} /* '+?' */
! 2163: };
! 2164:
! 2165: extern void
! 2166: onig_reduce_nested_quantifier(Node* pnode, Node* cnode)
! 2167: {
! 2168: int pnum, cnum;
! 2169: QuantifierNode *p, *c;
! 2170:
! 2171: p = &(NQUANTIFIER(pnode));
! 2172: c = &(NQUANTIFIER(cnode));
! 2173: pnum = popular_quantifier_num(p);
! 2174: cnum = popular_quantifier_num(c);
! 2175:
! 2176: switch(ReduceTypeTable[cnum][pnum]) {
! 2177: case RQ_DEL:
! 2178: *p = *c;
! 2179: break;
! 2180: case RQ_A:
! 2181: p->target = c->target;
! 2182: p->lower = 0; p->upper = REPEAT_INFINITE; p->greedy = 1;
! 2183: break;
! 2184: case RQ_AQ:
! 2185: p->target = c->target;
! 2186: p->lower = 0; p->upper = REPEAT_INFINITE; p->greedy = 0;
! 2187: break;
! 2188: case RQ_QQ:
! 2189: p->target = c->target;
! 2190: p->lower = 0; p->upper = 1; p->greedy = 0;
! 2191: break;
! 2192: case RQ_P_QQ:
! 2193: p->target = cnode;
! 2194: p->lower = 0; p->upper = 1; p->greedy = 0;
! 2195: c->lower = 1; c->upper = REPEAT_INFINITE; c->greedy = 1;
! 2196: return ;
! 2197: break;
! 2198: case RQ_PQ_Q:
! 2199: p->target = cnode;
! 2200: p->lower = 0; p->upper = 1; p->greedy = 1;
! 2201: c->lower = 1; c->upper = REPEAT_INFINITE; c->greedy = 0;
! 2202: return ;
! 2203: break;
! 2204: case RQ_ASIS:
! 2205: p->target = cnode;
! 2206: return ;
! 2207: break;
! 2208: }
! 2209:
! 2210: c->target = NULL_NODE;
! 2211: onig_node_free(cnode);
! 2212: }
! 2213:
! 2214:
! 2215: enum TokenSyms {
! 2216: TK_EOT = 0, /* end of token */
! 2217: TK_RAW_BYTE = 1,
! 2218: TK_CHAR,
! 2219: TK_STRING,
! 2220: TK_CODE_POINT,
! 2221: TK_ANYCHAR,
! 2222: TK_CHAR_TYPE,
! 2223: TK_BACKREF,
! 2224: TK_CALL,
! 2225: TK_ANCHOR,
! 2226: TK_OP_REPEAT,
! 2227: TK_INTERVAL,
! 2228: TK_ANYCHAR_ANYTIME, /* SQL '%' == .* */
! 2229: TK_ALT,
! 2230: TK_SUBEXP_OPEN,
! 2231: TK_SUBEXP_CLOSE,
! 2232: TK_CC_OPEN,
! 2233: TK_QUOTE_OPEN,
! 2234: TK_CHAR_PROPERTY, /* \p{...}, \P{...} */
! 2235: /* in cc */
! 2236: TK_CC_CLOSE,
! 2237: TK_CC_RANGE,
! 2238: TK_POSIX_BRACKET_OPEN,
! 2239: TK_CC_AND, /* && */
! 2240: TK_CC_CC_OPEN /* [ */
! 2241: };
! 2242:
! 2243: typedef struct {
! 2244: enum TokenSyms type;
! 2245: int escaped;
! 2246: int base; /* is number: 8, 16 (used in [....]) */
! 2247: UChar* backp;
! 2248: union {
! 2249: UChar* s;
! 2250: int c;
! 2251: OnigCodePoint code;
! 2252: int anchor;
! 2253: int subtype;
! 2254: struct {
! 2255: int lower;
! 2256: int upper;
! 2257: int greedy;
! 2258: int possessive;
! 2259: } repeat;
! 2260: struct {
! 2261: int num;
! 2262: int ref1;
! 2263: int* refs;
! 2264: int by_name;
! 2265: #ifdef USE_BACKREF_AT_LEVEL
! 2266: int exist_level;
! 2267: int level; /* \k<name+n> */
! 2268: #endif
! 2269: } backref;
! 2270: struct {
! 2271: UChar* name;
! 2272: UChar* name_end;
! 2273: } call;
! 2274: struct {
! 2275: int not;
! 2276: } prop;
! 2277: } u;
! 2278: } OnigToken;
! 2279:
! 2280:
! 2281: static int
! 2282: fetch_range_quantifier(UChar** src, UChar* end, OnigToken* tok, ScanEnv* env)
! 2283: {
! 2284: int low, up, syn_allow, non_low = 0;
! 2285: int r = 0;
! 2286: OnigCodePoint c;
! 2287: OnigEncoding enc = env->enc;
! 2288: UChar* p = *src;
! 2289: PFETCH_READY;
! 2290:
! 2291: syn_allow = IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_INVALID_INTERVAL);
! 2292:
! 2293: if (PEND) {
! 2294: if (syn_allow)
! 2295: return 1; /* "....{" : OK! */
! 2296: else
! 2297: return ONIGERR_END_PATTERN_AT_LEFT_BRACE; /* "....{" syntax error */
! 2298: }
! 2299:
! 2300: if (! syn_allow) {
! 2301: c = PPEEK;
! 2302: if (c == ')' || c == '(' || c == '|') {
! 2303: return ONIGERR_END_PATTERN_AT_LEFT_BRACE;
! 2304: }
! 2305: }
! 2306:
! 2307: low = onig_scan_unsigned_number(&p, end, env->enc);
! 2308: if (low < 0) return ONIGERR_TOO_BIG_NUMBER_FOR_REPEAT_RANGE;
! 2309: if (low > ONIG_MAX_REPEAT_NUM)
! 2310: return ONIGERR_TOO_BIG_NUMBER_FOR_REPEAT_RANGE;
! 2311:
! 2312: if (p == *src) { /* can't read low */
! 2313: if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_INTERVAL_LOW_ABBREV)) {
! 2314: /* allow {,n} as {0,n} */
! 2315: low = 0;
! 2316: non_low = 1;
! 2317: }
! 2318: else
! 2319: goto invalid;
! 2320: }
! 2321:
! 2322: if (PEND) goto invalid;
! 2323: PFETCH(c);
! 2324: if (c == ',') {
! 2325: UChar* prev = p;
! 2326: up = onig_scan_unsigned_number(&p, end, env->enc);
! 2327: if (up < 0) return ONIGERR_TOO_BIG_NUMBER_FOR_REPEAT_RANGE;
! 2328: if (up > ONIG_MAX_REPEAT_NUM)
! 2329: return ONIGERR_TOO_BIG_NUMBER_FOR_REPEAT_RANGE;
! 2330:
! 2331: if (p == prev) {
! 2332: if (non_low != 0)
! 2333: goto invalid;
! 2334: up = REPEAT_INFINITE; /* {n,} : {n,infinite} */
! 2335: }
! 2336: }
! 2337: else {
! 2338: if (non_low != 0)
! 2339: goto invalid;
! 2340:
! 2341: PUNFETCH;
! 2342: up = low; /* {n} : exact n times */
! 2343: r = 2; /* fixed */
! 2344: }
! 2345:
! 2346: if (PEND) goto invalid;
! 2347: PFETCH(c);
! 2348: if (IS_SYNTAX_OP(env->syntax, ONIG_SYN_OP_ESC_BRACE_INTERVAL)) {
! 2349: if (c != MC_ESC(enc)) goto invalid;
! 2350: PFETCH(c);
! 2351: }
! 2352: if (c != '}') goto invalid;
! 2353:
! 2354: if (!IS_REPEAT_INFINITE(up) && low > up) {
! 2355: return ONIGERR_UPPER_SMALLER_THAN_LOWER_IN_REPEAT_RANGE;
! 2356: }
! 2357:
! 2358: tok->type = TK_INTERVAL;
! 2359: tok->u.repeat.lower = low;
! 2360: tok->u.repeat.upper = up;
! 2361: *src = p;
! 2362: return r; /* 0: normal {n,m}, 2: fixed {n} */
! 2363:
! 2364: invalid:
! 2365: if (syn_allow)
! 2366: return 1; /* OK */
! 2367: else
! 2368: return ONIGERR_INVALID_REPEAT_RANGE_PATTERN;
! 2369: }
! 2370:
! 2371: /* \M-, \C-, \c, or \... */
! 2372: static int
! 2373: fetch_escaped_value(UChar** src, UChar* end, ScanEnv* env)
! 2374: {
! 2375: int v;
! 2376: OnigCodePoint c;
! 2377: OnigEncoding enc = env->enc;
! 2378: UChar* p = *src;
! 2379: PFETCH_READY;
! 2380:
! 2381: if (PEND) return ONIGERR_END_PATTERN_AT_ESCAPE;
! 2382:
! 2383: PFETCH(c);
! 2384: switch (c) {
! 2385: case 'M':
! 2386: if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_ESC_CAPITAL_M_BAR_META)) {
! 2387: if (PEND) return ONIGERR_END_PATTERN_AT_META;
! 2388: PFETCH(c);
! 2389: if (c != '-') return ONIGERR_META_CODE_SYNTAX;
! 2390: if (PEND) return ONIGERR_END_PATTERN_AT_META;
! 2391: PFETCH(c);
! 2392: if (c == MC_ESC(enc)) {
! 2393: v = fetch_escaped_value(&p, end, env);
! 2394: if (v < 0) return v;
! 2395: c = (OnigCodePoint )v;
! 2396: }
! 2397: c = ((c & 0xff) | 0x80);
! 2398: }
! 2399: else
! 2400: goto backslash;
! 2401: break;
! 2402:
! 2403: case 'C':
! 2404: if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_ESC_CAPITAL_C_BAR_CONTROL)) {
! 2405: if (PEND) return ONIGERR_END_PATTERN_AT_CONTROL;
! 2406: PFETCH(c);
! 2407: if (c != '-') return ONIGERR_CONTROL_CODE_SYNTAX;
! 2408: goto control;
! 2409: }
! 2410: else
! 2411: goto backslash;
! 2412:
! 2413: case 'c':
! 2414: if (IS_SYNTAX_OP(env->syntax, ONIG_SYN_OP_ESC_C_CONTROL)) {
! 2415: control:
! 2416: if (PEND) return ONIGERR_END_PATTERN_AT_CONTROL;
! 2417: PFETCH(c);
! 2418: if (c == '?') {
! 2419: c = 0177;
! 2420: }
! 2421: else {
! 2422: if (c == MC_ESC(enc)) {
! 2423: v = fetch_escaped_value(&p, end, env);
! 2424: if (v < 0) return v;
! 2425: c = (OnigCodePoint )v;
! 2426: }
! 2427: c &= 0x9f;
! 2428: }
! 2429: break;
! 2430: }
! 2431: /* fall through */
! 2432:
! 2433: default:
! 2434: {
! 2435: backslash:
! 2436: c = conv_backslash_value(c, env);
! 2437: }
! 2438: break;
! 2439: }
! 2440:
! 2441: *src = p;
! 2442: return c;
! 2443: }
! 2444:
! 2445: static int fetch_token(OnigToken* tok, UChar** src, UChar* end, ScanEnv* env);
! 2446:
! 2447: #ifdef USE_NAMED_GROUP
! 2448: #ifdef USE_BACKREF_AT_LEVEL
! 2449: /*
! 2450: \k<name+n>, \k<name-n>
! 2451: */
! 2452: static int
! 2453: fetch_name_with_level(UChar** src, UChar* end, UChar** rname_end
! 2454: , ScanEnv* env, int* level)
! 2455: {
! 2456: int r, exist_level = 0;
! 2457: OnigCodePoint c = 0;
! 2458: OnigCodePoint first_code;
! 2459: OnigEncoding enc = env->enc;
! 2460: UChar *name_end;
! 2461: UChar *p = *src;
! 2462: PFETCH_READY;
! 2463:
! 2464: name_end = end;
! 2465: r = 0;
! 2466: if (PEND) {
! 2467: return ONIGERR_EMPTY_GROUP_NAME;
! 2468: }
! 2469: else {
! 2470: PFETCH(c);
! 2471: first_code = c;
! 2472: if (c == '>')
! 2473: return ONIGERR_EMPTY_GROUP_NAME;
! 2474:
! 2475: if (!ONIGENC_IS_CODE_WORD(enc, c)) {
! 2476: r = ONIGERR_INVALID_CHAR_IN_GROUP_NAME;
! 2477: }
! 2478: }
! 2479:
! 2480: while (!PEND) {
! 2481: name_end = p;
! 2482: PFETCH(c);
! 2483: if (c == '>' || c == ')' || c == '+' || c == '-') break;
! 2484:
! 2485: if (!ONIGENC_IS_CODE_WORD(enc, c)) {
! 2486: r = ONIGERR_INVALID_CHAR_IN_GROUP_NAME;
! 2487: }
! 2488: }
! 2489:
! 2490: if (c != '>') {
! 2491: if (c == '+' || c == '-') {
! 2492: int num;
! 2493: int flag = (c == '-' ? -1 : 1);
! 2494:
! 2495: PFETCH(c);
! 2496: if (! ONIGENC_IS_CODE_DIGIT(enc, c)) goto err;
! 2497: PUNFETCH;
! 2498: num = onig_scan_unsigned_number(&p, end, enc);
! 2499: if (num < 0) return ONIGERR_TOO_BIG_NUMBER;
! 2500: *level = (num * flag);
! 2501: exist_level = 1;
! 2502:
! 2503: PFETCH(c);
! 2504: if (c == '>')
! 2505: goto first_check;
! 2506: }
! 2507:
! 2508: err:
! 2509: r = ONIGERR_INVALID_GROUP_NAME;
! 2510: name_end = end;
! 2511: }
! 2512: else {
! 2513: first_check:
! 2514: if (ONIGENC_IS_CODE_ASCII(first_code) &&
! 2515: ONIGENC_IS_CODE_UPPER(enc, first_code))
! 2516: r = ONIGERR_INVALID_GROUP_NAME;
! 2517: }
! 2518:
! 2519: if (r == 0) {
! 2520: *rname_end = name_end;
! 2521: *src = p;
! 2522: return (exist_level ? 1 : 0);
! 2523: }
! 2524: else {
! 2525: onig_scan_env_set_error_string(env, r, *src, name_end);
! 2526: return r;
! 2527: }
! 2528: }
! 2529: #endif /* USE_BACKREF_AT_LEVEL */
! 2530:
! 2531: /*
! 2532: def: 0 -> define name (don't allow number name)
! 2533: 1 -> reference name (allow number name)
! 2534: */
! 2535: static int
! 2536: fetch_name(UChar** src, UChar* end, UChar** rname_end, ScanEnv* env, int ref)
! 2537: {
! 2538: int r, is_num;
! 2539: OnigCodePoint c = 0;
! 2540: OnigCodePoint first_code;
! 2541: OnigEncoding enc = env->enc;
! 2542: UChar *name_end;
! 2543: UChar *p = *src;
! 2544: PFETCH_READY;
! 2545:
! 2546: name_end = end;
! 2547: r = 0;
! 2548: is_num = 0;
! 2549: if (PEND) {
! 2550: return ONIGERR_EMPTY_GROUP_NAME;
! 2551: }
! 2552: else {
! 2553: PFETCH(c);
! 2554: first_code = c;
! 2555: if (c == '>')
! 2556: return ONIGERR_EMPTY_GROUP_NAME;
! 2557:
! 2558: if (ONIGENC_IS_CODE_DIGIT(enc, c)) {
! 2559: if (ref == 1)
! 2560: is_num = 1;
! 2561: else {
! 2562: r = ONIGERR_INVALID_GROUP_NAME;
! 2563: }
! 2564: }
! 2565: else if (!ONIGENC_IS_CODE_WORD(enc, c)) {
! 2566: r = ONIGERR_INVALID_CHAR_IN_GROUP_NAME;
! 2567: }
! 2568: }
! 2569:
! 2570: while (!PEND) {
! 2571: name_end = p;
! 2572: PFETCH(c);
! 2573: if (c == '>' || c == ')') break;
! 2574:
! 2575: if (is_num == 1) {
! 2576: if (! ONIGENC_IS_CODE_DIGIT(enc, c)) {
! 2577: if (!ONIGENC_IS_CODE_WORD(enc, c))
! 2578: r = ONIGERR_INVALID_CHAR_IN_GROUP_NAME;
! 2579: else
! 2580: r = ONIGERR_INVALID_GROUP_NAME;
! 2581: }
! 2582: }
! 2583: else {
! 2584: if (!ONIGENC_IS_CODE_WORD(enc, c)) {
! 2585: r = ONIGERR_INVALID_CHAR_IN_GROUP_NAME;
! 2586: }
! 2587: }
! 2588: }
! 2589:
! 2590: if (c != '>') {
! 2591: r = ONIGERR_INVALID_GROUP_NAME;
! 2592: name_end = end;
! 2593: }
! 2594: else {
! 2595: if (ONIGENC_IS_CODE_ASCII(first_code) &&
! 2596: ONIGENC_IS_CODE_UPPER(enc, first_code))
! 2597: r = ONIGERR_INVALID_GROUP_NAME;
! 2598: }
! 2599:
! 2600: if (r == 0) {
! 2601: *rname_end = name_end;
! 2602: *src = p;
! 2603: return 0;
! 2604: }
! 2605: else {
! 2606: onig_scan_env_set_error_string(env, r, *src, name_end);
! 2607: return r;
! 2608: }
! 2609: }
! 2610: #else
! 2611: static int
! 2612: fetch_name(UChar** src, UChar* end, UChar** rname_end, ScanEnv* env, int ref)
! 2613: {
! 2614: int r, len;
! 2615: OnigCodePoint c = 0;
! 2616: UChar *name_end;
! 2617: OnigEncoding enc = env->enc;
! 2618: UChar *p = *src;
! 2619: PFETCH_READY;
! 2620:
! 2621: r = 0;
! 2622: while (!PEND) {
! 2623: name_end = p;
! 2624: if (enc_len(enc, p) > 1)
! 2625: r = ONIGERR_INVALID_CHAR_IN_GROUP_NAME;
! 2626:
! 2627: PFETCH(c);
! 2628: if (c == '>' || c == ')') break;
! 2629: if (! ONIGENC_IS_CODE_DIGIT(enc, c))
! 2630: r = ONIGERR_INVALID_CHAR_IN_GROUP_NAME;
! 2631: }
! 2632: if (c != '>') {
! 2633: r = ONIGERR_INVALID_GROUP_NAME;
! 2634: name_end = end;
! 2635: }
! 2636:
! 2637: if (r == 0) {
! 2638: *rname_end = name_end;
! 2639: *src = p;
! 2640: return 0;
! 2641: }
! 2642: else {
! 2643: err:
! 2644: onig_scan_env_set_error_string(env, r, *src, name_end);
! 2645: return r;
! 2646: }
! 2647: }
! 2648: #endif
! 2649:
! 2650: static void
! 2651: CC_ESC_WARN(ScanEnv* env, UChar *c)
! 2652: {
! 2653: if (onig_warn == onig_null_warn) return ;
! 2654:
! 2655: if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_WARN_CC_OP_NOT_ESCAPED) &&
! 2656: IS_SYNTAX_BV(env->syntax, ONIG_SYN_BACKSLASH_ESCAPE_IN_CC)) {
! 2657: UChar buf[WARN_BUFSIZE];
! 2658: onig_snprintf_with_pattern(buf, WARN_BUFSIZE, env->enc,
! 2659: env->pattern, env->pattern_end,
! 2660: (UChar* )"character class has '%s' without escape", c);
! 2661: (*onig_warn)((char* )buf);
! 2662: }
! 2663: }
! 2664:
! 2665: static void
! 2666: CCEND_ESC_WARN(ScanEnv* env, UChar* c)
! 2667: {
! 2668: if (onig_warn == onig_null_warn) return ;
! 2669:
! 2670: if (IS_SYNTAX_BV((env)->syntax, ONIG_SYN_WARN_CC_OP_NOT_ESCAPED)) {
! 2671: UChar buf[WARN_BUFSIZE];
! 2672: onig_snprintf_with_pattern(buf, WARN_BUFSIZE, (env)->enc,
! 2673: (env)->pattern, (env)->pattern_end,
! 2674: (UChar* )"regular expression has '%s' without escape", c);
! 2675: (*onig_warn)((char* )buf);
! 2676: }
! 2677: }
! 2678:
! 2679: static UChar*
! 2680: find_str_position(OnigCodePoint s[], int n, UChar* from, UChar* to,
! 2681: UChar **next, OnigEncoding enc)
! 2682: {
! 2683: int i;
! 2684: OnigCodePoint x;
! 2685: UChar *q;
! 2686: UChar *p = from;
! 2687:
! 2688: while (p < to) {
! 2689: x = ONIGENC_MBC_TO_CODE(enc, p, to);
! 2690: q = p + enc_len(enc, p);
! 2691: if (x == s[0]) {
! 2692: for (i = 1; i < n && q < to; i++) {
! 2693: x = ONIGENC_MBC_TO_CODE(enc, q, to);
! 2694: if (x != s[i]) break;
! 2695: q += enc_len(enc, q);
! 2696: }
! 2697: if (i >= n) {
! 2698: if (IS_NOT_NULL(next))
! 2699: *next = q;
! 2700: return p;
! 2701: }
! 2702: }
! 2703: p = q;
! 2704: }
! 2705: return NULL_UCHARP;
! 2706: }
! 2707:
! 2708: static int
! 2709: str_exist_check_with_esc(OnigCodePoint s[], int n, UChar* from, UChar* to,
! 2710: OnigCodePoint bad, OnigEncoding enc)
! 2711: {
! 2712: int i, in_esc;
! 2713: OnigCodePoint x;
! 2714: UChar *q;
! 2715: UChar *p = from;
! 2716:
! 2717: in_esc = 0;
! 2718: while (p < to) {
! 2719: if (in_esc) {
! 2720: in_esc = 0;
! 2721: p += enc_len(enc, p);
! 2722: }
! 2723: else {
! 2724: x = ONIGENC_MBC_TO_CODE(enc, p, to);
! 2725: q = p + enc_len(enc, p);
! 2726: if (x == s[0]) {
! 2727: for (i = 1; i < n && q < to; i++) {
! 2728: x = ONIGENC_MBC_TO_CODE(enc, q, to);
! 2729: if (x != s[i]) break;
! 2730: q += enc_len(enc, q);
! 2731: }
! 2732: if (i >= n) return 1;
! 2733: p += enc_len(enc, p);
! 2734: }
! 2735: else {
! 2736: x = ONIGENC_MBC_TO_CODE(enc, p, to);
! 2737: if (x == bad) return 0;
! 2738: else if (x == MC_ESC(enc)) in_esc = 1;
! 2739: p = q;
! 2740: }
! 2741: }
! 2742: }
! 2743: return 0;
! 2744: }
! 2745:
! 2746: static int
! 2747: fetch_token_in_cc(OnigToken* tok, UChar** src, UChar* end, ScanEnv* env)
! 2748: {
! 2749: int num;
! 2750: OnigCodePoint c, c2;
! 2751: OnigSyntaxType* syn = env->syntax;
! 2752: OnigEncoding enc = env->enc;
! 2753: UChar* prev;
! 2754: UChar* p = *src;
! 2755: PFETCH_READY;
! 2756:
! 2757: if (PEND) {
! 2758: tok->type = TK_EOT;
! 2759: return tok->type;
! 2760: }
! 2761:
! 2762: PFETCH(c);
! 2763: tok->type = TK_CHAR;
! 2764: tok->base = 0;
! 2765: tok->u.c = c;
! 2766: tok->escaped = 0;
! 2767:
! 2768: if (c == ']') {
! 2769: tok->type = TK_CC_CLOSE;
! 2770: }
! 2771: else if (c == '-') {
! 2772: tok->type = TK_CC_RANGE;
! 2773: }
! 2774: else if (c == MC_ESC(enc)) {
! 2775: if (! IS_SYNTAX_BV(syn, ONIG_SYN_BACKSLASH_ESCAPE_IN_CC))
! 2776: goto end;
! 2777:
! 2778: if (PEND) return ONIGERR_END_PATTERN_AT_ESCAPE;
! 2779:
! 2780: PFETCH(c);
! 2781: tok->escaped = 1;
! 2782: tok->u.c = c;
! 2783: switch (c) {
! 2784: case 'w':
! 2785: tok->type = TK_CHAR_TYPE;
! 2786: tok->u.subtype = CTYPE_WORD;
! 2787: break;
! 2788: case 'W':
! 2789: tok->type = TK_CHAR_TYPE;
! 2790: tok->u.subtype = CTYPE_NOT_WORD;
! 2791: break;
! 2792: case 'd':
! 2793: tok->type = TK_CHAR_TYPE;
! 2794: tok->u.subtype = CTYPE_DIGIT;
! 2795: break;
! 2796: case 'D':
! 2797: tok->type = TK_CHAR_TYPE;
! 2798: tok->u.subtype = CTYPE_NOT_DIGIT;
! 2799: break;
! 2800: case 's':
! 2801: tok->type = TK_CHAR_TYPE;
! 2802: tok->u.subtype = CTYPE_WHITE_SPACE;
! 2803: break;
! 2804: case 'S':
! 2805: tok->type = TK_CHAR_TYPE;
! 2806: tok->u.subtype = CTYPE_NOT_WHITE_SPACE;
! 2807: break;
! 2808: case 'h':
! 2809: if (! IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_H_XDIGIT)) break;
! 2810: tok->type = TK_CHAR_TYPE;
! 2811: tok->u.subtype = CTYPE_XDIGIT;
! 2812: break;
! 2813: case 'H':
! 2814: if (! IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_H_XDIGIT)) break;
! 2815: tok->type = TK_CHAR_TYPE;
! 2816: tok->u.subtype = CTYPE_NOT_XDIGIT;
! 2817: break;
! 2818:
! 2819: case 'p':
! 2820: case 'P':
! 2821: c2 = PPEEK;
! 2822: if (c2 == '{' &&
! 2823: IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_P_BRACE_CHAR_PROPERTY)) {
! 2824: PINC;
! 2825: tok->type = TK_CHAR_PROPERTY;
! 2826: tok->u.prop.not = (c == 'P' ? 1 : 0);
! 2827:
! 2828: if (IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_P_BRACE_CIRCUMFLEX_NOT)) {
! 2829: PFETCH(c2);
! 2830: if (c2 == '^') {
! 2831: tok->u.prop.not = (tok->u.prop.not == 0 ? 1 : 0);
! 2832: }
! 2833: else
! 2834: PUNFETCH;
! 2835: }
! 2836: }
! 2837: break;
! 2838:
! 2839: case 'x':
! 2840: if (PEND) break;
! 2841:
! 2842: prev = p;
! 2843: if (PPEEK_IS('{') && IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_X_BRACE_HEX8)) {
! 2844: PINC;
! 2845: num = scan_unsigned_hexadecimal_number(&p, end, 8, enc);
! 2846: if (num < 0) return ONIGERR_TOO_BIG_WIDE_CHAR_VALUE;
! 2847: if (!PEND) {
! 2848: c2 = PPEEK;
! 2849: if (ONIGENC_IS_CODE_XDIGIT(enc, c2))
! 2850: return ONIGERR_TOO_LONG_WIDE_CHAR_VALUE;
! 2851: }
! 2852:
! 2853: if (p > prev + enc_len(enc, prev) && !PEND && (PPEEK_IS('}'))) {
! 2854: PINC;
! 2855: tok->type = TK_CODE_POINT;
! 2856: tok->base = 16;
! 2857: tok->u.code = (OnigCodePoint )num;
! 2858: }
! 2859: else {
! 2860: /* can't read nothing or invalid format */
! 2861: p = prev;
! 2862: }
! 2863: }
! 2864: else if (IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_X_HEX2)) {
! 2865: num = scan_unsigned_hexadecimal_number(&p, end, 2, enc);
! 2866: if (num < 0) return ONIGERR_TOO_BIG_NUMBER;
! 2867: if (p == prev) { /* can't read nothing. */
! 2868: num = 0; /* but, it's not error */
! 2869: }
! 2870: tok->type = TK_RAW_BYTE;
! 2871: tok->base = 16;
! 2872: tok->u.c = num;
! 2873: }
! 2874: break;
! 2875:
! 2876: case 'u':
! 2877: if (PEND) break;
! 2878:
! 2879: prev = p;
! 2880: if (IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_U_HEX4)) {
! 2881: num = scan_unsigned_hexadecimal_number(&p, end, 4, enc);
! 2882: if (num < 0) return ONIGERR_TOO_BIG_NUMBER;
! 2883: if (p == prev) { /* can't read nothing. */
! 2884: num = 0; /* but, it's not error */
! 2885: }
! 2886: tok->type = TK_CODE_POINT;
! 2887: tok->base = 16;
! 2888: tok->u.code = (OnigCodePoint )num;
! 2889: }
! 2890: break;
! 2891:
! 2892: case '0':
! 2893: case '1': case '2': case '3': case '4': case '5': case '6': case '7':
! 2894: if (IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_OCTAL3)) {
! 2895: PUNFETCH;
! 2896: prev = p;
! 2897: num = scan_unsigned_octal_number(&p, end, 3, enc);
! 2898: if (num < 0) return ONIGERR_TOO_BIG_NUMBER;
! 2899: if (p == prev) { /* can't read nothing. */
! 2900: num = 0; /* but, it's not error */
! 2901: }
! 2902: tok->type = TK_RAW_BYTE;
! 2903: tok->base = 8;
! 2904: tok->u.c = num;
! 2905: }
! 2906: break;
! 2907:
! 2908: default:
! 2909: PUNFETCH;
! 2910: num = fetch_escaped_value(&p, end, env);
! 2911: if (num < 0) return num;
! 2912: if (tok->u.c != num) {
! 2913: tok->u.code = (OnigCodePoint )num;
! 2914: tok->type = TK_CODE_POINT;
! 2915: }
! 2916: break;
! 2917: }
! 2918: }
! 2919: else if (c == '[') {
! 2920: if (IS_SYNTAX_OP(syn, ONIG_SYN_OP_POSIX_BRACKET) && (PPEEK_IS(':'))) {
! 2921: OnigCodePoint send[] = { (OnigCodePoint )':', (OnigCodePoint )']' };
! 2922: tok->backp = p; /* point at '[' is readed */
! 2923: PINC;
! 2924: if (str_exist_check_with_esc(send, 2, p, end,
! 2925: (OnigCodePoint )']', enc)) {
! 2926: tok->type = TK_POSIX_BRACKET_OPEN;
! 2927: }
! 2928: else {
! 2929: PUNFETCH;
! 2930: goto cc_in_cc;
! 2931: }
! 2932: }
! 2933: else {
! 2934: cc_in_cc:
! 2935: if (IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_CCLASS_SET_OP)) {
! 2936: tok->type = TK_CC_CC_OPEN;
! 2937: }
! 2938: else {
! 2939: CC_ESC_WARN(env, (UChar* )"[");
! 2940: }
! 2941: }
! 2942: }
! 2943: else if (c == '&') {
! 2944: if (IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_CCLASS_SET_OP) &&
! 2945: !PEND && (PPEEK_IS('&'))) {
! 2946: PINC;
! 2947: tok->type = TK_CC_AND;
! 2948: }
! 2949: }
! 2950:
! 2951: end:
! 2952: *src = p;
! 2953: return tok->type;
! 2954: }
! 2955:
! 2956: static int
! 2957: fetch_token(OnigToken* tok, UChar** src, UChar* end, ScanEnv* env)
! 2958: {
! 2959: int r, num;
! 2960: OnigCodePoint c;
! 2961: OnigEncoding enc = env->enc;
! 2962: OnigSyntaxType* syn = env->syntax;
! 2963: UChar* prev;
! 2964: UChar* p = *src;
! 2965: PFETCH_READY;
! 2966:
! 2967: start:
! 2968: if (PEND) {
! 2969: tok->type = TK_EOT;
! 2970: return tok->type;
! 2971: }
! 2972:
! 2973: tok->type = TK_STRING;
! 2974: tok->base = 0;
! 2975: tok->backp = p;
! 2976:
! 2977: PFETCH(c);
! 2978: if (IS_MC_ESC_CODE(c, enc, syn)) {
! 2979: if (PEND) return ONIGERR_END_PATTERN_AT_ESCAPE;
! 2980:
! 2981: tok->backp = p;
! 2982: PFETCH(c);
! 2983:
! 2984: tok->u.c = c;
! 2985: tok->escaped = 1;
! 2986: switch (c) {
! 2987: case '*':
! 2988: if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_ASTERISK_ZERO_INF)) break;
! 2989: tok->type = TK_OP_REPEAT;
! 2990: tok->u.repeat.lower = 0;
! 2991: tok->u.repeat.upper = REPEAT_INFINITE;
! 2992: goto greedy_check;
! 2993: break;
! 2994:
! 2995: case '+':
! 2996: if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_PLUS_ONE_INF)) break;
! 2997: tok->type = TK_OP_REPEAT;
! 2998: tok->u.repeat.lower = 1;
! 2999: tok->u.repeat.upper = REPEAT_INFINITE;
! 3000: goto greedy_check;
! 3001: break;
! 3002:
! 3003: case '?':
! 3004: if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_QMARK_ZERO_ONE)) break;
! 3005: tok->type = TK_OP_REPEAT;
! 3006: tok->u.repeat.lower = 0;
! 3007: tok->u.repeat.upper = 1;
! 3008: greedy_check:
! 3009: if (!PEND && PPEEK_IS('?') &&
! 3010: IS_SYNTAX_OP(syn, ONIG_SYN_OP_QMARK_NON_GREEDY)) {
! 3011: PFETCH(c);
! 3012: tok->u.repeat.greedy = 0;
! 3013: tok->u.repeat.possessive = 0;
! 3014: }
! 3015: else {
! 3016: possessive_check:
! 3017: if (!PEND && PPEEK_IS('+') &&
! 3018: ((IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_PLUS_POSSESSIVE_REPEAT) &&
! 3019: tok->type != TK_INTERVAL) ||
! 3020: (IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_PLUS_POSSESSIVE_INTERVAL) &&
! 3021: tok->type == TK_INTERVAL))) {
! 3022: PFETCH(c);
! 3023: tok->u.repeat.greedy = 1;
! 3024: tok->u.repeat.possessive = 1;
! 3025: }
! 3026: else {
! 3027: tok->u.repeat.greedy = 1;
! 3028: tok->u.repeat.possessive = 0;
! 3029: }
! 3030: }
! 3031: break;
! 3032:
! 3033: case '{':
! 3034: if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_BRACE_INTERVAL)) break;
! 3035: r = fetch_range_quantifier(&p, end, tok, env);
! 3036: if (r < 0) return r; /* error */
! 3037: if (r == 0) goto greedy_check;
! 3038: else if (r == 2) { /* {n} */
! 3039: if (IS_SYNTAX_BV(syn, ONIG_SYN_FIXED_INTERVAL_IS_GREEDY_ONLY))
! 3040: goto possessive_check;
! 3041:
! 3042: goto greedy_check;
! 3043: }
! 3044: /* r == 1 : normal char */
! 3045: break;
! 3046:
! 3047: case '|':
! 3048: if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_VBAR_ALT)) break;
! 3049: tok->type = TK_ALT;
! 3050: break;
! 3051:
! 3052: case '(':
! 3053: if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_LPAREN_SUBEXP)) break;
! 3054: tok->type = TK_SUBEXP_OPEN;
! 3055: break;
! 3056:
! 3057: case ')':
! 3058: if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_LPAREN_SUBEXP)) break;
! 3059: tok->type = TK_SUBEXP_CLOSE;
! 3060: break;
! 3061:
! 3062: case 'w':
! 3063: if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_W_WORD)) break;
! 3064: tok->type = TK_CHAR_TYPE;
! 3065: tok->u.subtype = CTYPE_WORD;
! 3066: break;
! 3067:
! 3068: case 'W':
! 3069: if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_W_WORD)) break;
! 3070: tok->type = TK_CHAR_TYPE;
! 3071: tok->u.subtype = CTYPE_NOT_WORD;
! 3072: break;
! 3073:
! 3074: case 'b':
! 3075: if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_B_WORD_BOUND)) break;
! 3076: tok->type = TK_ANCHOR;
! 3077: tok->u.anchor = ANCHOR_WORD_BOUND;
! 3078: break;
! 3079:
! 3080: case 'B':
! 3081: if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_B_WORD_BOUND)) break;
! 3082: tok->type = TK_ANCHOR;
! 3083: tok->u.anchor = ANCHOR_NOT_WORD_BOUND;
! 3084: break;
! 3085:
! 3086: #ifdef USE_WORD_BEGIN_END
! 3087: case '<':
! 3088: if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_LTGT_WORD_BEGIN_END)) break;
! 3089: tok->type = TK_ANCHOR;
! 3090: tok->u.anchor = ANCHOR_WORD_BEGIN;
! 3091: break;
! 3092:
! 3093: case '>':
! 3094: if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_LTGT_WORD_BEGIN_END)) break;
! 3095: tok->type = TK_ANCHOR;
! 3096: tok->u.anchor = ANCHOR_WORD_END;
! 3097: break;
! 3098: #endif
! 3099:
! 3100: case 's':
! 3101: if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_S_WHITE_SPACE)) break;
! 3102: tok->type = TK_CHAR_TYPE;
! 3103: tok->u.subtype = CTYPE_WHITE_SPACE;
! 3104: break;
! 3105:
! 3106: case 'S':
! 3107: if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_S_WHITE_SPACE)) break;
! 3108: tok->type = TK_CHAR_TYPE;
! 3109: tok->u.subtype = CTYPE_NOT_WHITE_SPACE;
! 3110: break;
! 3111:
! 3112: case 'd':
! 3113: if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_D_DIGIT)) break;
! 3114: tok->type = TK_CHAR_TYPE;
! 3115: tok->u.subtype = CTYPE_DIGIT;
! 3116: break;
! 3117:
! 3118: case 'D':
! 3119: if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_D_DIGIT)) break;
! 3120: tok->type = TK_CHAR_TYPE;
! 3121: tok->u.subtype = CTYPE_NOT_DIGIT;
! 3122: break;
! 3123:
! 3124: case 'h':
! 3125: if (! IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_H_XDIGIT)) break;
! 3126: tok->type = TK_CHAR_TYPE;
! 3127: tok->u.subtype = CTYPE_XDIGIT;
! 3128: break;
! 3129:
! 3130: case 'H':
! 3131: if (! IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_H_XDIGIT)) break;
! 3132: tok->type = TK_CHAR_TYPE;
! 3133: tok->u.subtype = CTYPE_NOT_XDIGIT;
! 3134: break;
! 3135:
! 3136: case 'A':
! 3137: if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_AZ_BUF_ANCHOR)) break;
! 3138: begin_buf:
! 3139: tok->type = TK_ANCHOR;
! 3140: tok->u.subtype = ANCHOR_BEGIN_BUF;
! 3141: break;
! 3142:
! 3143: case 'Z':
! 3144: if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_AZ_BUF_ANCHOR)) break;
! 3145: tok->type = TK_ANCHOR;
! 3146: tok->u.subtype = ANCHOR_SEMI_END_BUF;
! 3147: break;
! 3148:
! 3149: case 'z':
! 3150: if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_AZ_BUF_ANCHOR)) break;
! 3151: end_buf:
! 3152: tok->type = TK_ANCHOR;
! 3153: tok->u.subtype = ANCHOR_END_BUF;
! 3154: break;
! 3155:
! 3156: case 'G':
! 3157: if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_CAPITAL_G_BEGIN_ANCHOR)) break;
! 3158: tok->type = TK_ANCHOR;
! 3159: tok->u.subtype = ANCHOR_BEGIN_POSITION;
! 3160: break;
! 3161:
! 3162: case '`':
! 3163: if (! IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_GNU_BUF_ANCHOR)) break;
! 3164: goto begin_buf;
! 3165: break;
! 3166:
! 3167: case '\'':
! 3168: if (! IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_GNU_BUF_ANCHOR)) break;
! 3169: goto end_buf;
! 3170: break;
! 3171:
! 3172: case 'x':
! 3173: if (PEND) break;
! 3174:
! 3175: prev = p;
! 3176: if (PPEEK_IS('{') && IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_X_BRACE_HEX8)) {
! 3177: PINC;
! 3178: num = scan_unsigned_hexadecimal_number(&p, end, 8, enc);
! 3179: if (num < 0) return ONIGERR_TOO_BIG_WIDE_CHAR_VALUE;
! 3180: if (!PEND) {
! 3181: if (ONIGENC_IS_CODE_XDIGIT(enc, PPEEK))
! 3182: return ONIGERR_TOO_LONG_WIDE_CHAR_VALUE;
! 3183: }
! 3184:
! 3185: if ((p > prev + enc_len(enc, prev)) && !PEND && PPEEK_IS('}')) {
! 3186: PINC;
! 3187: tok->type = TK_CODE_POINT;
! 3188: tok->u.code = (OnigCodePoint )num;
! 3189: }
! 3190: else {
! 3191: /* can't read nothing or invalid format */
! 3192: p = prev;
! 3193: }
! 3194: }
! 3195: else if (IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_X_HEX2)) {
! 3196: num = scan_unsigned_hexadecimal_number(&p, end, 2, enc);
! 3197: if (num < 0) return ONIGERR_TOO_BIG_NUMBER;
! 3198: if (p == prev) { /* can't read nothing. */
! 3199: num = 0; /* but, it's not error */
! 3200: }
! 3201: tok->type = TK_RAW_BYTE;
! 3202: tok->base = 16;
! 3203: tok->u.c = num;
! 3204: }
! 3205: break;
! 3206:
! 3207: case 'u':
! 3208: if (PEND) break;
! 3209:
! 3210: prev = p;
! 3211: if (IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_U_HEX4)) {
! 3212: num = scan_unsigned_hexadecimal_number(&p, end, 4, enc);
! 3213: if (num < 0) return ONIGERR_TOO_BIG_NUMBER;
! 3214: if (p == prev) { /* can't read nothing. */
! 3215: num = 0; /* but, it's not error */
! 3216: }
! 3217: tok->type = TK_CODE_POINT;
! 3218: tok->base = 16;
! 3219: tok->u.code = (OnigCodePoint )num;
! 3220: }
! 3221: break;
! 3222:
! 3223: case '1': case '2': case '3': case '4':
! 3224: case '5': case '6': case '7': case '8': case '9':
! 3225: PUNFETCH;
! 3226: prev = p;
! 3227: num = onig_scan_unsigned_number(&p, end, enc);
! 3228: if (num < 0 || num > ONIG_MAX_BACKREF_NUM) {
! 3229: goto skip_backref;
! 3230: }
! 3231:
! 3232: if (IS_SYNTAX_OP(syn, ONIG_SYN_OP_DECIMAL_BACKREF) &&
! 3233: (num <= env->num_mem || num <= 9)) { /* This spec. from GNU regex */
! 3234: if (IS_SYNTAX_BV(syn, ONIG_SYN_STRICT_CHECK_BACKREF)) {
! 3235: if (num > env->num_mem || IS_NULL(SCANENV_MEM_NODES(env)[num]))
! 3236: return ONIGERR_INVALID_BACKREF;
! 3237: }
! 3238:
! 3239: tok->type = TK_BACKREF;
! 3240: tok->u.backref.num = 1;
! 3241: tok->u.backref.ref1 = num;
! 3242: tok->u.backref.by_name = 0;
! 3243: #ifdef USE_BACKREF_AT_LEVEL
! 3244: tok->u.backref.exist_level = 0;
! 3245: #endif
! 3246: break;
! 3247: }
! 3248:
! 3249: skip_backref:
! 3250: if (c == '8' || c == '9') {
! 3251: /* normal char */
! 3252: p = prev; PINC;
! 3253: break;
! 3254: }
! 3255:
! 3256: p = prev;
! 3257: /* fall through */
! 3258: case '0':
! 3259: if (IS_SYNTAX_OP(syn, ONIG_SYN_OP_ESC_OCTAL3)) {
! 3260: prev = p;
! 3261: num = scan_unsigned_octal_number(&p, end, (c == '0' ? 2:3), enc);
! 3262: if (num < 0) return ONIGERR_TOO_BIG_NUMBER;
! 3263: if (p == prev) { /* can't read nothing. */
! 3264: num = 0; /* but, it's not error */
! 3265: }
! 3266: tok->type = TK_RAW_BYTE;
! 3267: tok->base = 8;
! 3268: tok->u.c = num;
! 3269: }
! 3270: else if (c != '0') {
! 3271: PINC;
! 3272: }
! 3273: break;
! 3274:
! 3275: #ifdef USE_NAMED_GROUP
! 3276: case 'k':
! 3277: if (IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_K_NAMED_BACKREF)) {
! 3278: PFETCH(c);
! 3279: if (c == '<') {
! 3280: UChar* name_end;
! 3281: int* backs;
! 3282:
! 3283: prev = p;
! 3284:
! 3285: #ifdef USE_BACKREF_AT_LEVEL
! 3286: name_end = NULL_UCHARP; /* no need. escape gcc warning. */
! 3287: r = fetch_name_with_level(&p, end, &name_end, env, &tok->u.backref.level);
! 3288: if (r == 1) tok->u.backref.exist_level = 1;
! 3289: else tok->u.backref.exist_level = 0;
! 3290: #else
! 3291: r = fetch_name(&p, end, &name_end, env, 1);
! 3292: #endif
! 3293: if (r < 0) return r;
! 3294:
! 3295: num = onig_name_to_group_numbers(env->reg, prev, name_end, &backs);
! 3296: if (num <= 0) {
! 3297: onig_scan_env_set_error_string(env,
! 3298: ONIGERR_UNDEFINED_NAME_REFERENCE, prev, name_end);
! 3299: return ONIGERR_UNDEFINED_NAME_REFERENCE;
! 3300: }
! 3301: if (IS_SYNTAX_BV(syn, ONIG_SYN_STRICT_CHECK_BACKREF)) {
! 3302: int i;
! 3303: for (i = 0; i < num; i++) {
! 3304: if (backs[i] > env->num_mem ||
! 3305: IS_NULL(SCANENV_MEM_NODES(env)[backs[i]]))
! 3306: return ONIGERR_INVALID_BACKREF;
! 3307: }
! 3308: }
! 3309:
! 3310: tok->type = TK_BACKREF;
! 3311: tok->u.backref.by_name = 1;
! 3312: if (num == 1) {
! 3313: tok->u.backref.num = 1;
! 3314: tok->u.backref.ref1 = backs[0];
! 3315: }
! 3316: else {
! 3317: tok->u.backref.num = num;
! 3318: tok->u.backref.refs = backs;
! 3319: }
! 3320: }
! 3321: else
! 3322: PUNFETCH;
! 3323: }
! 3324: break;
! 3325: #endif
! 3326:
! 3327: #ifdef USE_SUBEXP_CALL
! 3328: case 'g':
! 3329: if (IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_G_SUBEXP_CALL)) {
! 3330: PFETCH(c);
! 3331: if (c == '<') {
! 3332: UChar* name_end;
! 3333:
! 3334: prev = p;
! 3335: r = fetch_name(&p, end, &name_end, env, 1);
! 3336: if (r < 0) return r;
! 3337:
! 3338: tok->type = TK_CALL;
! 3339: tok->u.call.name = prev;
! 3340: tok->u.call.name_end = name_end;
! 3341: }
! 3342: else
! 3343: PUNFETCH;
! 3344: }
! 3345: break;
! 3346: #endif
! 3347:
! 3348: case 'Q':
! 3349: if (IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_CAPITAL_Q_QUOTE)) {
! 3350: tok->type = TK_QUOTE_OPEN;
! 3351: }
! 3352: break;
! 3353:
! 3354: case 'p':
! 3355: case 'P':
! 3356: if (PPEEK_IS('{') &&
! 3357: IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_P_BRACE_CHAR_PROPERTY)) {
! 3358: PINC;
! 3359: tok->type = TK_CHAR_PROPERTY;
! 3360: tok->u.prop.not = (c == 'P' ? 1 : 0);
! 3361:
! 3362: if (IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_ESC_P_BRACE_CIRCUMFLEX_NOT)) {
! 3363: PFETCH(c);
! 3364: if (c == '^') {
! 3365: tok->u.prop.not = (tok->u.prop.not == 0 ? 1 : 0);
! 3366: }
! 3367: else
! 3368: PUNFETCH;
! 3369: }
! 3370: }
! 3371: break;
! 3372:
! 3373: default:
! 3374: PUNFETCH;
! 3375: num = fetch_escaped_value(&p, end, env);
! 3376: if (num < 0) return num;
! 3377: /* set_raw: */
! 3378: if (tok->u.c != num) {
! 3379: tok->type = TK_CODE_POINT;
! 3380: tok->u.code = (OnigCodePoint )num;
! 3381: }
! 3382: else { /* string */
! 3383: p = tok->backp + enc_len(enc, tok->backp);
! 3384: }
! 3385: break;
! 3386: }
! 3387: }
! 3388: else {
! 3389: tok->u.c = c;
! 3390: tok->escaped = 0;
! 3391:
! 3392: #ifdef USE_VARIABLE_META_CHARS
! 3393: if ((c != ONIG_INEFFECTIVE_META_CHAR) &&
! 3394: IS_SYNTAX_OP(syn, ONIG_SYN_OP_VARIABLE_META_CHARACTERS)) {
! 3395: if (c == MC_ANYCHAR(enc))
! 3396: goto any_char;
! 3397: else if (c == MC_ANYTIME(enc))
! 3398: goto anytime;
! 3399: else if (c == MC_ZERO_OR_ONE_TIME(enc))
! 3400: goto zero_or_one_time;
! 3401: else if (c == MC_ONE_OR_MORE_TIME(enc))
! 3402: goto one_or_more_time;
! 3403: else if (c == MC_ANYCHAR_ANYTIME(enc)) {
! 3404: tok->type = TK_ANYCHAR_ANYTIME;
! 3405: goto out;
! 3406: }
! 3407: }
! 3408: #endif
! 3409:
! 3410: switch (c) {
! 3411: case '.':
! 3412: if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_DOT_ANYCHAR)) break;
! 3413: #ifdef USE_VARIABLE_META_CHARS
! 3414: any_char:
! 3415: #endif
! 3416: tok->type = TK_ANYCHAR;
! 3417: break;
! 3418:
! 3419: case '*':
! 3420: if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_ASTERISK_ZERO_INF)) break;
! 3421: #ifdef USE_VARIABLE_META_CHARS
! 3422: anytime:
! 3423: #endif
! 3424: tok->type = TK_OP_REPEAT;
! 3425: tok->u.repeat.lower = 0;
! 3426: tok->u.repeat.upper = REPEAT_INFINITE;
! 3427: goto greedy_check;
! 3428: break;
! 3429:
! 3430: case '+':
! 3431: if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_PLUS_ONE_INF)) break;
! 3432: #ifdef USE_VARIABLE_META_CHARS
! 3433: one_or_more_time:
! 3434: #endif
! 3435: tok->type = TK_OP_REPEAT;
! 3436: tok->u.repeat.lower = 1;
! 3437: tok->u.repeat.upper = REPEAT_INFINITE;
! 3438: goto greedy_check;
! 3439: break;
! 3440:
! 3441: case '?':
! 3442: if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_QMARK_ZERO_ONE)) break;
! 3443: #ifdef USE_VARIABLE_META_CHARS
! 3444: zero_or_one_time:
! 3445: #endif
! 3446: tok->type = TK_OP_REPEAT;
! 3447: tok->u.repeat.lower = 0;
! 3448: tok->u.repeat.upper = 1;
! 3449: goto greedy_check;
! 3450: break;
! 3451:
! 3452: case '{':
! 3453: if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_BRACE_INTERVAL)) break;
! 3454: r = fetch_range_quantifier(&p, end, tok, env);
! 3455: if (r < 0) return r; /* error */
! 3456: if (r == 0) goto greedy_check;
! 3457: else if (r == 2) { /* {n} */
! 3458: if (IS_SYNTAX_BV(syn, ONIG_SYN_FIXED_INTERVAL_IS_GREEDY_ONLY))
! 3459: goto possessive_check;
! 3460:
! 3461: goto greedy_check;
! 3462: }
! 3463: /* r == 1 : normal char */
! 3464: break;
! 3465:
! 3466: case '|':
! 3467: if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_VBAR_ALT)) break;
! 3468: tok->type = TK_ALT;
! 3469: break;
! 3470:
! 3471: case '(':
! 3472: if (PPEEK_IS('?') &&
! 3473: IS_SYNTAX_OP2(syn, ONIG_SYN_OP2_QMARK_GROUP_EFFECT)) {
! 3474: PINC;
! 3475: if (PPEEK_IS('#')) {
! 3476: PFETCH(c);
! 3477: while (1) {
! 3478: if (PEND) return ONIGERR_END_PATTERN_IN_GROUP;
! 3479: PFETCH(c);
! 3480: if (c == MC_ESC(enc)) {
! 3481: if (!PEND) PFETCH(c);
! 3482: }
! 3483: else {
! 3484: if (c == ')') break;
! 3485: }
! 3486: }
! 3487: goto start;
! 3488: }
! 3489: PUNFETCH;
! 3490: }
! 3491:
! 3492: if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_LPAREN_SUBEXP)) break;
! 3493: tok->type = TK_SUBEXP_OPEN;
! 3494: break;
! 3495:
! 3496: case ')':
! 3497: if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_LPAREN_SUBEXP)) break;
! 3498: tok->type = TK_SUBEXP_CLOSE;
! 3499: break;
! 3500:
! 3501: case '^':
! 3502: if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_LINE_ANCHOR)) break;
! 3503: tok->type = TK_ANCHOR;
! 3504: tok->u.subtype = (IS_SINGLELINE(env->option)
! 3505: ? ANCHOR_BEGIN_BUF : ANCHOR_BEGIN_LINE);
! 3506: break;
! 3507:
! 3508: case '$':
! 3509: if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_LINE_ANCHOR)) break;
! 3510: tok->type = TK_ANCHOR;
! 3511: tok->u.subtype = (IS_SINGLELINE(env->option)
! 3512: ? ANCHOR_SEMI_END_BUF : ANCHOR_END_LINE);
! 3513: break;
! 3514:
! 3515: case '[':
! 3516: if (! IS_SYNTAX_OP(syn, ONIG_SYN_OP_BRACKET_CC)) break;
! 3517: tok->type = TK_CC_OPEN;
! 3518: break;
! 3519:
! 3520: case ']':
! 3521: if (*src > env->pattern) /* /].../ is allowed. */
! 3522: CCEND_ESC_WARN(env, (UChar* )"]");
! 3523: break;
! 3524:
! 3525: case '#':
! 3526: if (IS_EXTEND(env->option)) {
! 3527: while (!PEND) {
! 3528: PFETCH(c);
! 3529: if (ONIGENC_IS_CODE_NEWLINE(enc, c))
! 3530: break;
! 3531: }
! 3532: goto start;
! 3533: break;
! 3534: }
! 3535: break;
! 3536:
! 3537: case ' ': case '\t': case '\n': case '\r': case '\f':
! 3538: if (IS_EXTEND(env->option))
! 3539: goto start;
! 3540: break;
! 3541:
! 3542: default:
! 3543: /* string */
! 3544: break;
! 3545: }
! 3546: }
! 3547:
! 3548: #ifdef USE_VARIABLE_META_CHARS
! 3549: out:
! 3550: #endif
! 3551: *src = p;
! 3552: return tok->type;
! 3553: }
! 3554:
! 3555: static int
! 3556: add_ctype_to_cc_by_range(CClassNode* cc, int ctype, int not, OnigEncoding enc,
! 3557: const OnigCodePoint sbr[], const OnigCodePoint mbr[])
! 3558: {
! 3559: int i, r;
! 3560: OnigCodePoint j;
! 3561:
! 3562: int nsb = ONIGENC_CODE_RANGE_NUM(sbr);
! 3563: int nmb = ONIGENC_CODE_RANGE_NUM(mbr);
! 3564:
! 3565: if (not == 0) {
! 3566: for (i = 0; i < nsb; i++) {
! 3567: for (j = ONIGENC_CODE_RANGE_FROM(sbr, i);
! 3568: j <= ONIGENC_CODE_RANGE_TO(sbr, i); j++) {
! 3569: BITSET_SET_BIT(cc->bs, j);
! 3570: }
! 3571: }
! 3572:
! 3573: for (i = 0; i < nmb; i++) {
! 3574: r = add_code_range_to_buf(&(cc->mbuf),
! 3575: ONIGENC_CODE_RANGE_FROM(mbr, i),
! 3576: ONIGENC_CODE_RANGE_TO(mbr, i));
! 3577: if (r != 0) return r;
! 3578: }
! 3579: }
! 3580: else {
! 3581: OnigCodePoint prev = 0;
! 3582:
! 3583: if (ONIGENC_MBC_MINLEN(enc) == 1) {
! 3584: for (i = 0; i < nsb; i++) {
! 3585: for (j = prev;
! 3586: j < ONIGENC_CODE_RANGE_FROM(sbr, i); j++) {
! 3587: BITSET_SET_BIT(cc->bs, j);
! 3588: }
! 3589: prev = ONIGENC_CODE_RANGE_TO(sbr, i) + 1;
! 3590: }
! 3591: if (prev < 0x7f) {
! 3592: for (j = prev; j < 0x7f; j++) {
! 3593: BITSET_SET_BIT(cc->bs, j);
! 3594: }
! 3595: }
! 3596:
! 3597: prev = 0x80;
! 3598: }
! 3599:
! 3600: for (i = 0; i < nmb; i++) {
! 3601: if (prev < ONIGENC_CODE_RANGE_FROM(mbr, i)) {
! 3602: r = add_code_range_to_buf(&(cc->mbuf), prev,
! 3603: ONIGENC_CODE_RANGE_FROM(mbr, i) - 1);
! 3604: if (r != 0) return r;
! 3605: }
! 3606: prev = ONIGENC_CODE_RANGE_TO(mbr, i) + 1;
! 3607: }
! 3608: if (prev < 0x7fffffff) {
! 3609: r = add_code_range_to_buf(&(cc->mbuf), prev, 0x7fffffff);
! 3610: if (r != 0) return r;
! 3611: }
! 3612: }
! 3613:
! 3614: return 0;
! 3615: }
! 3616:
! 3617: static int
! 3618: add_ctype_to_cc(CClassNode* cc, int ctype, int not, ScanEnv* env)
! 3619: {
! 3620: int c, r;
! 3621: const OnigCodePoint *sbr, *mbr;
! 3622: OnigEncoding enc = env->enc;
! 3623:
! 3624: r = ONIGENC_GET_CTYPE_CODE_RANGE(enc, ctype, &sbr, &mbr);
! 3625: if (r == 0) {
! 3626: return add_ctype_to_cc_by_range(cc, ctype, not, env->enc, sbr, mbr);
! 3627: }
! 3628: else if (r != ONIG_NO_SUPPORT_CONFIG) {
! 3629: return r;
! 3630: }
! 3631:
! 3632: r = 0;
! 3633: switch (ctype) {
! 3634: case ONIGENC_CTYPE_ALPHA:
! 3635: case ONIGENC_CTYPE_BLANK:
! 3636: case ONIGENC_CTYPE_CNTRL:
! 3637: case ONIGENC_CTYPE_DIGIT:
! 3638: case ONIGENC_CTYPE_LOWER:
! 3639: case ONIGENC_CTYPE_PUNCT:
! 3640: case ONIGENC_CTYPE_SPACE:
! 3641: case ONIGENC_CTYPE_UPPER:
! 3642: case ONIGENC_CTYPE_XDIGIT:
! 3643: case ONIGENC_CTYPE_ASCII:
! 3644: case ONIGENC_CTYPE_ALNUM:
! 3645: if (not != 0) {
! 3646: for (c = 0; c < SINGLE_BYTE_SIZE; c++) {
! 3647: if (! ONIGENC_IS_CODE_CTYPE(enc, (OnigCodePoint )c, ctype))
! 3648: BITSET_SET_BIT(cc->bs, c);
! 3649: }
! 3650: ADD_ALL_MULTI_BYTE_RANGE(enc, cc->mbuf);
! 3651: }
! 3652: else {
! 3653: for (c = 0; c < SINGLE_BYTE_SIZE; c++) {
! 3654: if (ONIGENC_IS_CODE_CTYPE(enc, (OnigCodePoint )c, ctype))
! 3655: BITSET_SET_BIT(cc->bs, c);
! 3656: }
! 3657: }
! 3658: break;
! 3659:
! 3660: case ONIGENC_CTYPE_GRAPH:
! 3661: case ONIGENC_CTYPE_PRINT:
! 3662: if (not != 0) {
! 3663: for (c = 0; c < SINGLE_BYTE_SIZE; c++) {
! 3664: if (! ONIGENC_IS_CODE_CTYPE(enc, (OnigCodePoint )c, ctype))
! 3665: BITSET_SET_BIT(cc->bs, c);
! 3666: }
! 3667: }
! 3668: else {
! 3669: for (c = 0; c < SINGLE_BYTE_SIZE; c++) {
! 3670: if (ONIGENC_IS_CODE_CTYPE(enc, (OnigCodePoint )c, ctype))
! 3671: BITSET_SET_BIT(cc->bs, c);
! 3672: }
! 3673: ADD_ALL_MULTI_BYTE_RANGE(enc, cc->mbuf);
! 3674: }
! 3675: break;
! 3676:
! 3677: case ONIGENC_CTYPE_WORD:
! 3678: if (not == 0) {
! 3679: for (c = 0; c < SINGLE_BYTE_SIZE; c++) {
! 3680: if (ONIGENC_IS_CODE_SB_WORD(enc, c)) BITSET_SET_BIT(cc->bs, c);
! 3681: }
! 3682: ADD_ALL_MULTI_BYTE_RANGE(enc, cc->mbuf);
! 3683: }
! 3684: else {
! 3685: for (c = 0; c < SINGLE_BYTE_SIZE; c++) {
! 3686: if ((ONIGENC_CODE_TO_MBCLEN(enc, c) > 0) /* 0: invalid code point */
! 3687: && ! ONIGENC_IS_CODE_WORD(enc, c))
! 3688: BITSET_SET_BIT(cc->bs, c);
! 3689: }
! 3690: }
! 3691: break;
! 3692:
! 3693: default:
! 3694: return ONIGERR_PARSER_BUG;
! 3695: break;
! 3696: }
! 3697:
! 3698: return r;
! 3699: }
! 3700:
! 3701: static int
! 3702: parse_ctype_to_enc_ctype(int pctype, int* not)
! 3703: {
! 3704: int ctype;
! 3705:
! 3706: switch (pctype) {
! 3707: case CTYPE_WORD:
! 3708: ctype = ONIGENC_CTYPE_WORD;
! 3709: *not = 0;
! 3710: break;
! 3711: case CTYPE_NOT_WORD:
! 3712: ctype = ONIGENC_CTYPE_WORD;
! 3713: *not = 1;
! 3714: break;
! 3715: case CTYPE_WHITE_SPACE:
! 3716: ctype = ONIGENC_CTYPE_SPACE;
! 3717: *not = 0;
! 3718: break;
! 3719: case CTYPE_NOT_WHITE_SPACE:
! 3720: ctype = ONIGENC_CTYPE_SPACE;
! 3721: *not = 1;
! 3722: break;
! 3723: case CTYPE_DIGIT:
! 3724: ctype = ONIGENC_CTYPE_DIGIT;
! 3725: *not = 0;
! 3726: break;
! 3727: case CTYPE_NOT_DIGIT:
! 3728: ctype = ONIGENC_CTYPE_DIGIT;
! 3729: *not = 1;
! 3730: break;
! 3731: case CTYPE_XDIGIT:
! 3732: ctype = ONIGENC_CTYPE_XDIGIT;
! 3733: *not = 0;
! 3734: break;
! 3735: case CTYPE_NOT_XDIGIT:
! 3736: ctype = ONIGENC_CTYPE_XDIGIT;
! 3737: *not = 1;
! 3738: break;
! 3739: default:
! 3740: return ONIGERR_PARSER_BUG;
! 3741: break;
! 3742: }
! 3743: return ctype;
! 3744: }
! 3745:
! 3746: typedef struct {
! 3747: UChar *name;
! 3748: int ctype;
! 3749: short int len;
! 3750: } PosixBracketEntryType;
! 3751:
! 3752: static int
! 3753: parse_posix_bracket(CClassNode* cc, UChar** src, UChar* end, ScanEnv* env)
! 3754: {
! 3755: #define POSIX_BRACKET_CHECK_LIMIT_LENGTH 20
! 3756: #define POSIX_BRACKET_NAME_MAX_LEN 6
! 3757:
! 3758: static PosixBracketEntryType PBS[] = {
! 3759: { (UChar* )"alnum", ONIGENC_CTYPE_ALNUM, 5 },
! 3760: { (UChar* )"alpha", ONIGENC_CTYPE_ALPHA, 5 },
! 3761: { (UChar* )"blank", ONIGENC_CTYPE_BLANK, 5 },
! 3762: { (UChar* )"cntrl", ONIGENC_CTYPE_CNTRL, 5 },
! 3763: { (UChar* )"digit", ONIGENC_CTYPE_DIGIT, 5 },
! 3764: { (UChar* )"graph", ONIGENC_CTYPE_GRAPH, 5 },
! 3765: { (UChar* )"lower", ONIGENC_CTYPE_LOWER, 5 },
! 3766: { (UChar* )"print", ONIGENC_CTYPE_PRINT, 5 },
! 3767: { (UChar* )"punct", ONIGENC_CTYPE_PUNCT, 5 },
! 3768: { (UChar* )"space", ONIGENC_CTYPE_SPACE, 5 },
! 3769: { (UChar* )"upper", ONIGENC_CTYPE_UPPER, 5 },
! 3770: { (UChar* )"xdigit", ONIGENC_CTYPE_XDIGIT, 6 },
! 3771: { (UChar* )"ascii", ONIGENC_CTYPE_ASCII, 5 },
! 3772: { (UChar* )NULL, -1, 0 }
! 3773: };
! 3774:
! 3775: PosixBracketEntryType *pb;
! 3776: int not, i, r;
! 3777: OnigCodePoint c;
! 3778: OnigEncoding enc = env->enc;
! 3779: UChar *p = *src;
! 3780: PFETCH_READY;
! 3781:
! 3782: if (PPEEK_IS('^')) {
! 3783: PINC;
! 3784: not = 1;
! 3785: }
! 3786: else
! 3787: not = 0;
! 3788:
! 3789: if (onigenc_strlen(enc, p, end) < POSIX_BRACKET_NAME_MAX_LEN + 2)
! 3790: goto not_posix_bracket;
! 3791:
! 3792: for (pb = PBS; IS_NOT_NULL(pb->name); pb++) {
! 3793: if (onigenc_with_ascii_strncmp(enc, p, end, pb->name, pb->len) == 0) {
! 3794: p = (UChar* )onigenc_step(enc, p, end, pb->len);
! 3795: if (onigenc_with_ascii_strncmp(enc, p, end, (UChar* )":]", 2) != 0)
! 3796: return ONIGERR_INVALID_POSIX_BRACKET_TYPE;
! 3797:
! 3798: r = add_ctype_to_cc(cc, pb->ctype, not, env);
! 3799: if (r != 0) return r;
! 3800:
! 3801: PINC; PINC;
! 3802: *src = p;
! 3803: return 0;
! 3804: }
! 3805: }
! 3806:
! 3807: not_posix_bracket:
! 3808: c = 0;
! 3809: i = 0;
! 3810: while (!PEND && ((c = PPEEK) != ':') && c != ']') {
! 3811: PINC;
! 3812: if (++i > POSIX_BRACKET_CHECK_LIMIT_LENGTH) break;
! 3813: }
! 3814: if (c == ':' && ! PEND) {
! 3815: PINC;
! 3816: if (! PEND) {
! 3817: PFETCH(c);
! 3818: if (c == ']')
! 3819: return ONIGERR_INVALID_POSIX_BRACKET_TYPE;
! 3820: }
! 3821: }
! 3822:
! 3823: return 1; /* 1: is not POSIX bracket, but no error. */
! 3824: }
! 3825:
! 3826: static int
! 3827: property_name_to_ctype(UChar* p, UChar* end, OnigEncoding enc)
! 3828: {
! 3829: static PosixBracketEntryType PBS[] = {
! 3830: { (UChar* )"Alnum", ONIGENC_CTYPE_ALNUM, 5 },
! 3831: { (UChar* )"Alpha", ONIGENC_CTYPE_ALPHA, 5 },
! 3832: { (UChar* )"Blank", ONIGENC_CTYPE_BLANK, 5 },
! 3833: { (UChar* )"Cntrl", ONIGENC_CTYPE_CNTRL, 5 },
! 3834: { (UChar* )"Digit", ONIGENC_CTYPE_DIGIT, 5 },
! 3835: { (UChar* )"Graph", ONIGENC_CTYPE_GRAPH, 5 },
! 3836: { (UChar* )"Lower", ONIGENC_CTYPE_LOWER, 5 },
! 3837: { (UChar* )"Print", ONIGENC_CTYPE_PRINT, 5 },
! 3838: { (UChar* )"Punct", ONIGENC_CTYPE_PUNCT, 5 },
! 3839: { (UChar* )"Space", ONIGENC_CTYPE_SPACE, 5 },
! 3840: { (UChar* )"Upper", ONIGENC_CTYPE_UPPER, 5 },
! 3841: { (UChar* )"XDigit", ONIGENC_CTYPE_XDIGIT, 6 },
! 3842: { (UChar* )"ASCII", ONIGENC_CTYPE_ASCII, 5 },
! 3843: { (UChar* )NULL, -1, 0 }
! 3844: };
! 3845:
! 3846: PosixBracketEntryType *pb;
! 3847: int len;
! 3848:
! 3849: len = onigenc_strlen(enc, p, end);
! 3850: for (pb = PBS; IS_NOT_NULL(pb->name); pb++) {
! 3851: if (len == pb->len &&
! 3852: onigenc_with_ascii_strncmp(enc, p, end, pb->name, pb->len) == 0)
! 3853: return pb->ctype;
! 3854: }
! 3855:
! 3856: return -1;
! 3857: }
! 3858:
! 3859: static int
! 3860: fetch_char_property_to_ctype(UChar** src, UChar* end, ScanEnv* env)
! 3861: {
! 3862: int ctype;
! 3863: OnigCodePoint c;
! 3864: OnigEncoding enc = env->enc;
! 3865: UChar *prev, *start, *p = *src;
! 3866: PFETCH_READY;
! 3867:
! 3868: /* 'IsXXXX' => 'XXXX' */
! 3869: if (!PEND &&
! 3870: IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_CHAR_PROPERTY_PREFIX_IS)) {
! 3871: c = PPEEK;
! 3872: if (c == 'I') {
! 3873: PINC;
! 3874: if (! PEND) {
! 3875: c = PPEEK;
! 3876: if (c == 's')
! 3877: PINC;
! 3878: else
! 3879: PUNFETCH;
! 3880: }
! 3881: }
! 3882: }
! 3883:
! 3884: start = prev = p;
! 3885:
! 3886: while (!PEND) {
! 3887: prev = p;
! 3888: PFETCH(c);
! 3889: if (c == '}') {
! 3890: ctype = property_name_to_ctype(start, prev, enc);
! 3891: if (ctype < 0) break;
! 3892:
! 3893: *src = p;
! 3894: return ctype;
! 3895: }
! 3896: else if (c == '(' || c == ')' || c == '{' || c == '|')
! 3897: break;
! 3898: }
! 3899:
! 3900: onig_scan_env_set_error_string(env, ONIGERR_INVALID_CHAR_PROPERTY_NAME,
! 3901: *src, prev);
! 3902: return ONIGERR_INVALID_CHAR_PROPERTY_NAME;
! 3903: }
! 3904:
! 3905: static int
! 3906: parse_char_property(Node** np, OnigToken* tok, UChar** src, UChar* end,
! 3907: ScanEnv* env)
! 3908: {
! 3909: int r, ctype;
! 3910: CClassNode* cc;
! 3911:
! 3912: ctype = fetch_char_property_to_ctype(src, end, env);
! 3913: if (ctype < 0) return ctype;
! 3914:
! 3915: *np = node_new_cclass();
! 3916: CHECK_NULL_RETURN_VAL(*np, ONIGERR_MEMORY);
! 3917: cc = &(NCCLASS(*np));
! 3918: r = add_ctype_to_cc(cc, ctype, 0, env);
! 3919: if (r != 0) return r;
! 3920: if (tok->u.prop.not != 0) CCLASS_SET_NOT(cc);
! 3921:
! 3922: return 0;
! 3923: }
! 3924:
! 3925:
! 3926: enum CCSTATE {
! 3927: CCS_VALUE,
! 3928: CCS_RANGE,
! 3929: CCS_COMPLETE,
! 3930: CCS_START
! 3931: };
! 3932:
! 3933: enum CCVALTYPE {
! 3934: CCV_SB,
! 3935: CCV_CODE_POINT,
! 3936: CCV_CLASS
! 3937: };
! 3938:
! 3939: static int
! 3940: next_state_class(CClassNode* cc, OnigCodePoint* vs, enum CCVALTYPE* type,
! 3941: enum CCSTATE* state, ScanEnv* env)
! 3942: {
! 3943: int r;
! 3944:
! 3945: if (*state == CCS_RANGE)
! 3946: return ONIGERR_CHAR_CLASS_VALUE_AT_END_OF_RANGE;
! 3947:
! 3948: if (*state == CCS_VALUE && *type != CCV_CLASS) {
! 3949: if (*type == CCV_SB)
! 3950: BITSET_SET_BIT(cc->bs, (int )(*vs));
! 3951: else if (*type == CCV_CODE_POINT) {
! 3952: r = add_code_range(&(cc->mbuf), env, *vs, *vs);
! 3953: if (r < 0) return r;
! 3954: }
! 3955: }
! 3956:
! 3957: *state = CCS_VALUE;
! 3958: *type = CCV_CLASS;
! 3959: return 0;
! 3960: }
! 3961:
! 3962: static int
! 3963: next_state_val(CClassNode* cc, OnigCodePoint *vs, OnigCodePoint v,
! 3964: int* vs_israw, int v_israw,
! 3965: enum CCVALTYPE intype, enum CCVALTYPE* type,
! 3966: enum CCSTATE* state, ScanEnv* env)
! 3967: {
! 3968: int r;
! 3969:
! 3970: switch (*state) {
! 3971: case CCS_VALUE:
! 3972: if (*type == CCV_SB)
! 3973: BITSET_SET_BIT(cc->bs, (int )(*vs));
! 3974: else if (*type == CCV_CODE_POINT) {
! 3975: r = add_code_range(&(cc->mbuf), env, *vs, *vs);
! 3976: if (r < 0) return r;
! 3977: }
! 3978: break;
! 3979:
! 3980: case CCS_RANGE:
! 3981: if (intype == *type) {
! 3982: if (intype == CCV_SB) {
! 3983: if (*vs > 0xff || v > 0xff)
! 3984: return ONIGERR_INVALID_WIDE_CHAR_VALUE;
! 3985:
! 3986: if (*vs > v) {
! 3987: if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_EMPTY_RANGE_IN_CC))
! 3988: goto ccs_range_end;
! 3989: else
! 3990: return ONIGERR_EMPTY_RANGE_IN_CHAR_CLASS;
! 3991: }
! 3992: bitset_set_range(cc->bs, (int )*vs, (int )v);
! 3993: }
! 3994: else {
! 3995: r = add_code_range(&(cc->mbuf), env, *vs, v);
! 3996: if (r < 0) return r;
! 3997: }
! 3998: }
! 3999: else {
! 4000: #if 0
! 4001: if (intype == CCV_CODE_POINT && *type == CCV_SB) {
! 4002: #endif
! 4003: if (*vs > v) {
! 4004: if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_EMPTY_RANGE_IN_CC))
! 4005: goto ccs_range_end;
! 4006: else
! 4007: return ONIGERR_EMPTY_RANGE_IN_CHAR_CLASS;
! 4008: }
! 4009: bitset_set_range(cc->bs, (int )*vs, (int )(v < 0xff ? v : 0xff));
! 4010: r = add_code_range(&(cc->mbuf), env, (OnigCodePoint )*vs, v);
! 4011: if (r < 0) return r;
! 4012: #if 0
! 4013: }
! 4014: else
! 4015: return ONIGERR_MISMATCH_CODE_LENGTH_IN_CLASS_RANGE;
! 4016: #endif
! 4017: }
! 4018: ccs_range_end:
! 4019: *state = CCS_COMPLETE;
! 4020: break;
! 4021:
! 4022: case CCS_COMPLETE:
! 4023: case CCS_START:
! 4024: *state = CCS_VALUE;
! 4025: break;
! 4026:
! 4027: default:
! 4028: break;
! 4029: }
! 4030:
! 4031: *vs_israw = v_israw;
! 4032: *vs = v;
! 4033: *type = intype;
! 4034: return 0;
! 4035: }
! 4036:
! 4037: static int
! 4038: code_exist_check(OnigCodePoint c, UChar* from, UChar* end, int ignore_escaped,
! 4039: OnigEncoding enc)
! 4040: {
! 4041: int in_esc;
! 4042: OnigCodePoint code;
! 4043: UChar* p = from;
! 4044: PFETCH_READY;
! 4045:
! 4046: in_esc = 0;
! 4047: while (! PEND) {
! 4048: if (ignore_escaped && in_esc) {
! 4049: in_esc = 0;
! 4050: }
! 4051: else {
! 4052: PFETCH(code);
! 4053: if (code == c) return 1;
! 4054: if (code == MC_ESC(enc)) in_esc = 1;
! 4055: }
! 4056: }
! 4057: return 0;
! 4058: }
! 4059:
! 4060: static int
! 4061: parse_char_class(Node** np, OnigToken* tok, UChar** src, UChar* end,
! 4062: ScanEnv* env)
! 4063: {
! 4064: int r, neg, len, fetched, and_start;
! 4065: OnigCodePoint v, vs;
! 4066: UChar *p;
! 4067: Node* node;
! 4068: CClassNode *cc, *prev_cc;
! 4069: CClassNode work_cc;
! 4070:
! 4071: enum CCSTATE state;
! 4072: enum CCVALTYPE val_type, in_type;
! 4073: int val_israw, in_israw;
! 4074:
! 4075: prev_cc = (CClassNode* )NULL;
! 4076: *np = NULL_NODE;
! 4077: r = fetch_token_in_cc(tok, src, end, env);
! 4078: if (r == TK_CHAR && tok->u.c == '^' && tok->escaped == 0) {
! 4079: neg = 1;
! 4080: r = fetch_token_in_cc(tok, src, end, env);
! 4081: }
! 4082: else {
! 4083: neg = 0;
! 4084: }
! 4085:
! 4086: if (r < 0) return r;
! 4087: if (r == TK_CC_CLOSE) {
! 4088: if (! code_exist_check((OnigCodePoint )']',
! 4089: *src, env->pattern_end, 1, env->enc))
! 4090: return ONIGERR_EMPTY_CHAR_CLASS;
! 4091:
! 4092: CC_ESC_WARN(env, (UChar* )"]");
! 4093: r = tok->type = TK_CHAR; /* allow []...] */
! 4094: }
! 4095:
! 4096: *np = node = node_new_cclass();
! 4097: CHECK_NULL_RETURN_VAL(node, ONIGERR_MEMORY);
! 4098: cc = &(NCCLASS(node));
! 4099:
! 4100: and_start = 0;
! 4101: state = CCS_START;
! 4102: p = *src;
! 4103: while (r != TK_CC_CLOSE) {
! 4104: fetched = 0;
! 4105: switch (r) {
! 4106: case TK_CHAR:
! 4107: len = ONIGENC_CODE_TO_MBCLEN(env->enc, tok->u.c);
! 4108: if (len > 1) {
! 4109: in_type = CCV_CODE_POINT;
! 4110: }
! 4111: else {
! 4112: sb_char:
! 4113: in_type = CCV_SB;
! 4114: }
! 4115: v = (OnigCodePoint )tok->u.c;
! 4116: in_israw = 0;
! 4117: goto val_entry2;
! 4118: break;
! 4119:
! 4120: case TK_RAW_BYTE:
! 4121: /* tok->base != 0 : octal or hexadec. */
! 4122: if (! ONIGENC_IS_SINGLEBYTE(env->enc) && tok->base != 0) {
! 4123: UChar buf[ONIGENC_CODE_TO_MBC_MAXLEN];
! 4124: UChar* bufe = buf + ONIGENC_CODE_TO_MBC_MAXLEN;
! 4125: UChar* psave = p;
! 4126: int i, base = tok->base;
! 4127:
! 4128: buf[0] = tok->u.c;
! 4129: for (i = 1; i < ONIGENC_MBC_MAXLEN(env->enc); i++) {
! 4130: r = fetch_token_in_cc(tok, &p, end, env);
! 4131: if (r < 0) goto err;
! 4132: if (r != TK_RAW_BYTE || tok->base != base) {
! 4133: fetched = 1;
! 4134: break;
! 4135: }
! 4136: buf[i] = tok->u.c;
! 4137: }
! 4138:
! 4139: if (i < ONIGENC_MBC_MINLEN(env->enc)) {
! 4140: r = ONIGERR_TOO_SHORT_MULTI_BYTE_STRING;
! 4141: goto err;
! 4142: }
! 4143:
! 4144: len = enc_len(env->enc, buf);
! 4145: if (i < len) {
! 4146: r = ONIGERR_TOO_SHORT_MULTI_BYTE_STRING;
! 4147: goto err;
! 4148: }
! 4149: else if (i > len) { /* fetch back */
! 4150: p = psave;
! 4151: for (i = 1; i < len; i++) {
! 4152: r = fetch_token_in_cc(tok, &p, end, env);
! 4153: }
! 4154: fetched = 0;
! 4155: }
! 4156:
! 4157: if (i == 1) {
! 4158: v = (OnigCodePoint )buf[0];
! 4159: goto raw_single;
! 4160: }
! 4161: else {
! 4162: v = ONIGENC_MBC_TO_CODE(env->enc, buf, bufe);
! 4163: in_type = CCV_CODE_POINT;
! 4164: }
! 4165: }
! 4166: else {
! 4167: v = (OnigCodePoint )tok->u.c;
! 4168: raw_single:
! 4169: in_type = CCV_SB;
! 4170: }
! 4171: in_israw = 1;
! 4172: goto val_entry2;
! 4173: break;
! 4174:
! 4175: case TK_CODE_POINT:
! 4176: v = tok->u.code;
! 4177: in_israw = 1;
! 4178: val_entry:
! 4179: len = ONIGENC_CODE_TO_MBCLEN(env->enc, v);
! 4180: if (len < 0) {
! 4181: r = len;
! 4182: goto err;
! 4183: }
! 4184: in_type = (len == 1 ? CCV_SB : CCV_CODE_POINT);
! 4185: val_entry2:
! 4186: r = next_state_val(cc, &vs, v, &val_israw, in_israw, in_type, &val_type,
! 4187: &state, env);
! 4188: if (r != 0) goto err;
! 4189: break;
! 4190:
! 4191: case TK_POSIX_BRACKET_OPEN:
! 4192: r = parse_posix_bracket(cc, &p, end, env);
! 4193: if (r < 0) goto err;
! 4194: if (r == 1) { /* is not POSIX bracket */
! 4195: CC_ESC_WARN(env, (UChar* )"[");
! 4196: p = tok->backp;
! 4197: v = (OnigCodePoint )tok->u.c;
! 4198: in_israw = 0;
! 4199: goto val_entry;
! 4200: }
! 4201: goto next_class;
! 4202: break;
! 4203:
! 4204: case TK_CHAR_TYPE:
! 4205: {
! 4206: int ctype, not;
! 4207: ctype = parse_ctype_to_enc_ctype(tok->u.subtype, ¬);
! 4208: r = add_ctype_to_cc(cc, ctype, not, env);
! 4209: if (r != 0) return r;
! 4210: }
! 4211:
! 4212: next_class:
! 4213: r = next_state_class(cc, &vs, &val_type, &state, env);
! 4214: if (r != 0) goto err;
! 4215: break;
! 4216:
! 4217: case TK_CHAR_PROPERTY:
! 4218: {
! 4219: int ctype;
! 4220:
! 4221: ctype = fetch_char_property_to_ctype(&p, end, env);
! 4222: if (ctype < 0) return ctype;
! 4223: r = add_ctype_to_cc(cc, ctype, tok->u.prop.not, env);
! 4224: if (r != 0) return r;
! 4225: goto next_class;
! 4226: }
! 4227: break;
! 4228:
! 4229: case TK_CC_RANGE:
! 4230: if (state == CCS_VALUE) {
! 4231: r = fetch_token_in_cc(tok, &p, end, env);
! 4232: if (r < 0) goto err;
! 4233: fetched = 1;
! 4234: if (r == TK_CC_CLOSE) { /* allow [x-] */
! 4235: range_end_val:
! 4236: v = (OnigCodePoint )'-';
! 4237: in_israw = 0;
! 4238: goto val_entry;
! 4239: }
! 4240: else if (r == TK_CC_AND) {
! 4241: CC_ESC_WARN(env, (UChar* )"-");
! 4242: goto range_end_val;
! 4243: }
! 4244: state = CCS_RANGE;
! 4245: }
! 4246: else if (state == CCS_START) {
! 4247: /* [-xa] is allowed */
! 4248: v = (OnigCodePoint )tok->u.c;
! 4249: in_israw = 0;
! 4250:
! 4251: r = fetch_token_in_cc(tok, &p, end, env);
! 4252: if (r < 0) goto err;
! 4253: fetched = 1;
! 4254: /* [--x] or [a&&-x] is warned. */
! 4255: if (r == TK_CC_RANGE || and_start != 0)
! 4256: CC_ESC_WARN(env, (UChar* )"-");
! 4257:
! 4258: goto val_entry;
! 4259: }
! 4260: else if (state == CCS_RANGE) {
! 4261: CC_ESC_WARN(env, (UChar* )"-");
! 4262: goto sb_char; /* [!--x] is allowed */
! 4263: }
! 4264: else { /* CCS_COMPLETE */
! 4265: r = fetch_token_in_cc(tok, &p, end, env);
! 4266: if (r < 0) goto err;
! 4267: fetched = 1;
! 4268: if (r == TK_CC_CLOSE) goto range_end_val; /* allow [a-b-] */
! 4269: else if (r == TK_CC_AND) {
! 4270: CC_ESC_WARN(env, (UChar* )"-");
! 4271: goto range_end_val;
! 4272: }
! 4273:
! 4274: if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_DOUBLE_RANGE_OP_IN_CC)) {
! 4275: CC_ESC_WARN(env, (UChar* )"-");
! 4276: goto sb_char; /* [0-9-a] is allowed as [0-9\-a] */
! 4277: }
! 4278: r = ONIGERR_UNMATCHED_RANGE_SPECIFIER_IN_CHAR_CLASS;
! 4279: goto err;
! 4280: }
! 4281: break;
! 4282:
! 4283: case TK_CC_CC_OPEN: /* [ */
! 4284: {
! 4285: Node *anode;
! 4286: CClassNode* acc;
! 4287:
! 4288: r = parse_char_class(&anode, tok, &p, end, env);
! 4289: if (r != 0) goto cc_open_err;
! 4290: acc = &(NCCLASS(anode));
! 4291: r = or_cclass(cc, acc, env->enc);
! 4292:
! 4293: onig_node_free(anode);
! 4294: cc_open_err:
! 4295: if (r != 0) goto err;
! 4296: }
! 4297: break;
! 4298:
! 4299: case TK_CC_AND: /* && */
! 4300: {
! 4301: if (state == CCS_VALUE) {
! 4302: r = next_state_val(cc, &vs, 0, &val_israw, 0, val_type,
! 4303: &val_type, &state, env);
! 4304: if (r != 0) goto err;
! 4305: }
! 4306: /* initialize local variables */
! 4307: and_start = 1;
! 4308: state = CCS_START;
! 4309:
! 4310: if (IS_NOT_NULL(prev_cc)) {
! 4311: r = and_cclass(prev_cc, cc, env->enc);
! 4312: if (r != 0) goto err;
! 4313: bbuf_free(cc->mbuf);
! 4314: }
! 4315: else {
! 4316: prev_cc = cc;
! 4317: cc = &work_cc;
! 4318: }
! 4319: initialize_cclass(cc);
! 4320: }
! 4321: break;
! 4322:
! 4323: case TK_EOT:
! 4324: r = ONIGERR_PREMATURE_END_OF_CHAR_CLASS;
! 4325: goto err;
! 4326: break;
! 4327: default:
! 4328: r = ONIGERR_PARSER_BUG;
! 4329: goto err;
! 4330: break;
! 4331: }
! 4332:
! 4333: if (fetched)
! 4334: r = tok->type;
! 4335: else {
! 4336: r = fetch_token_in_cc(tok, &p, end, env);
! 4337: if (r < 0) goto err;
! 4338: }
! 4339: }
! 4340:
! 4341: if (state == CCS_VALUE) {
! 4342: r = next_state_val(cc, &vs, 0, &val_israw, 0, val_type,
! 4343: &val_type, &state, env);
! 4344: if (r != 0) goto err;
! 4345: }
! 4346:
! 4347: if (IS_NOT_NULL(prev_cc)) {
! 4348: r = and_cclass(prev_cc, cc, env->enc);
! 4349: if (r != 0) goto err;
! 4350: bbuf_free(cc->mbuf);
! 4351: cc = prev_cc;
! 4352: }
! 4353:
! 4354: if (neg != 0)
! 4355: CCLASS_SET_NOT(cc);
! 4356: else
! 4357: CCLASS_CLEAR_NOT(cc);
! 4358: if (IS_CCLASS_NOT(cc) &&
! 4359: IS_SYNTAX_BV(env->syntax, ONIG_SYN_NOT_NEWLINE_IN_NEGATIVE_CC)) {
! 4360: int is_empty;
! 4361:
! 4362: is_empty = (IS_NULL(cc->mbuf) ? 1 : 0);
! 4363: if (is_empty != 0)
! 4364: BITSET_IS_EMPTY(cc->bs, is_empty);
! 4365:
! 4366: if (is_empty == 0) {
! 4367: #define NEWLINE_CODE 0x0a
! 4368:
! 4369: if (ONIGENC_IS_CODE_NEWLINE(env->enc, NEWLINE_CODE)) {
! 4370: if (ONIGENC_CODE_TO_MBCLEN(env->enc, NEWLINE_CODE) == 1)
! 4371: BITSET_SET_BIT(cc->bs, NEWLINE_CODE);
! 4372: else
! 4373: add_code_range(&(cc->mbuf), env, NEWLINE_CODE, NEWLINE_CODE);
! 4374: }
! 4375: }
! 4376: }
! 4377: *src = p;
! 4378: return 0;
! 4379:
! 4380: err:
! 4381: if (cc != &(NCCLASS(*np)))
! 4382: bbuf_free(cc->mbuf);
! 4383: onig_node_free(*np);
! 4384: return r;
! 4385: }
! 4386:
! 4387: static int parse_subexp(Node** top, OnigToken* tok, int term,
! 4388: UChar** src, UChar* end, ScanEnv* env);
! 4389:
! 4390: static int
! 4391: parse_effect(Node** np, OnigToken* tok, int term, UChar** src, UChar* end,
! 4392: ScanEnv* env)
! 4393: {
! 4394: int r, num;
! 4395: int list_capture;
! 4396: Node *target;
! 4397: OnigOptionType option;
! 4398: OnigEncoding enc = env->enc;
! 4399: OnigCodePoint c;
! 4400: UChar* p = *src;
! 4401: PFETCH_READY;
! 4402:
! 4403: *np = NULL;
! 4404: if (PEND) return ONIGERR_END_PATTERN_WITH_UNMATCHED_PARENTHESIS;
! 4405:
! 4406: option = env->option;
! 4407: if (PPEEK_IS('?') &&
! 4408: IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_GROUP_EFFECT)) {
! 4409: PINC;
! 4410: if (PEND) return ONIGERR_END_PATTERN_IN_GROUP;
! 4411:
! 4412: PFETCH(c);
! 4413: switch (c) {
! 4414: case ':': /* (?:...) grouping only */
! 4415: group:
! 4416: r = fetch_token(tok, &p, end, env);
! 4417: if (r < 0) return r;
! 4418: r = parse_subexp(np, tok, term, &p, end, env);
! 4419: if (r < 0) return r;
! 4420: *src = p;
! 4421: return 1; /* group */
! 4422: break;
! 4423:
! 4424: case '=':
! 4425: *np = onig_node_new_anchor(ANCHOR_PREC_READ);
! 4426: break;
! 4427: case '!': /* preceding read */
! 4428: *np = onig_node_new_anchor(ANCHOR_PREC_READ_NOT);
! 4429: break;
! 4430: case '>': /* (?>...) stop backtrack */
! 4431: *np = node_new_effect(EFFECT_STOP_BACKTRACK);
! 4432: break;
! 4433:
! 4434: case '<': /* look behind (?<=...), (?<!...) */
! 4435: PFETCH(c);
! 4436: if (c == '=')
! 4437: *np = onig_node_new_anchor(ANCHOR_LOOK_BEHIND);
! 4438: else if (c == '!')
! 4439: *np = onig_node_new_anchor(ANCHOR_LOOK_BEHIND_NOT);
! 4440: #ifdef USE_NAMED_GROUP
! 4441: else if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_LT_NAMED_GROUP)) {
! 4442: UChar *name;
! 4443: UChar *name_end;
! 4444:
! 4445: PUNFETCH;
! 4446: list_capture = 0;
! 4447:
! 4448: named_group:
! 4449: name = p;
! 4450: r = fetch_name(&p, end, &name_end, env, 0);
! 4451: if (r < 0) return r;
! 4452:
! 4453: num = scan_env_add_mem_entry(env);
! 4454: if (num < 0) return num;
! 4455: if (list_capture != 0 && num >= BIT_STATUS_BITS_NUM)
! 4456: return ONIGERR_GROUP_NUMBER_OVER_FOR_CAPTURE_HISTORY;
! 4457:
! 4458: r = name_add(env->reg, name, name_end, num, env);
! 4459: if (r != 0) return r;
! 4460: *np = node_new_effect_memory(env->option, 1);
! 4461: CHECK_NULL_RETURN_VAL(*np, ONIGERR_MEMORY);
! 4462: NEFFECT(*np).regnum = num;
! 4463: if (list_capture != 0)
! 4464: BIT_STATUS_ON_AT_SIMPLE(env->capture_history, num);
! 4465: env->num_named++;
! 4466: }
! 4467: #endif
! 4468: else
! 4469: return ONIGERR_UNDEFINED_GROUP_OPTION;
! 4470: break;
! 4471:
! 4472: case '@':
! 4473: if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_ATMARK_CAPTURE_HISTORY)) {
! 4474: #ifdef USE_NAMED_GROUP
! 4475: if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_QMARK_LT_NAMED_GROUP)) {
! 4476: PFETCH(c);
! 4477: if (c == '<') {
! 4478: list_capture = 1;
! 4479: goto named_group; /* (?@<name>...) */
! 4480: }
! 4481: PUNFETCH;
! 4482: }
! 4483: #endif
! 4484: *np = node_new_effect_memory(env->option, 0);
! 4485: CHECK_NULL_RETURN_VAL(*np, ONIGERR_MEMORY);
! 4486: num = scan_env_add_mem_entry(env);
! 4487: if (num < 0) {
! 4488: onig_node_free(*np);
! 4489: return num;
! 4490: }
! 4491: else if (num >= BIT_STATUS_BITS_NUM) {
! 4492: onig_node_free(*np);
! 4493: return ONIGERR_GROUP_NUMBER_OVER_FOR_CAPTURE_HISTORY;
! 4494: }
! 4495: NEFFECT(*np).regnum = num;
! 4496: BIT_STATUS_ON_AT_SIMPLE(env->capture_history, num);
! 4497: }
! 4498: else {
! 4499: return ONIGERR_UNDEFINED_GROUP_OPTION;
! 4500: }
! 4501: break;
! 4502:
! 4503: #ifdef USE_POSIXLINE_OPTION
! 4504: case 'p':
! 4505: #endif
! 4506: case '-': case 'i': case 'm': case 's': case 'x':
! 4507: {
! 4508: int neg = 0;
! 4509:
! 4510: while (1) {
! 4511: switch (c) {
! 4512: case ':':
! 4513: case ')':
! 4514: break;
! 4515:
! 4516: case '-': neg = 1; break;
! 4517: case 'x': ONOFF(option, ONIG_OPTION_EXTEND, neg); break;
! 4518: case 'i': ONOFF(option, ONIG_OPTION_IGNORECASE, neg); break;
! 4519: case 's':
! 4520: if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_PERL)) {
! 4521: ONOFF(option, ONIG_OPTION_MULTILINE, neg);
! 4522: }
! 4523: else
! 4524: return ONIGERR_UNDEFINED_GROUP_OPTION;
! 4525: break;
! 4526:
! 4527: case 'm':
! 4528: if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_PERL)) {
! 4529: ONOFF(option, ONIG_OPTION_SINGLELINE, (neg == 0 ? 1 : 0));
! 4530: }
! 4531: else if (IS_SYNTAX_OP2(env->syntax, ONIG_SYN_OP2_OPTION_RUBY)) {
! 4532: ONOFF(option, ONIG_OPTION_MULTILINE, neg);
! 4533: }
! 4534: else
! 4535: return ONIGERR_UNDEFINED_GROUP_OPTION;
! 4536: break;
! 4537: #ifdef USE_POSIXLINE_OPTION
! 4538: case 'p':
! 4539: ONOFF(option, ONIG_OPTION_MULTILINE|ONIG_OPTION_SINGLELINE, neg);
! 4540: break;
! 4541: #endif
! 4542: default:
! 4543: return ONIGERR_UNDEFINED_GROUP_OPTION;
! 4544: }
! 4545:
! 4546: if (c == ')') {
! 4547: *np = node_new_option(option);
! 4548: CHECK_NULL_RETURN_VAL(*np, ONIGERR_MEMORY);
! 4549: *src = p;
! 4550: return 2; /* option only */
! 4551: }
! 4552: else if (c == ':') {
! 4553: OnigOptionType prev = env->option;
! 4554:
! 4555: env->option = option;
! 4556: r = fetch_token(tok, &p, end, env);
! 4557: if (r < 0) return r;
! 4558: r = parse_subexp(&target, tok, term, &p, end, env);
! 4559: env->option = prev;
! 4560: if (r < 0) return r;
! 4561: *np = node_new_option(option);
! 4562: CHECK_NULL_RETURN_VAL(*np, ONIGERR_MEMORY);
! 4563: NEFFECT(*np).target = target;
! 4564: *src = p;
! 4565: return 0;
! 4566: }
! 4567:
! 4568: if (PEND) return ONIGERR_END_PATTERN_IN_GROUP;
! 4569: PFETCH(c);
! 4570: }
! 4571: }
! 4572: break;
! 4573:
! 4574: default:
! 4575: return ONIGERR_UNDEFINED_GROUP_OPTION;
! 4576: }
! 4577: }
! 4578: else {
! 4579: if (ONIG_IS_OPTION_ON(env->option, ONIG_OPTION_DONT_CAPTURE_GROUP))
! 4580: goto group;
! 4581:
! 4582: *np = node_new_effect_memory(env->option, 0);
! 4583: CHECK_NULL_RETURN_VAL(*np, ONIGERR_MEMORY);
! 4584: num = scan_env_add_mem_entry(env);
! 4585: if (num < 0) return num;
! 4586: NEFFECT(*np).regnum = num;
! 4587: }
! 4588:
! 4589: CHECK_NULL_RETURN_VAL(*np, ONIGERR_MEMORY);
! 4590: r = fetch_token(tok, &p, end, env);
! 4591: if (r < 0) return r;
! 4592: r = parse_subexp(&target, tok, term, &p, end, env);
! 4593: if (r < 0) return r;
! 4594:
! 4595: if (NTYPE(*np) == N_ANCHOR)
! 4596: NANCHOR(*np).target = target;
! 4597: else {
! 4598: NEFFECT(*np).target = target;
! 4599: if (NEFFECT(*np).type == EFFECT_MEMORY) {
! 4600: /* Don't move this to previous of parse_subexp() */
! 4601: r = scan_env_set_mem_node(env, NEFFECT(*np).regnum, *np);
! 4602: if (r != 0) return r;
! 4603: }
! 4604: }
! 4605:
! 4606: *src = p;
! 4607: return 0;
! 4608: }
! 4609:
! 4610: static const char* PopularQStr[] = {
! 4611: "?", "*", "+", "??", "*?", "+?"
! 4612: };
! 4613:
! 4614: static const char* ReduceQStr[] = {
! 4615: "", "", "*", "*?", "??", "+ and ??", "+? and ?"
! 4616: };
! 4617:
! 4618: static int
! 4619: set_quantifier(Node* qnode, Node* target, int group, ScanEnv* env)
! 4620: {
! 4621: QuantifierNode* qn;
! 4622:
! 4623: qn = &(NQUANTIFIER(qnode));
! 4624: if (qn->lower == 1 && qn->upper == 1) {
! 4625: return 1;
! 4626: }
! 4627:
! 4628: switch (NTYPE(target)) {
! 4629: case N_STRING:
! 4630: if (! group) {
! 4631: StrNode* sn = &(NSTRING(target));
! 4632: if (str_node_can_be_split(sn, env->enc)) {
! 4633: Node* n = str_node_split_last_char(sn, env->enc);
! 4634: if (IS_NOT_NULL(n)) {
! 4635: qn->target = n;
! 4636: return 2;
! 4637: }
! 4638: }
! 4639: }
! 4640: break;
! 4641:
! 4642: case N_QUANTIFIER:
! 4643: { /* check redundant double repeat. */
! 4644: /* verbose warn (?:.?)? etc... but not warn (.?)? etc... */
! 4645: QuantifierNode* qnt = &(NQUANTIFIER(target));
! 4646: int nestq_num = popular_quantifier_num(qn);
! 4647: int targetq_num = popular_quantifier_num(qnt);
! 4648:
! 4649: #ifdef USE_WARNING_REDUNDANT_NESTED_REPEAT_OPERATOR
! 4650: if (!IS_QUANTIFIER_BY_NUMBER(qn) && !IS_QUANTIFIER_BY_NUMBER(qnt) &&
! 4651: IS_SYNTAX_BV(env->syntax, ONIG_SYN_WARN_REDUNDANT_NESTED_REPEAT)) {
! 4652: UChar buf[WARN_BUFSIZE];
! 4653:
! 4654: switch(ReduceTypeTable[targetq_num][nestq_num]) {
! 4655: case RQ_ASIS:
! 4656: break;
! 4657:
! 4658: case RQ_DEL:
! 4659: if (onig_verb_warn != onig_null_warn) {
! 4660: onig_snprintf_with_pattern(buf, WARN_BUFSIZE, env->enc,
! 4661: env->pattern, env->pattern_end,
! 4662: (UChar* )"redundant nested repeat operator");
! 4663: (*onig_verb_warn)((char* )buf);
! 4664: }
! 4665: goto warn_exit;
! 4666: break;
! 4667:
! 4668: default:
! 4669: if (onig_verb_warn != onig_null_warn) {
! 4670: onig_snprintf_with_pattern(buf, WARN_BUFSIZE, env->enc,
! 4671: env->pattern, env->pattern_end,
! 4672: (UChar* )"nested repeat operator %s and %s was replaced with '%s'",
! 4673: PopularQStr[targetq_num], PopularQStr[nestq_num],
! 4674: ReduceQStr[ReduceTypeTable[targetq_num][nestq_num]]);
! 4675: (*onig_verb_warn)((char* )buf);
! 4676: }
! 4677: goto warn_exit;
! 4678: break;
! 4679: }
! 4680: }
! 4681:
! 4682: warn_exit:
! 4683: #endif
! 4684: if (targetq_num >= 0) {
! 4685: if (nestq_num >= 0) {
! 4686: onig_reduce_nested_quantifier(qnode, target);
! 4687: goto q_exit;
! 4688: }
! 4689: else if (targetq_num == 1 || targetq_num == 2) { /* * or + */
! 4690: /* (?:a*){n,m}, (?:a+){n,m} => (?:a*){n,n}, (?:a+){n,n} */
! 4691: if (! IS_REPEAT_INFINITE(qn->upper) && qn->upper > 1 && qn->greedy) {
! 4692: qn->upper = (qn->lower == 0 ? 1 : qn->lower);
! 4693: }
! 4694: }
! 4695: }
! 4696: }
! 4697: break;
! 4698:
! 4699: default:
! 4700: break;
! 4701: }
! 4702:
! 4703: qn->target = target;
! 4704: q_exit:
! 4705: return 0;
! 4706: }
! 4707:
! 4708: #ifdef USE_SHARED_CCLASS_TABLE
! 4709:
! 4710: #define THRESHOLD_RANGE_NUM_FOR_SHARE_CCLASS 8
! 4711:
! 4712: /* for ctype node hash table */
! 4713:
! 4714: typedef struct {
! 4715: OnigEncoding enc;
! 4716: int not;
! 4717: int type;
! 4718: } type_cclass_key;
! 4719:
! 4720: static int type_cclass_cmp(type_cclass_key* x, type_cclass_key* y)
! 4721: {
! 4722: if (x->type != y->type) return 1;
! 4723: if (x->enc != y->enc) return 1;
! 4724: if (x->not != y->not) return 1;
! 4725: return 0;
! 4726: }
! 4727:
! 4728: static int type_cclass_hash(type_cclass_key* key)
! 4729: {
! 4730: int i, val;
! 4731: unsigned char *p;
! 4732:
! 4733: val = 0;
! 4734:
! 4735: p = (unsigned char* )&(key->enc);
! 4736: for (i = 0; i < sizeof(key->enc); i++) {
! 4737: val = val * 997 + (int )*p++;
! 4738: }
! 4739:
! 4740: p = (unsigned char* )(&key->type);
! 4741: for (i = 0; i < sizeof(key->type); i++) {
! 4742: val = val * 997 + (int )*p++;
! 4743: }
! 4744:
! 4745: val += key->not;
! 4746: return val + (val >> 5);
! 4747: }
! 4748:
! 4749: static struct st_hash_type type_type_cclass_hash = {
! 4750: type_cclass_cmp,
! 4751: type_cclass_hash,
! 4752: };
! 4753:
! 4754: static st_table* OnigTypeCClassTable;
! 4755:
! 4756:
! 4757: static int
! 4758: i_free_shared_class(type_cclass_key* key, Node* node, void* arg)
! 4759: {
! 4760: if (IS_NOT_NULL(node)) {
! 4761: CClassNode* cc = &(NCCLASS(node));
! 4762: if (IS_NOT_NULL(cc->mbuf)) xfree(cc->mbuf);
! 4763: xfree(node);
! 4764: }
! 4765:
! 4766: if (IS_NOT_NULL(key)) xfree(key);
! 4767: return ST_DELETE;
! 4768: }
! 4769:
! 4770: extern int
! 4771: onig_free_shared_cclass_table(void)
! 4772: {
! 4773: if (IS_NOT_NULL(OnigTypeCClassTable)) {
! 4774: onig_st_foreach(OnigTypeCClassTable, i_free_shared_class, 0);
! 4775: onig_st_free_table(OnigTypeCClassTable);
! 4776: OnigTypeCClassTable = NULL;
! 4777: }
! 4778:
! 4779: return 0;
! 4780: }
! 4781:
! 4782: #endif /* USE_SHARED_CCLASS_TABLE */
! 4783:
! 4784:
! 4785: static int
! 4786: parse_exp(Node** np, OnigToken* tok, int term,
! 4787: UChar** src, UChar* end, ScanEnv* env)
! 4788: {
! 4789: int r, len, group = 0;
! 4790: Node* qn;
! 4791: Node** targetp;
! 4792:
! 4793: *np = NULL;
! 4794: if (tok->type == term)
! 4795: goto end_of_token;
! 4796:
! 4797: switch (tok->type) {
! 4798: case TK_ALT:
! 4799: case TK_EOT:
! 4800: end_of_token:
! 4801: *np = node_new_empty();
! 4802: return tok->type;
! 4803: break;
! 4804:
! 4805: case TK_SUBEXP_OPEN:
! 4806: r = parse_effect(np, tok, TK_SUBEXP_CLOSE, src, end, env);
! 4807: if (r < 0) return r;
! 4808: if (r == 1) group = 1;
! 4809: else if (r == 2) { /* option only */
! 4810: Node* target;
! 4811: OnigOptionType prev = env->option;
! 4812:
! 4813: env->option = NEFFECT(*np).option;
! 4814: r = fetch_token(tok, src, end, env);
! 4815: if (r < 0) return r;
! 4816: r = parse_subexp(&target, tok, term, src, end, env);
! 4817: env->option = prev;
! 4818: if (r < 0) return r;
! 4819: NEFFECT(*np).target = target;
! 4820: return tok->type;
! 4821: }
! 4822: break;
! 4823:
! 4824: case TK_SUBEXP_CLOSE:
! 4825: if (! IS_SYNTAX_BV(env->syntax, ONIG_SYN_ALLOW_UNMATCHED_CLOSE_SUBEXP))
! 4826: return ONIGERR_UNMATCHED_CLOSE_PARENTHESIS;
! 4827:
! 4828: if (tok->escaped) goto tk_raw_byte;
! 4829: else goto tk_byte;
! 4830: break;
! 4831:
! 4832: case TK_STRING:
! 4833: tk_byte:
! 4834: {
! 4835: *np = node_new_str(tok->backp, *src);
! 4836: CHECK_NULL_RETURN_VAL(*np, ONIGERR_MEMORY);
! 4837:
! 4838: while (1) {
! 4839: r = fetch_token(tok, src, end, env);
! 4840: if (r < 0) return r;
! 4841: if (r != TK_STRING) break;
! 4842:
! 4843: r = onig_node_str_cat(*np, tok->backp, *src);
! 4844: if (r < 0) return r;
! 4845: }
! 4846:
! 4847: string_end:
! 4848: targetp = np;
! 4849: goto repeat;
! 4850: }
! 4851: break;
! 4852:
! 4853: case TK_RAW_BYTE:
! 4854: tk_raw_byte:
! 4855: {
! 4856: *np = node_new_str_char((UChar )tok->u.c);
! 4857: CHECK_NULL_RETURN_VAL(*np, ONIGERR_MEMORY);
! 4858: len = 1;
! 4859: while (1) {
! 4860: if (len >= ONIGENC_MBC_MINLEN(env->enc)) {
! 4861: if (len == enc_len(env->enc, NSTRING(*np).s)) {
! 4862: r = fetch_token(tok, src, end, env);
! 4863: goto string_end;
! 4864: }
! 4865: }
! 4866:
! 4867: r = fetch_token(tok, src, end, env);
! 4868: if (r < 0) return r;
! 4869: if (r != TK_RAW_BYTE) {
! 4870: #ifdef USE_PAD_TO_SHORT_BYTE_CHAR
! 4871: int rem;
! 4872: if (len < ONIGENC_MBC_MINLEN(env->enc)) {
! 4873: rem = ONIGENC_MBC_MINLEN(env->enc) - len;
! 4874: (void )node_str_head_pad(&NSTRING(*np), rem, (UChar )0);
! 4875: if (len + rem == enc_len(env->enc, NSTRING(*np).s)) {
! 4876: goto string_end;
! 4877: }
! 4878: }
! 4879: #endif
! 4880: return ONIGERR_TOO_SHORT_MULTI_BYTE_STRING;
! 4881: }
! 4882:
! 4883: r = node_str_cat_char(*np, (UChar )tok->u.c);
! 4884: if (r < 0) return r;
! 4885:
! 4886: len++;
! 4887: }
! 4888: }
! 4889: break;
! 4890:
! 4891: case TK_CODE_POINT:
! 4892: {
! 4893: UChar buf[ONIGENC_CODE_TO_MBC_MAXLEN];
! 4894: int num = ONIGENC_CODE_TO_MBC(env->enc, tok->u.code, buf);
! 4895: if (num < 0) return num;
! 4896: #ifdef NUMBERED_CHAR_IS_NOT_CASE_AMBIG
! 4897: *np = node_new_str_raw(buf, buf + num);
! 4898: #else
! 4899: *np = node_new_str(buf, buf + num);
! 4900: #endif
! 4901: CHECK_NULL_RETURN_VAL(*np, ONIGERR_MEMORY);
! 4902: }
! 4903: break;
! 4904:
! 4905: case TK_QUOTE_OPEN:
! 4906: {
! 4907: OnigCodePoint end_op[2];
! 4908: UChar *qstart, *qend, *nextp;
! 4909:
! 4910: end_op[0] = (OnigCodePoint )MC_ESC(env->enc);
! 4911: end_op[1] = (OnigCodePoint )'E';
! 4912: qstart = *src;
! 4913: qend = find_str_position(end_op, 2, qstart, end, &nextp, env->enc);
! 4914: if (IS_NULL(qend)) {
! 4915: nextp = qend = end;
! 4916: }
! 4917: *np = node_new_str(qstart, qend);
! 4918: CHECK_NULL_RETURN_VAL(*np, ONIGERR_MEMORY);
! 4919: *src = nextp;
! 4920: }
! 4921: break;
! 4922:
! 4923: case TK_CHAR_TYPE:
! 4924: {
! 4925: switch (tok->u.subtype) {
! 4926: case CTYPE_WORD:
! 4927: case CTYPE_NOT_WORD:
! 4928: *np = node_new_ctype(tok->u.subtype);
! 4929: CHECK_NULL_RETURN_VAL(*np, ONIGERR_MEMORY);
! 4930: break;
! 4931:
! 4932: case CTYPE_WHITE_SPACE:
! 4933: case CTYPE_NOT_WHITE_SPACE:
! 4934: case CTYPE_DIGIT:
! 4935: case CTYPE_NOT_DIGIT:
! 4936: case CTYPE_XDIGIT:
! 4937: case CTYPE_NOT_XDIGIT:
! 4938: {
! 4939: CClassNode* cc;
! 4940: int ctype, not;
! 4941:
! 4942: #ifdef USE_SHARED_CCLASS_TABLE
! 4943: const OnigCodePoint *sbr, *mbr;
! 4944:
! 4945: ctype = parse_ctype_to_enc_ctype(tok->u.subtype, ¬);
! 4946: r = ONIGENC_GET_CTYPE_CODE_RANGE(env->enc, ctype, &sbr, &mbr);
! 4947: if (r == 0 &&
! 4948: ONIGENC_CODE_RANGE_NUM(mbr)
! 4949: >= THRESHOLD_RANGE_NUM_FOR_SHARE_CCLASS) {
! 4950: type_cclass_key key;
! 4951: type_cclass_key* new_key;
! 4952:
! 4953: key.enc = env->enc;
! 4954: key.not = not;
! 4955: key.type = ctype;
! 4956:
! 4957: THREAD_ATOMIC_START;
! 4958:
! 4959: if (IS_NULL(OnigTypeCClassTable)) {
! 4960: OnigTypeCClassTable
! 4961: = onig_st_init_table_with_size(&type_type_cclass_hash, 10);
! 4962: if (IS_NULL(OnigTypeCClassTable)) {
! 4963: THREAD_ATOMIC_END;
! 4964: return ONIGERR_MEMORY;
! 4965: }
! 4966: }
! 4967: else {
! 4968: if (onig_st_lookup(OnigTypeCClassTable, (st_data_t )&key,
! 4969: (st_data_t* )np)) {
! 4970: THREAD_ATOMIC_END;
! 4971: break;
! 4972: }
! 4973: }
! 4974:
! 4975: *np = node_new_cclass_by_codepoint_range(not, sbr, mbr);
! 4976: if (IS_NULL(*np)) {
! 4977: THREAD_ATOMIC_END;
! 4978: return ONIGERR_MEMORY;
! 4979: }
! 4980:
! 4981: CCLASS_SET_SHARE(&(NCCLASS(*np)));
! 4982: new_key = (type_cclass_key* )xmalloc(sizeof(type_cclass_key));
! 4983: xmemcpy(new_key, &key, sizeof(type_cclass_key));
! 4984: onig_st_add_direct(OnigTypeCClassTable, (st_data_t )new_key,
! 4985: (st_data_t )*np);
! 4986:
! 4987: THREAD_ATOMIC_END;
! 4988: }
! 4989: else {
! 4990: #endif
! 4991: ctype = parse_ctype_to_enc_ctype(tok->u.subtype, ¬);
! 4992: *np = node_new_cclass();
! 4993: CHECK_NULL_RETURN_VAL(*np, ONIGERR_MEMORY);
! 4994: cc = &(NCCLASS(*np));
! 4995: add_ctype_to_cc(cc, ctype, 0, env);
! 4996: if (not != 0) CCLASS_SET_NOT(cc);
! 4997: #ifdef USE_SHARED_CCLASS_TABLE
! 4998: }
! 4999: #endif
! 5000: }
! 5001: break;
! 5002:
! 5003: default:
! 5004: return ONIGERR_PARSER_BUG;
! 5005: break;
! 5006: }
! 5007: }
! 5008: break;
! 5009:
! 5010: case TK_CHAR_PROPERTY:
! 5011: r = parse_char_property(np, tok, src, end, env);
! 5012: if (r != 0) return r;
! 5013: break;
! 5014:
! 5015: case TK_CC_OPEN:
! 5016: {
! 5017: CClassNode* cc;
! 5018:
! 5019: r = parse_char_class(np, tok, src, end, env);
! 5020: if (r != 0) return r;
! 5021:
! 5022: cc = &(NCCLASS(*np));
! 5023:
! 5024: if (IS_IGNORECASE(env->option)) {
! 5025: int i, n, in_cc;
! 5026: const OnigPairAmbigCodes* ccs;
! 5027: BitSetRef bs = cc->bs;
! 5028: OnigAmbigType amb;
! 5029:
! 5030: for (amb = 0x01; amb <= ONIGENC_AMBIGUOUS_MATCH_LIMIT; amb <<= 1) {
! 5031: if ((amb & env->ambig_flag) == 0) continue;
! 5032:
! 5033: n = ONIGENC_GET_ALL_PAIR_AMBIG_CODES(env->enc, amb, &ccs);
! 5034: for (i = 0; i < n; i++) {
! 5035: in_cc = onig_is_code_in_cc(env->enc, ccs[i].from, cc);
! 5036:
! 5037: if ((in_cc != 0 && !IS_CCLASS_NOT(cc)) ||
! 5038: (in_cc == 0 && IS_CCLASS_NOT(cc))) {
! 5039: if (ONIGENC_MBC_MINLEN(env->enc) > 1 ||
! 5040: ccs[i].from >= SINGLE_BYTE_SIZE) {
! 5041: /* if (cc->not) clear_not_flag_cclass(cc, env->enc); */
! 5042: add_code_range(&(cc->mbuf), env, ccs[i].to, ccs[i].to);
! 5043: }
! 5044: else {
! 5045: if (BITSET_AT(bs, ccs[i].from)) {
! 5046: /* /(?i:[^A-C])/.match("a") ==> fail. */
! 5047: BITSET_SET_BIT(bs, ccs[i].to);
! 5048: }
! 5049: if (BITSET_AT(bs, ccs[i].to)) {
! 5050: BITSET_SET_BIT(bs, ccs[i].from);
! 5051: }
! 5052: }
! 5053: }
! 5054: }
! 5055: }
! 5056: }
! 5057: }
! 5058: break;
! 5059:
! 5060: case TK_ANYCHAR:
! 5061: *np = node_new_anychar();
! 5062: CHECK_NULL_RETURN_VAL(*np, ONIGERR_MEMORY);
! 5063: break;
! 5064:
! 5065: case TK_ANYCHAR_ANYTIME:
! 5066: *np = node_new_anychar();
! 5067: CHECK_NULL_RETURN_VAL(*np, ONIGERR_MEMORY);
! 5068: qn = node_new_quantifier(0, REPEAT_INFINITE, 0);
! 5069: CHECK_NULL_RETURN_VAL(qn, ONIGERR_MEMORY);
! 5070: NQUANTIFIER(qn).target = *np;
! 5071: *np = qn;
! 5072: break;
! 5073:
! 5074: case TK_BACKREF:
! 5075: len = tok->u.backref.num;
! 5076: *np = node_new_backref(len,
! 5077: (len > 1 ? tok->u.backref.refs : &(tok->u.backref.ref1)),
! 5078: tok->u.backref.by_name,
! 5079: #ifdef USE_BACKREF_AT_LEVEL
! 5080: tok->u.backref.exist_level,
! 5081: tok->u.backref.level,
! 5082: #endif
! 5083: env);
! 5084: CHECK_NULL_RETURN_VAL(*np, ONIGERR_MEMORY);
! 5085: break;
! 5086:
! 5087: #ifdef USE_SUBEXP_CALL
! 5088: case TK_CALL:
! 5089: *np = node_new_call(tok->u.call.name, tok->u.call.name_end);
! 5090: CHECK_NULL_RETURN_VAL(*np, ONIGERR_MEMORY);
! 5091: env->num_call++;
! 5092: break;
! 5093: #endif
! 5094:
! 5095: case TK_ANCHOR:
! 5096: *np = onig_node_new_anchor(tok->u.anchor);
! 5097: break;
! 5098:
! 5099: case TK_OP_REPEAT:
! 5100: case TK_INTERVAL:
! 5101: if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_CONTEXT_INDEP_REPEAT_OPS)) {
! 5102: if (IS_SYNTAX_BV(env->syntax, ONIG_SYN_CONTEXT_INVALID_REPEAT_OPS))
! 5103: return ONIGERR_TARGET_OF_REPEAT_OPERATOR_NOT_SPECIFIED;
! 5104: else
! 5105: *np = node_new_empty();
! 5106: }
! 5107: else {
! 5108: goto tk_byte;
! 5109: }
! 5110: break;
! 5111:
! 5112: default:
! 5113: return ONIGERR_PARSER_BUG;
! 5114: break;
! 5115: }
! 5116:
! 5117: {
! 5118: targetp = np;
! 5119:
! 5120: re_entry:
! 5121: r = fetch_token(tok, src, end, env);
! 5122: if (r < 0) return r;
! 5123:
! 5124: repeat:
! 5125: if (r == TK_OP_REPEAT || r == TK_INTERVAL) {
! 5126: if (is_invalid_quantifier_target(*targetp))
! 5127: return ONIGERR_TARGET_OF_REPEAT_OPERATOR_INVALID;
! 5128:
! 5129: qn = node_new_quantifier(tok->u.repeat.lower, tok->u.repeat.upper,
! 5130: (r == TK_INTERVAL ? 1 : 0));
! 5131: CHECK_NULL_RETURN_VAL(qn, ONIGERR_MEMORY);
! 5132: NQUANTIFIER(qn).greedy = tok->u.repeat.greedy;
! 5133: r = set_quantifier(qn, *targetp, group, env);
! 5134: if (r < 0) return r;
! 5135:
! 5136: if (tok->u.repeat.possessive != 0) {
! 5137: Node* en;
! 5138: en = node_new_effect(EFFECT_STOP_BACKTRACK);
! 5139: CHECK_NULL_RETURN_VAL(en, ONIGERR_MEMORY);
! 5140: NEFFECT(en).target = qn;
! 5141: qn = en;
! 5142: }
! 5143:
! 5144: if (r == 0) {
! 5145: *targetp = qn;
! 5146: }
! 5147: else if (r == 2) { /* split case: /abc+/ */
! 5148: Node *tmp;
! 5149:
! 5150: *targetp = node_new_list(*targetp, NULL);
! 5151: CHECK_NULL_RETURN_VAL(*targetp, ONIGERR_MEMORY);
! 5152: tmp = NCONS(*targetp).right = node_new_list(qn, NULL);
! 5153: CHECK_NULL_RETURN_VAL(tmp, ONIGERR_MEMORY);
! 5154: targetp = &(NCONS(tmp).left);
! 5155: }
! 5156: goto re_entry;
! 5157: }
! 5158: }
! 5159:
! 5160: return r;
! 5161: }
! 5162:
! 5163: static int
! 5164: parse_branch(Node** top, OnigToken* tok, int term,
! 5165: UChar** src, UChar* end, ScanEnv* env)
! 5166: {
! 5167: int r;
! 5168: Node *node, **headp;
! 5169:
! 5170: *top = NULL;
! 5171: r = parse_exp(&node, tok, term, src, end, env);
! 5172: if (r < 0) return r;
! 5173:
! 5174: if (r == TK_EOT || r == term || r == TK_ALT) {
! 5175: *top = node;
! 5176: }
! 5177: else {
! 5178: *top = node_new_list(node, NULL);
! 5179: headp = &(NCONS(*top).right);
! 5180: while (r != TK_EOT && r != term && r != TK_ALT) {
! 5181: r = parse_exp(&node, tok, term, src, end, env);
! 5182: if (r < 0) return r;
! 5183:
! 5184: if (NTYPE(node) == N_LIST) {
! 5185: *headp = node;
! 5186: while (IS_NOT_NULL(NCONS(node).right)) node = NCONS(node).right;
! 5187: headp = &(NCONS(node).right);
! 5188: }
! 5189: else {
! 5190: *headp = node_new_list(node, NULL);
! 5191: headp = &(NCONS(*headp).right);
! 5192: }
! 5193: }
! 5194: }
! 5195:
! 5196: return r;
! 5197: }
! 5198:
! 5199: /* term_tok: TK_EOT or TK_SUBEXP_CLOSE */
! 5200: static int
! 5201: parse_subexp(Node** top, OnigToken* tok, int term,
! 5202: UChar** src, UChar* end, ScanEnv* env)
! 5203: {
! 5204: int r;
! 5205: Node *node, **headp;
! 5206:
! 5207: *top = NULL;
! 5208: r = parse_branch(&node, tok, term, src, end, env);
! 5209: if (r < 0) {
! 5210: onig_node_free(node);
! 5211: return r;
! 5212: }
! 5213:
! 5214: if (r == term) {
! 5215: *top = node;
! 5216: }
! 5217: else if (r == TK_ALT) {
! 5218: *top = node_new_alt(node, NULL);
! 5219: headp = &(NCONS(*top).right);
! 5220: while (r == TK_ALT) {
! 5221: r = fetch_token(tok, src, end, env);
! 5222: if (r < 0) return r;
! 5223: r = parse_branch(&node, tok, term, src, end, env);
! 5224: if (r < 0) return r;
! 5225:
! 5226: *headp = node_new_alt(node, NULL);
! 5227: headp = &(NCONS(*headp).right);
! 5228: }
! 5229:
! 5230: if (tok->type != term)
! 5231: goto err;
! 5232: }
! 5233: else {
! 5234: err:
! 5235: if (term == TK_SUBEXP_CLOSE)
! 5236: return ONIGERR_END_PATTERN_WITH_UNMATCHED_PARENTHESIS;
! 5237: else
! 5238: return ONIGERR_PARSER_BUG;
! 5239: }
! 5240:
! 5241: return r;
! 5242: }
! 5243:
! 5244: static int
! 5245: parse_regexp(Node** top, UChar** src, UChar* end, ScanEnv* env)
! 5246: {
! 5247: int r;
! 5248: OnigToken tok;
! 5249:
! 5250: r = fetch_token(&tok, src, end, env);
! 5251: if (r < 0) return r;
! 5252: r = parse_subexp(top, &tok, TK_EOT, src, end, env);
! 5253: if (r < 0) return r;
! 5254: return 0;
! 5255: }
! 5256:
! 5257: extern int
! 5258: onig_parse_make_tree(Node** root, const UChar* pattern, const UChar* end, regex_t* reg,
! 5259: ScanEnv* env)
! 5260: {
! 5261: int r;
! 5262: UChar* p;
! 5263:
! 5264: #ifdef USE_NAMED_GROUP
! 5265: names_clear(reg);
! 5266: #endif
! 5267:
! 5268: scan_env_clear(env);
! 5269: env->option = reg->options;
! 5270: env->ambig_flag = reg->ambig_flag;
! 5271: env->enc = reg->enc;
! 5272: env->syntax = reg->syntax;
! 5273: env->pattern = (UChar* )pattern;
! 5274: env->pattern_end = (UChar* )end;
! 5275: env->reg = reg;
! 5276:
! 5277: *root = NULL;
! 5278: p = (UChar* )pattern;
! 5279: r = parse_regexp(root, &p, (UChar* )end, env);
! 5280: reg->num_mem = env->num_mem;
! 5281: return r;
! 5282: }
! 5283:
! 5284: extern void
! 5285: onig_scan_env_set_error_string(ScanEnv* env, int ecode,
! 5286: UChar* arg, UChar* arg_end)
! 5287: {
! 5288: env->error = arg;
! 5289: env->error_end = arg_end;
! 5290: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to regparse.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