1 /**********************************************************************
2 regparse.c - Oniguruma (regular expression library)
3 **********************************************************************/
5 * Copyright (c) 2002-2008 K.Kosako <sndgk393 AT ybb DOT ne DOT jp>
8 * (C) Copyright 2015 Hewlett Packard Enterprise Development LP<BR>
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35 #define WARN_BUFSIZE 256
37 #define CASE_FOLD_IS_APPLIED_INSIDE_NEGATIVE_CCLASS
40 OnigSyntaxType OnigSyntaxRuby
= {
41 (( SYN_GNU_REGEX_OP
| ONIG_SYN_OP_QMARK_NON_GREEDY
|
42 ONIG_SYN_OP_ESC_OCTAL3
| ONIG_SYN_OP_ESC_X_HEX2
|
43 ONIG_SYN_OP_ESC_X_BRACE_HEX8
| ONIG_SYN_OP_ESC_CONTROL_CHARS
|
44 ONIG_SYN_OP_ESC_C_CONTROL
)
45 & ~ONIG_SYN_OP_ESC_LTGT_WORD_BEGIN_END
)
46 , ( ONIG_SYN_OP2_QMARK_GROUP_EFFECT
|
47 ONIG_SYN_OP2_OPTION_RUBY
|
48 ONIG_SYN_OP2_QMARK_LT_NAMED_GROUP
| ONIG_SYN_OP2_ESC_K_NAMED_BACKREF
|
49 ONIG_SYN_OP2_ESC_G_SUBEXP_CALL
|
50 ONIG_SYN_OP2_ESC_P_BRACE_CHAR_PROPERTY
|
51 ONIG_SYN_OP2_ESC_P_BRACE_CIRCUMFLEX_NOT
|
52 ONIG_SYN_OP2_PLUS_POSSESSIVE_REPEAT
|
53 ONIG_SYN_OP2_CCLASS_SET_OP
| ONIG_SYN_OP2_ESC_CAPITAL_C_BAR_CONTROL
|
54 ONIG_SYN_OP2_ESC_CAPITAL_M_BAR_META
| ONIG_SYN_OP2_ESC_V_VTAB
|
55 ONIG_SYN_OP2_ESC_H_XDIGIT
)
56 , ( SYN_GNU_REGEX_BV
|
57 ONIG_SYN_ALLOW_INTERVAL_LOW_ABBREV
|
58 ONIG_SYN_DIFFERENT_LEN_ALT_LOOK_BEHIND
|
59 ONIG_SYN_CAPTURE_ONLY_NAMED_GROUP
|
60 ONIG_SYN_ALLOW_MULTIPLEX_DEFINITION_NAME
|
61 ONIG_SYN_FIXED_INTERVAL_IS_GREEDY_ONLY
|
62 ONIG_SYN_WARN_CC_OP_NOT_ESCAPED
|
63 ONIG_SYN_WARN_REDUNDANT_NESTED_REPEAT
)
67 (OnigCodePoint
)'\\' /* esc */
68 , (OnigCodePoint
)ONIG_INEFFECTIVE_META_CHAR
/* anychar '.' */
69 , (OnigCodePoint
)ONIG_INEFFECTIVE_META_CHAR
/* anytime '*' */
70 , (OnigCodePoint
)ONIG_INEFFECTIVE_META_CHAR
/* zero or one time '?' */
71 , (OnigCodePoint
)ONIG_INEFFECTIVE_META_CHAR
/* one or more time '+' */
72 , (OnigCodePoint
)ONIG_INEFFECTIVE_META_CHAR
/* anychar anytime */
76 OnigSyntaxType
* OnigDefaultSyntax
= ONIG_SYNTAX_RUBY
;
78 extern void onig_null_warn(const char* s ARG_UNUSED
) { }
80 #ifdef DEFAULT_WARN_FUNCTION
81 static OnigWarnFunc onig_warn
= (OnigWarnFunc
)DEFAULT_WARN_FUNCTION
;
83 static OnigWarnFunc onig_warn
= onig_null_warn
;
86 #ifdef DEFAULT_VERB_WARN_FUNCTION
87 static OnigWarnFunc onig_verb_warn
= (OnigWarnFunc
)DEFAULT_VERB_WARN_FUNCTION
;
89 static OnigWarnFunc onig_verb_warn
= onig_null_warn
;
92 extern void onig_set_warn_func(OnigWarnFunc f
)
97 extern void onig_set_verb_warn_func(OnigWarnFunc f
)
103 bbuf_free(BBuf
* bbuf
)
105 if (IS_NOT_NULL(bbuf
)) {
106 if (IS_NOT_NULL(bbuf
->p
)) xfree(bbuf
->p
);
112 bbuf_clone(BBuf
** rto
, BBuf
* from
)
117 *rto
= to
= (BBuf
* )xmalloc(sizeof(BBuf
));
118 CHECK_NULL_RETURN_MEMERR(to
);
119 r
= BBUF_INIT(to
, from
->alloc
);
120 if (r
!= 0) return r
;
121 to
->used
= from
->used
;
122 xmemcpy(to
->p
, from
->p
, from
->used
);
126 #define BACKREF_REL_TO_ABS(rel_no, env) \
127 ((env)->num_mem + 1 + (rel_no))
129 #define ONOFF(v,f,negative) (negative) ? ((v) &= ~(f)) : ((v) |= (f))
131 #define MBCODE_START_POS(enc) \
132 (OnigCodePoint )(ONIGENC_MBC_MINLEN(enc) > 1 ? 0 : 0x80)
134 #define SET_ALL_MULTI_BYTE_RANGE(enc, pbuf) \
135 add_code_range_to_buf(pbuf, MBCODE_START_POS(enc), ~((OnigCodePoint )0))
137 #define ADD_ALL_MULTI_BYTE_RANGE(enc, mbuf) do {\
138 if (! ONIGENC_IS_SINGLEBYTE(enc)) {\
139 r = SET_ALL_MULTI_BYTE_RANGE(enc, &(mbuf));\
145 #define BITSET_IS_EMPTY(bs,empty) do {\
148 for (i = 0; i < (int )BITSET_SIZE; i++) {\
156 bitset_set_range(BitSetRef bs
, int from
, int to
)
159 for (i
= from
; i
<= to
&& i
< SINGLE_BYTE_SIZE
; i
++) {
160 BITSET_SET_BIT(bs
, i
);
166 bitset_set_all(BitSetRef bs
)
169 for (i
= 0; i
< BITSET_SIZE
; i
++) { bs
[i
] = ~((Bits
)0); }
174 bitset_invert(BitSetRef bs
)
177 for (i
= 0; i
< (int )BITSET_SIZE
; i
++) { bs
[i
] = ~(bs
[i
]); }
181 bitset_invert_to(BitSetRef from
, BitSetRef to
)
184 for (i
= 0; i
< (int )BITSET_SIZE
; i
++) { to
[i
] = ~(from
[i
]); }
188 bitset_and(BitSetRef dest
, BitSetRef bs
)
191 for (i
= 0; i
< (int )BITSET_SIZE
; i
++) { dest
[i
] &= bs
[i
]; }
195 bitset_or(BitSetRef dest
, BitSetRef bs
)
198 for (i
= 0; i
< (int )BITSET_SIZE
; i
++) { dest
[i
] |= bs
[i
]; }
202 bitset_copy(BitSetRef dest
, BitSetRef bs
)
205 for (i
= 0; i
< (int )BITSET_SIZE
; i
++) { dest
[i
] = bs
[i
]; }
209 onig_strncmp(const UChar
* s1
, const UChar
* s2
, int n
)
221 onig_strcpy(UChar
* dest
, const UChar
* src
, const UChar
* end
)
223 int len
= (int)(end
- src
);
225 xmemcpy(dest
, src
, len
);
226 dest
[len
] = (UChar
)0;
230 #ifdef USE_NAMED_GROUP
232 strdup_with_null(OnigEncoding enc
, UChar
* s
, UChar
* end
)
234 int slen
, term_len
, i
;
237 slen
= (int)(end
- s
);
238 term_len
= ONIGENC_MBC_MINLEN(enc
);
240 r
= (UChar
* )xmalloc(slen
+ term_len
);
241 CHECK_NULL_RETURN(r
);
244 for (i
= 0; i
< term_len
; i
++)
245 r
[slen
+ i
] = (UChar
)0;
251 /* scan pattern methods */
254 #define PFETCH_READY UChar* pfetch_prev
255 #define PEND (p < end ? 0 : 1)
256 #define PUNFETCH p = pfetch_prev
259 p += ONIGENC_MBC_ENC_LEN(enc, p); \
261 #define PFETCH(c) do { \
262 c = ONIGENC_MBC_TO_CODE(enc, p, end); \
264 p += ONIGENC_MBC_ENC_LEN(enc, p); \
267 #define PINC_S do { \
268 p += ONIGENC_MBC_ENC_LEN(enc, p); \
270 #define PFETCH_S(c) do { \
271 c = ONIGENC_MBC_TO_CODE(enc, p, end); \
272 p += ONIGENC_MBC_ENC_LEN(enc, p); \
275 #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE)
276 #define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c)
279 strcat_capa(UChar
* dest
, UChar
* dest_end
, const UChar
* src
, const UChar
* src_end
,
280 int capa
, int oldCapa
)
285 r
= (UChar
* )xrealloc(dest
, capa
+ 1, oldCapa
);
287 r
= (UChar
* )xmalloc(capa
+ 1);
289 CHECK_NULL_RETURN(r
);
290 onig_strcpy(r
+ (dest_end
- dest
), src
, src_end
);
294 /* dest on static area */
296 strcat_capa_from_static(UChar
* dest
, UChar
* dest_end
,
297 const UChar
* src
, const UChar
* src_end
, int capa
)
301 r
= (UChar
* )xmalloc(capa
+ 1);
302 CHECK_NULL_RETURN(r
);
303 onig_strcpy(r
, dest
, dest_end
);
304 onig_strcpy(r
+ (dest_end
- dest
), src
, src_end
);
309 #ifdef USE_ST_LIBRARY
317 str_end_cmp(st_str_end_key
* x
, st_str_end_key
* y
)
322 if ((x
->end
- x
->s
) != (y
->end
- y
->s
))
328 c
= (int )*p
- (int )*q
;
329 if (c
!= 0) return c
;
338 str_end_hash(st_str_end_key
* x
)
345 val
= val
* 997 + (int )*p
++;
348 return val
+ (val
>> 5);
351 extern hash_table_type
*
352 onig_st_init_strend_table_with_size(int size
)
354 static struct st_hash_type hashType
= {
359 return (hash_table_type
* )
360 onig_st_init_table_with_size(&hashType
, size
);
364 onig_st_lookup_strend(hash_table_type
* table
, const UChar
* str_key
,
365 const UChar
* end_key
, hash_data_type
*value
)
369 key
.s
= (UChar
* )str_key
;
370 key
.end
= (UChar
* )end_key
;
372 return onig_st_lookup(table
, (st_data_t
)(UINTN
)(&key
), value
);
376 onig_st_insert_strend(hash_table_type
* table
, const UChar
* str_key
,
377 const UChar
* end_key
, hash_data_type value
)
382 key
= (st_str_end_key
* )xmalloc(sizeof(st_str_end_key
));
383 CHECK_NULL_RETURN_MEMERR(key
);
384 key
->s
= (UChar
* )str_key
;
385 key
->end
= (UChar
* )end_key
;
386 result
= onig_st_insert(table
, (st_data_t
)(UINTN
)key
, value
);
393 #endif /* USE_ST_LIBRARY */
396 #ifdef USE_NAMED_GROUP
398 #define INIT_NAME_BACKREFS_ALLOC_NUM 8
402 int name_len
; /* byte length */
403 int back_num
; /* number of backrefs */
409 #ifdef USE_ST_LIBRARY
411 typedef st_table NameTable
;
412 typedef st_data_t HashDataType
; /* 1.6 st.h doesn't define st_data_t type */
414 #define NAMEBUF_SIZE 24
415 #define NAMEBUF_SIZE_1 25
419 i_print_name_entry(UChar
* key
, NameEntry
* e
, void* arg
)
422 FILE* fp
= (FILE* )arg
;
424 fprintf(fp
, "%s: ", e
->name
);
425 if (e
->back_num
== 0)
427 else if (e
->back_num
== 1)
428 fprintf(fp
, "%d", e
->back_ref1
);
430 for (i
= 0; i
< e
->back_num
; i
++) {
431 if (i
> 0) fprintf(fp
, ", ");
432 fprintf(fp
, "%d", e
->back_refs
[i
]);
440 onig_print_names(FILE* fp
, regex_t
* reg
)
442 NameTable
* t
= (NameTable
* )reg
->name_table
;
444 if (IS_NOT_NULL(t
)) {
445 fprintf(fp
, "name table\n");
446 onig_st_foreach(t
, i_print_name_entry
, (HashDataType
)fp
);
451 #endif /* ONIG_DEBUG */
454 i_free_name_entry(UChar
* key
, NameEntry
* e
, void* arg ARG_UNUSED
)
457 if (IS_NOT_NULL(e
->back_refs
)) xfree(e
->back_refs
);
464 names_clear(regex_t
* reg
)
466 NameTable
* t
= (NameTable
* )reg
->name_table
;
468 if (IS_NOT_NULL(t
)) {
469 onig_st_foreach(t
, i_free_name_entry
, 0);
475 onig_names_free(regex_t
* reg
)
480 r
= names_clear(reg
);
483 t
= (NameTable
* )reg
->name_table
;
484 if (IS_NOT_NULL(t
)) onig_st_free_table(t
);
485 reg
->name_table
= (void* )NULL
;
490 name_find(regex_t
* reg
, const UChar
* name
, const UChar
* name_end
)
493 NameTable
* t
= (NameTable
* )reg
->name_table
;
495 e
= (NameEntry
* )NULL
;
496 if (IS_NOT_NULL(t
)) {
497 onig_st_lookup_strend(t
, name
, name_end
, (HashDataType
* )((void* )(&e
)));
503 int (*func
)(const UChar
*, const UChar
*,int,int*,regex_t
*,void*);
511 i_names(UChar
* key ARG_UNUSED
, NameEntry
* e
, INamesArg
* arg
)
513 int r
= (*(arg
->func
))(e
->name
,
514 e
->name
+ e
->name_len
,
516 (e
->back_num
> 1 ? e
->back_refs
: &(e
->back_ref1
)),
526 onig_foreach_name(regex_t
* reg
,
527 int (*func
)(const UChar
*, const UChar
*,int,int*,regex_t
*,void*), void* arg
)
530 NameTable
* t
= (NameTable
* )reg
->name_table
;
533 if (IS_NOT_NULL(t
)) {
537 narg
.enc
= reg
->enc
; /* should be pattern encoding. */
538 onig_st_foreach(t
, i_names
, (HashDataType
)(UINTN
)&narg
);
544 i_renumber_name(UChar
* key ARG_UNUSED
, NameEntry
* e
, GroupNumRemap
* map
)
548 if (e
->back_num
> 1) {
549 for (i
= 0; i
< e
->back_num
; i
++) {
550 e
->back_refs
[i
] = map
[e
->back_refs
[i
]].new_val
;
553 else if (e
->back_num
== 1) {
554 e
->back_ref1
= map
[e
->back_ref1
].new_val
;
561 onig_renumber_name_table(regex_t
* reg
, GroupNumRemap
* map
)
563 NameTable
* t
= (NameTable
* )reg
->name_table
;
565 if (IS_NOT_NULL(t
)) {
566 onig_st_foreach(t
, i_renumber_name
, (HashDataType
)(UINTN
)map
);
573 onig_number_of_names(regex_t
* reg
)
575 NameTable
* t
= (NameTable
* )reg
->name_table
;
578 return t
->num_entries
;
583 #else /* USE_ST_LIBRARY */
585 #define INIT_NAMES_ALLOC_NUM 8
595 onig_print_names(FILE* fp
, regex_t
* reg
)
599 NameTable
* t
= (NameTable
* )reg
->name_table
;
601 if (IS_NOT_NULL(t
) && t
->num
> 0) {
602 fprintf(fp
, "name table\n");
603 for (i
= 0; i
< t
->num
; i
++) {
605 fprintf(fp
, "%s: ", e
->name
);
606 if (e
->back_num
== 0) {
609 else if (e
->back_num
== 1) {
610 fprintf(fp
, "%d", e
->back_ref1
);
613 for (j
= 0; j
< e
->back_num
; j
++) {
614 if (j
> 0) fprintf(fp
, ", ");
615 fprintf(fp
, "%d", e
->back_refs
[j
]);
627 names_clear(regex_t
* reg
)
631 NameTable
* t
= (NameTable
* )reg
->name_table
;
633 if (IS_NOT_NULL(t
)) {
634 for (i
= 0; i
< t
->num
; i
++) {
636 if (IS_NOT_NULL(e
->name
)) {
642 if (IS_NOT_NULL(e
->back_refs
)) xfree(e
->back_refs
);
643 e
->back_refs
= (int* )NULL
;
646 if (IS_NOT_NULL(t
->e
)) {
656 onig_names_free(regex_t
* reg
)
661 r
= names_clear(reg
);
664 t
= (NameTable
* )reg
->name_table
;
665 if (IS_NOT_NULL(t
)) xfree(t
);
666 reg
->name_table
= NULL
;
671 name_find(regex_t
* reg
, UChar
* name
, UChar
* name_end
)
675 NameTable
* t
= (NameTable
* )reg
->name_table
;
677 if (IS_NOT_NULL(t
)) {
678 len
= name_end
- name
;
679 for (i
= 0; i
< t
->num
; i
++) {
681 if (len
== e
->name_len
&& onig_strncmp(name
, e
->name
, len
) == 0)
685 return (NameEntry
* )NULL
;
689 onig_foreach_name(regex_t
* reg
,
690 int (*func
)(const UChar
*, const UChar
*,int,int*,regex_t
*,void*), void* arg
)
694 NameTable
* t
= (NameTable
* )reg
->name_table
;
696 if (IS_NOT_NULL(t
)) {
697 for (i
= 0; i
< t
->num
; i
++) {
699 r
= (*func
)(e
->name
, e
->name
+ e
->name_len
, e
->back_num
,
700 (e
->back_num
> 1 ? e
->back_refs
: &(e
->back_ref1
)),
702 if (r
!= 0) return r
;
709 onig_number_of_names(regex_t
* reg
)
711 NameTable
* t
= (NameTable
* )reg
->name_table
;
719 #endif /* else USE_ST_LIBRARY */
722 name_add(regex_t
* reg
, UChar
* name
, UChar
* name_end
, int backref
, ScanEnv
* env
)
726 NameTable
* t
= (NameTable
* )reg
->name_table
;
728 if (name_end
- name
<= 0)
729 return ONIGERR_EMPTY_GROUP_NAME
;
731 e
= name_find(reg
, name
, name_end
);
733 #ifdef USE_ST_LIBRARY
735 t
= onig_st_init_strend_table_with_size(5);
736 CHECK_NULL_RETURN_MEMERR(t
);
737 reg
->name_table
= (void* )t
;
739 e
= (NameEntry
* )xmalloc(sizeof(NameEntry
));
740 CHECK_NULL_RETURN_MEMERR(e
);
742 e
->name
= strdup_with_null(reg
->enc
, name
, name_end
);
743 if (IS_NULL(e
->name
)) {
744 xfree(e
); return ONIGERR_MEMORY
;
746 onig_st_insert_strend(t
, e
->name
, (e
->name
+ (name_end
- name
)),
747 (HashDataType
)(UINTN
)e
);
749 e
->name_len
= (int)(name_end
- name
);
752 e
->back_refs
= (int* )NULL
;
757 alloc
= INIT_NAMES_ALLOC_NUM
;
758 t
= (NameTable
* )xmalloc(sizeof(NameTable
));
759 CHECK_NULL_RETURN_MEMERR(t
);
764 t
->e
= (NameEntry
* )xmalloc(sizeof(NameEntry
) * alloc
);
767 return ONIGERR_MEMORY
;
773 else if (t
->num
== t
->alloc
) {
776 alloc
= t
->alloc
* 2;
777 t
->e
= (NameEntry
* )xrealloc(t
->e
, sizeof(NameEntry
) * alloc
);
778 CHECK_NULL_RETURN_MEMERR(t
->e
);
782 for (i
= t
->num
; i
< t
->alloc
; i
++) {
784 t
->e
[i
].name_len
= 0;
785 t
->e
[i
].back_num
= 0;
786 t
->e
[i
].back_alloc
= 0;
787 t
->e
[i
].back_refs
= (int* )NULL
;
792 e
->name
= strdup_with_null(reg
->enc
, name
, name_end
);
793 if (IS_NULL(e
->name
)) return ONIGERR_MEMORY
;
794 e
->name_len
= name_end
- name
;
798 if (e
->back_num
>= 1 &&
799 ! IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_ALLOW_MULTIPLEX_DEFINITION_NAME
)) {
800 onig_scan_env_set_error_string(env
, ONIGERR_MULTIPLEX_DEFINED_NAME
,
802 return ONIGERR_MULTIPLEX_DEFINED_NAME
;
806 if (e
->back_num
== 1) {
807 e
->back_ref1
= backref
;
810 if (e
->back_num
== 2) {
811 alloc
= INIT_NAME_BACKREFS_ALLOC_NUM
;
812 e
->back_refs
= (int* )xmalloc(sizeof(int) * alloc
);
813 CHECK_NULL_RETURN_MEMERR(e
->back_refs
);
814 e
->back_alloc
= alloc
;
815 e
->back_refs
[0] = e
->back_ref1
;
816 e
->back_refs
[1] = backref
;
819 if (e
->back_num
> e
->back_alloc
) {
820 alloc
= e
->back_alloc
* 2;
821 e
->back_refs
= (int* )xrealloc(e
->back_refs
, sizeof(int) * alloc
, sizeof(int) * e
->back_alloc
);
822 CHECK_NULL_RETURN_MEMERR(e
->back_refs
);
823 e
->back_alloc
= alloc
;
825 e
->back_refs
[e
->back_num
- 1] = backref
;
833 onig_name_to_group_numbers(regex_t
* reg
, const UChar
* name
,
834 const UChar
* name_end
, int** nums
)
836 NameEntry
* e
= name_find(reg
, name
, name_end
);
838 if (IS_NULL(e
)) return ONIGERR_UNDEFINED_NAME_REFERENCE
;
840 switch (e
->back_num
) {
844 *nums
= &(e
->back_ref1
);
847 *nums
= e
->back_refs
;
854 onig_name_to_backref_number(regex_t
* reg
, const UChar
* name
,
855 const UChar
* name_end
, OnigRegion
*region
)
859 n
= onig_name_to_group_numbers(reg
, name
, name_end
, &nums
);
863 return ONIGERR_PARSER_BUG
;
867 if (IS_NOT_NULL(region
)) {
868 for (i
= n
- 1; i
>= 0; i
--) {
869 if (region
->beg
[nums
[i
]] != ONIG_REGION_NOTPOS
)
877 #else /* USE_NAMED_GROUP */
880 onig_name_to_group_numbers(regex_t
* reg
, const UChar
* name
,
881 const UChar
* name_end
, int** nums
)
883 return ONIG_NO_SUPPORT_CONFIG
;
887 onig_name_to_backref_number(regex_t
* reg
, const UChar
* name
,
888 const UChar
* name_end
, OnigRegion
* region
)
890 return ONIG_NO_SUPPORT_CONFIG
;
894 onig_foreach_name(regex_t
* reg
,
895 int (*func
)(const UChar
*, const UChar
*,int,int*,regex_t
*,void*), void* arg
)
897 return ONIG_NO_SUPPORT_CONFIG
;
901 onig_number_of_names(regex_t
* reg
)
905 #endif /* else USE_NAMED_GROUP */
908 onig_noname_group_capture_is_active(regex_t
* reg
)
910 if (ONIG_IS_OPTION_ON(reg
->options
, ONIG_OPTION_DONT_CAPTURE_GROUP
))
913 #ifdef USE_NAMED_GROUP
914 if (onig_number_of_names(reg
) > 0 &&
915 IS_SYNTAX_BV(reg
->syntax
, ONIG_SYN_CAPTURE_ONLY_NAMED_GROUP
) &&
916 !ONIG_IS_OPTION_ON(reg
->options
, ONIG_OPTION_CAPTURE_GROUP
)) {
925 #define INIT_SCANENV_MEMNODES_ALLOC_SIZE 16
928 scan_env_clear(ScanEnv
* env
)
932 BIT_STATUS_CLEAR(env
->capture_history
);
933 BIT_STATUS_CLEAR(env
->bt_mem_start
);
934 BIT_STATUS_CLEAR(env
->bt_mem_end
);
935 BIT_STATUS_CLEAR(env
->backrefed_mem
);
936 env
->error
= (UChar
* )NULL
;
937 env
->error_end
= (UChar
* )NULL
;
940 #ifdef USE_NAMED_GROUP
944 env
->mem_nodes_dynamic
= (Node
** )NULL
;
946 for (i
= 0; i
< SCANENV_MEMNODES_SIZE
; i
++)
947 env
->mem_nodes_static
[i
] = NULL_NODE
;
949 #ifdef USE_COMBINATION_EXPLOSION_CHECK
950 env
->num_comb_exp_check
= 0;
951 env
->comb_exp_max_regnum
= 0;
952 env
->curr_max_regnum
= 0;
953 env
->has_recursion
= 0;
958 scan_env_add_mem_entry(ScanEnv
* env
)
963 need
= env
->num_mem
+ 1;
964 if (need
>= SCANENV_MEMNODES_SIZE
) {
965 if (env
->mem_alloc
<= need
) {
966 if (IS_NULL(env
->mem_nodes_dynamic
)) {
967 alloc
= INIT_SCANENV_MEMNODES_ALLOC_SIZE
;
968 p
= (Node
** )xmalloc(sizeof(Node
*) * alloc
);
969 CHECK_NULL_RETURN_MEMERR(p
);
971 xmemcpy(p
, env
->mem_nodes_static
,
972 sizeof(Node
*) * SCANENV_MEMNODES_SIZE
);
975 alloc
= env
->mem_alloc
* 2;
976 p
= (Node
** )xrealloc(env
->mem_nodes_dynamic
, sizeof(Node
*) * alloc
, sizeof(Node
*) * env
->mem_alloc
);
978 CHECK_NULL_RETURN_MEMERR(p
);
980 for (i
= env
->num_mem
+ 1; i
< alloc
; i
++)
983 env
->mem_nodes_dynamic
= p
;
984 env
->mem_alloc
= alloc
;
993 scan_env_set_mem_node(ScanEnv
* env
, int num
, Node
* node
)
995 if (env
->num_mem
>= num
)
996 SCANENV_MEM_NODES(env
)[num
] = node
;
998 return ONIGERR_PARSER_BUG
;
1003 #ifdef USE_PARSE_TREE_NODE_RECYCLE
1004 typedef struct _FreeNode
{
1005 struct _FreeNode
* next
;
1008 static FreeNode
* FreeNodeList
= (FreeNode
* )NULL
;
1012 onig_node_free(Node
* node
)
1015 if (IS_NULL(node
)) return ;
1017 switch (NTYPE(node
)) {
1019 if (NSTR(node
)->capa
!= 0 &&
1020 IS_NOT_NULL(NSTR(node
)->s
) && NSTR(node
)->s
!= NSTR(node
)->buf
) {
1021 xfree(NSTR(node
)->s
);
1027 onig_node_free(NCAR(node
));
1029 Node
* next_node
= NCDR(node
);
1031 #ifdef USE_PARSE_TREE_NODE_RECYCLE
1033 FreeNode
* n
= (FreeNode
* )node
;
1035 THREAD_ATOMIC_START
;
1036 n
->next
= FreeNodeList
;
1050 CClassNode
* cc
= NCCLASS(node
);
1052 if (IS_NCCLASS_SHARE(cc
)) return ;
1054 bbuf_free(cc
->mbuf
);
1059 if (NQTFR(node
)->target
)
1060 onig_node_free(NQTFR(node
)->target
);
1064 if (NENCLOSE(node
)->target
)
1065 onig_node_free(NENCLOSE(node
)->target
);
1069 if (IS_NOT_NULL(NBREF(node
)->back_dynamic
))
1070 xfree(NBREF(node
)->back_dynamic
);
1074 if (NANCHOR(node
)->target
)
1075 onig_node_free(NANCHOR(node
)->target
);
1079 #ifdef USE_PARSE_TREE_NODE_RECYCLE
1081 FreeNode
* n
= (FreeNode
* )node
;
1083 THREAD_ATOMIC_START
;
1084 n
->next
= FreeNodeList
;
1093 #ifdef USE_PARSE_TREE_NODE_RECYCLE
1095 onig_free_node_list(void)
1099 /* THREAD_ATOMIC_START; */
1100 while (IS_NOT_NULL(FreeNodeList
)) {
1102 FreeNodeList
= FreeNodeList
->next
;
1105 /* THREAD_ATOMIC_END; */
1115 #ifdef USE_PARSE_TREE_NODE_RECYCLE
1116 THREAD_ATOMIC_START
;
1117 if (IS_NOT_NULL(FreeNodeList
)) {
1118 node
= (Node
* )FreeNodeList
;
1119 FreeNodeList
= FreeNodeList
->next
;
1126 node
= (Node
* )xmalloc(sizeof(Node
));
1127 /* xmemset(node, 0, sizeof(Node)); */
1133 initialize_cclass(CClassNode
* cc
)
1135 BITSET_CLEAR(cc
->bs
);
1136 /* cc->base.flags = 0; */
1142 node_new_cclass(void)
1144 Node
* node
= node_new();
1145 CHECK_NULL_RETURN(node
);
1147 SET_NTYPE(node
, NT_CCLASS
);
1148 initialize_cclass(NCCLASS(node
));
1153 node_new_cclass_by_codepoint_range(int not, OnigCodePoint sb_out
,
1154 const OnigCodePoint ranges
[])
1160 Node
* node
= node_new_cclass();
1161 CHECK_NULL_RETURN(node
);
1164 if (not != 0) NCCLASS_SET_NOT(cc
);
1166 BITSET_CLEAR(cc
->bs
);
1167 if (sb_out
> 0 && IS_NOT_NULL(ranges
)) {
1168 n
= ONIGENC_CODE_RANGE_NUM(ranges
);
1169 for (i
= 0; i
< n
; i
++) {
1170 for (j
= ONIGENC_CODE_RANGE_FROM(ranges
, i
);
1171 j
<= (OnigCodePoint
)ONIGENC_CODE_RANGE_TO(ranges
, i
); j
++) {
1172 if (j
>= sb_out
) goto sb_end
;
1174 BITSET_SET_BIT(cc
->bs
, j
);
1180 if (IS_NULL(ranges
)) {
1187 n
= ONIGENC_CODE_RANGE_NUM(ranges
);
1188 if (n
== 0) goto is_null
;
1190 bbuf
= (BBuf
* )xmalloc(sizeof(BBuf
));
1191 CHECK_NULL_RETURN(bbuf
);
1192 bbuf
->alloc
= n
+ 1;
1194 bbuf
->p
= (UChar
* )((void* )ranges
);
1203 node_new_ctype(int type
, int not)
1205 Node
* node
= node_new();
1206 CHECK_NULL_RETURN(node
);
1208 SET_NTYPE(node
, NT_CTYPE
);
1209 NCTYPE(node
)->ctype
= type
;
1210 NCTYPE(node
)->not = not;
1215 node_new_anychar(void)
1217 Node
* node
= node_new();
1218 CHECK_NULL_RETURN(node
);
1220 SET_NTYPE(node
, NT_CANY
);
1225 node_new_list(Node
* left
, Node
* right
)
1227 Node
* node
= node_new();
1228 CHECK_NULL_RETURN(node
);
1230 SET_NTYPE(node
, NT_LIST
);
1237 onig_node_new_list(Node
* left
, Node
* right
)
1239 return node_new_list(left
, right
);
1243 onig_node_list_add(Node
* list
, Node
* x
)
1247 n
= onig_node_new_list(x
, NULL
);
1248 if (IS_NULL(n
)) return NULL_NODE
;
1250 if (IS_NOT_NULL(list
)) {
1251 while (IS_NOT_NULL(NCDR(list
)))
1261 onig_node_new_alt(Node
* left
, Node
* right
)
1263 Node
* node
= node_new();
1264 CHECK_NULL_RETURN(node
);
1266 SET_NTYPE(node
, NT_ALT
);
1273 onig_node_new_anchor(int type
)
1275 Node
* node
= node_new();
1276 CHECK_NULL_RETURN(node
);
1278 SET_NTYPE(node
, NT_ANCHOR
);
1279 NANCHOR(node
)->type
= type
;
1280 NANCHOR(node
)->target
= NULL
;
1281 NANCHOR(node
)->char_len
= -1;
1286 node_new_backref(int back_num
, int* backrefs
, int by_name
,
1287 #ifdef USE_BACKREF_WITH_LEVEL
1288 int exist_level
, int nest_level
,
1293 Node
* node
= node_new();
1295 CHECK_NULL_RETURN(node
);
1297 SET_NTYPE(node
, NT_BREF
);
1298 NBREF(node
)->state
= 0;
1299 NBREF(node
)->back_num
= back_num
;
1300 NBREF(node
)->back_dynamic
= (int* )NULL
;
1302 NBREF(node
)->state
|= NST_NAME_REF
;
1304 #ifdef USE_BACKREF_WITH_LEVEL
1305 if (exist_level
!= 0) {
1306 NBREF(node
)->state
|= NST_NEST_LEVEL
;
1307 NBREF(node
)->nest_level
= nest_level
;
1311 for (i
= 0; i
< back_num
; i
++) {
1312 if (backrefs
[i
] <= env
->num_mem
&&
1313 IS_NULL(SCANENV_MEM_NODES(env
)[backrefs
[i
]])) {
1314 NBREF(node
)->state
|= NST_RECURSION
; /* /...(\1).../ */
1319 if (back_num
<= NODE_BACKREFS_SIZE
) {
1320 for (i
= 0; i
< back_num
; i
++)
1321 NBREF(node
)->back_static
[i
] = backrefs
[i
];
1324 int* p
= (int* )xmalloc(sizeof(int) * back_num
);
1326 onig_node_free(node
);
1329 NBREF(node
)->back_dynamic
= p
;
1330 for (i
= 0; i
< back_num
; i
++)
1336 #ifdef USE_SUBEXP_CALL
1338 node_new_call(UChar
* name
, UChar
* name_end
, int gnum
)
1340 Node
* node
= node_new();
1341 CHECK_NULL_RETURN(node
);
1343 SET_NTYPE(node
, NT_CALL
);
1344 NCALL(node
)->state
= 0;
1345 NCALL(node
)->target
= NULL_NODE
;
1346 NCALL(node
)->name
= name
;
1347 NCALL(node
)->name_end
= name_end
;
1348 NCALL(node
)->group_num
= gnum
; /* call by number if gnum != 0 */
1354 node_new_quantifier(int lower
, int upper
, int by_number
)
1356 Node
* node
= node_new();
1357 CHECK_NULL_RETURN(node
);
1359 SET_NTYPE(node
, NT_QTFR
);
1360 NQTFR(node
)->state
= 0;
1361 NQTFR(node
)->target
= NULL
;
1362 NQTFR(node
)->lower
= lower
;
1363 NQTFR(node
)->upper
= upper
;
1364 NQTFR(node
)->greedy
= 1;
1365 NQTFR(node
)->target_empty_info
= NQ_TARGET_ISNOT_EMPTY
;
1366 NQTFR(node
)->head_exact
= NULL_NODE
;
1367 NQTFR(node
)->next_head_exact
= NULL_NODE
;
1368 NQTFR(node
)->is_refered
= 0;
1370 NQTFR(node
)->state
|= NST_BY_NUMBER
;
1372 #ifdef USE_COMBINATION_EXPLOSION_CHECK
1373 NQTFR(node
)->comb_exp_check_num
= 0;
1380 node_new_enclose(int type
)
1382 Node
* node
= node_new();
1383 CHECK_NULL_RETURN(node
);
1385 SET_NTYPE(node
, NT_ENCLOSE
);
1386 NENCLOSE(node
)->type
= type
;
1387 NENCLOSE(node
)->state
= 0;
1388 NENCLOSE(node
)->regnum
= 0;
1389 NENCLOSE(node
)->option
= 0;
1390 NENCLOSE(node
)->target
= NULL
;
1391 NENCLOSE(node
)->call_addr
= -1;
1392 NENCLOSE(node
)->opt_count
= 0;
1397 onig_node_new_enclose(int type
)
1399 return node_new_enclose(type
);
1403 node_new_enclose_memory(OnigOptionType option
, int is_named
)
1405 Node
* node
= node_new_enclose(ENCLOSE_MEMORY
);
1406 CHECK_NULL_RETURN(node
);
1408 SET_ENCLOSE_STATUS(node
, NST_NAMED_GROUP
);
1410 #ifdef USE_SUBEXP_CALL
1411 NENCLOSE(node
)->option
= option
;
1417 node_new_option(OnigOptionType option
)
1419 Node
* node
= node_new_enclose(ENCLOSE_OPTION
);
1420 CHECK_NULL_RETURN(node
);
1421 NENCLOSE(node
)->option
= option
;
1426 onig_node_str_cat(Node
* node
, const UChar
* s
, const UChar
* end
)
1428 int addlen
= (int)(end
- s
);
1431 int len
= (int)(NSTR(node
)->end
- NSTR(node
)->s
);
1433 if (NSTR(node
)->capa
> 0 || (len
+ addlen
> NODE_STR_BUF_SIZE
- 1)) {
1435 int capa
= len
+ addlen
+ NODE_STR_MARGIN
;
1437 if (capa
<= NSTR(node
)->capa
) {
1438 onig_strcpy(NSTR(node
)->s
+ len
, s
, end
);
1441 if (NSTR(node
)->s
== NSTR(node
)->buf
)
1442 p
= strcat_capa_from_static(NSTR(node
)->s
, NSTR(node
)->end
,
1445 p
= strcat_capa(NSTR(node
)->s
, NSTR(node
)->end
, s
, end
, capa
, NSTR(node
)->capa
);
1447 CHECK_NULL_RETURN_MEMERR(p
);
1449 NSTR(node
)->capa
= capa
;
1453 onig_strcpy(NSTR(node
)->s
+ len
, s
, end
);
1455 NSTR(node
)->end
= NSTR(node
)->s
+ len
+ addlen
;
1462 onig_node_str_set(Node
* node
, const UChar
* s
, const UChar
* end
)
1464 onig_node_str_clear(node
);
1465 return onig_node_str_cat(node
, s
, end
);
1469 node_str_cat_char(Node
* node
, UChar c
)
1474 return onig_node_str_cat(node
, s
, s
+ 1);
1478 onig_node_conv_to_str_node(Node
* node
, int flag
)
1480 SET_NTYPE(node
, NT_STR
);
1481 NSTR(node
)->flag
= flag
;
1482 NSTR(node
)->capa
= 0;
1483 NSTR(node
)->s
= NSTR(node
)->buf
;
1484 NSTR(node
)->end
= NSTR(node
)->buf
;
1488 onig_node_str_clear(Node
* node
)
1490 if (NSTR(node
)->capa
!= 0 &&
1491 IS_NOT_NULL(NSTR(node
)->s
) && NSTR(node
)->s
!= NSTR(node
)->buf
) {
1492 xfree(NSTR(node
)->s
);
1495 NSTR(node
)->capa
= 0;
1496 NSTR(node
)->flag
= 0;
1497 NSTR(node
)->s
= NSTR(node
)->buf
;
1498 NSTR(node
)->end
= NSTR(node
)->buf
;
1502 node_new_str(const UChar
* s
, const UChar
* end
)
1504 Node
* node
= node_new();
1505 CHECK_NULL_RETURN(node
);
1507 SET_NTYPE(node
, NT_STR
);
1508 NSTR(node
)->capa
= 0;
1509 NSTR(node
)->flag
= 0;
1510 NSTR(node
)->s
= NSTR(node
)->buf
;
1511 NSTR(node
)->end
= NSTR(node
)->buf
;
1512 if (onig_node_str_cat(node
, s
, end
)) {
1513 onig_node_free(node
);
1520 onig_node_new_str(const UChar
* s
, const UChar
* end
)
1522 return node_new_str(s
, end
);
1526 node_new_str_raw(UChar
* s
, UChar
* end
)
1528 Node
* node
= node_new_str(s
, end
);
1529 CHECK_NULL_RETURN(node
);
1530 NSTRING_SET_RAW(node
);
1535 node_new_empty(void)
1537 return node_new_str(NULL
, NULL
);
1541 node_new_str_raw_char(UChar c
)
1546 return node_new_str_raw(p
, p
+ 1);
1550 str_node_split_last_char(StrNode
* sn
, OnigEncoding enc
)
1553 Node
* n
= NULL_NODE
;
1555 if (sn
->end
> sn
->s
) {
1556 p
= onigenc_get_prev_char_head(enc
, sn
->s
, sn
->end
);
1557 if (p
&& p
> sn
->s
) { /* can be splitted. */
1558 n
= node_new_str(p
, sn
->end
);
1559 CHECK_NULL_RETURN(n
);
1560 if ((sn
->flag
& NSTR_RAW
) != 0)
1562 sn
->end
= (UChar
* )p
;
1569 str_node_can_be_split(StrNode
* sn
, OnigEncoding enc
)
1571 if (sn
->end
> sn
->s
) {
1572 return ((enclen(enc
, sn
->s
) < sn
->end
- sn
->s
) ? 1 : 0);
1577 #ifdef USE_PAD_TO_SHORT_BYTE_CHAR
1579 node_str_head_pad(StrNode
* sn
, int num
, UChar val
)
1581 UChar buf
[NODE_STR_BUF_SIZE
];
1584 len
= sn
->end
- sn
->s
;
1585 onig_strcpy(buf
, sn
->s
, sn
->end
);
1586 onig_strcpy(&(sn
->s
[num
]), buf
, buf
+ len
);
1589 for (i
= 0; i
< num
; i
++) {
1596 onig_scan_unsigned_number(UChar
** src
, const UChar
* end
, OnigEncoding enc
)
1598 unsigned int num
, val
;
1606 if (ONIGENC_IS_CODE_DIGIT(enc
, c
)) {
1607 val
= (unsigned int )DIGITVAL(c
);
1608 if ((INT_MAX_LIMIT
- val
) / 10UL < num
)
1609 return -1; /* overflow */
1611 num
= num
* 10 + val
;
1623 scan_unsigned_hexadecimal_number(UChar
** src
, UChar
* end
, int maxlen
,
1627 unsigned int num
, val
;
1632 while (!PEND
&& maxlen
-- != 0) {
1634 if (ONIGENC_IS_CODE_XDIGIT(enc
, c
)) {
1635 val
= (unsigned int )XDIGITVAL(enc
,c
);
1636 if ((INT_MAX_LIMIT
- val
) / 16UL < num
)
1637 return -1; /* overflow */
1639 num
= (num
<< 4) + XDIGITVAL(enc
,c
);
1651 scan_unsigned_octal_number(UChar
** src
, UChar
* end
, int maxlen
,
1655 unsigned int num
, val
;
1660 while (!PEND
&& maxlen
-- != 0) {
1662 if (ONIGENC_IS_CODE_DIGIT(enc
, c
) && c
< '8') {
1664 if ((INT_MAX_LIMIT
- val
) / 8UL < num
)
1665 return -1; /* overflow */
1667 num
= (num
<< 3) + val
;
1679 #define BBUF_WRITE_CODE_POINT(bbuf,pos,code) \
1680 BBUF_WRITE(bbuf, pos, &(code), SIZE_CODE_POINT)
1683 [n][from-1][to-1][from-2][to-2] ... [from-n][to-n]
1684 (all data size is OnigCodePoint)
1687 new_code_range(BBuf
** pbuf
)
1689 #define INIT_MULTI_BYTE_RANGE_SIZE (SIZE_CODE_POINT * 5)
1694 bbuf
= *pbuf
= (BBuf
* )xmalloc(sizeof(BBuf
));
1695 CHECK_NULL_RETURN_MEMERR(*pbuf
);
1696 r
= BBUF_INIT(*pbuf
, INIT_MULTI_BYTE_RANGE_SIZE
);
1700 BBUF_WRITE_CODE_POINT(bbuf
, 0, n
);
1705 add_code_range_to_buf(BBuf
** pbuf
, OnigCodePoint from
, OnigCodePoint to
)
1708 int low
, high
, bound
, x
;
1709 OnigCodePoint n
, *data
;
1713 n
= from
; from
= to
; to
= n
;
1716 if (IS_NULL(*pbuf
)) {
1717 r
= new_code_range(pbuf
);
1724 GET_CODE_POINT(n
, bbuf
->p
);
1726 data
= (OnigCodePoint
* )(bbuf
->p
);
1729 for (low
= 0, bound
= n
; low
< bound
; ) {
1730 x
= (low
+ bound
) >> 1;
1731 if (from
> data
[x
*2 + 1])
1737 for (high
= low
, bound
= n
; high
< bound
; ) {
1738 x
= (high
+ bound
) >> 1;
1739 if (to
>= data
[x
*2] - 1)
1745 inc_n
= low
+ 1 - high
;
1746 if (n
+ inc_n
> ONIG_MAX_MULTI_BYTE_RANGES_NUM
)
1747 return ONIGERR_TOO_MANY_MULTI_BYTE_RANGES
;
1750 if (from
> data
[low
*2])
1752 if (to
< data
[(high
- 1)*2 + 1])
1753 to
= data
[(high
- 1)*2 + 1];
1756 if (inc_n
!= 0 && (OnigCodePoint
)high
< n
) {
1757 int from_pos
= SIZE_CODE_POINT
* (1 + high
* 2);
1758 int to_pos
= SIZE_CODE_POINT
* (1 + (low
+ 1) * 2);
1759 int size
= (n
- high
) * 2 * SIZE_CODE_POINT
;
1762 BBUF_MOVE_RIGHT(bbuf
, from_pos
, to_pos
, size
);
1765 BBUF_MOVE_LEFT_REDUCE(bbuf
, from_pos
, to_pos
);
1769 pos
= SIZE_CODE_POINT
* (1 + low
* 2);
1770 BBUF_ENSURE_SIZE(bbuf
, pos
+ SIZE_CODE_POINT
* 2);
1771 BBUF_WRITE_CODE_POINT(bbuf
, pos
, from
);
1772 BBUF_WRITE_CODE_POINT(bbuf
, pos
+ SIZE_CODE_POINT
, to
);
1774 BBUF_WRITE_CODE_POINT(bbuf
, 0, n
);
1780 add_code_range(BBuf
** pbuf
, ScanEnv
* env
, OnigCodePoint from
, OnigCodePoint to
)
1783 if (IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_ALLOW_EMPTY_RANGE_IN_CC
))
1786 return ONIGERR_EMPTY_RANGE_IN_CHAR_CLASS
;
1789 return add_code_range_to_buf(pbuf
, from
, to
);
1793 not_code_range_buf(OnigEncoding enc
, BBuf
* bbuf
, BBuf
** pbuf
)
1796 OnigCodePoint pre
, from
, *data
, to
= 0;
1798 *pbuf
= (BBuf
* )NULL
;
1799 if (IS_NULL(bbuf
)) {
1801 return SET_ALL_MULTI_BYTE_RANGE(enc
, pbuf
);
1804 data
= (OnigCodePoint
* )(bbuf
->p
);
1805 GET_CODE_POINT(n
, data
);
1807 if (n
<= 0) goto set_all
;
1810 pre
= MBCODE_START_POS(enc
);
1811 for (i
= 0; i
< n
; i
++) {
1814 if (pre
<= from
- 1) {
1815 r
= add_code_range_to_buf(pbuf
, pre
, from
- 1);
1816 if (r
!= 0) return r
;
1818 if (to
== ~((OnigCodePoint
)0)) break;
1821 if (to
< ~((OnigCodePoint
)0)) {
1822 r
= add_code_range_to_buf(pbuf
, to
+ 1, ~((OnigCodePoint
)0));
1827 #define SWAP_BBUF_NOT(bbuf1, not1, bbuf2, not2) do {\
1830 tnot = not1; not1 = not2; not2 = tnot; \
1831 tbuf = bbuf1; bbuf1 = bbuf2; bbuf2 = tbuf; \
1835 or_code_range_buf(OnigEncoding enc
, BBuf
* bbuf1
, int not1
,
1836 BBuf
* bbuf2
, int not2
, BBuf
** pbuf
)
1839 OnigCodePoint i
, n1
, *data1
;
1840 OnigCodePoint from
, to
;
1842 *pbuf
= (BBuf
* )NULL
;
1843 if (IS_NULL(bbuf1
) && IS_NULL(bbuf2
)) {
1844 if (not1
!= 0 || not2
!= 0)
1845 return SET_ALL_MULTI_BYTE_RANGE(enc
, pbuf
);
1851 SWAP_BBUF_NOT(bbuf1
, not1
, bbuf2
, not2
);
1853 if (IS_NULL(bbuf1
)) {
1855 return SET_ALL_MULTI_BYTE_RANGE(enc
, pbuf
);
1859 return bbuf_clone(pbuf
, bbuf2
);
1862 return not_code_range_buf(enc
, bbuf2
, pbuf
);
1868 SWAP_BBUF_NOT(bbuf1
, not1
, bbuf2
, not2
);
1870 data1
= (OnigCodePoint
* )(bbuf1
->p
);
1871 GET_CODE_POINT(n1
, data1
);
1874 if (not2
== 0 && not1
== 0) { /* 1 OR 2 */
1875 r
= bbuf_clone(pbuf
, bbuf2
);
1877 else if (not1
== 0) { /* 1 OR (not 2) */
1878 r
= not_code_range_buf(enc
, bbuf2
, pbuf
);
1880 if (r
!= 0) return r
;
1882 for (i
= 0; i
< n1
; i
++) {
1885 r
= add_code_range_to_buf(pbuf
, from
, to
);
1886 if (r
!= 0) return r
;
1892 and_code_range1(BBuf
** pbuf
, OnigCodePoint from1
, OnigCodePoint to1
,
1893 OnigCodePoint
* data
, int n
)
1896 OnigCodePoint from2
, to2
;
1898 for (i
= 0; i
< n
; i
++) {
1901 if (from2
< from1
) {
1902 if (to2
< from1
) continue;
1907 else if (from2
<= to1
) {
1909 if (from1
<= from2
- 1) {
1910 r
= add_code_range_to_buf(pbuf
, from1
, from2
-1);
1911 if (r
!= 0) return r
;
1922 if (from1
> to1
) break;
1925 r
= add_code_range_to_buf(pbuf
, from1
, to1
);
1926 if (r
!= 0) return r
;
1932 and_code_range_buf(BBuf
* bbuf1
, int not1
, BBuf
* bbuf2
, int not2
, BBuf
** pbuf
)
1935 OnigCodePoint i
, j
, n1
, n2
, *data1
, *data2
;
1936 OnigCodePoint from
, to
, from1
, to1
, from2
, to2
;
1938 *pbuf
= (BBuf
* )NULL
;
1939 if (IS_NULL(bbuf1
)) {
1940 if (not1
!= 0 && IS_NOT_NULL(bbuf2
)) /* not1 != 0 -> not2 == 0 */
1941 return bbuf_clone(pbuf
, bbuf2
);
1944 else if (IS_NULL(bbuf2
)) {
1946 return bbuf_clone(pbuf
, bbuf1
);
1951 SWAP_BBUF_NOT(bbuf1
, not1
, bbuf2
, not2
);
1953 data1
= (OnigCodePoint
* )(bbuf1
->p
);
1954 data2
= (OnigCodePoint
* )(bbuf2
->p
);
1955 GET_CODE_POINT(n1
, data1
);
1956 GET_CODE_POINT(n2
, data2
);
1960 if (not2
== 0 && not1
== 0) { /* 1 AND 2 */
1961 for (i
= 0; i
< n1
; i
++) {
1964 for (j
= 0; j
< n2
; j
++) {
1967 if (from2
> to1
) break;
1968 if (to2
< from1
) continue;
1969 from
= MAX(from1
, from2
);
1971 r
= add_code_range_to_buf(pbuf
, from
, to
);
1972 if (r
!= 0) return r
;
1976 else if (not1
== 0) { /* 1 AND (not 2) */
1977 for (i
= 0; i
< n1
; i
++) {
1980 r
= and_code_range1(pbuf
, from1
, to1
, data2
, n2
);
1981 if (r
!= 0) return r
;
1989 and_cclass(CClassNode
* dest
, CClassNode
* cc
, OnigEncoding enc
)
1992 BBuf
*buf1
, *buf2
, *pbuf
;
1993 BitSetRef bsr1
, bsr2
;
1996 not1
= IS_NCCLASS_NOT(dest
);
1999 not2
= IS_NCCLASS_NOT(cc
);
2004 bitset_invert_to(bsr1
, bs1
);
2008 bitset_invert_to(bsr2
, bs2
);
2011 bitset_and(bsr1
, bsr2
);
2012 if (bsr1
!= dest
->bs
) {
2013 bitset_copy(dest
->bs
, bsr1
);
2017 bitset_invert(dest
->bs
);
2020 if (! ONIGENC_IS_SINGLEBYTE(enc
)) {
2021 if (not1
!= 0 && not2
!= 0) {
2022 r
= or_code_range_buf(enc
, buf1
, 0, buf2
, 0, &pbuf
);
2025 r
= and_code_range_buf(buf1
, not1
, buf2
, not2
, &pbuf
);
2026 if (r
== 0 && not1
!= 0) {
2028 r
= not_code_range_buf(enc
, pbuf
, &tbuf
);
2037 if (r
!= 0) return r
;
2047 or_cclass(CClassNode
* dest
, CClassNode
* cc
, OnigEncoding enc
)
2050 BBuf
*buf1
, *buf2
, *pbuf
;
2051 BitSetRef bsr1
, bsr2
;
2054 not1
= IS_NCCLASS_NOT(dest
);
2057 not2
= IS_NCCLASS_NOT(cc
);
2062 bitset_invert_to(bsr1
, bs1
);
2066 bitset_invert_to(bsr2
, bs2
);
2069 bitset_or(bsr1
, bsr2
);
2070 if (bsr1
!= dest
->bs
) {
2071 bitset_copy(dest
->bs
, bsr1
);
2075 bitset_invert(dest
->bs
);
2078 if (! ONIGENC_IS_SINGLEBYTE(enc
)) {
2079 if (not1
!= 0 && not2
!= 0) {
2080 r
= and_code_range_buf(buf1
, 0, buf2
, 0, &pbuf
);
2083 r
= or_code_range_buf(enc
, buf1
, not1
, buf2
, not2
, &pbuf
);
2084 if (r
== 0 && not1
!= 0) {
2086 r
= not_code_range_buf(enc
, pbuf
, &tbuf
);
2095 if (r
!= 0) return r
;
2106 conv_backslash_value(int c
, ScanEnv
* env
)
2108 if (IS_SYNTAX_OP(env
->syntax
, ONIG_SYN_OP_ESC_CONTROL_CHARS
)) {
2110 case 'n': return '\n';
2111 case 't': return '\t';
2112 case 'r': return '\r';
2113 case 'f': return '\f';
2114 case 'a': return '\007';
2115 case 'b': return '\010';
2116 case 'e': return '\033';
2118 if (IS_SYNTAX_OP2(env
->syntax
, ONIG_SYN_OP2_ESC_V_VTAB
))
2130 is_invalid_quantifier_target(Node
* node
)
2132 switch (NTYPE(node
)) {
2138 /* allow enclosed elements */
2139 /* return is_invalid_quantifier_target(NENCLOSE(node)->target); */
2144 if (! is_invalid_quantifier_target(NCAR(node
))) return 0;
2145 } while (IS_NOT_NULL(node
= NCDR(node
)));
2151 if (is_invalid_quantifier_target(NCAR(node
))) return 1;
2152 } while (IS_NOT_NULL(node
= NCDR(node
)));
2161 /* ?:0, *:1, +:2, ??:3, *?:4, +?:5 */
2163 popular_quantifier_num(QtfrNode
* q
)
2166 if (q
->lower
== 0) {
2167 if (q
->upper
== 1) return 0;
2168 else if (IS_REPEAT_INFINITE(q
->upper
)) return 1;
2170 else if (q
->lower
== 1) {
2171 if (IS_REPEAT_INFINITE(q
->upper
)) return 2;
2175 if (q
->lower
== 0) {
2176 if (q
->upper
== 1) return 3;
2177 else if (IS_REPEAT_INFINITE(q
->upper
)) return 4;
2179 else if (q
->lower
== 1) {
2180 if (IS_REPEAT_INFINITE(q
->upper
)) return 5;
2188 RQ_ASIS
= 0, /* as is */
2189 RQ_DEL
= 1, /* delete parent */
2191 RQ_AQ
, /* to '*?' */
2192 RQ_QQ
, /* to '??' */
2193 RQ_P_QQ
, /* to '+)??' */
2194 RQ_PQ_Q
/* to '+?)?' */
2197 static enum ReduceType ReduceTypeTable
[6][6] = {
2198 {RQ_DEL
, RQ_A
, RQ_A
, RQ_QQ
, RQ_AQ
, RQ_ASIS
}, /* '?' */
2199 {RQ_DEL
, RQ_DEL
, RQ_DEL
, RQ_P_QQ
, RQ_P_QQ
, RQ_DEL
}, /* '*' */
2200 {RQ_A
, RQ_A
, RQ_DEL
, RQ_ASIS
, RQ_P_QQ
, RQ_DEL
}, /* '+' */
2201 {RQ_DEL
, RQ_AQ
, RQ_AQ
, RQ_DEL
, RQ_AQ
, RQ_AQ
}, /* '??' */
2202 {RQ_DEL
, RQ_DEL
, RQ_DEL
, RQ_DEL
, RQ_DEL
, RQ_DEL
}, /* '*?' */
2203 {RQ_ASIS
, RQ_PQ_Q
, RQ_DEL
, RQ_AQ
, RQ_AQ
, RQ_DEL
} /* '+?' */
2207 onig_reduce_nested_quantifier(Node
* pnode
, Node
* cnode
)
2214 pnum
= popular_quantifier_num(p
);
2215 cnum
= popular_quantifier_num(c
);
2216 if (pnum
< 0 || cnum
< 0) return ;
2218 switch(ReduceTypeTable
[cnum
][pnum
]) {
2220 CopyMem (pnode
, cnode
, sizeof (Node
));
2223 p
->target
= c
->target
;
2224 p
->lower
= 0; p
->upper
= REPEAT_INFINITE
; p
->greedy
= 1;
2227 p
->target
= c
->target
;
2228 p
->lower
= 0; p
->upper
= REPEAT_INFINITE
; p
->greedy
= 0;
2231 p
->target
= c
->target
;
2232 p
->lower
= 0; p
->upper
= 1; p
->greedy
= 0;
2236 p
->lower
= 0; p
->upper
= 1; p
->greedy
= 0;
2237 c
->lower
= 1; c
->upper
= REPEAT_INFINITE
; c
->greedy
= 1;
2242 p
->lower
= 0; p
->upper
= 1; p
->greedy
= 1;
2243 c
->lower
= 1; c
->upper
= REPEAT_INFINITE
; c
->greedy
= 0;
2252 c
->target
= NULL_NODE
;
2253 onig_node_free(cnode
);
2258 TK_EOT
= 0, /* end of token */
2270 TK_ANYCHAR_ANYTIME
, /* SQL '%' == .* */
2276 TK_CHAR_PROPERTY
, /* \p{...}, \P{...} */
2280 TK_POSIX_BRACKET_OPEN
,
2282 TK_CC_CC_OPEN
/* [ */
2286 enum TokenSyms type
;
2288 int base
; /* is number: 8, 16 (used in [....]) */
2307 #ifdef USE_BACKREF_WITH_LEVEL
2309 int level
; /* \k<name+n> */
2326 fetch_range_quantifier(UChar
** src
, UChar
* end
, OnigToken
* tok
, ScanEnv
* env
)
2328 int low
, up
, syn_allow
, non_low
= 0;
2331 OnigEncoding enc
= env
->enc
;
2335 syn_allow
= IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_ALLOW_INVALID_INTERVAL
);
2339 return 1; /* "....{" : OK! */
2341 return ONIGERR_END_PATTERN_AT_LEFT_BRACE
; /* "....{" syntax error */
2346 if (c
== ')' || c
== '(' || c
== '|') {
2347 return ONIGERR_END_PATTERN_AT_LEFT_BRACE
;
2351 low
= onig_scan_unsigned_number(&p
, end
, env
->enc
);
2352 if (low
< 0) return ONIGERR_TOO_BIG_NUMBER_FOR_REPEAT_RANGE
;
2353 if (low
> ONIG_MAX_REPEAT_NUM
)
2354 return ONIGERR_TOO_BIG_NUMBER_FOR_REPEAT_RANGE
;
2356 if (p
== *src
) { /* can't read low */
2357 if (IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_ALLOW_INTERVAL_LOW_ABBREV
)) {
2358 /* allow {,n} as {0,n} */
2366 if (PEND
) goto invalid
;
2370 up
= onig_scan_unsigned_number(&p
, end
, env
->enc
);
2371 if (up
< 0) return ONIGERR_TOO_BIG_NUMBER_FOR_REPEAT_RANGE
;
2372 if (up
> ONIG_MAX_REPEAT_NUM
)
2373 return ONIGERR_TOO_BIG_NUMBER_FOR_REPEAT_RANGE
;
2378 up
= REPEAT_INFINITE
; /* {n,} : {n,infinite} */
2386 up
= low
; /* {n} : exact n times */
2390 if (PEND
) goto invalid
;
2392 if (IS_SYNTAX_OP(env
->syntax
, ONIG_SYN_OP_ESC_BRACE_INTERVAL
)) {
2393 if (c
!= MC_ESC(env
->syntax
)) goto invalid
;
2396 if (c
!= '}') goto invalid
;
2398 if (!IS_REPEAT_INFINITE(up
) && low
> up
) {
2399 return ONIGERR_UPPER_SMALLER_THAN_LOWER_IN_REPEAT_RANGE
;
2402 tok
->type
= TK_INTERVAL
;
2403 tok
->u
.repeat
.lower
= low
;
2404 tok
->u
.repeat
.upper
= up
;
2406 return r
; /* 0: normal {n,m}, 2: fixed {n} */
2412 return ONIGERR_INVALID_REPEAT_RANGE_PATTERN
;
2415 /* \M-, \C-, \c, or \... */
2417 fetch_escaped_value(UChar
** src
, UChar
* end
, ScanEnv
* env
)
2421 OnigEncoding enc
= env
->enc
;
2424 if (PEND
) return ONIGERR_END_PATTERN_AT_ESCAPE
;
2429 if (IS_SYNTAX_OP2(env
->syntax
, ONIG_SYN_OP2_ESC_CAPITAL_M_BAR_META
)) {
2430 if (PEND
) return ONIGERR_END_PATTERN_AT_META
;
2432 if (c
!= '-') return ONIGERR_META_CODE_SYNTAX
;
2433 if (PEND
) return ONIGERR_END_PATTERN_AT_META
;
2435 if (c
== MC_ESC(env
->syntax
)) {
2436 v
= fetch_escaped_value(&p
, end
, env
);
2437 if (v
< 0) return v
;
2438 c
= (OnigCodePoint
)v
;
2440 c
= ((c
& 0xff) | 0x80);
2447 if (IS_SYNTAX_OP2(env
->syntax
, ONIG_SYN_OP2_ESC_CAPITAL_C_BAR_CONTROL
)) {
2448 if (PEND
) return ONIGERR_END_PATTERN_AT_CONTROL
;
2450 if (c
!= '-') return ONIGERR_CONTROL_CODE_SYNTAX
;
2457 if (IS_SYNTAX_OP(env
->syntax
, ONIG_SYN_OP_ESC_C_CONTROL
)) {
2459 if (PEND
) return ONIGERR_END_PATTERN_AT_CONTROL
;
2465 if (c
== MC_ESC(env
->syntax
)) {
2466 v
= fetch_escaped_value(&p
, end
, env
);
2467 if (v
< 0) return v
;
2468 c
= (OnigCodePoint
)v
;
2479 c
= conv_backslash_value(c
, env
);
2488 static int fetch_token(OnigToken
* tok
, UChar
** src
, UChar
* end
, ScanEnv
* env
);
2490 static OnigCodePoint
2491 get_name_end_code_point(OnigCodePoint start
)
2494 case '<': return (OnigCodePoint
)'>'; break;
2495 case '\'': return (OnigCodePoint
)'\''; break;
2500 return (OnigCodePoint
)0;
2503 #ifdef USE_NAMED_GROUP
2504 #ifdef USE_BACKREF_WITH_LEVEL
2506 \k<name+n>, \k<name-n>
2507 \k<num+n>, \k<num-n>
2508 \k<-num+n>, \k<-num-n>
2511 fetch_name_with_level(OnigCodePoint start_code
, UChar
** src
, UChar
* end
,
2512 UChar
** rname_end
, ScanEnv
* env
,
2513 int* rback_num
, int* rlevel
)
2515 int r
, sign
, is_num
, exist_level
;
2516 OnigCodePoint end_code
;
2517 OnigCodePoint c
= 0;
2518 OnigEncoding enc
= env
->enc
;
2525 is_num
= exist_level
= 0;
2529 end_code
= get_name_end_code_point(start_code
);
2534 return ONIGERR_EMPTY_GROUP_NAME
;
2539 return ONIGERR_EMPTY_GROUP_NAME
;
2541 if (ONIGENC_IS_CODE_DIGIT(enc
, c
)) {
2544 else if (c
== '-') {
2549 else if (!ONIGENC_IS_CODE_WORD(enc
, c
)) {
2550 r
= ONIGERR_INVALID_CHAR_IN_GROUP_NAME
;
2557 if (c
== end_code
|| c
== ')' || c
== '+' || c
== '-') {
2558 if (is_num
== 2) r
= ONIGERR_INVALID_GROUP_NAME
;
2563 if (ONIGENC_IS_CODE_DIGIT(enc
, c
)) {
2567 r
= ONIGERR_INVALID_GROUP_NAME
;
2571 else if (!ONIGENC_IS_CODE_WORD(enc
, c
)) {
2572 r
= ONIGERR_INVALID_CHAR_IN_GROUP_NAME
;
2576 if (r
== 0 && c
!= end_code
) {
2577 if (c
== '+' || c
== '-') {
2579 int flag
= (c
== '-' ? -1 : 1);
2582 if (! ONIGENC_IS_CODE_DIGIT(enc
, c
)) goto err
;
2584 level
= onig_scan_unsigned_number(&p
, end
, enc
);
2585 if (level
< 0) return ONIGERR_TOO_BIG_NUMBER
;
2586 *rlevel
= (level
* flag
);
2595 r
= ONIGERR_INVALID_GROUP_NAME
;
2602 *rback_num
= onig_scan_unsigned_number(&pnum_head
, name_end
, enc
);
2603 if (*rback_num
< 0) return ONIGERR_TOO_BIG_NUMBER
;
2604 else if (*rback_num
== 0) goto err
;
2609 *rname_end
= name_end
;
2611 return (exist_level
? 1 : 0);
2614 onig_scan_env_set_error_string(env
, r
, *src
, name_end
);
2618 #endif /* USE_BACKREF_WITH_LEVEL */
2621 def: 0 -> define name (don't allow number name)
2622 1 -> reference name (allow number name)
2625 fetch_name(OnigCodePoint start_code
, UChar
** src
, UChar
* end
,
2626 UChar
** rname_end
, ScanEnv
* env
, int* rback_num
, int ref
)
2628 int r
, is_num
, sign
;
2629 OnigCodePoint end_code
;
2630 OnigCodePoint c
= 0;
2631 OnigEncoding enc
= env
->enc
;
2638 end_code
= get_name_end_code_point(start_code
);
2646 return ONIGERR_EMPTY_GROUP_NAME
;
2651 return ONIGERR_EMPTY_GROUP_NAME
;
2653 if (ONIGENC_IS_CODE_DIGIT(enc
, c
)) {
2657 r
= ONIGERR_INVALID_GROUP_NAME
;
2661 else if (c
== '-') {
2668 r
= ONIGERR_INVALID_GROUP_NAME
;
2672 else if (!ONIGENC_IS_CODE_WORD(enc
, c
)) {
2673 r
= ONIGERR_INVALID_CHAR_IN_GROUP_NAME
;
2681 if (c
== end_code
|| c
== ')') {
2682 if (is_num
== 2) r
= ONIGERR_INVALID_GROUP_NAME
;
2687 if (ONIGENC_IS_CODE_DIGIT(enc
, c
)) {
2691 if (!ONIGENC_IS_CODE_WORD(enc
, c
))
2692 r
= ONIGERR_INVALID_CHAR_IN_GROUP_NAME
;
2694 r
= ONIGERR_INVALID_GROUP_NAME
;
2699 if (!ONIGENC_IS_CODE_WORD(enc
, c
)) {
2700 r
= ONIGERR_INVALID_CHAR_IN_GROUP_NAME
;
2705 if (c
!= end_code
) {
2706 r
= ONIGERR_INVALID_GROUP_NAME
;
2711 *rback_num
= onig_scan_unsigned_number(&pnum_head
, name_end
, enc
);
2712 if (*rback_num
< 0) return ONIGERR_TOO_BIG_NUMBER
;
2713 else if (*rback_num
== 0) {
2714 r
= ONIGERR_INVALID_GROUP_NAME
;
2721 *rname_end
= name_end
;
2729 if (c
== end_code
|| c
== ')')
2736 onig_scan_env_set_error_string(env
, r
, *src
, name_end
);
2742 fetch_name(OnigCodePoint start_code
, UChar
** src
, UChar
* end
,
2743 UChar
** rname_end
, ScanEnv
* env
, int* rback_num
, int ref
)
2745 int r
, is_num
, sign
;
2746 OnigCodePoint end_code
;
2747 OnigCodePoint c
= 0;
2749 OnigEncoding enc
= env
->enc
;
2756 end_code
= get_name_end_code_point(start_code
);
2758 *rname_end
= name_end
= end
;
2765 return ONIGERR_EMPTY_GROUP_NAME
;
2770 return ONIGERR_EMPTY_GROUP_NAME
;
2772 if (ONIGENC_IS_CODE_DIGIT(enc
, c
)) {
2775 else if (c
== '-') {
2781 r
= ONIGERR_INVALID_CHAR_IN_GROUP_NAME
;
2789 if (c
== end_code
|| c
== ')') break;
2790 if (! ONIGENC_IS_CODE_DIGIT(enc
, c
))
2791 r
= ONIGERR_INVALID_CHAR_IN_GROUP_NAME
;
2793 if (r
== 0 && c
!= end_code
) {
2794 r
= ONIGERR_INVALID_GROUP_NAME
;
2799 *rback_num
= onig_scan_unsigned_number(&pnum_head
, name_end
, enc
);
2800 if (*rback_num
< 0) return ONIGERR_TOO_BIG_NUMBER
;
2801 else if (*rback_num
== 0) {
2802 r
= ONIGERR_INVALID_GROUP_NAME
;
2807 *rname_end
= name_end
;
2813 onig_scan_env_set_error_string(env
, r
, *src
, name_end
);
2817 #endif /* USE_NAMED_GROUP */
2820 CC_ESC_WARN(ScanEnv
* env
, UChar
*c
)
2822 if (onig_warn
== onig_null_warn
) return ;
2824 if (IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_WARN_CC_OP_NOT_ESCAPED
) &&
2825 IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_BACKSLASH_ESCAPE_IN_CC
)) {
2826 UChar buf
[WARN_BUFSIZE
];
2827 onig_snprintf_with_pattern(buf
, WARN_BUFSIZE
, env
->enc
,
2828 env
->pattern
, env
->pattern_end
,
2829 (UChar
* )"character class has '%s' without escape", c
);
2830 (*onig_warn
)((char* )buf
);
2835 CLOSE_BRACKET_WITHOUT_ESC_WARN(ScanEnv
* env
, UChar
* c
)
2837 if (onig_warn
== onig_null_warn
) return ;
2839 if (IS_SYNTAX_BV((env
)->syntax
, ONIG_SYN_WARN_CC_OP_NOT_ESCAPED
)) {
2840 UChar buf
[WARN_BUFSIZE
];
2841 onig_snprintf_with_pattern(buf
, WARN_BUFSIZE
, (env
)->enc
,
2842 (env
)->pattern
, (env
)->pattern_end
,
2843 (UChar
* )"regular expression has '%s' without escape", c
);
2844 (*onig_warn
)((char* )buf
);
2849 find_str_position(OnigCodePoint s
[], int n
, UChar
* from
, UChar
* to
,
2850 UChar
**next
, OnigEncoding enc
)
2858 x
= ONIGENC_MBC_TO_CODE(enc
, p
, to
);
2859 q
= p
+ enclen(enc
, p
);
2861 for (i
= 1; i
< n
&& q
< to
; i
++) {
2862 x
= ONIGENC_MBC_TO_CODE(enc
, q
, to
);
2863 if (x
!= s
[i
]) break;
2864 q
+= enclen(enc
, q
);
2867 if (IS_NOT_NULL(next
))
2878 str_exist_check_with_esc(OnigCodePoint s
[], int n
, UChar
* from
, UChar
* to
,
2879 OnigCodePoint bad
, OnigEncoding enc
, OnigSyntaxType
* syn
)
2890 p
+= enclen(enc
, p
);
2893 x
= ONIGENC_MBC_TO_CODE(enc
, p
, to
);
2894 q
= p
+ enclen(enc
, p
);
2896 for (i
= 1; i
< n
&& q
< to
; i
++) {
2897 x
= ONIGENC_MBC_TO_CODE(enc
, q
, to
);
2898 if (x
!= s
[i
]) break;
2899 q
+= enclen(enc
, q
);
2901 if (i
>= n
) return 1;
2902 p
+= enclen(enc
, p
);
2905 x
= ONIGENC_MBC_TO_CODE(enc
, p
, to
);
2906 if (x
== bad
) return 0;
2907 else if (x
== MC_ESC(syn
)) in_esc
= 1;
2916 fetch_token_in_cc(OnigToken
* tok
, UChar
** src
, UChar
* end
, ScanEnv
* env
)
2919 OnigCodePoint c
, c2
;
2920 OnigSyntaxType
* syn
= env
->syntax
;
2921 OnigEncoding enc
= env
->enc
;
2932 tok
->type
= TK_CHAR
;
2938 tok
->type
= TK_CC_CLOSE
;
2940 else if (c
== '-') {
2941 tok
->type
= TK_CC_RANGE
;
2943 else if (c
== MC_ESC(syn
)) {
2944 if (! IS_SYNTAX_BV(syn
, ONIG_SYN_BACKSLASH_ESCAPE_IN_CC
))
2947 if (PEND
) return ONIGERR_END_PATTERN_AT_ESCAPE
;
2954 tok
->type
= TK_CHAR_TYPE
;
2955 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_WORD
;
2956 tok
->u
.prop
.not = 0;
2959 tok
->type
= TK_CHAR_TYPE
;
2960 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_WORD
;
2961 tok
->u
.prop
.not = 1;
2964 tok
->type
= TK_CHAR_TYPE
;
2965 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_DIGIT
;
2966 tok
->u
.prop
.not = 0;
2969 tok
->type
= TK_CHAR_TYPE
;
2970 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_DIGIT
;
2971 tok
->u
.prop
.not = 1;
2974 tok
->type
= TK_CHAR_TYPE
;
2975 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_SPACE
;
2976 tok
->u
.prop
.not = 0;
2979 tok
->type
= TK_CHAR_TYPE
;
2980 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_SPACE
;
2981 tok
->u
.prop
.not = 1;
2984 if (! IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_H_XDIGIT
)) break;
2985 tok
->type
= TK_CHAR_TYPE
;
2986 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_XDIGIT
;
2987 tok
->u
.prop
.not = 0;
2990 if (! IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_H_XDIGIT
)) break;
2991 tok
->type
= TK_CHAR_TYPE
;
2992 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_XDIGIT
;
2993 tok
->u
.prop
.not = 1;
3000 IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_P_BRACE_CHAR_PROPERTY
)) {
3002 tok
->type
= TK_CHAR_PROPERTY
;
3003 tok
->u
.prop
.not = (c
== 'P' ? 1 : 0);
3005 if (IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_P_BRACE_CIRCUMFLEX_NOT
)) {
3008 tok
->u
.prop
.not = (tok
->u
.prop
.not == 0 ? 1 : 0);
3020 if (PPEEK_IS('{') && IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_X_BRACE_HEX8
)) {
3022 num
= scan_unsigned_hexadecimal_number(&p
, end
, 8, enc
);
3023 if (num
< 0) return ONIGERR_TOO_BIG_WIDE_CHAR_VALUE
;
3026 if (ONIGENC_IS_CODE_XDIGIT(enc
, c2
))
3027 return ONIGERR_TOO_LONG_WIDE_CHAR_VALUE
;
3030 if (p
> prev
+ enclen(enc
, prev
) && !PEND
&& (PPEEK_IS('}'))) {
3032 tok
->type
= TK_CODE_POINT
;
3034 tok
->u
.code
= (OnigCodePoint
)num
;
3037 /* can't read nothing or invalid format */
3041 else if (IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_X_HEX2
)) {
3042 num
= scan_unsigned_hexadecimal_number(&p
, end
, 2, enc
);
3043 if (num
< 0) return ONIGERR_TOO_BIG_NUMBER
;
3044 if (p
== prev
) { /* can't read nothing. */
3045 num
= 0; /* but, it's not error */
3047 tok
->type
= TK_RAW_BYTE
;
3057 if (IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_U_HEX4
)) {
3058 num
= scan_unsigned_hexadecimal_number(&p
, end
, 4, enc
);
3059 if (num
< 0) return ONIGERR_TOO_BIG_NUMBER
;
3060 if (p
== prev
) { /* can't read nothing. */
3061 num
= 0; /* but, it's not error */
3063 tok
->type
= TK_CODE_POINT
;
3065 tok
->u
.code
= (OnigCodePoint
)num
;
3070 case '1': case '2': case '3': case '4': case '5': case '6': case '7':
3071 if (IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_OCTAL3
)) {
3074 num
= scan_unsigned_octal_number(&p
, end
, 3, enc
);
3075 if (num
< 0) return ONIGERR_TOO_BIG_NUMBER
;
3076 if (p
== prev
) { /* can't read nothing. */
3077 num
= 0; /* but, it's not error */
3079 tok
->type
= TK_RAW_BYTE
;
3087 num
= fetch_escaped_value(&p
, end
, env
);
3088 if (num
< 0) return num
;
3089 if (tok
->u
.c
!= num
) {
3090 tok
->u
.code
= (OnigCodePoint
)num
;
3091 tok
->type
= TK_CODE_POINT
;
3096 else if (c
== '[') {
3097 if (IS_SYNTAX_OP(syn
, ONIG_SYN_OP_POSIX_BRACKET
) && (PPEEK_IS(':'))) {
3098 OnigCodePoint send
[] = { (OnigCodePoint
)':', (OnigCodePoint
)']' };
3099 tok
->backp
= p
; /* point at '[' is readed */
3101 if (str_exist_check_with_esc(send
, 2, p
, end
,
3102 (OnigCodePoint
)']', enc
, syn
)) {
3103 tok
->type
= TK_POSIX_BRACKET_OPEN
;
3112 if (IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_CCLASS_SET_OP
)) {
3113 tok
->type
= TK_CC_CC_OPEN
;
3116 CC_ESC_WARN(env
, (UChar
* )"[");
3120 else if (c
== '&') {
3121 if (IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_CCLASS_SET_OP
) &&
3122 !PEND
&& (PPEEK_IS('&'))) {
3124 tok
->type
= TK_CC_AND
;
3134 fetch_token(OnigToken
* tok
, UChar
** src
, UChar
* end
, ScanEnv
* env
)
3138 OnigEncoding enc
= env
->enc
;
3139 OnigSyntaxType
* syn
= env
->syntax
;
3150 tok
->type
= TK_STRING
;
3155 if (IS_MC_ESC_CODE(c
, syn
)) {
3156 if (PEND
) return ONIGERR_END_PATTERN_AT_ESCAPE
;
3165 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_ASTERISK_ZERO_INF
)) break;
3166 tok
->type
= TK_OP_REPEAT
;
3167 tok
->u
.repeat
.lower
= 0;
3168 tok
->u
.repeat
.upper
= REPEAT_INFINITE
;
3173 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_PLUS_ONE_INF
)) break;
3174 tok
->type
= TK_OP_REPEAT
;
3175 tok
->u
.repeat
.lower
= 1;
3176 tok
->u
.repeat
.upper
= REPEAT_INFINITE
;
3181 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_QMARK_ZERO_ONE
)) break;
3182 tok
->type
= TK_OP_REPEAT
;
3183 tok
->u
.repeat
.lower
= 0;
3184 tok
->u
.repeat
.upper
= 1;
3186 if (!PEND
&& PPEEK_IS('?') &&
3187 IS_SYNTAX_OP(syn
, ONIG_SYN_OP_QMARK_NON_GREEDY
)) {
3189 tok
->u
.repeat
.greedy
= 0;
3190 tok
->u
.repeat
.possessive
= 0;
3194 if (!PEND
&& PPEEK_IS('+') &&
3195 ((IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_PLUS_POSSESSIVE_REPEAT
) &&
3196 tok
->type
!= TK_INTERVAL
) ||
3197 (IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_PLUS_POSSESSIVE_INTERVAL
) &&
3198 tok
->type
== TK_INTERVAL
))) {
3200 tok
->u
.repeat
.greedy
= 1;
3201 tok
->u
.repeat
.possessive
= 1;
3204 tok
->u
.repeat
.greedy
= 1;
3205 tok
->u
.repeat
.possessive
= 0;
3211 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_BRACE_INTERVAL
)) break;
3212 r
= fetch_range_quantifier(&p
, end
, tok
, env
);
3213 if (r
< 0) return r
; /* error */
3214 if (r
== 0) goto greedy_check
;
3215 else if (r
== 2) { /* {n} */
3216 if (IS_SYNTAX_BV(syn
, ONIG_SYN_FIXED_INTERVAL_IS_GREEDY_ONLY
))
3217 goto possessive_check
;
3221 /* r == 1 : normal char */
3225 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_VBAR_ALT
)) break;
3230 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_LPAREN_SUBEXP
)) break;
3231 tok
->type
= TK_SUBEXP_OPEN
;
3235 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_LPAREN_SUBEXP
)) break;
3236 tok
->type
= TK_SUBEXP_CLOSE
;
3240 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_W_WORD
)) break;
3241 tok
->type
= TK_CHAR_TYPE
;
3242 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_WORD
;
3243 tok
->u
.prop
.not = 0;
3247 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_W_WORD
)) break;
3248 tok
->type
= TK_CHAR_TYPE
;
3249 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_WORD
;
3250 tok
->u
.prop
.not = 1;
3254 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_B_WORD_BOUND
)) break;
3255 tok
->type
= TK_ANCHOR
;
3256 tok
->u
.anchor
= ANCHOR_WORD_BOUND
;
3260 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_B_WORD_BOUND
)) break;
3261 tok
->type
= TK_ANCHOR
;
3262 tok
->u
.anchor
= ANCHOR_NOT_WORD_BOUND
;
3265 #ifdef USE_WORD_BEGIN_END
3267 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_LTGT_WORD_BEGIN_END
)) break;
3268 tok
->type
= TK_ANCHOR
;
3269 tok
->u
.anchor
= ANCHOR_WORD_BEGIN
;
3273 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_LTGT_WORD_BEGIN_END
)) break;
3274 tok
->type
= TK_ANCHOR
;
3275 tok
->u
.anchor
= ANCHOR_WORD_END
;
3280 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_S_WHITE_SPACE
)) break;
3281 tok
->type
= TK_CHAR_TYPE
;
3282 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_SPACE
;
3283 tok
->u
.prop
.not = 0;
3287 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_S_WHITE_SPACE
)) break;
3288 tok
->type
= TK_CHAR_TYPE
;
3289 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_SPACE
;
3290 tok
->u
.prop
.not = 1;
3294 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_D_DIGIT
)) break;
3295 tok
->type
= TK_CHAR_TYPE
;
3296 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_DIGIT
;
3297 tok
->u
.prop
.not = 0;
3301 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_D_DIGIT
)) break;
3302 tok
->type
= TK_CHAR_TYPE
;
3303 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_DIGIT
;
3304 tok
->u
.prop
.not = 1;
3308 if (! IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_H_XDIGIT
)) break;
3309 tok
->type
= TK_CHAR_TYPE
;
3310 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_XDIGIT
;
3311 tok
->u
.prop
.not = 0;
3315 if (! IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_H_XDIGIT
)) break;
3316 tok
->type
= TK_CHAR_TYPE
;
3317 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_XDIGIT
;
3318 tok
->u
.prop
.not = 1;
3322 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_AZ_BUF_ANCHOR
)) break;
3324 tok
->type
= TK_ANCHOR
;
3325 tok
->u
.subtype
= ANCHOR_BEGIN_BUF
;
3329 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_AZ_BUF_ANCHOR
)) break;
3330 tok
->type
= TK_ANCHOR
;
3331 tok
->u
.subtype
= ANCHOR_SEMI_END_BUF
;
3335 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_AZ_BUF_ANCHOR
)) break;
3337 tok
->type
= TK_ANCHOR
;
3338 tok
->u
.subtype
= ANCHOR_END_BUF
;
3342 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_CAPITAL_G_BEGIN_ANCHOR
)) break;
3343 tok
->type
= TK_ANCHOR
;
3344 tok
->u
.subtype
= ANCHOR_BEGIN_POSITION
;
3348 if (! IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_GNU_BUF_ANCHOR
)) break;
3353 if (! IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_GNU_BUF_ANCHOR
)) break;
3361 if (PPEEK_IS('{') && IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_X_BRACE_HEX8
)) {
3363 num
= scan_unsigned_hexadecimal_number(&p
, end
, 8, enc
);
3364 if (num
< 0) return ONIGERR_TOO_BIG_WIDE_CHAR_VALUE
;
3366 if (ONIGENC_IS_CODE_XDIGIT(enc
, PPEEK
))
3367 return ONIGERR_TOO_LONG_WIDE_CHAR_VALUE
;
3370 if ((p
> prev
+ enclen(enc
, prev
)) && !PEND
&& PPEEK_IS('}')) {
3372 tok
->type
= TK_CODE_POINT
;
3373 tok
->u
.code
= (OnigCodePoint
)num
;
3376 /* can't read nothing or invalid format */
3380 else if (IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_X_HEX2
)) {
3381 num
= scan_unsigned_hexadecimal_number(&p
, end
, 2, enc
);
3382 if (num
< 0) return ONIGERR_TOO_BIG_NUMBER
;
3383 if (p
== prev
) { /* can't read nothing. */
3384 num
= 0; /* but, it's not error */
3386 tok
->type
= TK_RAW_BYTE
;
3396 if (IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_U_HEX4
)) {
3397 num
= scan_unsigned_hexadecimal_number(&p
, end
, 4, enc
);
3398 if (num
< 0) return ONIGERR_TOO_BIG_NUMBER
;
3399 if (p
== prev
) { /* can't read nothing. */
3400 num
= 0; /* but, it's not error */
3402 tok
->type
= TK_CODE_POINT
;
3404 tok
->u
.code
= (OnigCodePoint
)num
;
3408 case '1': case '2': case '3': case '4':
3409 case '5': case '6': case '7': case '8': case '9':
3412 num
= onig_scan_unsigned_number(&p
, end
, enc
);
3413 if (num
< 0 || num
> ONIG_MAX_BACKREF_NUM
) {
3417 if (IS_SYNTAX_OP(syn
, ONIG_SYN_OP_DECIMAL_BACKREF
) &&
3418 (num
<= env
->num_mem
|| num
<= 9)) { /* This spec. from GNU regex */
3419 if (IS_SYNTAX_BV(syn
, ONIG_SYN_STRICT_CHECK_BACKREF
)) {
3420 if (num
> env
->num_mem
|| IS_NULL(SCANENV_MEM_NODES(env
)[num
]))
3421 return ONIGERR_INVALID_BACKREF
;
3424 tok
->type
= TK_BACKREF
;
3425 tok
->u
.backref
.num
= 1;
3426 tok
->u
.backref
.ref1
= num
;
3427 tok
->u
.backref
.by_name
= 0;
3428 #ifdef USE_BACKREF_WITH_LEVEL
3429 tok
->u
.backref
.exist_level
= 0;
3435 if (c
== '8' || c
== '9') {
3444 if (IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_OCTAL3
)) {
3446 num
= scan_unsigned_octal_number(&p
, end
, (c
== '0' ? 2:3), enc
);
3447 if (num
< 0) return ONIGERR_TOO_BIG_NUMBER
;
3448 if (p
== prev
) { /* can't read nothing. */
3449 num
= 0; /* but, it's not error */
3451 tok
->type
= TK_RAW_BYTE
;
3455 else if (c
!= '0') {
3460 #ifdef USE_NAMED_GROUP
3462 if (IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_K_NAMED_BACKREF
)) {
3464 if (c
== '<' || c
== '\'') {
3471 #ifdef USE_BACKREF_WITH_LEVEL
3472 name_end
= NULL_UCHARP
; /* no need. escape gcc warning. */
3473 r
= fetch_name_with_level((OnigCodePoint
)c
, &p
, end
, &name_end
,
3474 env
, &back_num
, &tok
->u
.backref
.level
);
3475 if (r
== 1) tok
->u
.backref
.exist_level
= 1;
3476 else tok
->u
.backref
.exist_level
= 0;
3478 r
= fetch_name(&p
, end
, &name_end
, env
, &back_num
, 1);
3480 if (r
< 0) return r
;
3482 if (back_num
!= 0) {
3484 back_num
= BACKREF_REL_TO_ABS(back_num
, env
);
3486 return ONIGERR_INVALID_BACKREF
;
3489 if (IS_SYNTAX_BV(syn
, ONIG_SYN_STRICT_CHECK_BACKREF
)) {
3490 if (back_num
> env
->num_mem
||
3491 IS_NULL(SCANENV_MEM_NODES(env
)[back_num
]))
3492 return ONIGERR_INVALID_BACKREF
;
3494 tok
->type
= TK_BACKREF
;
3495 tok
->u
.backref
.by_name
= 0;
3496 tok
->u
.backref
.num
= 1;
3497 tok
->u
.backref
.ref1
= back_num
;
3500 num
= onig_name_to_group_numbers(env
->reg
, prev
, name_end
, &backs
);
3502 onig_scan_env_set_error_string(env
,
3503 ONIGERR_UNDEFINED_NAME_REFERENCE
, prev
, name_end
);
3504 return ONIGERR_UNDEFINED_NAME_REFERENCE
;
3506 if (IS_SYNTAX_BV(syn
, ONIG_SYN_STRICT_CHECK_BACKREF
)) {
3508 for (i
= 0; i
< num
; i
++) {
3509 if (backs
[i
] > env
->num_mem
||
3510 IS_NULL(SCANENV_MEM_NODES(env
)[backs
[i
]]))
3511 return ONIGERR_INVALID_BACKREF
;
3515 tok
->type
= TK_BACKREF
;
3516 tok
->u
.backref
.by_name
= 1;
3518 tok
->u
.backref
.num
= 1;
3519 tok
->u
.backref
.ref1
= backs
[0];
3522 tok
->u
.backref
.num
= num
;
3523 tok
->u
.backref
.refs
= backs
;
3533 #ifdef USE_SUBEXP_CALL
3535 if (IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_G_SUBEXP_CALL
)) {
3537 if (c
== '<' || c
== '\'') {
3542 r
= fetch_name((OnigCodePoint
)c
, &p
, end
, &name_end
, env
, &gnum
, 1);
3543 if (r
< 0) return r
;
3545 tok
->type
= TK_CALL
;
3546 tok
->u
.call
.name
= prev
;
3547 tok
->u
.call
.name_end
= name_end
;
3548 tok
->u
.call
.gnum
= gnum
;
3557 if (IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_CAPITAL_Q_QUOTE
)) {
3558 tok
->type
= TK_QUOTE_OPEN
;
3564 if (PPEEK_IS('{') &&
3565 IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_P_BRACE_CHAR_PROPERTY
)) {
3567 tok
->type
= TK_CHAR_PROPERTY
;
3568 tok
->u
.prop
.not = (c
== 'P' ? 1 : 0);
3570 if (IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_P_BRACE_CIRCUMFLEX_NOT
)) {
3573 tok
->u
.prop
.not = (tok
->u
.prop
.not == 0 ? 1 : 0);
3583 num
= fetch_escaped_value(&p
, end
, env
);
3584 if (num
< 0) return num
;
3586 if (tok
->u
.c
!= num
) {
3587 tok
->type
= TK_CODE_POINT
;
3588 tok
->u
.code
= (OnigCodePoint
)num
;
3591 p
= tok
->backp
+ enclen(enc
, tok
->backp
);
3600 #ifdef USE_VARIABLE_META_CHARS
3601 if ((c
!= ONIG_INEFFECTIVE_META_CHAR
) &&
3602 IS_SYNTAX_OP(syn
, ONIG_SYN_OP_VARIABLE_META_CHARACTERS
)) {
3603 if (c
== MC_ANYCHAR(syn
))
3605 else if (c
== MC_ANYTIME(syn
))
3607 else if (c
== MC_ZERO_OR_ONE_TIME(syn
))
3608 goto zero_or_one_time
;
3609 else if (c
== MC_ONE_OR_MORE_TIME(syn
))
3610 goto one_or_more_time
;
3611 else if (c
== MC_ANYCHAR_ANYTIME(syn
)) {
3612 tok
->type
= TK_ANYCHAR_ANYTIME
;
3620 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_DOT_ANYCHAR
)) break;
3621 #ifdef USE_VARIABLE_META_CHARS
3624 tok
->type
= TK_ANYCHAR
;
3628 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ASTERISK_ZERO_INF
)) break;
3629 #ifdef USE_VARIABLE_META_CHARS
3632 tok
->type
= TK_OP_REPEAT
;
3633 tok
->u
.repeat
.lower
= 0;
3634 tok
->u
.repeat
.upper
= REPEAT_INFINITE
;
3639 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_PLUS_ONE_INF
)) break;
3640 #ifdef USE_VARIABLE_META_CHARS
3643 tok
->type
= TK_OP_REPEAT
;
3644 tok
->u
.repeat
.lower
= 1;
3645 tok
->u
.repeat
.upper
= REPEAT_INFINITE
;
3650 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_QMARK_ZERO_ONE
)) break;
3651 #ifdef USE_VARIABLE_META_CHARS
3654 tok
->type
= TK_OP_REPEAT
;
3655 tok
->u
.repeat
.lower
= 0;
3656 tok
->u
.repeat
.upper
= 1;
3661 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_BRACE_INTERVAL
)) break;
3662 r
= fetch_range_quantifier(&p
, end
, tok
, env
);
3663 if (r
< 0) return r
; /* error */
3664 if (r
== 0) goto greedy_check
;
3665 else if (r
== 2) { /* {n} */
3666 if (IS_SYNTAX_BV(syn
, ONIG_SYN_FIXED_INTERVAL_IS_GREEDY_ONLY
))
3667 goto possessive_check
;
3671 /* r == 1 : normal char */
3675 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_VBAR_ALT
)) break;
3680 if (PPEEK_IS('?') &&
3681 IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_QMARK_GROUP_EFFECT
)) {
3683 if (PPEEK_IS('#')) {
3686 if (PEND
) return ONIGERR_END_PATTERN_IN_GROUP
;
3688 if (c
== MC_ESC(syn
)) {
3689 if (!PEND
) PFETCH(c
);
3692 if (c
== ')') break;
3700 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_LPAREN_SUBEXP
)) break;
3701 tok
->type
= TK_SUBEXP_OPEN
;
3705 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_LPAREN_SUBEXP
)) break;
3706 tok
->type
= TK_SUBEXP_CLOSE
;
3710 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_LINE_ANCHOR
)) break;
3711 tok
->type
= TK_ANCHOR
;
3712 tok
->u
.subtype
= (IS_SINGLELINE(env
->option
)
3713 ? ANCHOR_BEGIN_BUF
: ANCHOR_BEGIN_LINE
);
3717 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_LINE_ANCHOR
)) break;
3718 tok
->type
= TK_ANCHOR
;
3719 tok
->u
.subtype
= (IS_SINGLELINE(env
->option
)
3720 ? ANCHOR_SEMI_END_BUF
: ANCHOR_END_LINE
);
3724 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_BRACKET_CC
)) break;
3725 tok
->type
= TK_CC_OPEN
;
3729 if (*src
> env
->pattern
) /* /].../ is allowed. */
3730 CLOSE_BRACKET_WITHOUT_ESC_WARN(env
, (UChar
* )"]");
3734 if (IS_EXTEND(env
->option
)) {
3737 if (ONIGENC_IS_CODE_NEWLINE(enc
, c
))
3745 case ' ': case '\t': case '\n': case '\r': case '\f':
3746 if (IS_EXTEND(env
->option
))
3756 #ifdef USE_VARIABLE_META_CHARS
3764 add_ctype_to_cc_by_range(CClassNode
* cc
, int ctype ARG_UNUSED
, int not,
3765 OnigEncoding enc ARG_UNUSED
,
3766 OnigCodePoint sb_out
, const OnigCodePoint mbr
[])
3771 int n
= ONIGENC_CODE_RANGE_NUM(mbr
);
3774 for (i
= 0; i
< n
; i
++) {
3775 for (j
= ONIGENC_CODE_RANGE_FROM(mbr
, i
);
3776 j
<= ONIGENC_CODE_RANGE_TO(mbr
, i
); j
++) {
3778 if (j
== ONIGENC_CODE_RANGE_TO(mbr
, i
)) i
++;
3779 else if (j
> ONIGENC_CODE_RANGE_FROM(mbr
, i
)) {
3780 r
= add_code_range_to_buf(&(cc
->mbuf
), j
,
3781 ONIGENC_CODE_RANGE_TO(mbr
, i
));
3782 if (r
!= 0) return r
;
3788 BITSET_SET_BIT(cc
->bs
, j
);
3793 for ( ; i
< n
; i
++) {
3794 r
= add_code_range_to_buf(&(cc
->mbuf
),
3795 ONIGENC_CODE_RANGE_FROM(mbr
, i
),
3796 ONIGENC_CODE_RANGE_TO(mbr
, i
));
3797 if (r
!= 0) return r
;
3801 OnigCodePoint prev
= 0;
3803 for (i
= 0; i
< n
; i
++) {
3805 j
< ONIGENC_CODE_RANGE_FROM(mbr
, i
); j
++) {
3809 BITSET_SET_BIT(cc
->bs
, j
);
3811 prev
= ONIGENC_CODE_RANGE_TO(mbr
, i
) + 1;
3813 for (j
= prev
; j
< sb_out
; j
++) {
3814 BITSET_SET_BIT(cc
->bs
, j
);
3820 for (i
= 0; i
< n
; i
++) {
3821 if (prev
< ONIGENC_CODE_RANGE_FROM(mbr
, i
)) {
3822 r
= add_code_range_to_buf(&(cc
->mbuf
), prev
,
3823 ONIGENC_CODE_RANGE_FROM(mbr
, i
) - 1);
3824 if (r
!= 0) return r
;
3826 prev
= ONIGENC_CODE_RANGE_TO(mbr
, i
) + 1;
3828 if (prev
< 0x7fffffff) {
3829 r
= add_code_range_to_buf(&(cc
->mbuf
), prev
, 0x7fffffff);
3830 if (r
!= 0) return r
;
3838 add_ctype_to_cc(CClassNode
* cc
, int ctype
, int not, ScanEnv
* env
)
3841 const OnigCodePoint
*ranges
;
3842 OnigCodePoint sb_out
;
3843 OnigEncoding enc
= env
->enc
;
3845 r
= ONIGENC_GET_CTYPE_CODE_RANGE(enc
, ctype
, &sb_out
, &ranges
);
3847 return add_ctype_to_cc_by_range(cc
, ctype
, not, env
->enc
, sb_out
, ranges
);
3849 else if (r
!= ONIG_NO_SUPPORT_CONFIG
) {
3855 case ONIGENC_CTYPE_ALPHA
:
3856 case ONIGENC_CTYPE_BLANK
:
3857 case ONIGENC_CTYPE_CNTRL
:
3858 case ONIGENC_CTYPE_DIGIT
:
3859 case ONIGENC_CTYPE_LOWER
:
3860 case ONIGENC_CTYPE_PUNCT
:
3861 case ONIGENC_CTYPE_SPACE
:
3862 case ONIGENC_CTYPE_UPPER
:
3863 case ONIGENC_CTYPE_XDIGIT
:
3864 case ONIGENC_CTYPE_ASCII
:
3865 case ONIGENC_CTYPE_ALNUM
:
3867 for (c
= 0; c
< SINGLE_BYTE_SIZE
; c
++) {
3868 if (! ONIGENC_IS_CODE_CTYPE(enc
, (OnigCodePoint
)c
, ctype
))
3869 BITSET_SET_BIT(cc
->bs
, c
);
3871 ADD_ALL_MULTI_BYTE_RANGE(enc
, cc
->mbuf
);
3874 for (c
= 0; c
< SINGLE_BYTE_SIZE
; c
++) {
3875 if (ONIGENC_IS_CODE_CTYPE(enc
, (OnigCodePoint
)c
, ctype
))
3876 BITSET_SET_BIT(cc
->bs
, c
);
3881 case ONIGENC_CTYPE_GRAPH
:
3882 case ONIGENC_CTYPE_PRINT
:
3884 for (c
= 0; c
< SINGLE_BYTE_SIZE
; c
++) {
3885 if (! ONIGENC_IS_CODE_CTYPE(enc
, (OnigCodePoint
)c
, ctype
))
3886 BITSET_SET_BIT(cc
->bs
, c
);
3890 for (c
= 0; c
< SINGLE_BYTE_SIZE
; c
++) {
3891 if (ONIGENC_IS_CODE_CTYPE(enc
, (OnigCodePoint
)c
, ctype
))
3892 BITSET_SET_BIT(cc
->bs
, c
);
3894 ADD_ALL_MULTI_BYTE_RANGE(enc
, cc
->mbuf
);
3898 case ONIGENC_CTYPE_WORD
:
3900 for (c
= 0; c
< SINGLE_BYTE_SIZE
; c
++) {
3901 if (IS_CODE_SB_WORD(enc
, c
)) BITSET_SET_BIT(cc
->bs
, c
);
3903 ADD_ALL_MULTI_BYTE_RANGE(enc
, cc
->mbuf
);
3906 for (c
= 0; c
< SINGLE_BYTE_SIZE
; c
++) {
3907 if ((ONIGENC_CODE_TO_MBCLEN(enc
, c
) > 0) /* check invalid code point */
3908 && ! ONIGENC_IS_CODE_WORD(enc
, c
))
3909 BITSET_SET_BIT(cc
->bs
, c
);
3915 return ONIGERR_PARSER_BUG
;
3923 parse_posix_bracket(CClassNode
* cc
, UChar
** src
, UChar
* end
, ScanEnv
* env
)
3925 #define POSIX_BRACKET_CHECK_LIMIT_LENGTH 20
3926 #define POSIX_BRACKET_NAME_MIN_LEN 4
3928 static PosixBracketEntryType PBS
[] = {
3929 { (UChar
* )"alnum", ONIGENC_CTYPE_ALNUM
, 5 },
3930 { (UChar
* )"alpha", ONIGENC_CTYPE_ALPHA
, 5 },
3931 { (UChar
* )"blank", ONIGENC_CTYPE_BLANK
, 5 },
3932 { (UChar
* )"cntrl", ONIGENC_CTYPE_CNTRL
, 5 },
3933 { (UChar
* )"digit", ONIGENC_CTYPE_DIGIT
, 5 },
3934 { (UChar
* )"graph", ONIGENC_CTYPE_GRAPH
, 5 },
3935 { (UChar
* )"lower", ONIGENC_CTYPE_LOWER
, 5 },
3936 { (UChar
* )"print", ONIGENC_CTYPE_PRINT
, 5 },
3937 { (UChar
* )"punct", ONIGENC_CTYPE_PUNCT
, 5 },
3938 { (UChar
* )"space", ONIGENC_CTYPE_SPACE
, 5 },
3939 { (UChar
* )"upper", ONIGENC_CTYPE_UPPER
, 5 },
3940 { (UChar
* )"xdigit", ONIGENC_CTYPE_XDIGIT
, 6 },
3941 { (UChar
* )"ascii", ONIGENC_CTYPE_ASCII
, 5 },
3942 { (UChar
* )"word", ONIGENC_CTYPE_WORD
, 4 },
3943 { (UChar
* )NULL
, -1, 0 }
3946 PosixBracketEntryType
*pb
;
3949 OnigEncoding enc
= env
->enc
;
3952 if (PPEEK_IS('^')) {
3959 if (onigenc_strlen(enc
, p
, end
) < POSIX_BRACKET_NAME_MIN_LEN
+ 3)
3960 goto not_posix_bracket
;
3962 for (pb
= PBS
; IS_NOT_NULL(pb
->name
); pb
++) {
3963 if (onigenc_with_ascii_strncmp(enc
, p
, end
, pb
->name
, pb
->len
) == 0) {
3964 p
= (UChar
* )onigenc_step(enc
, p
, end
, pb
->len
);
3965 if (onigenc_with_ascii_strncmp(enc
, p
, end
, (UChar
* )":]", 2) != 0)
3966 return ONIGERR_INVALID_POSIX_BRACKET_TYPE
;
3968 r
= add_ctype_to_cc(cc
, pb
->ctype
, not, env
);
3969 if (r
!= 0) return r
;
3980 while (!PEND
&& ((c
= PPEEK
) != ':') && c
!= ']') {
3982 if (++i
> POSIX_BRACKET_CHECK_LIMIT_LENGTH
) break;
3984 if (c
== ':' && ! PEND
) {
3989 return ONIGERR_INVALID_POSIX_BRACKET_TYPE
;
3993 return 1; /* 1: is not POSIX bracket, but no error. */
3997 fetch_char_property_to_ctype(UChar
** src
, UChar
* end
, ScanEnv
* env
)
4001 OnigEncoding enc
= env
->enc
;
4002 UChar
*prev
, *start
, *p
= *src
;
4011 r
= ONIGENC_PROPERTY_NAME_TO_CTYPE(enc
, start
, prev
);
4017 else if (c
== '(' || c
== ')' || c
== '{' || c
== '|') {
4018 r
= ONIGERR_INVALID_CHAR_PROPERTY_NAME
;
4023 onig_scan_env_set_error_string(env
, r
, *src
, prev
);
4028 parse_char_property(Node
** np
, OnigToken
* tok
, UChar
** src
, UChar
* end
,
4034 ctype
= fetch_char_property_to_ctype(src
, end
, env
);
4035 if (ctype
< 0) return ctype
;
4037 *np
= node_new_cclass();
4038 CHECK_NULL_RETURN_MEMERR(*np
);
4040 r
= add_ctype_to_cc(cc
, ctype
, 0, env
);
4041 if (r
!= 0) return r
;
4042 if (tok
->u
.prop
.not != 0) NCCLASS_SET_NOT(cc
);
4062 next_state_class(CClassNode
* cc
, OnigCodePoint
* vs
, enum CCVALTYPE
* type
,
4063 enum CCSTATE
* state
, ScanEnv
* env
)
4067 if (*state
== CCS_RANGE
)
4068 return ONIGERR_CHAR_CLASS_VALUE_AT_END_OF_RANGE
;
4070 if (*state
== CCS_VALUE
&& *type
!= CCV_CLASS
) {
4071 if (*type
== CCV_SB
)
4072 BITSET_SET_BIT(cc
->bs
, (int )(*vs
));
4073 else if (*type
== CCV_CODE_POINT
) {
4074 r
= add_code_range(&(cc
->mbuf
), env
, *vs
, *vs
);
4075 if (r
< 0) return r
;
4085 next_state_val(CClassNode
* cc
, OnigCodePoint
*vs
, OnigCodePoint v
,
4086 int* vs_israw
, int v_israw
,
4087 enum CCVALTYPE intype
, enum CCVALTYPE
* type
,
4088 enum CCSTATE
* state
, ScanEnv
* env
)
4094 if (*type
== CCV_SB
)
4095 BITSET_SET_BIT(cc
->bs
, (int )(*vs
));
4096 else if (*type
== CCV_CODE_POINT
) {
4097 r
= add_code_range(&(cc
->mbuf
), env
, *vs
, *vs
);
4098 if (r
< 0) return r
;
4103 if (intype
== *type
) {
4104 if (intype
== CCV_SB
) {
4105 if (*vs
> 0xff || v
> 0xff)
4106 return ONIGERR_INVALID_CODE_POINT_VALUE
;
4109 if (IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_ALLOW_EMPTY_RANGE_IN_CC
))
4112 return ONIGERR_EMPTY_RANGE_IN_CHAR_CLASS
;
4114 bitset_set_range(cc
->bs
, (int )*vs
, (int )v
);
4117 r
= add_code_range(&(cc
->mbuf
), env
, *vs
, v
);
4118 if (r
< 0) return r
;
4123 if (intype
== CCV_CODE_POINT
&& *type
== CCV_SB
) {
4126 if (IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_ALLOW_EMPTY_RANGE_IN_CC
))
4129 return ONIGERR_EMPTY_RANGE_IN_CHAR_CLASS
;
4131 bitset_set_range(cc
->bs
, (int )*vs
, (int )(v
< 0xff ? v
: 0xff));
4132 r
= add_code_range(&(cc
->mbuf
), env
, (OnigCodePoint
)*vs
, v
);
4133 if (r
< 0) return r
;
4137 return ONIGERR_MISMATCH_CODE_LENGTH_IN_CLASS_RANGE
;
4141 *state
= CCS_COMPLETE
;
4153 *vs_israw
= v_israw
;
4160 code_exist_check(OnigCodePoint c
, UChar
* from
, UChar
* end
, int ignore_escaped
,
4165 OnigEncoding enc
= env
->enc
;
4170 if (ignore_escaped
&& in_esc
) {
4175 if (code
== c
) return 1;
4176 if (code
== MC_ESC(env
->syntax
)) in_esc
= 1;
4183 parse_char_class(Node
** np
, OnigToken
* tok
, UChar
** src
, UChar
* end
,
4186 int r
, neg
, len
, fetched
, and_start
;
4187 OnigCodePoint v
, vs
;
4190 CClassNode
*cc
, *prev_cc
;
4194 enum CCVALTYPE val_type
, in_type
;
4195 int val_israw
, in_israw
;
4197 prev_cc
= (CClassNode
* )NULL
;
4199 r
= fetch_token_in_cc(tok
, src
, end
, env
);
4200 if (r
== TK_CHAR
&& tok
->u
.c
== '^' && tok
->escaped
== 0) {
4202 r
= fetch_token_in_cc(tok
, src
, end
, env
);
4208 if (r
< 0) return r
;
4209 if (r
== TK_CC_CLOSE
) {
4210 if (! code_exist_check((OnigCodePoint
)']',
4211 *src
, env
->pattern_end
, 1, env
))
4212 return ONIGERR_EMPTY_CHAR_CLASS
;
4214 CC_ESC_WARN(env
, (UChar
* )"]");
4215 r
= tok
->type
= TK_CHAR
; /* allow []...] */
4218 *np
= node
= node_new_cclass();
4219 CHECK_NULL_RETURN_MEMERR(node
);
4225 while (r
!= TK_CC_CLOSE
) {
4229 len
= ONIGENC_CODE_TO_MBCLEN(env
->enc
, tok
->u
.c
);
4231 in_type
= CCV_CODE_POINT
;
4241 v
= (OnigCodePoint
)tok
->u
.c
;
4247 /* tok->base != 0 : octal or hexadec. */
4248 if (! ONIGENC_IS_SINGLEBYTE(env
->enc
) && tok
->base
!= 0) {
4249 UChar buf
[ONIGENC_CODE_TO_MBC_MAXLEN
];
4250 UChar
* bufe
= buf
+ ONIGENC_CODE_TO_MBC_MAXLEN
;
4252 int i
, base
= tok
->base
;
4254 buf
[0] = (UChar
)tok
->u
.c
;
4255 for (i
= 1; i
< ONIGENC_MBC_MAXLEN(env
->enc
); i
++) {
4256 r
= fetch_token_in_cc(tok
, &p
, end
, env
);
4257 if (r
< 0) goto err
;
4258 if (r
!= TK_RAW_BYTE
|| tok
->base
!= base
) {
4262 buf
[i
] = (UChar
)tok
->u
.c
;
4265 if (i
< ONIGENC_MBC_MINLEN(env
->enc
)) {
4266 r
= ONIGERR_TOO_SHORT_MULTI_BYTE_STRING
;
4270 len
= enclen(env
->enc
, buf
);
4272 r
= ONIGERR_TOO_SHORT_MULTI_BYTE_STRING
;
4275 else if (i
> len
) { /* fetch back */
4277 for (i
= 1; i
< len
; i
++) {
4278 r
= fetch_token_in_cc(tok
, &p
, end
, env
);
4284 v
= (OnigCodePoint
)buf
[0];
4288 v
= ONIGENC_MBC_TO_CODE(env
->enc
, buf
, bufe
);
4289 in_type
= CCV_CODE_POINT
;
4293 v
= (OnigCodePoint
)tok
->u
.c
;
4305 len
= ONIGENC_CODE_TO_MBCLEN(env
->enc
, v
);
4310 in_type
= (len
== 1 ? CCV_SB
: CCV_CODE_POINT
);
4312 r
= next_state_val(cc
, &vs
, v
, &val_israw
, in_israw
, in_type
, &val_type
,
4314 if (r
!= 0) goto err
;
4317 case TK_POSIX_BRACKET_OPEN
:
4318 r
= parse_posix_bracket(cc
, &p
, end
, env
);
4319 if (r
< 0) goto err
;
4320 if (r
== 1) { /* is not POSIX bracket */
4321 CC_ESC_WARN(env
, (UChar
* )"[");
4323 v
= (OnigCodePoint
)tok
->u
.c
;
4331 r
= add_ctype_to_cc(cc
, tok
->u
.prop
.ctype
, tok
->u
.prop
.not, env
);
4332 if (r
!= 0) return r
;
4335 r
= next_state_class(cc
, &vs
, &val_type
, &state
, env
);
4336 if (r
!= 0) goto err
;
4339 case TK_CHAR_PROPERTY
:
4343 ctype
= fetch_char_property_to_ctype(&p
, end
, env
);
4344 if (ctype
< 0) return ctype
;
4345 r
= add_ctype_to_cc(cc
, ctype
, tok
->u
.prop
.not, env
);
4346 if (r
!= 0) return r
;
4352 if (state
== CCS_VALUE
) {
4353 r
= fetch_token_in_cc(tok
, &p
, end
, env
);
4354 if (r
< 0) goto err
;
4356 if (r
== TK_CC_CLOSE
) { /* allow [x-] */
4358 v
= (OnigCodePoint
)'-';
4362 else if (r
== TK_CC_AND
) {
4363 CC_ESC_WARN(env
, (UChar
* )"-");
4368 else if (state
== CCS_START
) {
4369 /* [-xa] is allowed */
4370 v
= (OnigCodePoint
)tok
->u
.c
;
4373 r
= fetch_token_in_cc(tok
, &p
, end
, env
);
4374 if (r
< 0) goto err
;
4376 /* [--x] or [a&&-x] is warned. */
4377 if (r
== TK_CC_RANGE
|| and_start
!= 0)
4378 CC_ESC_WARN(env
, (UChar
* )"-");
4382 else if (state
== CCS_RANGE
) {
4383 CC_ESC_WARN(env
, (UChar
* )"-");
4384 goto sb_char
; /* [!--x] is allowed */
4386 else { /* CCS_COMPLETE */
4387 r
= fetch_token_in_cc(tok
, &p
, end
, env
);
4388 if (r
< 0) goto err
;
4390 if (r
== TK_CC_CLOSE
) goto range_end_val
; /* allow [a-b-] */
4391 else if (r
== TK_CC_AND
) {
4392 CC_ESC_WARN(env
, (UChar
* )"-");
4396 if (IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_ALLOW_DOUBLE_RANGE_OP_IN_CC
)) {
4397 CC_ESC_WARN(env
, (UChar
* )"-");
4398 goto sb_char
; /* [0-9-a] is allowed as [0-9\-a] */
4400 r
= ONIGERR_UNMATCHED_RANGE_SPECIFIER_IN_CHAR_CLASS
;
4405 case TK_CC_CC_OPEN
: /* [ */
4410 r
= parse_char_class(&anode
, tok
, &p
, end
, env
);
4411 if (r
!= 0) goto cc_open_err
;
4412 acc
= NCCLASS(anode
);
4413 r
= or_cclass(cc
, acc
, env
->enc
);
4415 onig_node_free(anode
);
4417 if (r
!= 0) goto err
;
4421 case TK_CC_AND
: /* && */
4423 if (state
== CCS_VALUE
) {
4424 r
= next_state_val(cc
, &vs
, 0, &val_israw
, 0, val_type
,
4425 &val_type
, &state
, env
);
4426 if (r
!= 0) goto err
;
4428 /* initialize local variables */
4432 if (IS_NOT_NULL(prev_cc
)) {
4433 r
= and_cclass(prev_cc
, cc
, env
->enc
);
4434 if (r
!= 0) goto err
;
4435 bbuf_free(cc
->mbuf
);
4441 initialize_cclass(cc
);
4446 r
= ONIGERR_PREMATURE_END_OF_CHAR_CLASS
;
4450 r
= ONIGERR_PARSER_BUG
;
4458 r
= fetch_token_in_cc(tok
, &p
, end
, env
);
4459 if (r
< 0) goto err
;
4463 if (state
== CCS_VALUE
) {
4464 r
= next_state_val(cc
, &vs
, 0, &val_israw
, 0, val_type
,
4465 &val_type
, &state
, env
);
4466 if (r
!= 0) goto err
;
4469 if (IS_NOT_NULL(prev_cc
)) {
4470 r
= and_cclass(prev_cc
, cc
, env
->enc
);
4471 if (r
!= 0) goto err
;
4472 bbuf_free(cc
->mbuf
);
4477 NCCLASS_SET_NOT(cc
);
4479 NCCLASS_CLEAR_NOT(cc
);
4480 if (IS_NCCLASS_NOT(cc
) &&
4481 IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_NOT_NEWLINE_IN_NEGATIVE_CC
)) {
4484 is_empty
= (IS_NULL(cc
->mbuf
) ? 1 : 0);
4486 BITSET_IS_EMPTY(cc
->bs
, is_empty
);
4488 if (is_empty
== 0) {
4489 #define NEWLINE_CODE 0x0a
4491 if (ONIGENC_IS_CODE_NEWLINE(env
->enc
, NEWLINE_CODE
)) {
4492 if (ONIGENC_CODE_TO_MBCLEN(env
->enc
, NEWLINE_CODE
) == 1)
4493 BITSET_SET_BIT(cc
->bs
, NEWLINE_CODE
);
4495 add_code_range(&(cc
->mbuf
), env
, NEWLINE_CODE
, NEWLINE_CODE
);
4503 if (cc
!= NCCLASS(*np
))
4504 bbuf_free(cc
->mbuf
);
4505 onig_node_free(*np
);
4509 static int parse_subexp(Node
** top
, OnigToken
* tok
, int term
,
4510 UChar
** src
, UChar
* end
, ScanEnv
* env
);
4513 parse_enclose(Node
** np
, OnigToken
* tok
, int term
, UChar
** src
, UChar
* end
,
4518 OnigOptionType option
;
4520 OnigEncoding enc
= env
->enc
;
4522 #ifdef USE_NAMED_GROUP
4530 if (PEND
) return ONIGERR_END_PATTERN_WITH_UNMATCHED_PARENTHESIS
;
4532 option
= env
->option
;
4533 if (PPEEK_IS('?') &&
4534 IS_SYNTAX_OP2(env
->syntax
, ONIG_SYN_OP2_QMARK_GROUP_EFFECT
)) {
4536 if (PEND
) return ONIGERR_END_PATTERN_IN_GROUP
;
4540 case ':': /* (?:...) grouping only */
4542 r
= fetch_token(tok
, &p
, end
, env
);
4543 if (r
< 0) return r
;
4544 r
= parse_subexp(np
, tok
, term
, &p
, end
, env
);
4545 if (r
< 0) return r
;
4547 return 1; /* group */
4551 *np
= onig_node_new_anchor(ANCHOR_PREC_READ
);
4553 case '!': /* preceding read */
4554 *np
= onig_node_new_anchor(ANCHOR_PREC_READ_NOT
);
4556 case '>': /* (?>...) stop backtrack */
4557 *np
= node_new_enclose(ENCLOSE_STOP_BACKTRACK
);
4560 #ifdef USE_NAMED_GROUP
4562 if (IS_SYNTAX_OP2(env
->syntax
, ONIG_SYN_OP2_QMARK_LT_NAMED_GROUP
)) {
4566 return ONIGERR_UNDEFINED_GROUP_OPTION
;
4570 case '<': /* look behind (?<=...), (?<!...) */
4573 *np
= onig_node_new_anchor(ANCHOR_LOOK_BEHIND
);
4575 *np
= onig_node_new_anchor(ANCHOR_LOOK_BEHIND_NOT
);
4576 #ifdef USE_NAMED_GROUP
4578 if (IS_SYNTAX_OP2(env
->syntax
, ONIG_SYN_OP2_QMARK_LT_NAMED_GROUP
)) {
4590 r
= fetch_name((OnigCodePoint
)c
, &p
, end
, &name_end
, env
, &num
, 0);
4591 if (r
< 0) return r
;
4593 num
= scan_env_add_mem_entry(env
);
4594 if (num
< 0) return num
;
4595 if (list_capture
!= 0 && num
>= (int )BIT_STATUS_BITS_NUM
)
4596 return ONIGERR_GROUP_NUMBER_OVER_FOR_CAPTURE_HISTORY
;
4598 r
= name_add(env
->reg
, name
, name_end
, num
, env
);
4599 if (r
!= 0) return r
;
4600 *np
= node_new_enclose_memory(env
->option
, 1);
4601 CHECK_NULL_RETURN_MEMERR(*np
);
4602 NENCLOSE(*np
)->regnum
= num
;
4603 if (list_capture
!= 0)
4604 BIT_STATUS_ON_AT_SIMPLE(env
->capture_history
, num
);
4608 return ONIGERR_UNDEFINED_GROUP_OPTION
;
4613 return ONIGERR_UNDEFINED_GROUP_OPTION
;
4619 if (IS_SYNTAX_OP2(env
->syntax
, ONIG_SYN_OP2_ATMARK_CAPTURE_HISTORY
)) {
4620 #ifdef USE_NAMED_GROUP
4621 if (IS_SYNTAX_OP2(env
->syntax
, ONIG_SYN_OP2_QMARK_LT_NAMED_GROUP
)) {
4623 if (c
== '<' || c
== '\'') {
4625 goto named_group2
; /* (?@<name>...) */
4630 *np
= node_new_enclose_memory(env
->option
, 0);
4631 CHECK_NULL_RETURN_MEMERR(*np
);
4632 num
= scan_env_add_mem_entry(env
);
4634 onig_node_free(*np
);
4637 else if (num
>= (int )BIT_STATUS_BITS_NUM
) {
4638 onig_node_free(*np
);
4639 return ONIGERR_GROUP_NUMBER_OVER_FOR_CAPTURE_HISTORY
;
4641 NENCLOSE(*np
)->regnum
= num
;
4642 BIT_STATUS_ON_AT_SIMPLE(env
->capture_history
, num
);
4645 return ONIGERR_UNDEFINED_GROUP_OPTION
;
4649 #ifdef USE_POSIXLINE_OPTION
4652 case '-': case 'i': case 'm': case 's': case 'x':
4662 case '-': neg
= 1; break;
4663 case 'x': ONOFF(option
, ONIG_OPTION_EXTEND
, neg
); break;
4664 case 'i': ONOFF(option
, ONIG_OPTION_IGNORECASE
, neg
); break;
4666 if (IS_SYNTAX_OP2(env
->syntax
, ONIG_SYN_OP2_OPTION_PERL
)) {
4667 ONOFF(option
, ONIG_OPTION_MULTILINE
, neg
);
4670 return ONIGERR_UNDEFINED_GROUP_OPTION
;
4674 if (IS_SYNTAX_OP2(env
->syntax
, ONIG_SYN_OP2_OPTION_PERL
)) {
4675 ONOFF(option
, ONIG_OPTION_SINGLELINE
, (neg
== 0 ? 1 : 0));
4677 else if (IS_SYNTAX_OP2(env
->syntax
, ONIG_SYN_OP2_OPTION_RUBY
)) {
4678 ONOFF(option
, ONIG_OPTION_MULTILINE
, neg
);
4681 return ONIGERR_UNDEFINED_GROUP_OPTION
;
4683 #ifdef USE_POSIXLINE_OPTION
4685 ONOFF(option
, ONIG_OPTION_MULTILINE
|ONIG_OPTION_SINGLELINE
, neg
);
4689 return ONIGERR_UNDEFINED_GROUP_OPTION
;
4693 *np
= node_new_option(option
);
4694 CHECK_NULL_RETURN_MEMERR(*np
);
4696 return 2; /* option only */
4698 else if (c
== ':') {
4699 OnigOptionType prev
= env
->option
;
4701 env
->option
= option
;
4702 r
= fetch_token(tok
, &p
, end
, env
);
4703 if (r
< 0) return r
;
4704 r
= parse_subexp(&target
, tok
, term
, &p
, end
, env
);
4706 if (r
< 0) return r
;
4707 *np
= node_new_option(option
);
4708 CHECK_NULL_RETURN_MEMERR(*np
);
4709 NENCLOSE(*np
)->target
= target
;
4714 if (PEND
) return ONIGERR_END_PATTERN_IN_GROUP
;
4721 return ONIGERR_UNDEFINED_GROUP_OPTION
;
4725 if (ONIG_IS_OPTION_ON(env
->option
, ONIG_OPTION_DONT_CAPTURE_GROUP
))
4728 *np
= node_new_enclose_memory(env
->option
, 0);
4729 CHECK_NULL_RETURN_MEMERR(*np
);
4730 num
= scan_env_add_mem_entry(env
);
4731 if (num
< 0) return num
;
4732 NENCLOSE(*np
)->regnum
= num
;
4735 CHECK_NULL_RETURN_MEMERR(*np
);
4736 r
= fetch_token(tok
, &p
, end
, env
);
4737 if (r
< 0) return r
;
4738 r
= parse_subexp(&target
, tok
, term
, &p
, end
, env
);
4739 if (r
< 0) return r
;
4741 if (NTYPE(*np
) == NT_ANCHOR
)
4742 NANCHOR(*np
)->target
= target
;
4744 NENCLOSE(*np
)->target
= target
;
4745 if (NENCLOSE(*np
)->type
== ENCLOSE_MEMORY
) {
4746 /* Don't move this to previous of parse_subexp() */
4747 r
= scan_env_set_mem_node(env
, NENCLOSE(*np
)->regnum
, *np
);
4748 if (r
!= 0) return r
;
4756 static const char* PopularQStr
[] = {
4757 "?", "*", "+", "??", "*?", "+?"
4760 static const char* ReduceQStr
[] = {
4761 "", "", "*", "*?", "??", "+ and ??", "+? and ?"
4765 set_quantifier(Node
* qnode
, Node
* target
, int group
, ScanEnv
* env
)
4770 if (qn
->lower
== 1 && qn
->upper
== 1) {
4774 switch (NTYPE(target
)) {
4777 StrNode
* sn
= NSTR(target
);
4778 if (str_node_can_be_split(sn
, env
->enc
)) {
4779 Node
* n
= str_node_split_last_char(sn
, env
->enc
);
4780 if (IS_NOT_NULL(n
)) {
4789 { /* check redundant double repeat. */
4790 /* verbose warn (?:.?)? etc... but not warn (.?)? etc... */
4791 QtfrNode
* qnt
= NQTFR(target
);
4792 int nestq_num
= popular_quantifier_num(qn
);
4793 int targetq_num
= popular_quantifier_num(qnt
);
4794 if (nestq_num
< 0 || targetq_num
< 0) {
4795 return ONIGERR_TYPE_BUG
;
4798 #ifdef USE_WARNING_REDUNDANT_NESTED_REPEAT_OPERATOR
4799 if (!IS_QUANTIFIER_BY_NUMBER(qn
) && !IS_QUANTIFIER_BY_NUMBER(qnt
) &&
4800 IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_WARN_REDUNDANT_NESTED_REPEAT
)) {
4801 UChar buf
[WARN_BUFSIZE
];
4803 switch(ReduceTypeTable
[targetq_num
][nestq_num
]) {
4808 if (onig_verb_warn
!= onig_null_warn
) {
4809 onig_snprintf_with_pattern(buf
, WARN_BUFSIZE
, env
->enc
,
4810 env
->pattern
, env
->pattern_end
,
4811 (UChar
* )"redundant nested repeat operator");
4812 (*onig_verb_warn
)((char* )buf
);
4818 if (onig_verb_warn
!= onig_null_warn
) {
4819 onig_snprintf_with_pattern(buf
, WARN_BUFSIZE
, env
->enc
,
4820 env
->pattern
, env
->pattern_end
,
4821 (UChar
* )"nested repeat operator %s and %s was replaced with '%s'",
4822 PopularQStr
[targetq_num
], PopularQStr
[nestq_num
],
4823 ReduceQStr
[ReduceTypeTable
[targetq_num
][nestq_num
]]);
4824 (*onig_verb_warn
)((char* )buf
);
4833 if (targetq_num
>= 0) {
4834 if (nestq_num
>= 0) {
4835 onig_reduce_nested_quantifier(qnode
, target
);
4838 else if (targetq_num
== 1 || targetq_num
== 2) { /* * or + */
4839 /* (?:a*){n,m}, (?:a+){n,m} => (?:a*){n,n}, (?:a+){n,n} */
4840 if (! IS_REPEAT_INFINITE(qn
->upper
) && qn
->upper
> 1 && qn
->greedy
) {
4841 qn
->upper
= (qn
->lower
== 0 ? 1 : qn
->lower
);
4852 qn
->target
= target
;
4858 #ifdef USE_SHARED_CCLASS_TABLE
4860 #define THRESHOLD_RANGE_NUM_FOR_SHARE_CCLASS 8
4862 /* for ctype node hash table */
4870 static int type_cclass_cmp(type_cclass_key
* x
, type_cclass_key
* y
)
4872 if (x
->type
!= y
->type
) return 1;
4873 if (x
->enc
!= y
->enc
) return 1;
4874 if (x
->not != y
->not) return 1;
4878 static int type_cclass_hash(type_cclass_key
* key
)
4885 p
= (UChar
* )&(key
->enc
);
4886 for (i
= 0; i
< (int )sizeof(key
->enc
); i
++) {
4887 val
= val
* 997 + (int )*p
++;
4890 p
= (UChar
* )(&key
->type
);
4891 for (i
= 0; i
< (int )sizeof(key
->type
); i
++) {
4892 val
= val
* 997 + (int )*p
++;
4896 return val
+ (val
>> 5);
4899 static struct st_hash_type type_type_cclass_hash
= {
4904 static st_table
* OnigTypeCClassTable
;
4908 i_free_shared_class(type_cclass_key
* key
, Node
* node
, void* arg ARG_UNUSED
)
4910 if (IS_NOT_NULL(node
)) {
4911 CClassNode
* cc
= NCCLASS(node
);
4912 if (IS_NOT_NULL(cc
->mbuf
)) xfree(cc
->mbuf
);
4916 if (IS_NOT_NULL(key
)) xfree(key
);
4921 onig_free_shared_cclass_table(void)
4923 if (IS_NOT_NULL(OnigTypeCClassTable
)) {
4924 onig_st_foreach(OnigTypeCClassTable
, i_free_shared_class
, 0);
4925 onig_st_free_table(OnigTypeCClassTable
);
4926 OnigTypeCClassTable
= NULL
;
4932 #endif /* USE_SHARED_CCLASS_TABLE */
4935 #ifndef CASE_FOLD_IS_APPLIED_INSIDE_NEGATIVE_CCLASS
4937 clear_not_flag_cclass(CClassNode
* cc
, OnigEncoding enc
)
4942 if (IS_NCCLASS_NOT(cc
)) {
4943 bitset_invert(cc
->bs
);
4945 if (! ONIGENC_IS_SINGLEBYTE(enc
)) {
4946 r
= not_code_range_buf(enc
, cc
->mbuf
, &tbuf
);
4947 if (r
!= 0) return r
;
4949 bbuf_free(cc
->mbuf
);
4953 NCCLASS_CLEAR_NOT(cc
);
4958 #endif /* CASE_FOLD_IS_APPLIED_INSIDE_NEGATIVE_CCLASS */
4965 } IApplyCaseFoldArg
;
4968 i_apply_case_fold(OnigCodePoint from
, OnigCodePoint to
[],
4969 int to_len
, void* arg
)
4971 IApplyCaseFoldArg
* iarg
;
4976 iarg
= (IApplyCaseFoldArg
* )arg
;
4982 int is_in
= onig_is_code_in_cc(env
->enc
, from
, cc
);
4983 #ifdef CASE_FOLD_IS_APPLIED_INSIDE_NEGATIVE_CCLASS
4984 if ((is_in
!= 0 && !IS_NCCLASS_NOT(cc
)) ||
4985 (is_in
== 0 && IS_NCCLASS_NOT(cc
))) {
4986 if (ONIGENC_MBC_MINLEN(env
->enc
) > 1 || *to
>= SINGLE_BYTE_SIZE
) {
4987 add_code_range(&(cc
->mbuf
), env
, *to
, *to
);
4990 BITSET_SET_BIT(bs
, *to
);
4995 if (ONIGENC_MBC_MINLEN(env
->enc
) > 1 || *to
>= SINGLE_BYTE_SIZE
) {
4996 if (IS_NCCLASS_NOT(cc
)) clear_not_flag_cclass(cc
, env
->enc
);
4997 add_code_range(&(cc
->mbuf
), env
, *to
, *to
);
5000 if (IS_NCCLASS_NOT(cc
)) {
5001 BITSET_CLEAR_BIT(bs
, *to
);
5004 BITSET_SET_BIT(bs
, *to
);
5007 #endif /* CASE_FOLD_IS_APPLIED_INSIDE_NEGATIVE_CCLASS */
5011 UChar buf
[ONIGENC_CODE_TO_MBC_MAXLEN
];
5012 Node
*snode
= NULL_NODE
;
5014 if (onig_is_code_in_cc(env
->enc
, from
, cc
)
5015 #ifdef CASE_FOLD_IS_APPLIED_INSIDE_NEGATIVE_CCLASS
5016 && !IS_NCCLASS_NOT(cc
)
5019 for (i
= 0; i
< to_len
; i
++) {
5020 len
= ONIGENC_CODE_TO_MBC(env
->enc
, to
[i
], buf
);
5022 snode
= onig_node_new_str(buf
, buf
+ len
);
5023 CHECK_NULL_RETURN_MEMERR(snode
);
5025 /* char-class expanded multi-char only
5026 compare with string folded at match time. */
5027 NSTRING_SET_AMBIG(snode
);
5030 r
= onig_node_str_cat(snode
, buf
, buf
+ len
);
5032 onig_node_free(snode
);
5038 *(iarg
->ptail
) = onig_node_new_alt(snode
, NULL_NODE
);
5039 CHECK_NULL_RETURN_MEMERR(*(iarg
->ptail
));
5040 iarg
->ptail
= &(NCDR((*(iarg
->ptail
))));
5048 parse_exp(Node
** np
, OnigToken
* tok
, int term
,
5049 UChar
** src
, UChar
* end
, ScanEnv
* env
)
5051 int r
, len
, group
= 0;
5056 if (tok
->type
== (enum TokenSyms
)term
)
5059 switch (tok
->type
) {
5063 *np
= node_new_empty();
5067 case TK_SUBEXP_OPEN
:
5068 r
= parse_enclose(np
, tok
, TK_SUBEXP_CLOSE
, src
, end
, env
);
5069 if (r
< 0) return r
;
5070 if (r
== 1) group
= 1;
5071 else if (r
== 2) { /* option only */
5073 OnigOptionType prev
= env
->option
;
5075 env
->option
= NENCLOSE(*np
)->option
;
5076 r
= fetch_token(tok
, src
, end
, env
);
5077 if (r
< 0) return r
;
5078 r
= parse_subexp(&target
, tok
, term
, src
, end
, env
);
5080 if (r
< 0) return r
;
5081 NENCLOSE(*np
)->target
= target
;
5086 case TK_SUBEXP_CLOSE
:
5087 if (! IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_ALLOW_UNMATCHED_CLOSE_SUBEXP
))
5088 return ONIGERR_UNMATCHED_CLOSE_PARENTHESIS
;
5090 if (tok
->escaped
) goto tk_raw_byte
;
5097 *np
= node_new_str(tok
->backp
, *src
);
5098 CHECK_NULL_RETURN_MEMERR(*np
);
5101 r
= fetch_token(tok
, src
, end
, env
);
5102 if (r
< 0) return r
;
5103 if (r
!= TK_STRING
) break;
5105 r
= onig_node_str_cat(*np
, tok
->backp
, *src
);
5106 if (r
< 0) return r
;
5118 *np
= node_new_str_raw_char((UChar
)tok
->u
.c
);
5119 CHECK_NULL_RETURN_MEMERR(*np
);
5122 if (len
>= ONIGENC_MBC_MINLEN(env
->enc
)) {
5123 if (len
== enclen(env
->enc
, NSTR(*np
)->s
)) {
5124 r
= fetch_token(tok
, src
, end
, env
);
5125 NSTRING_CLEAR_RAW(*np
);
5130 r
= fetch_token(tok
, src
, end
, env
);
5131 if (r
< 0) return r
;
5132 if (r
!= TK_RAW_BYTE
) {
5133 /* Don't use this, it is wrong for little endian encodings. */
5134 #ifdef USE_PAD_TO_SHORT_BYTE_CHAR
5136 if (len
< ONIGENC_MBC_MINLEN(env
->enc
)) {
5137 rem
= ONIGENC_MBC_MINLEN(env
->enc
) - len
;
5138 (void )node_str_head_pad(NSTR(*np
), rem
, (UChar
)0);
5139 if (len
+ rem
== enclen(env
->enc
, NSTR(*np
)->s
)) {
5140 NSTRING_CLEAR_RAW(*np
);
5145 return ONIGERR_TOO_SHORT_MULTI_BYTE_STRING
;
5148 r
= node_str_cat_char(*np
, (UChar
)tok
->u
.c
);
5149 if (r
< 0) return r
;
5158 UChar buf
[ONIGENC_CODE_TO_MBC_MAXLEN
];
5159 int num
= ONIGENC_CODE_TO_MBC(env
->enc
, tok
->u
.code
, buf
);
5160 if (num
< 0) return num
;
5161 #ifdef NUMBERED_CHAR_IS_NOT_CASE_AMBIG
5162 *np
= node_new_str_raw(buf
, buf
+ num
);
5164 *np
= node_new_str(buf
, buf
+ num
);
5166 CHECK_NULL_RETURN_MEMERR(*np
);
5172 OnigCodePoint end_op
[2];
5173 UChar
*qstart
, *qend
, *nextp
;
5175 end_op
[0] = (OnigCodePoint
)MC_ESC(env
->syntax
);
5176 end_op
[1] = (OnigCodePoint
)'E';
5178 qend
= find_str_position(end_op
, 2, qstart
, end
, &nextp
, env
->enc
);
5179 if (IS_NULL(qend
)) {
5182 *np
= node_new_str(qstart
, qend
);
5183 CHECK_NULL_RETURN_MEMERR(*np
);
5190 switch (tok
->u
.prop
.ctype
) {
5191 case ONIGENC_CTYPE_WORD
:
5192 *np
= node_new_ctype(tok
->u
.prop
.ctype
, tok
->u
.prop
.not);
5193 CHECK_NULL_RETURN_MEMERR(*np
);
5196 case ONIGENC_CTYPE_SPACE
:
5197 case ONIGENC_CTYPE_DIGIT
:
5198 case ONIGENC_CTYPE_XDIGIT
:
5202 #ifdef USE_SHARED_CCLASS_TABLE
5203 const OnigCodePoint
*mbr
;
5204 OnigCodePoint sb_out
;
5206 r
= ONIGENC_GET_CTYPE_CODE_RANGE(env
->enc
, tok
->u
.prop
.ctype
,
5209 ONIGENC_CODE_RANGE_NUM(mbr
)
5210 >= THRESHOLD_RANGE_NUM_FOR_SHARE_CCLASS
) {
5211 type_cclass_key key
;
5212 type_cclass_key
* new_key
;
5215 key
.not = tok
->u
.prop
.not;
5216 key
.type
= tok
->u
.prop
.ctype
;
5218 THREAD_ATOMIC_START
;
5220 if (IS_NULL(OnigTypeCClassTable
)) {
5222 = onig_st_init_table_with_size(&type_type_cclass_hash
, 10);
5223 if (IS_NULL(OnigTypeCClassTable
)) {
5225 return ONIGERR_MEMORY
;
5229 if (onig_st_lookup(OnigTypeCClassTable
, (st_data_t
)(UINTN
)&key
,
5236 *np
= node_new_cclass_by_codepoint_range(tok
->u
.prop
.not,
5240 return ONIGERR_MEMORY
;
5244 NCCLASS_SET_SHARE(cc
);
5245 new_key
= (type_cclass_key
* )xmalloc(sizeof(type_cclass_key
));
5246 CHECK_NULL_RETURN_MEMERR(new_key
);
5247 xmemcpy(new_key
, &key
, sizeof(type_cclass_key
));
5248 onig_st_add_direct(OnigTypeCClassTable
, (st_data_t
)(UINTN
)new_key
,
5249 (st_data_t
)(UINTN
)*np
);
5255 *np
= node_new_cclass();
5256 CHECK_NULL_RETURN_MEMERR(*np
);
5258 add_ctype_to_cc(cc
, tok
->u
.prop
.ctype
, 0, env
);
5259 if (tok
->u
.prop
.not != 0) NCCLASS_SET_NOT(cc
);
5260 #ifdef USE_SHARED_CCLASS_TABLE
5267 return ONIGERR_PARSER_BUG
;
5273 case TK_CHAR_PROPERTY
:
5274 r
= parse_char_property(np
, tok
, src
, end
, env
);
5275 if (r
!= 0) return r
;
5282 r
= parse_char_class(np
, tok
, src
, end
, env
);
5283 if (r
!= 0) return r
;
5286 if (IS_IGNORECASE(env
->option
)) {
5287 IApplyCaseFoldArg iarg
;
5291 iarg
.alt_root
= NULL_NODE
;
5292 iarg
.ptail
= &(iarg
.alt_root
);
5294 r
= ONIGENC_APPLY_ALL_CASE_FOLD(env
->enc
, env
->case_fold_flag
,
5295 i_apply_case_fold
, &iarg
);
5297 onig_node_free(iarg
.alt_root
);
5300 if (IS_NOT_NULL(iarg
.alt_root
)) {
5301 Node
* work
= onig_node_new_alt(*np
, iarg
.alt_root
);
5302 if (IS_NULL(work
)) {
5303 onig_node_free(iarg
.alt_root
);
5304 return ONIGERR_MEMORY
;
5313 *np
= node_new_anychar();
5314 CHECK_NULL_RETURN_MEMERR(*np
);
5317 case TK_ANYCHAR_ANYTIME
:
5318 *np
= node_new_anychar();
5319 CHECK_NULL_RETURN_MEMERR(*np
);
5320 qn
= node_new_quantifier(0, REPEAT_INFINITE
, 0);
5321 CHECK_NULL_RETURN_MEMERR(qn
);
5322 NQTFR(qn
)->target
= *np
;
5327 len
= tok
->u
.backref
.num
;
5328 *np
= node_new_backref(len
,
5329 (len
> 1 ? tok
->u
.backref
.refs
: &(tok
->u
.backref
.ref1
)),
5330 tok
->u
.backref
.by_name
,
5331 #ifdef USE_BACKREF_WITH_LEVEL
5332 tok
->u
.backref
.exist_level
,
5333 tok
->u
.backref
.level
,
5336 CHECK_NULL_RETURN_MEMERR(*np
);
5339 #ifdef USE_SUBEXP_CALL
5342 int gnum
= tok
->u
.call
.gnum
;
5345 gnum
= BACKREF_REL_TO_ABS(gnum
, env
);
5347 return ONIGERR_INVALID_BACKREF
;
5349 *np
= node_new_call(tok
->u
.call
.name
, tok
->u
.call
.name_end
, gnum
);
5350 CHECK_NULL_RETURN_MEMERR(*np
);
5357 *np
= onig_node_new_anchor(tok
->u
.anchor
);
5358 CHECK_NULL_RETURN_MEMERR(*np
);
5363 if (IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_CONTEXT_INDEP_REPEAT_OPS
)) {
5364 if (IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_CONTEXT_INVALID_REPEAT_OPS
))
5365 return ONIGERR_TARGET_OF_REPEAT_OPERATOR_NOT_SPECIFIED
;
5367 *np
= node_new_empty();
5368 CHECK_NULL_RETURN_MEMERR(*np
);
5376 return ONIGERR_PARSER_BUG
;
5384 r
= fetch_token(tok
, src
, end
, env
);
5385 if (r
< 0) return r
;
5388 if (r
== TK_OP_REPEAT
|| r
== TK_INTERVAL
) {
5389 if (is_invalid_quantifier_target(*targetp
))
5390 return ONIGERR_TARGET_OF_REPEAT_OPERATOR_INVALID
;
5392 qn
= node_new_quantifier(tok
->u
.repeat
.lower
, tok
->u
.repeat
.upper
,
5393 (r
== TK_INTERVAL
? 1 : 0));
5394 CHECK_NULL_RETURN_MEMERR(qn
);
5395 NQTFR(qn
)->greedy
= tok
->u
.repeat
.greedy
;
5396 r
= set_quantifier(qn
, *targetp
, group
, env
);
5402 if (tok
->u
.repeat
.possessive
!= 0) {
5404 en
= node_new_enclose(ENCLOSE_STOP_BACKTRACK
);
5407 return ONIGERR_MEMORY
;
5409 NENCLOSE(en
)->target
= qn
;
5419 else if (r
== 2) { /* split case: /abc+/ */
5422 *targetp
= node_new_list(*targetp
, NULL
);
5423 if (IS_NULL(*targetp
)) {
5425 return ONIGERR_MEMORY
;
5427 tmp
= NCDR(*targetp
) = node_new_list(qn
, NULL
);
5430 return ONIGERR_MEMORY
;
5432 targetp
= &(NCAR(tmp
));
5442 parse_branch(Node
** top
, OnigToken
* tok
, int term
,
5443 UChar
** src
, UChar
* end
, ScanEnv
* env
)
5446 Node
*node
, **headp
;
5449 r
= parse_exp(&node
, tok
, term
, src
, end
, env
);
5450 if (r
< 0) return r
;
5452 if (r
== TK_EOT
|| r
== term
|| r
== TK_ALT
) {
5456 *top
= node_new_list(node
, NULL
);
5457 CHECK_NULL_RETURN_MEMERR(*top
);
5458 headp
= &(NCDR(*top
));
5459 while (r
!= TK_EOT
&& r
!= term
&& r
!= TK_ALT
) {
5460 r
= parse_exp(&node
, tok
, term
, src
, end
, env
);
5461 CHECK_NULL_RETURN_MEMERR(node
);
5462 if (r
< 0) return r
;
5464 if (NTYPE(node
) == NT_LIST
) {
5466 while (IS_NOT_NULL(NCDR(node
))) node
= NCDR(node
);
5467 headp
= &(NCDR(node
));
5470 *headp
= node_new_list(node
, NULL
);
5471 headp
= &(NCDR(*headp
));
5479 /* term_tok: TK_EOT or TK_SUBEXP_CLOSE */
5481 parse_subexp(Node
** top
, OnigToken
* tok
, int term
,
5482 UChar
** src
, UChar
* end
, ScanEnv
* env
)
5485 Node
*node
, **headp
;
5488 r
= parse_branch(&node
, tok
, term
, src
, end
, env
);
5490 onig_node_free(node
);
5497 else if (r
== TK_ALT
) {
5498 *top
= onig_node_new_alt(node
, NULL
);
5499 CHECK_NULL_RETURN_MEMERR(*top
);
5500 headp
= &(NCDR(*top
));
5501 while (r
== TK_ALT
) {
5502 r
= fetch_token(tok
, src
, end
, env
);
5503 if (r
< 0) return r
;
5504 r
= parse_branch(&node
, tok
, term
, src
, end
, env
);
5505 if (r
< 0) return r
;
5507 *headp
= onig_node_new_alt(node
, NULL
);
5508 headp
= &(NCDR(*headp
));
5511 if (tok
->type
!= (enum TokenSyms
)term
)
5516 if (term
== TK_SUBEXP_CLOSE
)
5517 return ONIGERR_END_PATTERN_WITH_UNMATCHED_PARENTHESIS
;
5519 return ONIGERR_PARSER_BUG
;
5526 parse_regexp(Node
** top
, UChar
** src
, UChar
* end
, ScanEnv
* env
)
5531 r
= fetch_token(&tok
, src
, end
, env
);
5532 if (r
< 0) return r
;
5533 r
= parse_subexp(top
, &tok
, TK_EOT
, src
, end
, env
);
5534 if (r
< 0) return r
;
5539 onig_parse_make_tree(Node
** root
, const UChar
* pattern
, const UChar
* end
,
5540 regex_t
* reg
, ScanEnv
* env
)
5545 #ifdef USE_NAMED_GROUP
5549 scan_env_clear(env
);
5550 env
->option
= reg
->options
;
5551 env
->case_fold_flag
= reg
->case_fold_flag
;
5552 env
->enc
= reg
->enc
;
5553 env
->syntax
= reg
->syntax
;
5554 env
->pattern
= (UChar
* )pattern
;
5555 env
->pattern_end
= (UChar
* )end
;
5559 p
= (UChar
* )pattern
;
5560 r
= parse_regexp(root
, &p
, (UChar
* )end
, env
);
5561 reg
->num_mem
= env
->num_mem
;
5566 onig_scan_env_set_error_string(ScanEnv
* env
, int ecode ARG_UNUSED
,
5567 UChar
* arg
, UChar
* arg_end
)
5570 env
->error_end
= arg_end
;