1 /**********************************************************************
2 regparse.c - Oniguruma (regular expression library)
3 **********************************************************************/
5 * Copyright (c) 2002-2008 K.Kosako <sndgk393 AT ybb DOT ne DOT jp>
8 * Copyright (c) 2015, Hewlett Packard Enterprise Development, L.P.<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
)(&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 key
->s
= (UChar
* )str_key
;
384 key
->end
= (UChar
* )end_key
;
385 result
= onig_st_insert(table
, (st_data_t
)key
, value
);
392 #endif /* USE_ST_LIBRARY */
395 #ifdef USE_NAMED_GROUP
397 #define INIT_NAME_BACKREFS_ALLOC_NUM 8
401 int name_len
; /* byte length */
402 int back_num
; /* number of backrefs */
408 #ifdef USE_ST_LIBRARY
410 typedef st_table NameTable
;
411 typedef st_data_t HashDataType
; /* 1.6 st.h doesn't define st_data_t type */
413 #define NAMEBUF_SIZE 24
414 #define NAMEBUF_SIZE_1 25
418 i_print_name_entry(UChar
* key
, NameEntry
* e
, void* arg
)
421 FILE* fp
= (FILE* )arg
;
423 fprintf(fp
, "%s: ", e
->name
);
424 if (e
->back_num
== 0)
426 else if (e
->back_num
== 1)
427 fprintf(fp
, "%d", e
->back_ref1
);
429 for (i
= 0; i
< e
->back_num
; i
++) {
430 if (i
> 0) fprintf(fp
, ", ");
431 fprintf(fp
, "%d", e
->back_refs
[i
]);
439 onig_print_names(FILE* fp
, regex_t
* reg
)
441 NameTable
* t
= (NameTable
* )reg
->name_table
;
443 if (IS_NOT_NULL(t
)) {
444 fprintf(fp
, "name table\n");
445 onig_st_foreach(t
, i_print_name_entry
, (HashDataType
)fp
);
450 #endif /* ONIG_DEBUG */
453 i_free_name_entry(UChar
* key
, NameEntry
* e
, void* arg ARG_UNUSED
)
456 if (IS_NOT_NULL(e
->back_refs
)) xfree(e
->back_refs
);
463 names_clear(regex_t
* reg
)
465 NameTable
* t
= (NameTable
* )reg
->name_table
;
467 if (IS_NOT_NULL(t
)) {
468 onig_st_foreach(t
, i_free_name_entry
, 0);
474 onig_names_free(regex_t
* reg
)
479 r
= names_clear(reg
);
482 t
= (NameTable
* )reg
->name_table
;
483 if (IS_NOT_NULL(t
)) onig_st_free_table(t
);
484 reg
->name_table
= (void* )NULL
;
489 name_find(regex_t
* reg
, const UChar
* name
, const UChar
* name_end
)
492 NameTable
* t
= (NameTable
* )reg
->name_table
;
494 e
= (NameEntry
* )NULL
;
495 if (IS_NOT_NULL(t
)) {
496 onig_st_lookup_strend(t
, name
, name_end
, (HashDataType
* )((void* )(&e
)));
502 int (*func
)(const UChar
*, const UChar
*,int,int*,regex_t
*,void*);
510 i_names(UChar
* key ARG_UNUSED
, NameEntry
* e
, INamesArg
* arg
)
512 int r
= (*(arg
->func
))(e
->name
,
513 e
->name
+ e
->name_len
,
515 (e
->back_num
> 1 ? e
->back_refs
: &(e
->back_ref1
)),
525 onig_foreach_name(regex_t
* reg
,
526 int (*func
)(const UChar
*, const UChar
*,int,int*,regex_t
*,void*), void* arg
)
529 NameTable
* t
= (NameTable
* )reg
->name_table
;
532 if (IS_NOT_NULL(t
)) {
536 narg
.enc
= reg
->enc
; /* should be pattern encoding. */
537 onig_st_foreach(t
, i_names
, (HashDataType
)&narg
);
543 i_renumber_name(UChar
* key ARG_UNUSED
, NameEntry
* e
, GroupNumRemap
* map
)
547 if (e
->back_num
> 1) {
548 for (i
= 0; i
< e
->back_num
; i
++) {
549 e
->back_refs
[i
] = map
[e
->back_refs
[i
]].new_val
;
552 else if (e
->back_num
== 1) {
553 e
->back_ref1
= map
[e
->back_ref1
].new_val
;
560 onig_renumber_name_table(regex_t
* reg
, GroupNumRemap
* map
)
562 NameTable
* t
= (NameTable
* )reg
->name_table
;
564 if (IS_NOT_NULL(t
)) {
565 onig_st_foreach(t
, i_renumber_name
, (HashDataType
)map
);
572 onig_number_of_names(regex_t
* reg
)
574 NameTable
* t
= (NameTable
* )reg
->name_table
;
577 return t
->num_entries
;
582 #else /* USE_ST_LIBRARY */
584 #define INIT_NAMES_ALLOC_NUM 8
594 onig_print_names(FILE* fp
, regex_t
* reg
)
598 NameTable
* t
= (NameTable
* )reg
->name_table
;
600 if (IS_NOT_NULL(t
) && t
->num
> 0) {
601 fprintf(fp
, "name table\n");
602 for (i
= 0; i
< t
->num
; i
++) {
604 fprintf(fp
, "%s: ", e
->name
);
605 if (e
->back_num
== 0) {
608 else if (e
->back_num
== 1) {
609 fprintf(fp
, "%d", e
->back_ref1
);
612 for (j
= 0; j
< e
->back_num
; j
++) {
613 if (j
> 0) fprintf(fp
, ", ");
614 fprintf(fp
, "%d", e
->back_refs
[j
]);
626 names_clear(regex_t
* reg
)
630 NameTable
* t
= (NameTable
* )reg
->name_table
;
632 if (IS_NOT_NULL(t
)) {
633 for (i
= 0; i
< t
->num
; i
++) {
635 if (IS_NOT_NULL(e
->name
)) {
641 if (IS_NOT_NULL(e
->back_refs
)) xfree(e
->back_refs
);
642 e
->back_refs
= (int* )NULL
;
645 if (IS_NOT_NULL(t
->e
)) {
655 onig_names_free(regex_t
* reg
)
660 r
= names_clear(reg
);
663 t
= (NameTable
* )reg
->name_table
;
664 if (IS_NOT_NULL(t
)) xfree(t
);
665 reg
->name_table
= NULL
;
670 name_find(regex_t
* reg
, UChar
* name
, UChar
* name_end
)
674 NameTable
* t
= (NameTable
* )reg
->name_table
;
676 if (IS_NOT_NULL(t
)) {
677 len
= name_end
- name
;
678 for (i
= 0; i
< t
->num
; i
++) {
680 if (len
== e
->name_len
&& onig_strncmp(name
, e
->name
, len
) == 0)
684 return (NameEntry
* )NULL
;
688 onig_foreach_name(regex_t
* reg
,
689 int (*func
)(const UChar
*, const UChar
*,int,int*,regex_t
*,void*), void* arg
)
693 NameTable
* t
= (NameTable
* )reg
->name_table
;
695 if (IS_NOT_NULL(t
)) {
696 for (i
= 0; i
< t
->num
; i
++) {
698 r
= (*func
)(e
->name
, e
->name
+ e
->name_len
, e
->back_num
,
699 (e
->back_num
> 1 ? e
->back_refs
: &(e
->back_ref1
)),
701 if (r
!= 0) return r
;
708 onig_number_of_names(regex_t
* reg
)
710 NameTable
* t
= (NameTable
* )reg
->name_table
;
718 #endif /* else USE_ST_LIBRARY */
721 name_add(regex_t
* reg
, UChar
* name
, UChar
* name_end
, int backref
, ScanEnv
* env
)
725 NameTable
* t
= (NameTable
* )reg
->name_table
;
727 if (name_end
- name
<= 0)
728 return ONIGERR_EMPTY_GROUP_NAME
;
730 e
= name_find(reg
, name
, name_end
);
732 #ifdef USE_ST_LIBRARY
734 t
= onig_st_init_strend_table_with_size(5);
735 reg
->name_table
= (void* )t
;
737 e
= (NameEntry
* )xmalloc(sizeof(NameEntry
));
738 CHECK_NULL_RETURN_MEMERR(e
);
740 e
->name
= strdup_with_null(reg
->enc
, name
, name_end
);
741 if (IS_NULL(e
->name
)) {
742 xfree(e
); return ONIGERR_MEMORY
;
744 onig_st_insert_strend(t
, e
->name
, (e
->name
+ (name_end
- name
)),
747 e
->name_len
= (int)(name_end
- name
);
750 e
->back_refs
= (int* )NULL
;
755 alloc
= INIT_NAMES_ALLOC_NUM
;
756 t
= (NameTable
* )xmalloc(sizeof(NameTable
));
757 CHECK_NULL_RETURN_MEMERR(t
);
762 t
->e
= (NameEntry
* )xmalloc(sizeof(NameEntry
) * alloc
);
765 return ONIGERR_MEMORY
;
771 else if (t
->num
== t
->alloc
) {
774 alloc
= t
->alloc
* 2;
775 t
->e
= (NameEntry
* )xrealloc(t
->e
, sizeof(NameEntry
) * alloc
);
776 CHECK_NULL_RETURN_MEMERR(t
->e
);
780 for (i
= t
->num
; i
< t
->alloc
; i
++) {
782 t
->e
[i
].name_len
= 0;
783 t
->e
[i
].back_num
= 0;
784 t
->e
[i
].back_alloc
= 0;
785 t
->e
[i
].back_refs
= (int* )NULL
;
790 e
->name
= strdup_with_null(reg
->enc
, name
, name_end
);
791 if (IS_NULL(e
->name
)) return ONIGERR_MEMORY
;
792 e
->name_len
= name_end
- name
;
796 if (e
->back_num
>= 1 &&
797 ! IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_ALLOW_MULTIPLEX_DEFINITION_NAME
)) {
798 onig_scan_env_set_error_string(env
, ONIGERR_MULTIPLEX_DEFINED_NAME
,
800 return ONIGERR_MULTIPLEX_DEFINED_NAME
;
804 if (e
->back_num
== 1) {
805 e
->back_ref1
= backref
;
808 if (e
->back_num
== 2) {
809 alloc
= INIT_NAME_BACKREFS_ALLOC_NUM
;
810 e
->back_refs
= (int* )xmalloc(sizeof(int) * alloc
);
811 CHECK_NULL_RETURN_MEMERR(e
->back_refs
);
812 e
->back_alloc
= alloc
;
813 e
->back_refs
[0] = e
->back_ref1
;
814 e
->back_refs
[1] = backref
;
817 if (e
->back_num
> e
->back_alloc
) {
818 alloc
= e
->back_alloc
* 2;
819 e
->back_refs
= (int* )xrealloc(e
->back_refs
, sizeof(int) * alloc
, sizeof(int) * e
->back_alloc
);
820 CHECK_NULL_RETURN_MEMERR(e
->back_refs
);
821 e
->back_alloc
= alloc
;
823 e
->back_refs
[e
->back_num
- 1] = backref
;
831 onig_name_to_group_numbers(regex_t
* reg
, const UChar
* name
,
832 const UChar
* name_end
, int** nums
)
834 NameEntry
* e
= name_find(reg
, name
, name_end
);
836 if (IS_NULL(e
)) return ONIGERR_UNDEFINED_NAME_REFERENCE
;
838 switch (e
->back_num
) {
842 *nums
= &(e
->back_ref1
);
845 *nums
= e
->back_refs
;
852 onig_name_to_backref_number(regex_t
* reg
, const UChar
* name
,
853 const UChar
* name_end
, OnigRegion
*region
)
857 n
= onig_name_to_group_numbers(reg
, name
, name_end
, &nums
);
861 return ONIGERR_PARSER_BUG
;
865 if (IS_NOT_NULL(region
)) {
866 for (i
= n
- 1; i
>= 0; i
--) {
867 if (region
->beg
[nums
[i
]] != ONIG_REGION_NOTPOS
)
875 #else /* USE_NAMED_GROUP */
878 onig_name_to_group_numbers(regex_t
* reg
, const UChar
* name
,
879 const UChar
* name_end
, int** nums
)
881 return ONIG_NO_SUPPORT_CONFIG
;
885 onig_name_to_backref_number(regex_t
* reg
, const UChar
* name
,
886 const UChar
* name_end
, OnigRegion
* region
)
888 return ONIG_NO_SUPPORT_CONFIG
;
892 onig_foreach_name(regex_t
* reg
,
893 int (*func
)(const UChar
*, const UChar
*,int,int*,regex_t
*,void*), void* arg
)
895 return ONIG_NO_SUPPORT_CONFIG
;
899 onig_number_of_names(regex_t
* reg
)
903 #endif /* else USE_NAMED_GROUP */
906 onig_noname_group_capture_is_active(regex_t
* reg
)
908 if (ONIG_IS_OPTION_ON(reg
->options
, ONIG_OPTION_DONT_CAPTURE_GROUP
))
911 #ifdef USE_NAMED_GROUP
912 if (onig_number_of_names(reg
) > 0 &&
913 IS_SYNTAX_BV(reg
->syntax
, ONIG_SYN_CAPTURE_ONLY_NAMED_GROUP
) &&
914 !ONIG_IS_OPTION_ON(reg
->options
, ONIG_OPTION_CAPTURE_GROUP
)) {
923 #define INIT_SCANENV_MEMNODES_ALLOC_SIZE 16
926 scan_env_clear(ScanEnv
* env
)
930 BIT_STATUS_CLEAR(env
->capture_history
);
931 BIT_STATUS_CLEAR(env
->bt_mem_start
);
932 BIT_STATUS_CLEAR(env
->bt_mem_end
);
933 BIT_STATUS_CLEAR(env
->backrefed_mem
);
934 env
->error
= (UChar
* )NULL
;
935 env
->error_end
= (UChar
* )NULL
;
938 #ifdef USE_NAMED_GROUP
942 env
->mem_nodes_dynamic
= (Node
** )NULL
;
944 for (i
= 0; i
< SCANENV_MEMNODES_SIZE
; i
++)
945 env
->mem_nodes_static
[i
] = NULL_NODE
;
947 #ifdef USE_COMBINATION_EXPLOSION_CHECK
948 env
->num_comb_exp_check
= 0;
949 env
->comb_exp_max_regnum
= 0;
950 env
->curr_max_regnum
= 0;
951 env
->has_recursion
= 0;
956 scan_env_add_mem_entry(ScanEnv
* env
)
961 need
= env
->num_mem
+ 1;
962 if (need
>= SCANENV_MEMNODES_SIZE
) {
963 if (env
->mem_alloc
<= need
) {
964 if (IS_NULL(env
->mem_nodes_dynamic
)) {
965 alloc
= INIT_SCANENV_MEMNODES_ALLOC_SIZE
;
966 p
= (Node
** )xmalloc(sizeof(Node
*) * alloc
);
967 xmemcpy(p
, env
->mem_nodes_static
,
968 sizeof(Node
*) * SCANENV_MEMNODES_SIZE
);
971 alloc
= env
->mem_alloc
* 2;
972 p
= (Node
** )xrealloc(env
->mem_nodes_dynamic
, sizeof(Node
*) * alloc
, sizeof(Node
*) * env
->mem_alloc
);
974 CHECK_NULL_RETURN_MEMERR(p
);
976 for (i
= env
->num_mem
+ 1; i
< alloc
; i
++)
979 env
->mem_nodes_dynamic
= p
;
980 env
->mem_alloc
= alloc
;
989 scan_env_set_mem_node(ScanEnv
* env
, int num
, Node
* node
)
991 if (env
->num_mem
>= num
)
992 SCANENV_MEM_NODES(env
)[num
] = node
;
994 return ONIGERR_PARSER_BUG
;
999 #ifdef USE_PARSE_TREE_NODE_RECYCLE
1000 typedef struct _FreeNode
{
1001 struct _FreeNode
* next
;
1004 static FreeNode
* FreeNodeList
= (FreeNode
* )NULL
;
1008 onig_node_free(Node
* node
)
1011 if (IS_NULL(node
)) return ;
1013 switch (NTYPE(node
)) {
1015 if (NSTR(node
)->capa
!= 0 &&
1016 IS_NOT_NULL(NSTR(node
)->s
) && NSTR(node
)->s
!= NSTR(node
)->buf
) {
1017 xfree(NSTR(node
)->s
);
1023 onig_node_free(NCAR(node
));
1025 Node
* next_node
= NCDR(node
);
1027 #ifdef USE_PARSE_TREE_NODE_RECYCLE
1029 FreeNode
* n
= (FreeNode
* )node
;
1031 THREAD_ATOMIC_START
;
1032 n
->next
= FreeNodeList
;
1046 CClassNode
* cc
= NCCLASS(node
);
1048 if (IS_NCCLASS_SHARE(cc
)) return ;
1050 bbuf_free(cc
->mbuf
);
1055 if (NQTFR(node
)->target
)
1056 onig_node_free(NQTFR(node
)->target
);
1060 if (NENCLOSE(node
)->target
)
1061 onig_node_free(NENCLOSE(node
)->target
);
1065 if (IS_NOT_NULL(NBREF(node
)->back_dynamic
))
1066 xfree(NBREF(node
)->back_dynamic
);
1070 if (NANCHOR(node
)->target
)
1071 onig_node_free(NANCHOR(node
)->target
);
1075 #ifdef USE_PARSE_TREE_NODE_RECYCLE
1077 FreeNode
* n
= (FreeNode
* )node
;
1079 THREAD_ATOMIC_START
;
1080 n
->next
= FreeNodeList
;
1089 #ifdef USE_PARSE_TREE_NODE_RECYCLE
1091 onig_free_node_list(void)
1095 /* THREAD_ATOMIC_START; */
1096 while (IS_NOT_NULL(FreeNodeList
)) {
1098 FreeNodeList
= FreeNodeList
->next
;
1101 /* THREAD_ATOMIC_END; */
1111 #ifdef USE_PARSE_TREE_NODE_RECYCLE
1112 THREAD_ATOMIC_START
;
1113 if (IS_NOT_NULL(FreeNodeList
)) {
1114 node
= (Node
* )FreeNodeList
;
1115 FreeNodeList
= FreeNodeList
->next
;
1122 node
= (Node
* )xmalloc(sizeof(Node
));
1123 /* xmemset(node, 0, sizeof(Node)); */
1129 initialize_cclass(CClassNode
* cc
)
1131 BITSET_CLEAR(cc
->bs
);
1132 /* cc->base.flags = 0; */
1138 node_new_cclass(void)
1140 Node
* node
= node_new();
1141 CHECK_NULL_RETURN(node
);
1143 SET_NTYPE(node
, NT_CCLASS
);
1144 initialize_cclass(NCCLASS(node
));
1149 node_new_cclass_by_codepoint_range(int not, OnigCodePoint sb_out
,
1150 const OnigCodePoint ranges
[])
1156 Node
* node
= node_new_cclass();
1157 CHECK_NULL_RETURN(node
);
1160 if (not != 0) NCCLASS_SET_NOT(cc
);
1162 BITSET_CLEAR(cc
->bs
);
1163 if (sb_out
> 0 && IS_NOT_NULL(ranges
)) {
1164 n
= ONIGENC_CODE_RANGE_NUM(ranges
);
1165 for (i
= 0; i
< n
; i
++) {
1166 for (j
= ONIGENC_CODE_RANGE_FROM(ranges
, i
);
1167 j
<= (OnigCodePoint
)ONIGENC_CODE_RANGE_TO(ranges
, i
); j
++) {
1168 if (j
>= sb_out
) goto sb_end
;
1170 BITSET_SET_BIT(cc
->bs
, j
);
1176 if (IS_NULL(ranges
)) {
1183 n
= ONIGENC_CODE_RANGE_NUM(ranges
);
1184 if (n
== 0) goto is_null
;
1186 bbuf
= (BBuf
* )xmalloc(sizeof(BBuf
));
1187 CHECK_NULL_RETURN(bbuf
);
1188 bbuf
->alloc
= n
+ 1;
1190 bbuf
->p
= (UChar
* )((void* )ranges
);
1199 node_new_ctype(int type
, int not)
1201 Node
* node
= node_new();
1202 CHECK_NULL_RETURN(node
);
1204 SET_NTYPE(node
, NT_CTYPE
);
1205 NCTYPE(node
)->ctype
= type
;
1206 NCTYPE(node
)->not = not;
1211 node_new_anychar(void)
1213 Node
* node
= node_new();
1214 CHECK_NULL_RETURN(node
);
1216 SET_NTYPE(node
, NT_CANY
);
1221 node_new_list(Node
* left
, Node
* right
)
1223 Node
* node
= node_new();
1224 CHECK_NULL_RETURN(node
);
1226 SET_NTYPE(node
, NT_LIST
);
1233 onig_node_new_list(Node
* left
, Node
* right
)
1235 return node_new_list(left
, right
);
1239 onig_node_list_add(Node
* list
, Node
* x
)
1243 n
= onig_node_new_list(x
, NULL
);
1244 if (IS_NULL(n
)) return NULL_NODE
;
1246 if (IS_NOT_NULL(list
)) {
1247 while (IS_NOT_NULL(NCDR(list
)))
1257 onig_node_new_alt(Node
* left
, Node
* right
)
1259 Node
* node
= node_new();
1260 CHECK_NULL_RETURN(node
);
1262 SET_NTYPE(node
, NT_ALT
);
1269 onig_node_new_anchor(int type
)
1271 Node
* node
= node_new();
1272 CHECK_NULL_RETURN(node
);
1274 SET_NTYPE(node
, NT_ANCHOR
);
1275 NANCHOR(node
)->type
= type
;
1276 NANCHOR(node
)->target
= NULL
;
1277 NANCHOR(node
)->char_len
= -1;
1282 node_new_backref(int back_num
, int* backrefs
, int by_name
,
1283 #ifdef USE_BACKREF_WITH_LEVEL
1284 int exist_level
, int nest_level
,
1289 Node
* node
= node_new();
1291 CHECK_NULL_RETURN(node
);
1293 SET_NTYPE(node
, NT_BREF
);
1294 NBREF(node
)->state
= 0;
1295 NBREF(node
)->back_num
= back_num
;
1296 NBREF(node
)->back_dynamic
= (int* )NULL
;
1298 NBREF(node
)->state
|= NST_NAME_REF
;
1300 #ifdef USE_BACKREF_WITH_LEVEL
1301 if (exist_level
!= 0) {
1302 NBREF(node
)->state
|= NST_NEST_LEVEL
;
1303 NBREF(node
)->nest_level
= nest_level
;
1307 for (i
= 0; i
< back_num
; i
++) {
1308 if (backrefs
[i
] <= env
->num_mem
&&
1309 IS_NULL(SCANENV_MEM_NODES(env
)[backrefs
[i
]])) {
1310 NBREF(node
)->state
|= NST_RECURSION
; /* /...(\1).../ */
1315 if (back_num
<= NODE_BACKREFS_SIZE
) {
1316 for (i
= 0; i
< back_num
; i
++)
1317 NBREF(node
)->back_static
[i
] = backrefs
[i
];
1320 int* p
= (int* )xmalloc(sizeof(int) * back_num
);
1322 onig_node_free(node
);
1325 NBREF(node
)->back_dynamic
= p
;
1326 for (i
= 0; i
< back_num
; i
++)
1332 #ifdef USE_SUBEXP_CALL
1334 node_new_call(UChar
* name
, UChar
* name_end
, int gnum
)
1336 Node
* node
= node_new();
1337 CHECK_NULL_RETURN(node
);
1339 SET_NTYPE(node
, NT_CALL
);
1340 NCALL(node
)->state
= 0;
1341 NCALL(node
)->target
= NULL_NODE
;
1342 NCALL(node
)->name
= name
;
1343 NCALL(node
)->name_end
= name_end
;
1344 NCALL(node
)->group_num
= gnum
; /* call by number if gnum != 0 */
1350 node_new_quantifier(int lower
, int upper
, int by_number
)
1352 Node
* node
= node_new();
1353 CHECK_NULL_RETURN(node
);
1355 SET_NTYPE(node
, NT_QTFR
);
1356 NQTFR(node
)->state
= 0;
1357 NQTFR(node
)->target
= NULL
;
1358 NQTFR(node
)->lower
= lower
;
1359 NQTFR(node
)->upper
= upper
;
1360 NQTFR(node
)->greedy
= 1;
1361 NQTFR(node
)->target_empty_info
= NQ_TARGET_ISNOT_EMPTY
;
1362 NQTFR(node
)->head_exact
= NULL_NODE
;
1363 NQTFR(node
)->next_head_exact
= NULL_NODE
;
1364 NQTFR(node
)->is_refered
= 0;
1366 NQTFR(node
)->state
|= NST_BY_NUMBER
;
1368 #ifdef USE_COMBINATION_EXPLOSION_CHECK
1369 NQTFR(node
)->comb_exp_check_num
= 0;
1376 node_new_enclose(int type
)
1378 Node
* node
= node_new();
1379 CHECK_NULL_RETURN(node
);
1381 SET_NTYPE(node
, NT_ENCLOSE
);
1382 NENCLOSE(node
)->type
= type
;
1383 NENCLOSE(node
)->state
= 0;
1384 NENCLOSE(node
)->regnum
= 0;
1385 NENCLOSE(node
)->option
= 0;
1386 NENCLOSE(node
)->target
= NULL
;
1387 NENCLOSE(node
)->call_addr
= -1;
1388 NENCLOSE(node
)->opt_count
= 0;
1393 onig_node_new_enclose(int type
)
1395 return node_new_enclose(type
);
1399 node_new_enclose_memory(OnigOptionType option
, int is_named
)
1401 Node
* node
= node_new_enclose(ENCLOSE_MEMORY
);
1402 CHECK_NULL_RETURN(node
);
1404 SET_ENCLOSE_STATUS(node
, NST_NAMED_GROUP
);
1406 #ifdef USE_SUBEXP_CALL
1407 NENCLOSE(node
)->option
= option
;
1413 node_new_option(OnigOptionType option
)
1415 Node
* node
= node_new_enclose(ENCLOSE_OPTION
);
1416 CHECK_NULL_RETURN(node
);
1417 NENCLOSE(node
)->option
= option
;
1422 onig_node_str_cat(Node
* node
, const UChar
* s
, const UChar
* end
)
1424 int addlen
= (int)(end
- s
);
1427 int len
= (int)(NSTR(node
)->end
- NSTR(node
)->s
);
1429 if (NSTR(node
)->capa
> 0 || (len
+ addlen
> NODE_STR_BUF_SIZE
- 1)) {
1431 int capa
= len
+ addlen
+ NODE_STR_MARGIN
;
1433 if (capa
<= NSTR(node
)->capa
) {
1434 onig_strcpy(NSTR(node
)->s
+ len
, s
, end
);
1437 if (NSTR(node
)->s
== NSTR(node
)->buf
)
1438 p
= strcat_capa_from_static(NSTR(node
)->s
, NSTR(node
)->end
,
1441 p
= strcat_capa(NSTR(node
)->s
, NSTR(node
)->end
, s
, end
, capa
, NSTR(node
)->capa
);
1443 CHECK_NULL_RETURN_MEMERR(p
);
1445 NSTR(node
)->capa
= capa
;
1449 onig_strcpy(NSTR(node
)->s
+ len
, s
, end
);
1451 NSTR(node
)->end
= NSTR(node
)->s
+ len
+ addlen
;
1458 onig_node_str_set(Node
* node
, const UChar
* s
, const UChar
* end
)
1460 onig_node_str_clear(node
);
1461 return onig_node_str_cat(node
, s
, end
);
1465 node_str_cat_char(Node
* node
, UChar c
)
1470 return onig_node_str_cat(node
, s
, s
+ 1);
1474 onig_node_conv_to_str_node(Node
* node
, int flag
)
1476 SET_NTYPE(node
, NT_STR
);
1477 NSTR(node
)->flag
= flag
;
1478 NSTR(node
)->capa
= 0;
1479 NSTR(node
)->s
= NSTR(node
)->buf
;
1480 NSTR(node
)->end
= NSTR(node
)->buf
;
1484 onig_node_str_clear(Node
* node
)
1486 if (NSTR(node
)->capa
!= 0 &&
1487 IS_NOT_NULL(NSTR(node
)->s
) && NSTR(node
)->s
!= NSTR(node
)->buf
) {
1488 xfree(NSTR(node
)->s
);
1491 NSTR(node
)->capa
= 0;
1492 NSTR(node
)->flag
= 0;
1493 NSTR(node
)->s
= NSTR(node
)->buf
;
1494 NSTR(node
)->end
= NSTR(node
)->buf
;
1498 node_new_str(const UChar
* s
, const UChar
* end
)
1500 Node
* node
= node_new();
1501 CHECK_NULL_RETURN(node
);
1503 SET_NTYPE(node
, NT_STR
);
1504 NSTR(node
)->capa
= 0;
1505 NSTR(node
)->flag
= 0;
1506 NSTR(node
)->s
= NSTR(node
)->buf
;
1507 NSTR(node
)->end
= NSTR(node
)->buf
;
1508 if (onig_node_str_cat(node
, s
, end
)) {
1509 onig_node_free(node
);
1516 onig_node_new_str(const UChar
* s
, const UChar
* end
)
1518 return node_new_str(s
, end
);
1522 node_new_str_raw(UChar
* s
, UChar
* end
)
1524 Node
* node
= node_new_str(s
, end
);
1525 NSTRING_SET_RAW(node
);
1530 node_new_empty(void)
1532 return node_new_str(NULL
, NULL
);
1536 node_new_str_raw_char(UChar c
)
1541 return node_new_str_raw(p
, p
+ 1);
1545 str_node_split_last_char(StrNode
* sn
, OnigEncoding enc
)
1548 Node
* n
= NULL_NODE
;
1550 if (sn
->end
> sn
->s
) {
1551 p
= onigenc_get_prev_char_head(enc
, sn
->s
, sn
->end
);
1552 if (p
&& p
> sn
->s
) { /* can be splitted. */
1553 n
= node_new_str(p
, sn
->end
);
1554 if ((sn
->flag
& NSTR_RAW
) != 0)
1556 sn
->end
= (UChar
* )p
;
1563 str_node_can_be_split(StrNode
* sn
, OnigEncoding enc
)
1565 if (sn
->end
> sn
->s
) {
1566 return ((enclen(enc
, sn
->s
) < sn
->end
- sn
->s
) ? 1 : 0);
1571 #ifdef USE_PAD_TO_SHORT_BYTE_CHAR
1573 node_str_head_pad(StrNode
* sn
, int num
, UChar val
)
1575 UChar buf
[NODE_STR_BUF_SIZE
];
1578 len
= sn
->end
- sn
->s
;
1579 onig_strcpy(buf
, sn
->s
, sn
->end
);
1580 onig_strcpy(&(sn
->s
[num
]), buf
, buf
+ len
);
1583 for (i
= 0; i
< num
; i
++) {
1590 onig_scan_unsigned_number(UChar
** src
, const UChar
* end
, OnigEncoding enc
)
1592 unsigned int num
, val
;
1600 if (ONIGENC_IS_CODE_DIGIT(enc
, c
)) {
1601 val
= (unsigned int )DIGITVAL(c
);
1602 if ((INT_MAX_LIMIT
- val
) / 10UL < num
)
1603 return -1; /* overflow */
1605 num
= num
* 10 + val
;
1617 scan_unsigned_hexadecimal_number(UChar
** src
, UChar
* end
, int maxlen
,
1621 unsigned int num
, val
;
1626 while (!PEND
&& maxlen
-- != 0) {
1628 if (ONIGENC_IS_CODE_XDIGIT(enc
, c
)) {
1629 val
= (unsigned int )XDIGITVAL(enc
,c
);
1630 if ((INT_MAX_LIMIT
- val
) / 16UL < num
)
1631 return -1; /* overflow */
1633 num
= (num
<< 4) + XDIGITVAL(enc
,c
);
1645 scan_unsigned_octal_number(UChar
** src
, UChar
* end
, int maxlen
,
1649 unsigned int num
, val
;
1654 while (!PEND
&& maxlen
-- != 0) {
1656 if (ONIGENC_IS_CODE_DIGIT(enc
, c
) && c
< '8') {
1658 if ((INT_MAX_LIMIT
- val
) / 8UL < num
)
1659 return -1; /* overflow */
1661 num
= (num
<< 3) + val
;
1673 #define BBUF_WRITE_CODE_POINT(bbuf,pos,code) \
1674 BBUF_WRITE(bbuf, pos, &(code), SIZE_CODE_POINT)
1677 [n][from-1][to-1][from-2][to-2] ... [from-n][to-n]
1678 (all data size is OnigCodePoint)
1681 new_code_range(BBuf
** pbuf
)
1683 #define INIT_MULTI_BYTE_RANGE_SIZE (SIZE_CODE_POINT * 5)
1688 bbuf
= *pbuf
= (BBuf
* )xmalloc(sizeof(BBuf
));
1689 CHECK_NULL_RETURN_MEMERR(*pbuf
);
1690 r
= BBUF_INIT(*pbuf
, INIT_MULTI_BYTE_RANGE_SIZE
);
1694 BBUF_WRITE_CODE_POINT(bbuf
, 0, n
);
1699 add_code_range_to_buf(BBuf
** pbuf
, OnigCodePoint from
, OnigCodePoint to
)
1702 int low
, high
, bound
, x
;
1703 OnigCodePoint n
, *data
;
1707 n
= from
; from
= to
; to
= n
;
1710 if (IS_NULL(*pbuf
)) {
1711 r
= new_code_range(pbuf
);
1718 GET_CODE_POINT(n
, bbuf
->p
);
1720 data
= (OnigCodePoint
* )(bbuf
->p
);
1723 for (low
= 0, bound
= n
; low
< bound
; ) {
1724 x
= (low
+ bound
) >> 1;
1725 if (from
> data
[x
*2 + 1])
1731 for (high
= low
, bound
= n
; high
< bound
; ) {
1732 x
= (high
+ bound
) >> 1;
1733 if (to
>= data
[x
*2] - 1)
1739 inc_n
= low
+ 1 - high
;
1740 if (n
+ inc_n
> ONIG_MAX_MULTI_BYTE_RANGES_NUM
)
1741 return ONIGERR_TOO_MANY_MULTI_BYTE_RANGES
;
1744 if (from
> data
[low
*2])
1746 if (to
< data
[(high
- 1)*2 + 1])
1747 to
= data
[(high
- 1)*2 + 1];
1750 if (inc_n
!= 0 && (OnigCodePoint
)high
< n
) {
1751 int from_pos
= SIZE_CODE_POINT
* (1 + high
* 2);
1752 int to_pos
= SIZE_CODE_POINT
* (1 + (low
+ 1) * 2);
1753 int size
= (n
- high
) * 2 * SIZE_CODE_POINT
;
1756 BBUF_MOVE_RIGHT(bbuf
, from_pos
, to_pos
, size
);
1759 BBUF_MOVE_LEFT_REDUCE(bbuf
, from_pos
, to_pos
);
1763 pos
= SIZE_CODE_POINT
* (1 + low
* 2);
1764 BBUF_ENSURE_SIZE(bbuf
, pos
+ SIZE_CODE_POINT
* 2);
1765 BBUF_WRITE_CODE_POINT(bbuf
, pos
, from
);
1766 BBUF_WRITE_CODE_POINT(bbuf
, pos
+ SIZE_CODE_POINT
, to
);
1768 BBUF_WRITE_CODE_POINT(bbuf
, 0, n
);
1774 add_code_range(BBuf
** pbuf
, ScanEnv
* env
, OnigCodePoint from
, OnigCodePoint to
)
1777 if (IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_ALLOW_EMPTY_RANGE_IN_CC
))
1780 return ONIGERR_EMPTY_RANGE_IN_CHAR_CLASS
;
1783 return add_code_range_to_buf(pbuf
, from
, to
);
1787 not_code_range_buf(OnigEncoding enc
, BBuf
* bbuf
, BBuf
** pbuf
)
1790 OnigCodePoint pre
, from
, *data
, to
= 0;
1792 *pbuf
= (BBuf
* )NULL
;
1793 if (IS_NULL(bbuf
)) {
1795 return SET_ALL_MULTI_BYTE_RANGE(enc
, pbuf
);
1798 data
= (OnigCodePoint
* )(bbuf
->p
);
1799 GET_CODE_POINT(n
, data
);
1801 if (n
<= 0) goto set_all
;
1804 pre
= MBCODE_START_POS(enc
);
1805 for (i
= 0; i
< n
; i
++) {
1808 if (pre
<= from
- 1) {
1809 r
= add_code_range_to_buf(pbuf
, pre
, from
- 1);
1810 if (r
!= 0) return r
;
1812 if (to
== ~((OnigCodePoint
)0)) break;
1815 if (to
< ~((OnigCodePoint
)0)) {
1816 r
= add_code_range_to_buf(pbuf
, to
+ 1, ~((OnigCodePoint
)0));
1821 #define SWAP_BBUF_NOT(bbuf1, not1, bbuf2, not2) do {\
1824 tnot = not1; not1 = not2; not2 = tnot; \
1825 tbuf = bbuf1; bbuf1 = bbuf2; bbuf2 = tbuf; \
1829 or_code_range_buf(OnigEncoding enc
, BBuf
* bbuf1
, int not1
,
1830 BBuf
* bbuf2
, int not2
, BBuf
** pbuf
)
1833 OnigCodePoint i
, n1
, *data1
;
1834 OnigCodePoint from
, to
;
1836 *pbuf
= (BBuf
* )NULL
;
1837 if (IS_NULL(bbuf1
) && IS_NULL(bbuf2
)) {
1838 if (not1
!= 0 || not2
!= 0)
1839 return SET_ALL_MULTI_BYTE_RANGE(enc
, pbuf
);
1845 SWAP_BBUF_NOT(bbuf1
, not1
, bbuf2
, not2
);
1847 if (IS_NULL(bbuf1
)) {
1849 return SET_ALL_MULTI_BYTE_RANGE(enc
, pbuf
);
1853 return bbuf_clone(pbuf
, bbuf2
);
1856 return not_code_range_buf(enc
, bbuf2
, pbuf
);
1862 SWAP_BBUF_NOT(bbuf1
, not1
, bbuf2
, not2
);
1864 data1
= (OnigCodePoint
* )(bbuf1
->p
);
1865 GET_CODE_POINT(n1
, data1
);
1868 if (not2
== 0 && not1
== 0) { /* 1 OR 2 */
1869 r
= bbuf_clone(pbuf
, bbuf2
);
1871 else if (not1
== 0) { /* 1 OR (not 2) */
1872 r
= not_code_range_buf(enc
, bbuf2
, pbuf
);
1874 if (r
!= 0) return r
;
1876 for (i
= 0; i
< n1
; i
++) {
1879 r
= add_code_range_to_buf(pbuf
, from
, to
);
1880 if (r
!= 0) return r
;
1886 and_code_range1(BBuf
** pbuf
, OnigCodePoint from1
, OnigCodePoint to1
,
1887 OnigCodePoint
* data
, int n
)
1890 OnigCodePoint from2
, to2
;
1892 for (i
= 0; i
< n
; i
++) {
1895 if (from2
< from1
) {
1896 if (to2
< from1
) continue;
1901 else if (from2
<= to1
) {
1903 if (from1
<= from2
- 1) {
1904 r
= add_code_range_to_buf(pbuf
, from1
, from2
-1);
1905 if (r
!= 0) return r
;
1916 if (from1
> to1
) break;
1919 r
= add_code_range_to_buf(pbuf
, from1
, to1
);
1920 if (r
!= 0) return r
;
1926 and_code_range_buf(BBuf
* bbuf1
, int not1
, BBuf
* bbuf2
, int not2
, BBuf
** pbuf
)
1929 OnigCodePoint i
, j
, n1
, n2
, *data1
, *data2
;
1930 OnigCodePoint from
, to
, from1
, to1
, from2
, to2
;
1932 *pbuf
= (BBuf
* )NULL
;
1933 if (IS_NULL(bbuf1
)) {
1934 if (not1
!= 0 && IS_NOT_NULL(bbuf2
)) /* not1 != 0 -> not2 == 0 */
1935 return bbuf_clone(pbuf
, bbuf2
);
1938 else if (IS_NULL(bbuf2
)) {
1940 return bbuf_clone(pbuf
, bbuf1
);
1945 SWAP_BBUF_NOT(bbuf1
, not1
, bbuf2
, not2
);
1947 data1
= (OnigCodePoint
* )(bbuf1
->p
);
1948 data2
= (OnigCodePoint
* )(bbuf2
->p
);
1949 GET_CODE_POINT(n1
, data1
);
1950 GET_CODE_POINT(n2
, data2
);
1954 if (not2
== 0 && not1
== 0) { /* 1 AND 2 */
1955 for (i
= 0; i
< n1
; i
++) {
1958 for (j
= 0; j
< n2
; j
++) {
1961 if (from2
> to1
) break;
1962 if (to2
< from1
) continue;
1963 from
= MAX(from1
, from2
);
1965 r
= add_code_range_to_buf(pbuf
, from
, to
);
1966 if (r
!= 0) return r
;
1970 else if (not1
== 0) { /* 1 AND (not 2) */
1971 for (i
= 0; i
< n1
; i
++) {
1974 r
= and_code_range1(pbuf
, from1
, to1
, data2
, n2
);
1975 if (r
!= 0) return r
;
1983 and_cclass(CClassNode
* dest
, CClassNode
* cc
, OnigEncoding enc
)
1986 BBuf
*buf1
, *buf2
, *pbuf
;
1987 BitSetRef bsr1
, bsr2
;
1990 not1
= IS_NCCLASS_NOT(dest
);
1993 not2
= IS_NCCLASS_NOT(cc
);
1998 bitset_invert_to(bsr1
, bs1
);
2002 bitset_invert_to(bsr2
, bs2
);
2005 bitset_and(bsr1
, bsr2
);
2006 if (bsr1
!= dest
->bs
) {
2007 bitset_copy(dest
->bs
, bsr1
);
2011 bitset_invert(dest
->bs
);
2014 if (! ONIGENC_IS_SINGLEBYTE(enc
)) {
2015 if (not1
!= 0 && not2
!= 0) {
2016 r
= or_code_range_buf(enc
, buf1
, 0, buf2
, 0, &pbuf
);
2019 r
= and_code_range_buf(buf1
, not1
, buf2
, not2
, &pbuf
);
2020 if (r
== 0 && not1
!= 0) {
2022 r
= not_code_range_buf(enc
, pbuf
, &tbuf
);
2031 if (r
!= 0) return r
;
2041 or_cclass(CClassNode
* dest
, CClassNode
* cc
, OnigEncoding enc
)
2044 BBuf
*buf1
, *buf2
, *pbuf
;
2045 BitSetRef bsr1
, bsr2
;
2048 not1
= IS_NCCLASS_NOT(dest
);
2051 not2
= IS_NCCLASS_NOT(cc
);
2056 bitset_invert_to(bsr1
, bs1
);
2060 bitset_invert_to(bsr2
, bs2
);
2063 bitset_or(bsr1
, bsr2
);
2064 if (bsr1
!= dest
->bs
) {
2065 bitset_copy(dest
->bs
, bsr1
);
2069 bitset_invert(dest
->bs
);
2072 if (! ONIGENC_IS_SINGLEBYTE(enc
)) {
2073 if (not1
!= 0 && not2
!= 0) {
2074 r
= and_code_range_buf(buf1
, 0, buf2
, 0, &pbuf
);
2077 r
= or_code_range_buf(enc
, buf1
, not1
, buf2
, not2
, &pbuf
);
2078 if (r
== 0 && not1
!= 0) {
2080 r
= not_code_range_buf(enc
, pbuf
, &tbuf
);
2089 if (r
!= 0) return r
;
2100 conv_backslash_value(int c
, ScanEnv
* env
)
2102 if (IS_SYNTAX_OP(env
->syntax
, ONIG_SYN_OP_ESC_CONTROL_CHARS
)) {
2104 case 'n': return '\n';
2105 case 't': return '\t';
2106 case 'r': return '\r';
2107 case 'f': return '\f';
2108 case 'a': return '\007';
2109 case 'b': return '\010';
2110 case 'e': return '\033';
2112 if (IS_SYNTAX_OP2(env
->syntax
, ONIG_SYN_OP2_ESC_V_VTAB
))
2124 is_invalid_quantifier_target(Node
* node
)
2126 switch (NTYPE(node
)) {
2132 /* allow enclosed elements */
2133 /* return is_invalid_quantifier_target(NENCLOSE(node)->target); */
2138 if (! is_invalid_quantifier_target(NCAR(node
))) return 0;
2139 } while (IS_NOT_NULL(node
= NCDR(node
)));
2145 if (is_invalid_quantifier_target(NCAR(node
))) return 1;
2146 } while (IS_NOT_NULL(node
= NCDR(node
)));
2155 /* ?:0, *:1, +:2, ??:3, *?:4, +?:5 */
2157 popular_quantifier_num(QtfrNode
* q
)
2160 if (q
->lower
== 0) {
2161 if (q
->upper
== 1) return 0;
2162 else if (IS_REPEAT_INFINITE(q
->upper
)) return 1;
2164 else if (q
->lower
== 1) {
2165 if (IS_REPEAT_INFINITE(q
->upper
)) return 2;
2169 if (q
->lower
== 0) {
2170 if (q
->upper
== 1) return 3;
2171 else if (IS_REPEAT_INFINITE(q
->upper
)) return 4;
2173 else if (q
->lower
== 1) {
2174 if (IS_REPEAT_INFINITE(q
->upper
)) return 5;
2182 RQ_ASIS
= 0, /* as is */
2183 RQ_DEL
= 1, /* delete parent */
2185 RQ_AQ
, /* to '*?' */
2186 RQ_QQ
, /* to '??' */
2187 RQ_P_QQ
, /* to '+)??' */
2188 RQ_PQ_Q
/* to '+?)?' */
2191 static enum ReduceType ReduceTypeTable
[6][6] = {
2192 {RQ_DEL
, RQ_A
, RQ_A
, RQ_QQ
, RQ_AQ
, RQ_ASIS
}, /* '?' */
2193 {RQ_DEL
, RQ_DEL
, RQ_DEL
, RQ_P_QQ
, RQ_P_QQ
, RQ_DEL
}, /* '*' */
2194 {RQ_A
, RQ_A
, RQ_DEL
, RQ_ASIS
, RQ_P_QQ
, RQ_DEL
}, /* '+' */
2195 {RQ_DEL
, RQ_AQ
, RQ_AQ
, RQ_DEL
, RQ_AQ
, RQ_AQ
}, /* '??' */
2196 {RQ_DEL
, RQ_DEL
, RQ_DEL
, RQ_DEL
, RQ_DEL
, RQ_DEL
}, /* '*?' */
2197 {RQ_ASIS
, RQ_PQ_Q
, RQ_DEL
, RQ_AQ
, RQ_AQ
, RQ_DEL
} /* '+?' */
2201 onig_reduce_nested_quantifier(Node
* pnode
, Node
* cnode
)
2208 pnum
= popular_quantifier_num(p
);
2209 cnum
= popular_quantifier_num(c
);
2210 if (pnum
< 0 || cnum
< 0) return ;
2212 switch(ReduceTypeTable
[cnum
][pnum
]) {
2217 p
->target
= c
->target
;
2218 p
->lower
= 0; p
->upper
= REPEAT_INFINITE
; p
->greedy
= 1;
2221 p
->target
= c
->target
;
2222 p
->lower
= 0; p
->upper
= REPEAT_INFINITE
; p
->greedy
= 0;
2225 p
->target
= c
->target
;
2226 p
->lower
= 0; p
->upper
= 1; p
->greedy
= 0;
2230 p
->lower
= 0; p
->upper
= 1; p
->greedy
= 0;
2231 c
->lower
= 1; c
->upper
= REPEAT_INFINITE
; c
->greedy
= 1;
2236 p
->lower
= 0; p
->upper
= 1; p
->greedy
= 1;
2237 c
->lower
= 1; c
->upper
= REPEAT_INFINITE
; c
->greedy
= 0;
2246 c
->target
= NULL_NODE
;
2247 onig_node_free(cnode
);
2252 TK_EOT
= 0, /* end of token */
2264 TK_ANYCHAR_ANYTIME
, /* SQL '%' == .* */
2270 TK_CHAR_PROPERTY
, /* \p{...}, \P{...} */
2274 TK_POSIX_BRACKET_OPEN
,
2276 TK_CC_CC_OPEN
/* [ */
2280 enum TokenSyms type
;
2282 int base
; /* is number: 8, 16 (used in [....]) */
2301 #ifdef USE_BACKREF_WITH_LEVEL
2303 int level
; /* \k<name+n> */
2320 fetch_range_quantifier(UChar
** src
, UChar
* end
, OnigToken
* tok
, ScanEnv
* env
)
2322 int low
, up
, syn_allow
, non_low
= 0;
2325 OnigEncoding enc
= env
->enc
;
2329 syn_allow
= IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_ALLOW_INVALID_INTERVAL
);
2333 return 1; /* "....{" : OK! */
2335 return ONIGERR_END_PATTERN_AT_LEFT_BRACE
; /* "....{" syntax error */
2340 if (c
== ')' || c
== '(' || c
== '|') {
2341 return ONIGERR_END_PATTERN_AT_LEFT_BRACE
;
2345 low
= onig_scan_unsigned_number(&p
, end
, env
->enc
);
2346 if (low
< 0) return ONIGERR_TOO_BIG_NUMBER_FOR_REPEAT_RANGE
;
2347 if (low
> ONIG_MAX_REPEAT_NUM
)
2348 return ONIGERR_TOO_BIG_NUMBER_FOR_REPEAT_RANGE
;
2350 if (p
== *src
) { /* can't read low */
2351 if (IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_ALLOW_INTERVAL_LOW_ABBREV
)) {
2352 /* allow {,n} as {0,n} */
2360 if (PEND
) goto invalid
;
2364 up
= onig_scan_unsigned_number(&p
, end
, env
->enc
);
2365 if (up
< 0) return ONIGERR_TOO_BIG_NUMBER_FOR_REPEAT_RANGE
;
2366 if (up
> ONIG_MAX_REPEAT_NUM
)
2367 return ONIGERR_TOO_BIG_NUMBER_FOR_REPEAT_RANGE
;
2372 up
= REPEAT_INFINITE
; /* {n,} : {n,infinite} */
2380 up
= low
; /* {n} : exact n times */
2384 if (PEND
) goto invalid
;
2386 if (IS_SYNTAX_OP(env
->syntax
, ONIG_SYN_OP_ESC_BRACE_INTERVAL
)) {
2387 if (c
!= MC_ESC(env
->syntax
)) goto invalid
;
2390 if (c
!= '}') goto invalid
;
2392 if (!IS_REPEAT_INFINITE(up
) && low
> up
) {
2393 return ONIGERR_UPPER_SMALLER_THAN_LOWER_IN_REPEAT_RANGE
;
2396 tok
->type
= TK_INTERVAL
;
2397 tok
->u
.repeat
.lower
= low
;
2398 tok
->u
.repeat
.upper
= up
;
2400 return r
; /* 0: normal {n,m}, 2: fixed {n} */
2406 return ONIGERR_INVALID_REPEAT_RANGE_PATTERN
;
2409 /* \M-, \C-, \c, or \... */
2411 fetch_escaped_value(UChar
** src
, UChar
* end
, ScanEnv
* env
)
2415 OnigEncoding enc
= env
->enc
;
2418 if (PEND
) return ONIGERR_END_PATTERN_AT_ESCAPE
;
2423 if (IS_SYNTAX_OP2(env
->syntax
, ONIG_SYN_OP2_ESC_CAPITAL_M_BAR_META
)) {
2424 if (PEND
) return ONIGERR_END_PATTERN_AT_META
;
2426 if (c
!= '-') return ONIGERR_META_CODE_SYNTAX
;
2427 if (PEND
) return ONIGERR_END_PATTERN_AT_META
;
2429 if (c
== MC_ESC(env
->syntax
)) {
2430 v
= fetch_escaped_value(&p
, end
, env
);
2431 if (v
< 0) return v
;
2432 c
= (OnigCodePoint
)v
;
2434 c
= ((c
& 0xff) | 0x80);
2441 if (IS_SYNTAX_OP2(env
->syntax
, ONIG_SYN_OP2_ESC_CAPITAL_C_BAR_CONTROL
)) {
2442 if (PEND
) return ONIGERR_END_PATTERN_AT_CONTROL
;
2444 if (c
!= '-') return ONIGERR_CONTROL_CODE_SYNTAX
;
2451 if (IS_SYNTAX_OP(env
->syntax
, ONIG_SYN_OP_ESC_C_CONTROL
)) {
2453 if (PEND
) return ONIGERR_END_PATTERN_AT_CONTROL
;
2459 if (c
== MC_ESC(env
->syntax
)) {
2460 v
= fetch_escaped_value(&p
, end
, env
);
2461 if (v
< 0) return v
;
2462 c
= (OnigCodePoint
)v
;
2473 c
= conv_backslash_value(c
, env
);
2482 static int fetch_token(OnigToken
* tok
, UChar
** src
, UChar
* end
, ScanEnv
* env
);
2484 static OnigCodePoint
2485 get_name_end_code_point(OnigCodePoint start
)
2488 case '<': return (OnigCodePoint
)'>'; break;
2489 case '\'': return (OnigCodePoint
)'\''; break;
2494 return (OnigCodePoint
)0;
2497 #ifdef USE_NAMED_GROUP
2498 #ifdef USE_BACKREF_WITH_LEVEL
2500 \k<name+n>, \k<name-n>
2501 \k<num+n>, \k<num-n>
2502 \k<-num+n>, \k<-num-n>
2505 fetch_name_with_level(OnigCodePoint start_code
, UChar
** src
, UChar
* end
,
2506 UChar
** rname_end
, ScanEnv
* env
,
2507 int* rback_num
, int* rlevel
)
2509 int r
, sign
, is_num
, exist_level
;
2510 OnigCodePoint end_code
;
2511 OnigCodePoint c
= 0;
2512 OnigEncoding enc
= env
->enc
;
2519 is_num
= exist_level
= 0;
2523 end_code
= get_name_end_code_point(start_code
);
2528 return ONIGERR_EMPTY_GROUP_NAME
;
2533 return ONIGERR_EMPTY_GROUP_NAME
;
2535 if (ONIGENC_IS_CODE_DIGIT(enc
, c
)) {
2538 else if (c
== '-') {
2543 else if (!ONIGENC_IS_CODE_WORD(enc
, c
)) {
2544 r
= ONIGERR_INVALID_CHAR_IN_GROUP_NAME
;
2551 if (c
== end_code
|| c
== ')' || c
== '+' || c
== '-') {
2552 if (is_num
== 2) r
= ONIGERR_INVALID_GROUP_NAME
;
2557 if (ONIGENC_IS_CODE_DIGIT(enc
, c
)) {
2561 r
= ONIGERR_INVALID_GROUP_NAME
;
2565 else if (!ONIGENC_IS_CODE_WORD(enc
, c
)) {
2566 r
= ONIGERR_INVALID_CHAR_IN_GROUP_NAME
;
2570 if (r
== 0 && c
!= end_code
) {
2571 if (c
== '+' || c
== '-') {
2573 int flag
= (c
== '-' ? -1 : 1);
2576 if (! ONIGENC_IS_CODE_DIGIT(enc
, c
)) goto err
;
2578 level
= onig_scan_unsigned_number(&p
, end
, enc
);
2579 if (level
< 0) return ONIGERR_TOO_BIG_NUMBER
;
2580 *rlevel
= (level
* flag
);
2589 r
= ONIGERR_INVALID_GROUP_NAME
;
2596 *rback_num
= onig_scan_unsigned_number(&pnum_head
, name_end
, enc
);
2597 if (*rback_num
< 0) return ONIGERR_TOO_BIG_NUMBER
;
2598 else if (*rback_num
== 0) goto err
;
2603 *rname_end
= name_end
;
2605 return (exist_level
? 1 : 0);
2608 onig_scan_env_set_error_string(env
, r
, *src
, name_end
);
2612 #endif /* USE_BACKREF_WITH_LEVEL */
2615 def: 0 -> define name (don't allow number name)
2616 1 -> reference name (allow number name)
2619 fetch_name(OnigCodePoint start_code
, UChar
** src
, UChar
* end
,
2620 UChar
** rname_end
, ScanEnv
* env
, int* rback_num
, int ref
)
2622 int r
, is_num
, sign
;
2623 OnigCodePoint end_code
;
2624 OnigCodePoint c
= 0;
2625 OnigEncoding enc
= env
->enc
;
2632 end_code
= get_name_end_code_point(start_code
);
2640 return ONIGERR_EMPTY_GROUP_NAME
;
2645 return ONIGERR_EMPTY_GROUP_NAME
;
2647 if (ONIGENC_IS_CODE_DIGIT(enc
, c
)) {
2651 r
= ONIGERR_INVALID_GROUP_NAME
;
2655 else if (c
== '-') {
2662 r
= ONIGERR_INVALID_GROUP_NAME
;
2666 else if (!ONIGENC_IS_CODE_WORD(enc
, c
)) {
2667 r
= ONIGERR_INVALID_CHAR_IN_GROUP_NAME
;
2675 if (c
== end_code
|| c
== ')') {
2676 if (is_num
== 2) r
= ONIGERR_INVALID_GROUP_NAME
;
2681 if (ONIGENC_IS_CODE_DIGIT(enc
, c
)) {
2685 if (!ONIGENC_IS_CODE_WORD(enc
, c
))
2686 r
= ONIGERR_INVALID_CHAR_IN_GROUP_NAME
;
2688 r
= ONIGERR_INVALID_GROUP_NAME
;
2693 if (!ONIGENC_IS_CODE_WORD(enc
, c
)) {
2694 r
= ONIGERR_INVALID_CHAR_IN_GROUP_NAME
;
2699 if (c
!= end_code
) {
2700 r
= ONIGERR_INVALID_GROUP_NAME
;
2705 *rback_num
= onig_scan_unsigned_number(&pnum_head
, name_end
, enc
);
2706 if (*rback_num
< 0) return ONIGERR_TOO_BIG_NUMBER
;
2707 else if (*rback_num
== 0) {
2708 r
= ONIGERR_INVALID_GROUP_NAME
;
2715 *rname_end
= name_end
;
2723 if (c
== end_code
|| c
== ')')
2730 onig_scan_env_set_error_string(env
, r
, *src
, name_end
);
2736 fetch_name(OnigCodePoint start_code
, UChar
** src
, UChar
* end
,
2737 UChar
** rname_end
, ScanEnv
* env
, int* rback_num
, int ref
)
2739 int r
, is_num
, sign
;
2740 OnigCodePoint end_code
;
2741 OnigCodePoint c
= 0;
2743 OnigEncoding enc
= env
->enc
;
2750 end_code
= get_name_end_code_point(start_code
);
2752 *rname_end
= name_end
= end
;
2759 return ONIGERR_EMPTY_GROUP_NAME
;
2764 return ONIGERR_EMPTY_GROUP_NAME
;
2766 if (ONIGENC_IS_CODE_DIGIT(enc
, c
)) {
2769 else if (c
== '-') {
2775 r
= ONIGERR_INVALID_CHAR_IN_GROUP_NAME
;
2783 if (c
== end_code
|| c
== ')') break;
2784 if (! ONIGENC_IS_CODE_DIGIT(enc
, c
))
2785 r
= ONIGERR_INVALID_CHAR_IN_GROUP_NAME
;
2787 if (r
== 0 && c
!= end_code
) {
2788 r
= ONIGERR_INVALID_GROUP_NAME
;
2793 *rback_num
= onig_scan_unsigned_number(&pnum_head
, name_end
, enc
);
2794 if (*rback_num
< 0) return ONIGERR_TOO_BIG_NUMBER
;
2795 else if (*rback_num
== 0) {
2796 r
= ONIGERR_INVALID_GROUP_NAME
;
2801 *rname_end
= name_end
;
2807 onig_scan_env_set_error_string(env
, r
, *src
, name_end
);
2811 #endif /* USE_NAMED_GROUP */
2814 CC_ESC_WARN(ScanEnv
* env
, UChar
*c
)
2816 if (onig_warn
== onig_null_warn
) return ;
2818 if (IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_WARN_CC_OP_NOT_ESCAPED
) &&
2819 IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_BACKSLASH_ESCAPE_IN_CC
)) {
2820 UChar buf
[WARN_BUFSIZE
];
2821 onig_snprintf_with_pattern(buf
, WARN_BUFSIZE
, env
->enc
,
2822 env
->pattern
, env
->pattern_end
,
2823 (UChar
* )"character class has '%s' without escape", c
);
2824 (*onig_warn
)((char* )buf
);
2829 CLOSE_BRACKET_WITHOUT_ESC_WARN(ScanEnv
* env
, UChar
* c
)
2831 if (onig_warn
== onig_null_warn
) return ;
2833 if (IS_SYNTAX_BV((env
)->syntax
, ONIG_SYN_WARN_CC_OP_NOT_ESCAPED
)) {
2834 UChar buf
[WARN_BUFSIZE
];
2835 onig_snprintf_with_pattern(buf
, WARN_BUFSIZE
, (env
)->enc
,
2836 (env
)->pattern
, (env
)->pattern_end
,
2837 (UChar
* )"regular expression has '%s' without escape", c
);
2838 (*onig_warn
)((char* )buf
);
2843 find_str_position(OnigCodePoint s
[], int n
, UChar
* from
, UChar
* to
,
2844 UChar
**next
, OnigEncoding enc
)
2852 x
= ONIGENC_MBC_TO_CODE(enc
, p
, to
);
2853 q
= p
+ enclen(enc
, p
);
2855 for (i
= 1; i
< n
&& q
< to
; i
++) {
2856 x
= ONIGENC_MBC_TO_CODE(enc
, q
, to
);
2857 if (x
!= s
[i
]) break;
2858 q
+= enclen(enc
, q
);
2861 if (IS_NOT_NULL(next
))
2872 str_exist_check_with_esc(OnigCodePoint s
[], int n
, UChar
* from
, UChar
* to
,
2873 OnigCodePoint bad
, OnigEncoding enc
, OnigSyntaxType
* syn
)
2884 p
+= enclen(enc
, p
);
2887 x
= ONIGENC_MBC_TO_CODE(enc
, p
, to
);
2888 q
= p
+ enclen(enc
, p
);
2890 for (i
= 1; i
< n
&& q
< to
; i
++) {
2891 x
= ONIGENC_MBC_TO_CODE(enc
, q
, to
);
2892 if (x
!= s
[i
]) break;
2893 q
+= enclen(enc
, q
);
2895 if (i
>= n
) return 1;
2896 p
+= enclen(enc
, p
);
2899 x
= ONIGENC_MBC_TO_CODE(enc
, p
, to
);
2900 if (x
== bad
) return 0;
2901 else if (x
== MC_ESC(syn
)) in_esc
= 1;
2910 fetch_token_in_cc(OnigToken
* tok
, UChar
** src
, UChar
* end
, ScanEnv
* env
)
2913 OnigCodePoint c
, c2
;
2914 OnigSyntaxType
* syn
= env
->syntax
;
2915 OnigEncoding enc
= env
->enc
;
2926 tok
->type
= TK_CHAR
;
2932 tok
->type
= TK_CC_CLOSE
;
2934 else if (c
== '-') {
2935 tok
->type
= TK_CC_RANGE
;
2937 else if (c
== MC_ESC(syn
)) {
2938 if (! IS_SYNTAX_BV(syn
, ONIG_SYN_BACKSLASH_ESCAPE_IN_CC
))
2941 if (PEND
) return ONIGERR_END_PATTERN_AT_ESCAPE
;
2948 tok
->type
= TK_CHAR_TYPE
;
2949 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_WORD
;
2950 tok
->u
.prop
.not = 0;
2953 tok
->type
= TK_CHAR_TYPE
;
2954 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_WORD
;
2955 tok
->u
.prop
.not = 1;
2958 tok
->type
= TK_CHAR_TYPE
;
2959 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_DIGIT
;
2960 tok
->u
.prop
.not = 0;
2963 tok
->type
= TK_CHAR_TYPE
;
2964 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_DIGIT
;
2965 tok
->u
.prop
.not = 1;
2968 tok
->type
= TK_CHAR_TYPE
;
2969 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_SPACE
;
2970 tok
->u
.prop
.not = 0;
2973 tok
->type
= TK_CHAR_TYPE
;
2974 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_SPACE
;
2975 tok
->u
.prop
.not = 1;
2978 if (! IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_H_XDIGIT
)) break;
2979 tok
->type
= TK_CHAR_TYPE
;
2980 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_XDIGIT
;
2981 tok
->u
.prop
.not = 0;
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 = 1;
2994 IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_P_BRACE_CHAR_PROPERTY
)) {
2996 tok
->type
= TK_CHAR_PROPERTY
;
2997 tok
->u
.prop
.not = (c
== 'P' ? 1 : 0);
2999 if (IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_P_BRACE_CIRCUMFLEX_NOT
)) {
3002 tok
->u
.prop
.not = (tok
->u
.prop
.not == 0 ? 1 : 0);
3014 if (PPEEK_IS('{') && IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_X_BRACE_HEX8
)) {
3016 num
= scan_unsigned_hexadecimal_number(&p
, end
, 8, enc
);
3017 if (num
< 0) return ONIGERR_TOO_BIG_WIDE_CHAR_VALUE
;
3020 if (ONIGENC_IS_CODE_XDIGIT(enc
, c2
))
3021 return ONIGERR_TOO_LONG_WIDE_CHAR_VALUE
;
3024 if (p
> prev
+ enclen(enc
, prev
) && !PEND
&& (PPEEK_IS('}'))) {
3026 tok
->type
= TK_CODE_POINT
;
3028 tok
->u
.code
= (OnigCodePoint
)num
;
3031 /* can't read nothing or invalid format */
3035 else if (IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_X_HEX2
)) {
3036 num
= scan_unsigned_hexadecimal_number(&p
, end
, 2, enc
);
3037 if (num
< 0) return ONIGERR_TOO_BIG_NUMBER
;
3038 if (p
== prev
) { /* can't read nothing. */
3039 num
= 0; /* but, it's not error */
3041 tok
->type
= TK_RAW_BYTE
;
3051 if (IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_U_HEX4
)) {
3052 num
= scan_unsigned_hexadecimal_number(&p
, end
, 4, enc
);
3053 if (num
< 0) return ONIGERR_TOO_BIG_NUMBER
;
3054 if (p
== prev
) { /* can't read nothing. */
3055 num
= 0; /* but, it's not error */
3057 tok
->type
= TK_CODE_POINT
;
3059 tok
->u
.code
= (OnigCodePoint
)num
;
3064 case '1': case '2': case '3': case '4': case '5': case '6': case '7':
3065 if (IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_OCTAL3
)) {
3068 num
= scan_unsigned_octal_number(&p
, end
, 3, enc
);
3069 if (num
< 0) return ONIGERR_TOO_BIG_NUMBER
;
3070 if (p
== prev
) { /* can't read nothing. */
3071 num
= 0; /* but, it's not error */
3073 tok
->type
= TK_RAW_BYTE
;
3081 num
= fetch_escaped_value(&p
, end
, env
);
3082 if (num
< 0) return num
;
3083 if (tok
->u
.c
!= num
) {
3084 tok
->u
.code
= (OnigCodePoint
)num
;
3085 tok
->type
= TK_CODE_POINT
;
3090 else if (c
== '[') {
3091 if (IS_SYNTAX_OP(syn
, ONIG_SYN_OP_POSIX_BRACKET
) && (PPEEK_IS(':'))) {
3092 OnigCodePoint send
[] = { (OnigCodePoint
)':', (OnigCodePoint
)']' };
3093 tok
->backp
= p
; /* point at '[' is readed */
3095 if (str_exist_check_with_esc(send
, 2, p
, end
,
3096 (OnigCodePoint
)']', enc
, syn
)) {
3097 tok
->type
= TK_POSIX_BRACKET_OPEN
;
3106 if (IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_CCLASS_SET_OP
)) {
3107 tok
->type
= TK_CC_CC_OPEN
;
3110 CC_ESC_WARN(env
, (UChar
* )"[");
3114 else if (c
== '&') {
3115 if (IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_CCLASS_SET_OP
) &&
3116 !PEND
&& (PPEEK_IS('&'))) {
3118 tok
->type
= TK_CC_AND
;
3128 fetch_token(OnigToken
* tok
, UChar
** src
, UChar
* end
, ScanEnv
* env
)
3132 OnigEncoding enc
= env
->enc
;
3133 OnigSyntaxType
* syn
= env
->syntax
;
3144 tok
->type
= TK_STRING
;
3149 if (IS_MC_ESC_CODE(c
, syn
)) {
3150 if (PEND
) return ONIGERR_END_PATTERN_AT_ESCAPE
;
3159 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_ASTERISK_ZERO_INF
)) break;
3160 tok
->type
= TK_OP_REPEAT
;
3161 tok
->u
.repeat
.lower
= 0;
3162 tok
->u
.repeat
.upper
= REPEAT_INFINITE
;
3167 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_PLUS_ONE_INF
)) break;
3168 tok
->type
= TK_OP_REPEAT
;
3169 tok
->u
.repeat
.lower
= 1;
3170 tok
->u
.repeat
.upper
= REPEAT_INFINITE
;
3175 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_QMARK_ZERO_ONE
)) break;
3176 tok
->type
= TK_OP_REPEAT
;
3177 tok
->u
.repeat
.lower
= 0;
3178 tok
->u
.repeat
.upper
= 1;
3180 if (!PEND
&& PPEEK_IS('?') &&
3181 IS_SYNTAX_OP(syn
, ONIG_SYN_OP_QMARK_NON_GREEDY
)) {
3183 tok
->u
.repeat
.greedy
= 0;
3184 tok
->u
.repeat
.possessive
= 0;
3188 if (!PEND
&& PPEEK_IS('+') &&
3189 ((IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_PLUS_POSSESSIVE_REPEAT
) &&
3190 tok
->type
!= TK_INTERVAL
) ||
3191 (IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_PLUS_POSSESSIVE_INTERVAL
) &&
3192 tok
->type
== TK_INTERVAL
))) {
3194 tok
->u
.repeat
.greedy
= 1;
3195 tok
->u
.repeat
.possessive
= 1;
3198 tok
->u
.repeat
.greedy
= 1;
3199 tok
->u
.repeat
.possessive
= 0;
3205 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_BRACE_INTERVAL
)) break;
3206 r
= fetch_range_quantifier(&p
, end
, tok
, env
);
3207 if (r
< 0) return r
; /* error */
3208 if (r
== 0) goto greedy_check
;
3209 else if (r
== 2) { /* {n} */
3210 if (IS_SYNTAX_BV(syn
, ONIG_SYN_FIXED_INTERVAL_IS_GREEDY_ONLY
))
3211 goto possessive_check
;
3215 /* r == 1 : normal char */
3219 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_VBAR_ALT
)) break;
3224 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_LPAREN_SUBEXP
)) break;
3225 tok
->type
= TK_SUBEXP_OPEN
;
3229 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_LPAREN_SUBEXP
)) break;
3230 tok
->type
= TK_SUBEXP_CLOSE
;
3234 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_W_WORD
)) break;
3235 tok
->type
= TK_CHAR_TYPE
;
3236 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_WORD
;
3237 tok
->u
.prop
.not = 0;
3241 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_W_WORD
)) break;
3242 tok
->type
= TK_CHAR_TYPE
;
3243 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_WORD
;
3244 tok
->u
.prop
.not = 1;
3248 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_B_WORD_BOUND
)) break;
3249 tok
->type
= TK_ANCHOR
;
3250 tok
->u
.anchor
= ANCHOR_WORD_BOUND
;
3254 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_B_WORD_BOUND
)) break;
3255 tok
->type
= TK_ANCHOR
;
3256 tok
->u
.anchor
= ANCHOR_NOT_WORD_BOUND
;
3259 #ifdef USE_WORD_BEGIN_END
3261 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_LTGT_WORD_BEGIN_END
)) break;
3262 tok
->type
= TK_ANCHOR
;
3263 tok
->u
.anchor
= ANCHOR_WORD_BEGIN
;
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_END
;
3274 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_S_WHITE_SPACE
)) break;
3275 tok
->type
= TK_CHAR_TYPE
;
3276 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_SPACE
;
3277 tok
->u
.prop
.not = 0;
3281 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_S_WHITE_SPACE
)) break;
3282 tok
->type
= TK_CHAR_TYPE
;
3283 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_SPACE
;
3284 tok
->u
.prop
.not = 1;
3288 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_D_DIGIT
)) break;
3289 tok
->type
= TK_CHAR_TYPE
;
3290 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_DIGIT
;
3291 tok
->u
.prop
.not = 0;
3295 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_D_DIGIT
)) break;
3296 tok
->type
= TK_CHAR_TYPE
;
3297 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_DIGIT
;
3298 tok
->u
.prop
.not = 1;
3302 if (! IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_H_XDIGIT
)) break;
3303 tok
->type
= TK_CHAR_TYPE
;
3304 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_XDIGIT
;
3305 tok
->u
.prop
.not = 0;
3309 if (! IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_H_XDIGIT
)) break;
3310 tok
->type
= TK_CHAR_TYPE
;
3311 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_XDIGIT
;
3312 tok
->u
.prop
.not = 1;
3316 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_AZ_BUF_ANCHOR
)) break;
3318 tok
->type
= TK_ANCHOR
;
3319 tok
->u
.subtype
= ANCHOR_BEGIN_BUF
;
3323 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_AZ_BUF_ANCHOR
)) break;
3324 tok
->type
= TK_ANCHOR
;
3325 tok
->u
.subtype
= ANCHOR_SEMI_END_BUF
;
3329 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_AZ_BUF_ANCHOR
)) break;
3331 tok
->type
= TK_ANCHOR
;
3332 tok
->u
.subtype
= ANCHOR_END_BUF
;
3336 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_CAPITAL_G_BEGIN_ANCHOR
)) break;
3337 tok
->type
= TK_ANCHOR
;
3338 tok
->u
.subtype
= ANCHOR_BEGIN_POSITION
;
3342 if (! IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_GNU_BUF_ANCHOR
)) break;
3347 if (! IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_GNU_BUF_ANCHOR
)) break;
3355 if (PPEEK_IS('{') && IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_X_BRACE_HEX8
)) {
3357 num
= scan_unsigned_hexadecimal_number(&p
, end
, 8, enc
);
3358 if (num
< 0) return ONIGERR_TOO_BIG_WIDE_CHAR_VALUE
;
3360 if (ONIGENC_IS_CODE_XDIGIT(enc
, PPEEK
))
3361 return ONIGERR_TOO_LONG_WIDE_CHAR_VALUE
;
3364 if ((p
> prev
+ enclen(enc
, prev
)) && !PEND
&& PPEEK_IS('}')) {
3366 tok
->type
= TK_CODE_POINT
;
3367 tok
->u
.code
= (OnigCodePoint
)num
;
3370 /* can't read nothing or invalid format */
3374 else if (IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_X_HEX2
)) {
3375 num
= scan_unsigned_hexadecimal_number(&p
, end
, 2, enc
);
3376 if (num
< 0) return ONIGERR_TOO_BIG_NUMBER
;
3377 if (p
== prev
) { /* can't read nothing. */
3378 num
= 0; /* but, it's not error */
3380 tok
->type
= TK_RAW_BYTE
;
3390 if (IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_U_HEX4
)) {
3391 num
= scan_unsigned_hexadecimal_number(&p
, end
, 4, enc
);
3392 if (num
< 0) return ONIGERR_TOO_BIG_NUMBER
;
3393 if (p
== prev
) { /* can't read nothing. */
3394 num
= 0; /* but, it's not error */
3396 tok
->type
= TK_CODE_POINT
;
3398 tok
->u
.code
= (OnigCodePoint
)num
;
3402 case '1': case '2': case '3': case '4':
3403 case '5': case '6': case '7': case '8': case '9':
3406 num
= onig_scan_unsigned_number(&p
, end
, enc
);
3407 if (num
< 0 || num
> ONIG_MAX_BACKREF_NUM
) {
3411 if (IS_SYNTAX_OP(syn
, ONIG_SYN_OP_DECIMAL_BACKREF
) &&
3412 (num
<= env
->num_mem
|| num
<= 9)) { /* This spec. from GNU regex */
3413 if (IS_SYNTAX_BV(syn
, ONIG_SYN_STRICT_CHECK_BACKREF
)) {
3414 if (num
> env
->num_mem
|| IS_NULL(SCANENV_MEM_NODES(env
)[num
]))
3415 return ONIGERR_INVALID_BACKREF
;
3418 tok
->type
= TK_BACKREF
;
3419 tok
->u
.backref
.num
= 1;
3420 tok
->u
.backref
.ref1
= num
;
3421 tok
->u
.backref
.by_name
= 0;
3422 #ifdef USE_BACKREF_WITH_LEVEL
3423 tok
->u
.backref
.exist_level
= 0;
3429 if (c
== '8' || c
== '9') {
3438 if (IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_OCTAL3
)) {
3440 num
= scan_unsigned_octal_number(&p
, end
, (c
== '0' ? 2:3), enc
);
3441 if (num
< 0) return ONIGERR_TOO_BIG_NUMBER
;
3442 if (p
== prev
) { /* can't read nothing. */
3443 num
= 0; /* but, it's not error */
3445 tok
->type
= TK_RAW_BYTE
;
3449 else if (c
!= '0') {
3454 #ifdef USE_NAMED_GROUP
3456 if (IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_K_NAMED_BACKREF
)) {
3458 if (c
== '<' || c
== '\'') {
3465 #ifdef USE_BACKREF_WITH_LEVEL
3466 name_end
= NULL_UCHARP
; /* no need. escape gcc warning. */
3467 r
= fetch_name_with_level((OnigCodePoint
)c
, &p
, end
, &name_end
,
3468 env
, &back_num
, &tok
->u
.backref
.level
);
3469 if (r
== 1) tok
->u
.backref
.exist_level
= 1;
3470 else tok
->u
.backref
.exist_level
= 0;
3472 r
= fetch_name(&p
, end
, &name_end
, env
, &back_num
, 1);
3474 if (r
< 0) return r
;
3476 if (back_num
!= 0) {
3478 back_num
= BACKREF_REL_TO_ABS(back_num
, env
);
3480 return ONIGERR_INVALID_BACKREF
;
3483 if (IS_SYNTAX_BV(syn
, ONIG_SYN_STRICT_CHECK_BACKREF
)) {
3484 if (back_num
> env
->num_mem
||
3485 IS_NULL(SCANENV_MEM_NODES(env
)[back_num
]))
3486 return ONIGERR_INVALID_BACKREF
;
3488 tok
->type
= TK_BACKREF
;
3489 tok
->u
.backref
.by_name
= 0;
3490 tok
->u
.backref
.num
= 1;
3491 tok
->u
.backref
.ref1
= back_num
;
3494 num
= onig_name_to_group_numbers(env
->reg
, prev
, name_end
, &backs
);
3496 onig_scan_env_set_error_string(env
,
3497 ONIGERR_UNDEFINED_NAME_REFERENCE
, prev
, name_end
);
3498 return ONIGERR_UNDEFINED_NAME_REFERENCE
;
3500 if (IS_SYNTAX_BV(syn
, ONIG_SYN_STRICT_CHECK_BACKREF
)) {
3502 for (i
= 0; i
< num
; i
++) {
3503 if (backs
[i
] > env
->num_mem
||
3504 IS_NULL(SCANENV_MEM_NODES(env
)[backs
[i
]]))
3505 return ONIGERR_INVALID_BACKREF
;
3509 tok
->type
= TK_BACKREF
;
3510 tok
->u
.backref
.by_name
= 1;
3512 tok
->u
.backref
.num
= 1;
3513 tok
->u
.backref
.ref1
= backs
[0];
3516 tok
->u
.backref
.num
= num
;
3517 tok
->u
.backref
.refs
= backs
;
3527 #ifdef USE_SUBEXP_CALL
3529 if (IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_G_SUBEXP_CALL
)) {
3531 if (c
== '<' || c
== '\'') {
3536 r
= fetch_name((OnigCodePoint
)c
, &p
, end
, &name_end
, env
, &gnum
, 1);
3537 if (r
< 0) return r
;
3539 tok
->type
= TK_CALL
;
3540 tok
->u
.call
.name
= prev
;
3541 tok
->u
.call
.name_end
= name_end
;
3542 tok
->u
.call
.gnum
= gnum
;
3551 if (IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_CAPITAL_Q_QUOTE
)) {
3552 tok
->type
= TK_QUOTE_OPEN
;
3558 if (PPEEK_IS('{') &&
3559 IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_P_BRACE_CHAR_PROPERTY
)) {
3561 tok
->type
= TK_CHAR_PROPERTY
;
3562 tok
->u
.prop
.not = (c
== 'P' ? 1 : 0);
3564 if (IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_P_BRACE_CIRCUMFLEX_NOT
)) {
3567 tok
->u
.prop
.not = (tok
->u
.prop
.not == 0 ? 1 : 0);
3577 num
= fetch_escaped_value(&p
, end
, env
);
3578 if (num
< 0) return num
;
3580 if (tok
->u
.c
!= num
) {
3581 tok
->type
= TK_CODE_POINT
;
3582 tok
->u
.code
= (OnigCodePoint
)num
;
3585 p
= tok
->backp
+ enclen(enc
, tok
->backp
);
3594 #ifdef USE_VARIABLE_META_CHARS
3595 if ((c
!= ONIG_INEFFECTIVE_META_CHAR
) &&
3596 IS_SYNTAX_OP(syn
, ONIG_SYN_OP_VARIABLE_META_CHARACTERS
)) {
3597 if (c
== MC_ANYCHAR(syn
))
3599 else if (c
== MC_ANYTIME(syn
))
3601 else if (c
== MC_ZERO_OR_ONE_TIME(syn
))
3602 goto zero_or_one_time
;
3603 else if (c
== MC_ONE_OR_MORE_TIME(syn
))
3604 goto one_or_more_time
;
3605 else if (c
== MC_ANYCHAR_ANYTIME(syn
)) {
3606 tok
->type
= TK_ANYCHAR_ANYTIME
;
3614 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_DOT_ANYCHAR
)) break;
3615 #ifdef USE_VARIABLE_META_CHARS
3618 tok
->type
= TK_ANYCHAR
;
3622 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ASTERISK_ZERO_INF
)) break;
3623 #ifdef USE_VARIABLE_META_CHARS
3626 tok
->type
= TK_OP_REPEAT
;
3627 tok
->u
.repeat
.lower
= 0;
3628 tok
->u
.repeat
.upper
= REPEAT_INFINITE
;
3633 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_PLUS_ONE_INF
)) break;
3634 #ifdef USE_VARIABLE_META_CHARS
3637 tok
->type
= TK_OP_REPEAT
;
3638 tok
->u
.repeat
.lower
= 1;
3639 tok
->u
.repeat
.upper
= REPEAT_INFINITE
;
3644 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_QMARK_ZERO_ONE
)) break;
3645 #ifdef USE_VARIABLE_META_CHARS
3648 tok
->type
= TK_OP_REPEAT
;
3649 tok
->u
.repeat
.lower
= 0;
3650 tok
->u
.repeat
.upper
= 1;
3655 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_BRACE_INTERVAL
)) break;
3656 r
= fetch_range_quantifier(&p
, end
, tok
, env
);
3657 if (r
< 0) return r
; /* error */
3658 if (r
== 0) goto greedy_check
;
3659 else if (r
== 2) { /* {n} */
3660 if (IS_SYNTAX_BV(syn
, ONIG_SYN_FIXED_INTERVAL_IS_GREEDY_ONLY
))
3661 goto possessive_check
;
3665 /* r == 1 : normal char */
3669 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_VBAR_ALT
)) break;
3674 if (PPEEK_IS('?') &&
3675 IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_QMARK_GROUP_EFFECT
)) {
3677 if (PPEEK_IS('#')) {
3680 if (PEND
) return ONIGERR_END_PATTERN_IN_GROUP
;
3682 if (c
== MC_ESC(syn
)) {
3683 if (!PEND
) PFETCH(c
);
3686 if (c
== ')') break;
3694 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_LPAREN_SUBEXP
)) break;
3695 tok
->type
= TK_SUBEXP_OPEN
;
3699 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_LPAREN_SUBEXP
)) break;
3700 tok
->type
= TK_SUBEXP_CLOSE
;
3704 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_LINE_ANCHOR
)) break;
3705 tok
->type
= TK_ANCHOR
;
3706 tok
->u
.subtype
= (IS_SINGLELINE(env
->option
)
3707 ? ANCHOR_BEGIN_BUF
: ANCHOR_BEGIN_LINE
);
3711 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_LINE_ANCHOR
)) break;
3712 tok
->type
= TK_ANCHOR
;
3713 tok
->u
.subtype
= (IS_SINGLELINE(env
->option
)
3714 ? ANCHOR_SEMI_END_BUF
: ANCHOR_END_LINE
);
3718 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_BRACKET_CC
)) break;
3719 tok
->type
= TK_CC_OPEN
;
3723 if (*src
> env
->pattern
) /* /].../ is allowed. */
3724 CLOSE_BRACKET_WITHOUT_ESC_WARN(env
, (UChar
* )"]");
3728 if (IS_EXTEND(env
->option
)) {
3731 if (ONIGENC_IS_CODE_NEWLINE(enc
, c
))
3739 case ' ': case '\t': case '\n': case '\r': case '\f':
3740 if (IS_EXTEND(env
->option
))
3750 #ifdef USE_VARIABLE_META_CHARS
3758 add_ctype_to_cc_by_range(CClassNode
* cc
, int ctype ARG_UNUSED
, int not,
3759 OnigEncoding enc ARG_UNUSED
,
3760 OnigCodePoint sb_out
, const OnigCodePoint mbr
[])
3765 int n
= ONIGENC_CODE_RANGE_NUM(mbr
);
3768 for (i
= 0; i
< n
; i
++) {
3769 for (j
= ONIGENC_CODE_RANGE_FROM(mbr
, i
);
3770 j
<= ONIGENC_CODE_RANGE_TO(mbr
, i
); j
++) {
3772 if (j
== ONIGENC_CODE_RANGE_TO(mbr
, i
)) i
++;
3773 else if (j
> ONIGENC_CODE_RANGE_FROM(mbr
, i
)) {
3774 r
= add_code_range_to_buf(&(cc
->mbuf
), j
,
3775 ONIGENC_CODE_RANGE_TO(mbr
, i
));
3776 if (r
!= 0) return r
;
3782 BITSET_SET_BIT(cc
->bs
, j
);
3787 for ( ; i
< n
; i
++) {
3788 r
= add_code_range_to_buf(&(cc
->mbuf
),
3789 ONIGENC_CODE_RANGE_FROM(mbr
, i
),
3790 ONIGENC_CODE_RANGE_TO(mbr
, i
));
3791 if (r
!= 0) return r
;
3795 OnigCodePoint prev
= 0;
3797 for (i
= 0; i
< n
; i
++) {
3799 j
< ONIGENC_CODE_RANGE_FROM(mbr
, i
); j
++) {
3803 BITSET_SET_BIT(cc
->bs
, j
);
3805 prev
= ONIGENC_CODE_RANGE_TO(mbr
, i
) + 1;
3807 for (j
= prev
; j
< sb_out
; j
++) {
3808 BITSET_SET_BIT(cc
->bs
, j
);
3814 for (i
= 0; i
< n
; i
++) {
3815 if (prev
< ONIGENC_CODE_RANGE_FROM(mbr
, i
)) {
3816 r
= add_code_range_to_buf(&(cc
->mbuf
), prev
,
3817 ONIGENC_CODE_RANGE_FROM(mbr
, i
) - 1);
3818 if (r
!= 0) return r
;
3820 prev
= ONIGENC_CODE_RANGE_TO(mbr
, i
) + 1;
3822 if (prev
< 0x7fffffff) {
3823 r
= add_code_range_to_buf(&(cc
->mbuf
), prev
, 0x7fffffff);
3824 if (r
!= 0) return r
;
3832 add_ctype_to_cc(CClassNode
* cc
, int ctype
, int not, ScanEnv
* env
)
3835 const OnigCodePoint
*ranges
;
3836 OnigCodePoint sb_out
;
3837 OnigEncoding enc
= env
->enc
;
3839 r
= ONIGENC_GET_CTYPE_CODE_RANGE(enc
, ctype
, &sb_out
, &ranges
);
3841 return add_ctype_to_cc_by_range(cc
, ctype
, not, env
->enc
, sb_out
, ranges
);
3843 else if (r
!= ONIG_NO_SUPPORT_CONFIG
) {
3849 case ONIGENC_CTYPE_ALPHA
:
3850 case ONIGENC_CTYPE_BLANK
:
3851 case ONIGENC_CTYPE_CNTRL
:
3852 case ONIGENC_CTYPE_DIGIT
:
3853 case ONIGENC_CTYPE_LOWER
:
3854 case ONIGENC_CTYPE_PUNCT
:
3855 case ONIGENC_CTYPE_SPACE
:
3856 case ONIGENC_CTYPE_UPPER
:
3857 case ONIGENC_CTYPE_XDIGIT
:
3858 case ONIGENC_CTYPE_ASCII
:
3859 case ONIGENC_CTYPE_ALNUM
:
3861 for (c
= 0; c
< SINGLE_BYTE_SIZE
; c
++) {
3862 if (! ONIGENC_IS_CODE_CTYPE(enc
, (OnigCodePoint
)c
, ctype
))
3863 BITSET_SET_BIT(cc
->bs
, c
);
3865 ADD_ALL_MULTI_BYTE_RANGE(enc
, cc
->mbuf
);
3868 for (c
= 0; c
< SINGLE_BYTE_SIZE
; c
++) {
3869 if (ONIGENC_IS_CODE_CTYPE(enc
, (OnigCodePoint
)c
, ctype
))
3870 BITSET_SET_BIT(cc
->bs
, c
);
3875 case ONIGENC_CTYPE_GRAPH
:
3876 case ONIGENC_CTYPE_PRINT
:
3878 for (c
= 0; c
< SINGLE_BYTE_SIZE
; c
++) {
3879 if (! ONIGENC_IS_CODE_CTYPE(enc
, (OnigCodePoint
)c
, ctype
))
3880 BITSET_SET_BIT(cc
->bs
, c
);
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
);
3888 ADD_ALL_MULTI_BYTE_RANGE(enc
, cc
->mbuf
);
3892 case ONIGENC_CTYPE_WORD
:
3894 for (c
= 0; c
< SINGLE_BYTE_SIZE
; c
++) {
3895 if (IS_CODE_SB_WORD(enc
, c
)) BITSET_SET_BIT(cc
->bs
, c
);
3897 ADD_ALL_MULTI_BYTE_RANGE(enc
, cc
->mbuf
);
3900 for (c
= 0; c
< SINGLE_BYTE_SIZE
; c
++) {
3901 if ((ONIGENC_CODE_TO_MBCLEN(enc
, c
) > 0) /* check invalid code point */
3902 && ! ONIGENC_IS_CODE_WORD(enc
, c
))
3903 BITSET_SET_BIT(cc
->bs
, c
);
3909 return ONIGERR_PARSER_BUG
;
3917 parse_posix_bracket(CClassNode
* cc
, UChar
** src
, UChar
* end
, ScanEnv
* env
)
3919 #define POSIX_BRACKET_CHECK_LIMIT_LENGTH 20
3920 #define POSIX_BRACKET_NAME_MIN_LEN 4
3922 static PosixBracketEntryType PBS
[] = {
3923 { (UChar
* )"alnum", ONIGENC_CTYPE_ALNUM
, 5 },
3924 { (UChar
* )"alpha", ONIGENC_CTYPE_ALPHA
, 5 },
3925 { (UChar
* )"blank", ONIGENC_CTYPE_BLANK
, 5 },
3926 { (UChar
* )"cntrl", ONIGENC_CTYPE_CNTRL
, 5 },
3927 { (UChar
* )"digit", ONIGENC_CTYPE_DIGIT
, 5 },
3928 { (UChar
* )"graph", ONIGENC_CTYPE_GRAPH
, 5 },
3929 { (UChar
* )"lower", ONIGENC_CTYPE_LOWER
, 5 },
3930 { (UChar
* )"print", ONIGENC_CTYPE_PRINT
, 5 },
3931 { (UChar
* )"punct", ONIGENC_CTYPE_PUNCT
, 5 },
3932 { (UChar
* )"space", ONIGENC_CTYPE_SPACE
, 5 },
3933 { (UChar
* )"upper", ONIGENC_CTYPE_UPPER
, 5 },
3934 { (UChar
* )"xdigit", ONIGENC_CTYPE_XDIGIT
, 6 },
3935 { (UChar
* )"ascii", ONIGENC_CTYPE_ASCII
, 5 },
3936 { (UChar
* )"word", ONIGENC_CTYPE_WORD
, 4 },
3937 { (UChar
* )NULL
, -1, 0 }
3940 PosixBracketEntryType
*pb
;
3943 OnigEncoding enc
= env
->enc
;
3946 if (PPEEK_IS('^')) {
3953 if (onigenc_strlen(enc
, p
, end
) < POSIX_BRACKET_NAME_MIN_LEN
+ 3)
3954 goto not_posix_bracket
;
3956 for (pb
= PBS
; IS_NOT_NULL(pb
->name
); pb
++) {
3957 if (onigenc_with_ascii_strncmp(enc
, p
, end
, pb
->name
, pb
->len
) == 0) {
3958 p
= (UChar
* )onigenc_step(enc
, p
, end
, pb
->len
);
3959 if (onigenc_with_ascii_strncmp(enc
, p
, end
, (UChar
* )":]", 2) != 0)
3960 return ONIGERR_INVALID_POSIX_BRACKET_TYPE
;
3962 r
= add_ctype_to_cc(cc
, pb
->ctype
, not, env
);
3963 if (r
!= 0) return r
;
3974 while (!PEND
&& ((c
= PPEEK
) != ':') && c
!= ']') {
3976 if (++i
> POSIX_BRACKET_CHECK_LIMIT_LENGTH
) break;
3978 if (c
== ':' && ! PEND
) {
3983 return ONIGERR_INVALID_POSIX_BRACKET_TYPE
;
3987 return 1; /* 1: is not POSIX bracket, but no error. */
3991 fetch_char_property_to_ctype(UChar
** src
, UChar
* end
, ScanEnv
* env
)
3995 OnigEncoding enc
= env
->enc
;
3996 UChar
*prev
, *start
, *p
= *src
;
4005 r
= ONIGENC_PROPERTY_NAME_TO_CTYPE(enc
, start
, prev
);
4011 else if (c
== '(' || c
== ')' || c
== '{' || c
== '|') {
4012 r
= ONIGERR_INVALID_CHAR_PROPERTY_NAME
;
4017 onig_scan_env_set_error_string(env
, r
, *src
, prev
);
4022 parse_char_property(Node
** np
, OnigToken
* tok
, UChar
** src
, UChar
* end
,
4028 ctype
= fetch_char_property_to_ctype(src
, end
, env
);
4029 if (ctype
< 0) return ctype
;
4031 *np
= node_new_cclass();
4032 CHECK_NULL_RETURN_MEMERR(*np
);
4034 r
= add_ctype_to_cc(cc
, ctype
, 0, env
);
4035 if (r
!= 0) return r
;
4036 if (tok
->u
.prop
.not != 0) NCCLASS_SET_NOT(cc
);
4056 next_state_class(CClassNode
* cc
, OnigCodePoint
* vs
, enum CCVALTYPE
* type
,
4057 enum CCSTATE
* state
, ScanEnv
* env
)
4061 if (*state
== CCS_RANGE
)
4062 return ONIGERR_CHAR_CLASS_VALUE_AT_END_OF_RANGE
;
4064 if (*state
== CCS_VALUE
&& *type
!= CCV_CLASS
) {
4065 if (*type
== CCV_SB
)
4066 BITSET_SET_BIT(cc
->bs
, (int )(*vs
));
4067 else if (*type
== CCV_CODE_POINT
) {
4068 r
= add_code_range(&(cc
->mbuf
), env
, *vs
, *vs
);
4069 if (r
< 0) return r
;
4079 next_state_val(CClassNode
* cc
, OnigCodePoint
*vs
, OnigCodePoint v
,
4080 int* vs_israw
, int v_israw
,
4081 enum CCVALTYPE intype
, enum CCVALTYPE
* type
,
4082 enum CCSTATE
* state
, ScanEnv
* env
)
4088 if (*type
== CCV_SB
)
4089 BITSET_SET_BIT(cc
->bs
, (int )(*vs
));
4090 else if (*type
== CCV_CODE_POINT
) {
4091 r
= add_code_range(&(cc
->mbuf
), env
, *vs
, *vs
);
4092 if (r
< 0) return r
;
4097 if (intype
== *type
) {
4098 if (intype
== CCV_SB
) {
4099 if (*vs
> 0xff || v
> 0xff)
4100 return ONIGERR_INVALID_CODE_POINT_VALUE
;
4103 if (IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_ALLOW_EMPTY_RANGE_IN_CC
))
4106 return ONIGERR_EMPTY_RANGE_IN_CHAR_CLASS
;
4108 bitset_set_range(cc
->bs
, (int )*vs
, (int )v
);
4111 r
= add_code_range(&(cc
->mbuf
), env
, *vs
, v
);
4112 if (r
< 0) return r
;
4117 if (intype
== CCV_CODE_POINT
&& *type
== CCV_SB
) {
4120 if (IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_ALLOW_EMPTY_RANGE_IN_CC
))
4123 return ONIGERR_EMPTY_RANGE_IN_CHAR_CLASS
;
4125 bitset_set_range(cc
->bs
, (int )*vs
, (int )(v
< 0xff ? v
: 0xff));
4126 r
= add_code_range(&(cc
->mbuf
), env
, (OnigCodePoint
)*vs
, v
);
4127 if (r
< 0) return r
;
4131 return ONIGERR_MISMATCH_CODE_LENGTH_IN_CLASS_RANGE
;
4135 *state
= CCS_COMPLETE
;
4147 *vs_israw
= v_israw
;
4154 code_exist_check(OnigCodePoint c
, UChar
* from
, UChar
* end
, int ignore_escaped
,
4159 OnigEncoding enc
= env
->enc
;
4164 if (ignore_escaped
&& in_esc
) {
4169 if (code
== c
) return 1;
4170 if (code
== MC_ESC(env
->syntax
)) in_esc
= 1;
4177 parse_char_class(Node
** np
, OnigToken
* tok
, UChar
** src
, UChar
* end
,
4180 int r
, neg
, len
, fetched
, and_start
;
4181 OnigCodePoint v
, vs
;
4184 CClassNode
*cc
, *prev_cc
;
4188 enum CCVALTYPE val_type
, in_type
;
4189 int val_israw
, in_israw
;
4191 prev_cc
= (CClassNode
* )NULL
;
4193 r
= fetch_token_in_cc(tok
, src
, end
, env
);
4194 if (r
== TK_CHAR
&& tok
->u
.c
== '^' && tok
->escaped
== 0) {
4196 r
= fetch_token_in_cc(tok
, src
, end
, env
);
4202 if (r
< 0) return r
;
4203 if (r
== TK_CC_CLOSE
) {
4204 if (! code_exist_check((OnigCodePoint
)']',
4205 *src
, env
->pattern_end
, 1, env
))
4206 return ONIGERR_EMPTY_CHAR_CLASS
;
4208 CC_ESC_WARN(env
, (UChar
* )"]");
4209 r
= tok
->type
= TK_CHAR
; /* allow []...] */
4212 *np
= node
= node_new_cclass();
4213 CHECK_NULL_RETURN_MEMERR(node
);
4219 while (r
!= TK_CC_CLOSE
) {
4223 len
= ONIGENC_CODE_TO_MBCLEN(env
->enc
, tok
->u
.c
);
4225 in_type
= CCV_CODE_POINT
;
4235 v
= (OnigCodePoint
)tok
->u
.c
;
4241 /* tok->base != 0 : octal or hexadec. */
4242 if (! ONIGENC_IS_SINGLEBYTE(env
->enc
) && tok
->base
!= 0) {
4243 UChar buf
[ONIGENC_CODE_TO_MBC_MAXLEN
];
4244 UChar
* bufe
= buf
+ ONIGENC_CODE_TO_MBC_MAXLEN
;
4246 int i
, base
= tok
->base
;
4248 buf
[0] = (UChar
)tok
->u
.c
;
4249 for (i
= 1; i
< ONIGENC_MBC_MAXLEN(env
->enc
); i
++) {
4250 r
= fetch_token_in_cc(tok
, &p
, end
, env
);
4251 if (r
< 0) goto err
;
4252 if (r
!= TK_RAW_BYTE
|| tok
->base
!= base
) {
4256 buf
[i
] = (UChar
)tok
->u
.c
;
4259 if (i
< ONIGENC_MBC_MINLEN(env
->enc
)) {
4260 r
= ONIGERR_TOO_SHORT_MULTI_BYTE_STRING
;
4264 len
= enclen(env
->enc
, buf
);
4266 r
= ONIGERR_TOO_SHORT_MULTI_BYTE_STRING
;
4269 else if (i
> len
) { /* fetch back */
4271 for (i
= 1; i
< len
; i
++) {
4272 r
= fetch_token_in_cc(tok
, &p
, end
, env
);
4278 v
= (OnigCodePoint
)buf
[0];
4282 v
= ONIGENC_MBC_TO_CODE(env
->enc
, buf
, bufe
);
4283 in_type
= CCV_CODE_POINT
;
4287 v
= (OnigCodePoint
)tok
->u
.c
;
4299 len
= ONIGENC_CODE_TO_MBCLEN(env
->enc
, v
);
4304 in_type
= (len
== 1 ? CCV_SB
: CCV_CODE_POINT
);
4306 r
= next_state_val(cc
, &vs
, v
, &val_israw
, in_israw
, in_type
, &val_type
,
4308 if (r
!= 0) goto err
;
4311 case TK_POSIX_BRACKET_OPEN
:
4312 r
= parse_posix_bracket(cc
, &p
, end
, env
);
4313 if (r
< 0) goto err
;
4314 if (r
== 1) { /* is not POSIX bracket */
4315 CC_ESC_WARN(env
, (UChar
* )"[");
4317 v
= (OnigCodePoint
)tok
->u
.c
;
4325 r
= add_ctype_to_cc(cc
, tok
->u
.prop
.ctype
, tok
->u
.prop
.not, env
);
4326 if (r
!= 0) return r
;
4329 r
= next_state_class(cc
, &vs
, &val_type
, &state
, env
);
4330 if (r
!= 0) goto err
;
4333 case TK_CHAR_PROPERTY
:
4337 ctype
= fetch_char_property_to_ctype(&p
, end
, env
);
4338 if (ctype
< 0) return ctype
;
4339 r
= add_ctype_to_cc(cc
, ctype
, tok
->u
.prop
.not, env
);
4340 if (r
!= 0) return r
;
4346 if (state
== CCS_VALUE
) {
4347 r
= fetch_token_in_cc(tok
, &p
, end
, env
);
4348 if (r
< 0) goto err
;
4350 if (r
== TK_CC_CLOSE
) { /* allow [x-] */
4352 v
= (OnigCodePoint
)'-';
4356 else if (r
== TK_CC_AND
) {
4357 CC_ESC_WARN(env
, (UChar
* )"-");
4362 else if (state
== CCS_START
) {
4363 /* [-xa] is allowed */
4364 v
= (OnigCodePoint
)tok
->u
.c
;
4367 r
= fetch_token_in_cc(tok
, &p
, end
, env
);
4368 if (r
< 0) goto err
;
4370 /* [--x] or [a&&-x] is warned. */
4371 if (r
== TK_CC_RANGE
|| and_start
!= 0)
4372 CC_ESC_WARN(env
, (UChar
* )"-");
4376 else if (state
== CCS_RANGE
) {
4377 CC_ESC_WARN(env
, (UChar
* )"-");
4378 goto sb_char
; /* [!--x] is allowed */
4380 else { /* CCS_COMPLETE */
4381 r
= fetch_token_in_cc(tok
, &p
, end
, env
);
4382 if (r
< 0) goto err
;
4384 if (r
== TK_CC_CLOSE
) goto range_end_val
; /* allow [a-b-] */
4385 else if (r
== TK_CC_AND
) {
4386 CC_ESC_WARN(env
, (UChar
* )"-");
4390 if (IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_ALLOW_DOUBLE_RANGE_OP_IN_CC
)) {
4391 CC_ESC_WARN(env
, (UChar
* )"-");
4392 goto sb_char
; /* [0-9-a] is allowed as [0-9\-a] */
4394 r
= ONIGERR_UNMATCHED_RANGE_SPECIFIER_IN_CHAR_CLASS
;
4399 case TK_CC_CC_OPEN
: /* [ */
4404 r
= parse_char_class(&anode
, tok
, &p
, end
, env
);
4405 if (r
!= 0) goto cc_open_err
;
4406 acc
= NCCLASS(anode
);
4407 r
= or_cclass(cc
, acc
, env
->enc
);
4409 onig_node_free(anode
);
4411 if (r
!= 0) goto err
;
4415 case TK_CC_AND
: /* && */
4417 if (state
== CCS_VALUE
) {
4418 r
= next_state_val(cc
, &vs
, 0, &val_israw
, 0, val_type
,
4419 &val_type
, &state
, env
);
4420 if (r
!= 0) goto err
;
4422 /* initialize local variables */
4426 if (IS_NOT_NULL(prev_cc
)) {
4427 r
= and_cclass(prev_cc
, cc
, env
->enc
);
4428 if (r
!= 0) goto err
;
4429 bbuf_free(cc
->mbuf
);
4435 initialize_cclass(cc
);
4440 r
= ONIGERR_PREMATURE_END_OF_CHAR_CLASS
;
4444 r
= ONIGERR_PARSER_BUG
;
4452 r
= fetch_token_in_cc(tok
, &p
, end
, env
);
4453 if (r
< 0) goto err
;
4457 if (state
== CCS_VALUE
) {
4458 r
= next_state_val(cc
, &vs
, 0, &val_israw
, 0, val_type
,
4459 &val_type
, &state
, env
);
4460 if (r
!= 0) goto err
;
4463 if (IS_NOT_NULL(prev_cc
)) {
4464 r
= and_cclass(prev_cc
, cc
, env
->enc
);
4465 if (r
!= 0) goto err
;
4466 bbuf_free(cc
->mbuf
);
4471 NCCLASS_SET_NOT(cc
);
4473 NCCLASS_CLEAR_NOT(cc
);
4474 if (IS_NCCLASS_NOT(cc
) &&
4475 IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_NOT_NEWLINE_IN_NEGATIVE_CC
)) {
4478 is_empty
= (IS_NULL(cc
->mbuf
) ? 1 : 0);
4480 BITSET_IS_EMPTY(cc
->bs
, is_empty
);
4482 if (is_empty
== 0) {
4483 #define NEWLINE_CODE 0x0a
4485 if (ONIGENC_IS_CODE_NEWLINE(env
->enc
, NEWLINE_CODE
)) {
4486 if (ONIGENC_CODE_TO_MBCLEN(env
->enc
, NEWLINE_CODE
) == 1)
4487 BITSET_SET_BIT(cc
->bs
, NEWLINE_CODE
);
4489 add_code_range(&(cc
->mbuf
), env
, NEWLINE_CODE
, NEWLINE_CODE
);
4497 if (cc
!= NCCLASS(*np
))
4498 bbuf_free(cc
->mbuf
);
4499 onig_node_free(*np
);
4503 static int parse_subexp(Node
** top
, OnigToken
* tok
, int term
,
4504 UChar
** src
, UChar
* end
, ScanEnv
* env
);
4507 parse_enclose(Node
** np
, OnigToken
* tok
, int term
, UChar
** src
, UChar
* end
,
4512 OnigOptionType option
;
4514 OnigEncoding enc
= env
->enc
;
4516 #ifdef USE_NAMED_GROUP
4524 if (PEND
) return ONIGERR_END_PATTERN_WITH_UNMATCHED_PARENTHESIS
;
4526 option
= env
->option
;
4527 if (PPEEK_IS('?') &&
4528 IS_SYNTAX_OP2(env
->syntax
, ONIG_SYN_OP2_QMARK_GROUP_EFFECT
)) {
4530 if (PEND
) return ONIGERR_END_PATTERN_IN_GROUP
;
4534 case ':': /* (?:...) grouping only */
4536 r
= fetch_token(tok
, &p
, end
, env
);
4537 if (r
< 0) return r
;
4538 r
= parse_subexp(np
, tok
, term
, &p
, end
, env
);
4539 if (r
< 0) return r
;
4541 return 1; /* group */
4545 *np
= onig_node_new_anchor(ANCHOR_PREC_READ
);
4547 case '!': /* preceding read */
4548 *np
= onig_node_new_anchor(ANCHOR_PREC_READ_NOT
);
4550 case '>': /* (?>...) stop backtrack */
4551 *np
= node_new_enclose(ENCLOSE_STOP_BACKTRACK
);
4554 #ifdef USE_NAMED_GROUP
4556 if (IS_SYNTAX_OP2(env
->syntax
, ONIG_SYN_OP2_QMARK_LT_NAMED_GROUP
)) {
4560 return ONIGERR_UNDEFINED_GROUP_OPTION
;
4564 case '<': /* look behind (?<=...), (?<!...) */
4567 *np
= onig_node_new_anchor(ANCHOR_LOOK_BEHIND
);
4569 *np
= onig_node_new_anchor(ANCHOR_LOOK_BEHIND_NOT
);
4570 #ifdef USE_NAMED_GROUP
4572 if (IS_SYNTAX_OP2(env
->syntax
, ONIG_SYN_OP2_QMARK_LT_NAMED_GROUP
)) {
4584 r
= fetch_name((OnigCodePoint
)c
, &p
, end
, &name_end
, env
, &num
, 0);
4585 if (r
< 0) return r
;
4587 num
= scan_env_add_mem_entry(env
);
4588 if (num
< 0) return num
;
4589 if (list_capture
!= 0 && num
>= (int )BIT_STATUS_BITS_NUM
)
4590 return ONIGERR_GROUP_NUMBER_OVER_FOR_CAPTURE_HISTORY
;
4592 r
= name_add(env
->reg
, name
, name_end
, num
, env
);
4593 if (r
!= 0) return r
;
4594 *np
= node_new_enclose_memory(env
->option
, 1);
4595 CHECK_NULL_RETURN_MEMERR(*np
);
4596 NENCLOSE(*np
)->regnum
= num
;
4597 if (list_capture
!= 0)
4598 BIT_STATUS_ON_AT_SIMPLE(env
->capture_history
, num
);
4602 return ONIGERR_UNDEFINED_GROUP_OPTION
;
4607 return ONIGERR_UNDEFINED_GROUP_OPTION
;
4613 if (IS_SYNTAX_OP2(env
->syntax
, ONIG_SYN_OP2_ATMARK_CAPTURE_HISTORY
)) {
4614 #ifdef USE_NAMED_GROUP
4615 if (IS_SYNTAX_OP2(env
->syntax
, ONIG_SYN_OP2_QMARK_LT_NAMED_GROUP
)) {
4617 if (c
== '<' || c
== '\'') {
4619 goto named_group2
; /* (?@<name>...) */
4624 *np
= node_new_enclose_memory(env
->option
, 0);
4625 CHECK_NULL_RETURN_MEMERR(*np
);
4626 num
= scan_env_add_mem_entry(env
);
4628 onig_node_free(*np
);
4631 else if (num
>= (int )BIT_STATUS_BITS_NUM
) {
4632 onig_node_free(*np
);
4633 return ONIGERR_GROUP_NUMBER_OVER_FOR_CAPTURE_HISTORY
;
4635 NENCLOSE(*np
)->regnum
= num
;
4636 BIT_STATUS_ON_AT_SIMPLE(env
->capture_history
, num
);
4639 return ONIGERR_UNDEFINED_GROUP_OPTION
;
4643 #ifdef USE_POSIXLINE_OPTION
4646 case '-': case 'i': case 'm': case 's': case 'x':
4656 case '-': neg
= 1; break;
4657 case 'x': ONOFF(option
, ONIG_OPTION_EXTEND
, neg
); break;
4658 case 'i': ONOFF(option
, ONIG_OPTION_IGNORECASE
, neg
); break;
4660 if (IS_SYNTAX_OP2(env
->syntax
, ONIG_SYN_OP2_OPTION_PERL
)) {
4661 ONOFF(option
, ONIG_OPTION_MULTILINE
, neg
);
4664 return ONIGERR_UNDEFINED_GROUP_OPTION
;
4668 if (IS_SYNTAX_OP2(env
->syntax
, ONIG_SYN_OP2_OPTION_PERL
)) {
4669 ONOFF(option
, ONIG_OPTION_SINGLELINE
, (neg
== 0 ? 1 : 0));
4671 else if (IS_SYNTAX_OP2(env
->syntax
, ONIG_SYN_OP2_OPTION_RUBY
)) {
4672 ONOFF(option
, ONIG_OPTION_MULTILINE
, neg
);
4675 return ONIGERR_UNDEFINED_GROUP_OPTION
;
4677 #ifdef USE_POSIXLINE_OPTION
4679 ONOFF(option
, ONIG_OPTION_MULTILINE
|ONIG_OPTION_SINGLELINE
, neg
);
4683 return ONIGERR_UNDEFINED_GROUP_OPTION
;
4687 *np
= node_new_option(option
);
4688 CHECK_NULL_RETURN_MEMERR(*np
);
4690 return 2; /* option only */
4692 else if (c
== ':') {
4693 OnigOptionType prev
= env
->option
;
4695 env
->option
= option
;
4696 r
= fetch_token(tok
, &p
, end
, env
);
4697 if (r
< 0) return r
;
4698 r
= parse_subexp(&target
, tok
, term
, &p
, end
, env
);
4700 if (r
< 0) return r
;
4701 *np
= node_new_option(option
);
4702 CHECK_NULL_RETURN_MEMERR(*np
);
4703 NENCLOSE(*np
)->target
= target
;
4708 if (PEND
) return ONIGERR_END_PATTERN_IN_GROUP
;
4715 return ONIGERR_UNDEFINED_GROUP_OPTION
;
4719 if (ONIG_IS_OPTION_ON(env
->option
, ONIG_OPTION_DONT_CAPTURE_GROUP
))
4722 *np
= node_new_enclose_memory(env
->option
, 0);
4723 CHECK_NULL_RETURN_MEMERR(*np
);
4724 num
= scan_env_add_mem_entry(env
);
4725 if (num
< 0) return num
;
4726 NENCLOSE(*np
)->regnum
= num
;
4729 CHECK_NULL_RETURN_MEMERR(*np
);
4730 r
= fetch_token(tok
, &p
, end
, env
);
4731 if (r
< 0) return r
;
4732 r
= parse_subexp(&target
, tok
, term
, &p
, end
, env
);
4733 if (r
< 0) return r
;
4735 if (NTYPE(*np
) == NT_ANCHOR
)
4736 NANCHOR(*np
)->target
= target
;
4738 NENCLOSE(*np
)->target
= target
;
4739 if (NENCLOSE(*np
)->type
== ENCLOSE_MEMORY
) {
4740 /* Don't move this to previous of parse_subexp() */
4741 r
= scan_env_set_mem_node(env
, NENCLOSE(*np
)->regnum
, *np
);
4742 if (r
!= 0) return r
;
4750 static const char* PopularQStr
[] = {
4751 "?", "*", "+", "??", "*?", "+?"
4754 static const char* ReduceQStr
[] = {
4755 "", "", "*", "*?", "??", "+ and ??", "+? and ?"
4759 set_quantifier(Node
* qnode
, Node
* target
, int group
, ScanEnv
* env
)
4764 if (qn
->lower
== 1 && qn
->upper
== 1) {
4768 switch (NTYPE(target
)) {
4771 StrNode
* sn
= NSTR(target
);
4772 if (str_node_can_be_split(sn
, env
->enc
)) {
4773 Node
* n
= str_node_split_last_char(sn
, env
->enc
);
4774 if (IS_NOT_NULL(n
)) {
4783 { /* check redundant double repeat. */
4784 /* verbose warn (?:.?)? etc... but not warn (.?)? etc... */
4785 QtfrNode
* qnt
= NQTFR(target
);
4786 int nestq_num
= popular_quantifier_num(qn
);
4787 int targetq_num
= popular_quantifier_num(qnt
);
4789 #ifdef USE_WARNING_REDUNDANT_NESTED_REPEAT_OPERATOR
4790 if (!IS_QUANTIFIER_BY_NUMBER(qn
) && !IS_QUANTIFIER_BY_NUMBER(qnt
) &&
4791 IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_WARN_REDUNDANT_NESTED_REPEAT
)) {
4792 UChar buf
[WARN_BUFSIZE
];
4794 switch(ReduceTypeTable
[targetq_num
][nestq_num
]) {
4799 if (onig_verb_warn
!= onig_null_warn
) {
4800 onig_snprintf_with_pattern(buf
, WARN_BUFSIZE
, env
->enc
,
4801 env
->pattern
, env
->pattern_end
,
4802 (UChar
* )"redundant nested repeat operator");
4803 (*onig_verb_warn
)((char* )buf
);
4809 if (onig_verb_warn
!= onig_null_warn
) {
4810 onig_snprintf_with_pattern(buf
, WARN_BUFSIZE
, env
->enc
,
4811 env
->pattern
, env
->pattern_end
,
4812 (UChar
* )"nested repeat operator %s and %s was replaced with '%s'",
4813 PopularQStr
[targetq_num
], PopularQStr
[nestq_num
],
4814 ReduceQStr
[ReduceTypeTable
[targetq_num
][nestq_num
]]);
4815 (*onig_verb_warn
)((char* )buf
);
4824 if (targetq_num
>= 0) {
4825 if (nestq_num
>= 0) {
4826 onig_reduce_nested_quantifier(qnode
, target
);
4829 else if (targetq_num
== 1 || targetq_num
== 2) { /* * or + */
4830 /* (?:a*){n,m}, (?:a+){n,m} => (?:a*){n,n}, (?:a+){n,n} */
4831 if (! IS_REPEAT_INFINITE(qn
->upper
) && qn
->upper
> 1 && qn
->greedy
) {
4832 qn
->upper
= (qn
->lower
== 0 ? 1 : qn
->lower
);
4843 qn
->target
= target
;
4849 #ifdef USE_SHARED_CCLASS_TABLE
4851 #define THRESHOLD_RANGE_NUM_FOR_SHARE_CCLASS 8
4853 /* for ctype node hash table */
4861 static int type_cclass_cmp(type_cclass_key
* x
, type_cclass_key
* y
)
4863 if (x
->type
!= y
->type
) return 1;
4864 if (x
->enc
!= y
->enc
) return 1;
4865 if (x
->not != y
->not) return 1;
4869 static int type_cclass_hash(type_cclass_key
* key
)
4876 p
= (UChar
* )&(key
->enc
);
4877 for (i
= 0; i
< (int )sizeof(key
->enc
); i
++) {
4878 val
= val
* 997 + (int )*p
++;
4881 p
= (UChar
* )(&key
->type
);
4882 for (i
= 0; i
< (int )sizeof(key
->type
); i
++) {
4883 val
= val
* 997 + (int )*p
++;
4887 return val
+ (val
>> 5);
4890 static struct st_hash_type type_type_cclass_hash
= {
4895 static st_table
* OnigTypeCClassTable
;
4899 i_free_shared_class(type_cclass_key
* key
, Node
* node
, void* arg ARG_UNUSED
)
4901 if (IS_NOT_NULL(node
)) {
4902 CClassNode
* cc
= NCCLASS(node
);
4903 if (IS_NOT_NULL(cc
->mbuf
)) xfree(cc
->mbuf
);
4907 if (IS_NOT_NULL(key
)) xfree(key
);
4912 onig_free_shared_cclass_table(void)
4914 if (IS_NOT_NULL(OnigTypeCClassTable
)) {
4915 onig_st_foreach(OnigTypeCClassTable
, i_free_shared_class
, 0);
4916 onig_st_free_table(OnigTypeCClassTable
);
4917 OnigTypeCClassTable
= NULL
;
4923 #endif /* USE_SHARED_CCLASS_TABLE */
4926 #ifndef CASE_FOLD_IS_APPLIED_INSIDE_NEGATIVE_CCLASS
4928 clear_not_flag_cclass(CClassNode
* cc
, OnigEncoding enc
)
4933 if (IS_NCCLASS_NOT(cc
)) {
4934 bitset_invert(cc
->bs
);
4936 if (! ONIGENC_IS_SINGLEBYTE(enc
)) {
4937 r
= not_code_range_buf(enc
, cc
->mbuf
, &tbuf
);
4938 if (r
!= 0) return r
;
4940 bbuf_free(cc
->mbuf
);
4944 NCCLASS_CLEAR_NOT(cc
);
4949 #endif /* CASE_FOLD_IS_APPLIED_INSIDE_NEGATIVE_CCLASS */
4956 } IApplyCaseFoldArg
;
4959 i_apply_case_fold(OnigCodePoint from
, OnigCodePoint to
[],
4960 int to_len
, void* arg
)
4962 IApplyCaseFoldArg
* iarg
;
4967 iarg
= (IApplyCaseFoldArg
* )arg
;
4973 int is_in
= onig_is_code_in_cc(env
->enc
, from
, cc
);
4974 #ifdef CASE_FOLD_IS_APPLIED_INSIDE_NEGATIVE_CCLASS
4975 if ((is_in
!= 0 && !IS_NCCLASS_NOT(cc
)) ||
4976 (is_in
== 0 && IS_NCCLASS_NOT(cc
))) {
4977 if (ONIGENC_MBC_MINLEN(env
->enc
) > 1 || *to
>= SINGLE_BYTE_SIZE
) {
4978 add_code_range(&(cc
->mbuf
), env
, *to
, *to
);
4981 BITSET_SET_BIT(bs
, *to
);
4986 if (ONIGENC_MBC_MINLEN(env
->enc
) > 1 || *to
>= SINGLE_BYTE_SIZE
) {
4987 if (IS_NCCLASS_NOT(cc
)) clear_not_flag_cclass(cc
, env
->enc
);
4988 add_code_range(&(cc
->mbuf
), env
, *to
, *to
);
4991 if (IS_NCCLASS_NOT(cc
)) {
4992 BITSET_CLEAR_BIT(bs
, *to
);
4995 BITSET_SET_BIT(bs
, *to
);
4998 #endif /* CASE_FOLD_IS_APPLIED_INSIDE_NEGATIVE_CCLASS */
5002 UChar buf
[ONIGENC_CODE_TO_MBC_MAXLEN
];
5003 Node
*snode
= NULL_NODE
;
5005 if (onig_is_code_in_cc(env
->enc
, from
, cc
)
5006 #ifdef CASE_FOLD_IS_APPLIED_INSIDE_NEGATIVE_CCLASS
5007 && !IS_NCCLASS_NOT(cc
)
5010 for (i
= 0; i
< to_len
; i
++) {
5011 len
= ONIGENC_CODE_TO_MBC(env
->enc
, to
[i
], buf
);
5013 snode
= onig_node_new_str(buf
, buf
+ len
);
5014 CHECK_NULL_RETURN_MEMERR(snode
);
5016 /* char-class expanded multi-char only
5017 compare with string folded at match time. */
5018 NSTRING_SET_AMBIG(snode
);
5021 r
= onig_node_str_cat(snode
, buf
, buf
+ len
);
5023 onig_node_free(snode
);
5029 *(iarg
->ptail
) = onig_node_new_alt(snode
, NULL_NODE
);
5030 CHECK_NULL_RETURN_MEMERR(*(iarg
->ptail
));
5031 iarg
->ptail
= &(NCDR((*(iarg
->ptail
))));
5039 parse_exp(Node
** np
, OnigToken
* tok
, int term
,
5040 UChar
** src
, UChar
* end
, ScanEnv
* env
)
5042 int r
, len
, group
= 0;
5047 if (tok
->type
== (enum TokenSyms
)term
)
5050 switch (tok
->type
) {
5054 *np
= node_new_empty();
5058 case TK_SUBEXP_OPEN
:
5059 r
= parse_enclose(np
, tok
, TK_SUBEXP_CLOSE
, src
, end
, env
);
5060 if (r
< 0) return r
;
5061 if (r
== 1) group
= 1;
5062 else if (r
== 2) { /* option only */
5064 OnigOptionType prev
= env
->option
;
5066 env
->option
= NENCLOSE(*np
)->option
;
5067 r
= fetch_token(tok
, src
, end
, env
);
5068 if (r
< 0) return r
;
5069 r
= parse_subexp(&target
, tok
, term
, src
, end
, env
);
5071 if (r
< 0) return r
;
5072 NENCLOSE(*np
)->target
= target
;
5077 case TK_SUBEXP_CLOSE
:
5078 if (! IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_ALLOW_UNMATCHED_CLOSE_SUBEXP
))
5079 return ONIGERR_UNMATCHED_CLOSE_PARENTHESIS
;
5081 if (tok
->escaped
) goto tk_raw_byte
;
5088 *np
= node_new_str(tok
->backp
, *src
);
5089 CHECK_NULL_RETURN_MEMERR(*np
);
5092 r
= fetch_token(tok
, src
, end
, env
);
5093 if (r
< 0) return r
;
5094 if (r
!= TK_STRING
) break;
5096 r
= onig_node_str_cat(*np
, tok
->backp
, *src
);
5097 if (r
< 0) return r
;
5109 *np
= node_new_str_raw_char((UChar
)tok
->u
.c
);
5110 CHECK_NULL_RETURN_MEMERR(*np
);
5113 if (len
>= ONIGENC_MBC_MINLEN(env
->enc
)) {
5114 if (len
== enclen(env
->enc
, NSTR(*np
)->s
)) {
5115 r
= fetch_token(tok
, src
, end
, env
);
5116 NSTRING_CLEAR_RAW(*np
);
5121 r
= fetch_token(tok
, src
, end
, env
);
5122 if (r
< 0) return r
;
5123 if (r
!= TK_RAW_BYTE
) {
5124 /* Don't use this, it is wrong for little endian encodings. */
5125 #ifdef USE_PAD_TO_SHORT_BYTE_CHAR
5127 if (len
< ONIGENC_MBC_MINLEN(env
->enc
)) {
5128 rem
= ONIGENC_MBC_MINLEN(env
->enc
) - len
;
5129 (void )node_str_head_pad(NSTR(*np
), rem
, (UChar
)0);
5130 if (len
+ rem
== enclen(env
->enc
, NSTR(*np
)->s
)) {
5131 NSTRING_CLEAR_RAW(*np
);
5136 return ONIGERR_TOO_SHORT_MULTI_BYTE_STRING
;
5139 r
= node_str_cat_char(*np
, (UChar
)tok
->u
.c
);
5140 if (r
< 0) return r
;
5149 UChar buf
[ONIGENC_CODE_TO_MBC_MAXLEN
];
5150 int num
= ONIGENC_CODE_TO_MBC(env
->enc
, tok
->u
.code
, buf
);
5151 if (num
< 0) return num
;
5152 #ifdef NUMBERED_CHAR_IS_NOT_CASE_AMBIG
5153 *np
= node_new_str_raw(buf
, buf
+ num
);
5155 *np
= node_new_str(buf
, buf
+ num
);
5157 CHECK_NULL_RETURN_MEMERR(*np
);
5163 OnigCodePoint end_op
[2];
5164 UChar
*qstart
, *qend
, *nextp
;
5166 end_op
[0] = (OnigCodePoint
)MC_ESC(env
->syntax
);
5167 end_op
[1] = (OnigCodePoint
)'E';
5169 qend
= find_str_position(end_op
, 2, qstart
, end
, &nextp
, env
->enc
);
5170 if (IS_NULL(qend
)) {
5173 *np
= node_new_str(qstart
, qend
);
5174 CHECK_NULL_RETURN_MEMERR(*np
);
5181 switch (tok
->u
.prop
.ctype
) {
5182 case ONIGENC_CTYPE_WORD
:
5183 *np
= node_new_ctype(tok
->u
.prop
.ctype
, tok
->u
.prop
.not);
5184 CHECK_NULL_RETURN_MEMERR(*np
);
5187 case ONIGENC_CTYPE_SPACE
:
5188 case ONIGENC_CTYPE_DIGIT
:
5189 case ONIGENC_CTYPE_XDIGIT
:
5193 #ifdef USE_SHARED_CCLASS_TABLE
5194 const OnigCodePoint
*mbr
;
5195 OnigCodePoint sb_out
;
5197 r
= ONIGENC_GET_CTYPE_CODE_RANGE(env
->enc
, tok
->u
.prop
.ctype
,
5200 ONIGENC_CODE_RANGE_NUM(mbr
)
5201 >= THRESHOLD_RANGE_NUM_FOR_SHARE_CCLASS
) {
5202 type_cclass_key key
;
5203 type_cclass_key
* new_key
;
5206 key
.not = tok
->u
.prop
.not;
5207 key
.type
= tok
->u
.prop
.ctype
;
5209 THREAD_ATOMIC_START
;
5211 if (IS_NULL(OnigTypeCClassTable
)) {
5213 = onig_st_init_table_with_size(&type_type_cclass_hash
, 10);
5214 if (IS_NULL(OnigTypeCClassTable
)) {
5216 return ONIGERR_MEMORY
;
5220 if (onig_st_lookup(OnigTypeCClassTable
, (st_data_t
)&key
,
5227 *np
= node_new_cclass_by_codepoint_range(tok
->u
.prop
.not,
5231 return ONIGERR_MEMORY
;
5235 NCCLASS_SET_SHARE(cc
);
5236 new_key
= (type_cclass_key
* )xmalloc(sizeof(type_cclass_key
));
5237 xmemcpy(new_key
, &key
, sizeof(type_cclass_key
));
5238 onig_st_add_direct(OnigTypeCClassTable
, (st_data_t
)new_key
,
5245 *np
= node_new_cclass();
5246 CHECK_NULL_RETURN_MEMERR(*np
);
5248 add_ctype_to_cc(cc
, tok
->u
.prop
.ctype
, 0, env
);
5249 if (tok
->u
.prop
.not != 0) NCCLASS_SET_NOT(cc
);
5250 #ifdef USE_SHARED_CCLASS_TABLE
5257 return ONIGERR_PARSER_BUG
;
5263 case TK_CHAR_PROPERTY
:
5264 r
= parse_char_property(np
, tok
, src
, end
, env
);
5265 if (r
!= 0) return r
;
5272 r
= parse_char_class(np
, tok
, src
, end
, env
);
5273 if (r
!= 0) return r
;
5276 if (IS_IGNORECASE(env
->option
)) {
5277 IApplyCaseFoldArg iarg
;
5281 iarg
.alt_root
= NULL_NODE
;
5282 iarg
.ptail
= &(iarg
.alt_root
);
5284 r
= ONIGENC_APPLY_ALL_CASE_FOLD(env
->enc
, env
->case_fold_flag
,
5285 i_apply_case_fold
, &iarg
);
5287 onig_node_free(iarg
.alt_root
);
5290 if (IS_NOT_NULL(iarg
.alt_root
)) {
5291 Node
* work
= onig_node_new_alt(*np
, iarg
.alt_root
);
5292 if (IS_NULL(work
)) {
5293 onig_node_free(iarg
.alt_root
);
5294 return ONIGERR_MEMORY
;
5303 *np
= node_new_anychar();
5304 CHECK_NULL_RETURN_MEMERR(*np
);
5307 case TK_ANYCHAR_ANYTIME
:
5308 *np
= node_new_anychar();
5309 CHECK_NULL_RETURN_MEMERR(*np
);
5310 qn
= node_new_quantifier(0, REPEAT_INFINITE
, 0);
5311 CHECK_NULL_RETURN_MEMERR(qn
);
5312 NQTFR(qn
)->target
= *np
;
5317 len
= tok
->u
.backref
.num
;
5318 *np
= node_new_backref(len
,
5319 (len
> 1 ? tok
->u
.backref
.refs
: &(tok
->u
.backref
.ref1
)),
5320 tok
->u
.backref
.by_name
,
5321 #ifdef USE_BACKREF_WITH_LEVEL
5322 tok
->u
.backref
.exist_level
,
5323 tok
->u
.backref
.level
,
5326 CHECK_NULL_RETURN_MEMERR(*np
);
5329 #ifdef USE_SUBEXP_CALL
5332 int gnum
= tok
->u
.call
.gnum
;
5335 gnum
= BACKREF_REL_TO_ABS(gnum
, env
);
5337 return ONIGERR_INVALID_BACKREF
;
5339 *np
= node_new_call(tok
->u
.call
.name
, tok
->u
.call
.name_end
, gnum
);
5340 CHECK_NULL_RETURN_MEMERR(*np
);
5347 *np
= onig_node_new_anchor(tok
->u
.anchor
);
5352 if (IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_CONTEXT_INDEP_REPEAT_OPS
)) {
5353 if (IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_CONTEXT_INVALID_REPEAT_OPS
))
5354 return ONIGERR_TARGET_OF_REPEAT_OPERATOR_NOT_SPECIFIED
;
5356 *np
= node_new_empty();
5364 return ONIGERR_PARSER_BUG
;
5372 r
= fetch_token(tok
, src
, end
, env
);
5373 if (r
< 0) return r
;
5376 if (r
== TK_OP_REPEAT
|| r
== TK_INTERVAL
) {
5377 if (is_invalid_quantifier_target(*targetp
))
5378 return ONIGERR_TARGET_OF_REPEAT_OPERATOR_INVALID
;
5380 qn
= node_new_quantifier(tok
->u
.repeat
.lower
, tok
->u
.repeat
.upper
,
5381 (r
== TK_INTERVAL
? 1 : 0));
5382 CHECK_NULL_RETURN_MEMERR(qn
);
5383 NQTFR(qn
)->greedy
= tok
->u
.repeat
.greedy
;
5384 r
= set_quantifier(qn
, *targetp
, group
, env
);
5390 if (tok
->u
.repeat
.possessive
!= 0) {
5392 en
= node_new_enclose(ENCLOSE_STOP_BACKTRACK
);
5395 return ONIGERR_MEMORY
;
5397 NENCLOSE(en
)->target
= qn
;
5407 else if (r
== 2) { /* split case: /abc+/ */
5410 *targetp
= node_new_list(*targetp
, NULL
);
5411 if (IS_NULL(*targetp
)) {
5413 return ONIGERR_MEMORY
;
5415 tmp
= NCDR(*targetp
) = node_new_list(qn
, NULL
);
5418 return ONIGERR_MEMORY
;
5420 targetp
= &(NCAR(tmp
));
5430 parse_branch(Node
** top
, OnigToken
* tok
, int term
,
5431 UChar
** src
, UChar
* end
, ScanEnv
* env
)
5434 Node
*node
, **headp
;
5437 r
= parse_exp(&node
, tok
, term
, src
, end
, env
);
5438 if (r
< 0) return r
;
5440 if (r
== TK_EOT
|| r
== term
|| r
== TK_ALT
) {
5444 *top
= node_new_list(node
, NULL
);
5445 headp
= &(NCDR(*top
));
5446 while (r
!= TK_EOT
&& r
!= term
&& r
!= TK_ALT
) {
5447 r
= parse_exp(&node
, tok
, term
, src
, end
, env
);
5448 if (r
< 0) return r
;
5450 if (NTYPE(node
) == NT_LIST
) {
5452 while (IS_NOT_NULL(NCDR(node
))) node
= NCDR(node
);
5453 headp
= &(NCDR(node
));
5456 *headp
= node_new_list(node
, NULL
);
5457 headp
= &(NCDR(*headp
));
5465 /* term_tok: TK_EOT or TK_SUBEXP_CLOSE */
5467 parse_subexp(Node
** top
, OnigToken
* tok
, int term
,
5468 UChar
** src
, UChar
* end
, ScanEnv
* env
)
5471 Node
*node
, **headp
;
5474 r
= parse_branch(&node
, tok
, term
, src
, end
, env
);
5476 onig_node_free(node
);
5483 else if (r
== TK_ALT
) {
5484 *top
= onig_node_new_alt(node
, NULL
);
5485 headp
= &(NCDR(*top
));
5486 while (r
== TK_ALT
) {
5487 r
= fetch_token(tok
, src
, end
, env
);
5488 if (r
< 0) return r
;
5489 r
= parse_branch(&node
, tok
, term
, src
, end
, env
);
5490 if (r
< 0) return r
;
5492 *headp
= onig_node_new_alt(node
, NULL
);
5493 headp
= &(NCDR(*headp
));
5496 if (tok
->type
!= (enum TokenSyms
)term
)
5501 if (term
== TK_SUBEXP_CLOSE
)
5502 return ONIGERR_END_PATTERN_WITH_UNMATCHED_PARENTHESIS
;
5504 return ONIGERR_PARSER_BUG
;
5511 parse_regexp(Node
** top
, UChar
** src
, UChar
* end
, ScanEnv
* env
)
5516 r
= fetch_token(&tok
, src
, end
, env
);
5517 if (r
< 0) return r
;
5518 r
= parse_subexp(top
, &tok
, TK_EOT
, src
, end
, env
);
5519 if (r
< 0) return r
;
5524 onig_parse_make_tree(Node
** root
, const UChar
* pattern
, const UChar
* end
,
5525 regex_t
* reg
, ScanEnv
* env
)
5530 #ifdef USE_NAMED_GROUP
5534 scan_env_clear(env
);
5535 env
->option
= reg
->options
;
5536 env
->case_fold_flag
= reg
->case_fold_flag
;
5537 env
->enc
= reg
->enc
;
5538 env
->syntax
= reg
->syntax
;
5539 env
->pattern
= (UChar
* )pattern
;
5540 env
->pattern_end
= (UChar
* )end
;
5544 p
= (UChar
* )pattern
;
5545 r
= parse_regexp(root
, &p
, (UChar
* )end
, env
);
5546 reg
->num_mem
= env
->num_mem
;
5551 onig_scan_env_set_error_string(ScanEnv
* env
, int ecode ARG_UNUSED
,
5552 UChar
* arg
, UChar
* arg_end
)
5555 env
->error_end
= arg_end
;