1 /**********************************************************************
2 regparse.c - Oniguruma (regular expression library)
3 **********************************************************************/
5 * Copyright (c) 2002-2019 K.Kosako <sndgk393 AT ybb DOT ne DOT jp>
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 #ifdef DEBUG_NODE_FREE
37 #define INIT_TAG_NAMES_ALLOC_NUM 5
39 #define WARN_BUFSIZE 256
41 #define CASE_FOLD_IS_APPLIED_INSIDE_NEGATIVE_CCLASS
43 #define IS_ALLOWED_CODE_IN_CALLOUT_NAME(c) \
44 ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || c == '_' /* || c == '!' */)
45 #define IS_ALLOWED_CODE_IN_CALLOUT_TAG_NAME(c) \
46 ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || c == '_')
49 OnigSyntaxType OnigSyntaxOniguruma
= {
50 (( SYN_GNU_REGEX_OP
| ONIG_SYN_OP_QMARK_NON_GREEDY
|
51 ONIG_SYN_OP_ESC_OCTAL3
| ONIG_SYN_OP_ESC_X_HEX2
|
52 ONIG_SYN_OP_ESC_X_BRACE_HEX8
| ONIG_SYN_OP_ESC_O_BRACE_OCTAL
|
53 ONIG_SYN_OP_ESC_CONTROL_CHARS
|
54 ONIG_SYN_OP_ESC_C_CONTROL
)
55 & ~ONIG_SYN_OP_ESC_LTGT_WORD_BEGIN_END
)
56 , ( ONIG_SYN_OP2_QMARK_GROUP_EFFECT
|
57 ONIG_SYN_OP2_OPTION_ONIGURUMA
|
58 ONIG_SYN_OP2_QMARK_LT_NAMED_GROUP
| ONIG_SYN_OP2_ESC_K_NAMED_BACKREF
|
59 ONIG_SYN_OP2_QMARK_LPAREN_IF_ELSE
|
60 ONIG_SYN_OP2_QMARK_TILDE_ABSENT_GROUP
|
61 ONIG_SYN_OP2_QMARK_BRACE_CALLOUT_CONTENTS
|
62 ONIG_SYN_OP2_ASTERISK_CALLOUT_NAME
|
63 ONIG_SYN_OP2_ESC_X_Y_TEXT_SEGMENT
|
64 ONIG_SYN_OP2_ESC_CAPITAL_R_GENERAL_NEWLINE
|
65 ONIG_SYN_OP2_ESC_CAPITAL_N_O_SUPER_DOT
|
66 ONIG_SYN_OP2_ESC_CAPITAL_K_KEEP
|
67 ONIG_SYN_OP2_ESC_G_SUBEXP_CALL
|
68 ONIG_SYN_OP2_ESC_P_BRACE_CHAR_PROPERTY
|
69 ONIG_SYN_OP2_ESC_P_BRACE_CIRCUMFLEX_NOT
|
70 ONIG_SYN_OP2_PLUS_POSSESSIVE_REPEAT
|
71 ONIG_SYN_OP2_CCLASS_SET_OP
| ONIG_SYN_OP2_ESC_CAPITAL_C_BAR_CONTROL
|
72 ONIG_SYN_OP2_ESC_CAPITAL_M_BAR_META
| ONIG_SYN_OP2_ESC_V_VTAB
|
73 ONIG_SYN_OP2_ESC_H_XDIGIT
| ONIG_SYN_OP2_ESC_U_HEX4
)
74 , ( SYN_GNU_REGEX_BV
|
75 ONIG_SYN_ALLOW_INTERVAL_LOW_ABBREV
|
76 ONIG_SYN_DIFFERENT_LEN_ALT_LOOK_BEHIND
|
77 ONIG_SYN_CAPTURE_ONLY_NAMED_GROUP
|
78 ONIG_SYN_ALLOW_MULTIPLEX_DEFINITION_NAME
|
79 ONIG_SYN_FIXED_INTERVAL_IS_GREEDY_ONLY
|
80 ONIG_SYN_ALLOW_INVALID_CODE_END_OF_RANGE_IN_CC
|
81 ONIG_SYN_WARN_CC_OP_NOT_ESCAPED
|
82 ONIG_SYN_WARN_REDUNDANT_NESTED_REPEAT
)
86 (OnigCodePoint
)'\\' /* esc */
87 , (OnigCodePoint
)ONIG_INEFFECTIVE_META_CHAR
/* anychar '.' */
88 , (OnigCodePoint
)ONIG_INEFFECTIVE_META_CHAR
/* anytime '*' */
89 , (OnigCodePoint
)ONIG_INEFFECTIVE_META_CHAR
/* zero or one time '?' */
90 , (OnigCodePoint
)ONIG_INEFFECTIVE_META_CHAR
/* one or more time '+' */
91 , (OnigCodePoint
)ONIG_INEFFECTIVE_META_CHAR
/* anychar anytime */
95 OnigSyntaxType OnigSyntaxRuby
= {
96 (( SYN_GNU_REGEX_OP
| ONIG_SYN_OP_QMARK_NON_GREEDY
|
97 ONIG_SYN_OP_ESC_OCTAL3
| ONIG_SYN_OP_ESC_X_HEX2
|
98 ONIG_SYN_OP_ESC_X_BRACE_HEX8
| ONIG_SYN_OP_ESC_O_BRACE_OCTAL
|
99 ONIG_SYN_OP_ESC_CONTROL_CHARS
|
100 ONIG_SYN_OP_ESC_C_CONTROL
)
101 & ~ONIG_SYN_OP_ESC_LTGT_WORD_BEGIN_END
)
102 , ( ONIG_SYN_OP2_QMARK_GROUP_EFFECT
|
103 ONIG_SYN_OP2_OPTION_RUBY
|
104 ONIG_SYN_OP2_QMARK_LT_NAMED_GROUP
| ONIG_SYN_OP2_ESC_K_NAMED_BACKREF
|
105 ONIG_SYN_OP2_QMARK_LPAREN_IF_ELSE
|
106 ONIG_SYN_OP2_QMARK_TILDE_ABSENT_GROUP
|
107 ONIG_SYN_OP2_ESC_X_Y_TEXT_SEGMENT
|
108 ONIG_SYN_OP2_ESC_CAPITAL_R_GENERAL_NEWLINE
|
109 ONIG_SYN_OP2_ESC_CAPITAL_K_KEEP
|
110 ONIG_SYN_OP2_ESC_G_SUBEXP_CALL
|
111 ONIG_SYN_OP2_ESC_P_BRACE_CHAR_PROPERTY
|
112 ONIG_SYN_OP2_ESC_P_BRACE_CIRCUMFLEX_NOT
|
113 ONIG_SYN_OP2_PLUS_POSSESSIVE_REPEAT
|
114 ONIG_SYN_OP2_CCLASS_SET_OP
| ONIG_SYN_OP2_ESC_CAPITAL_C_BAR_CONTROL
|
115 ONIG_SYN_OP2_ESC_CAPITAL_M_BAR_META
| ONIG_SYN_OP2_ESC_V_VTAB
|
116 ONIG_SYN_OP2_ESC_H_XDIGIT
| ONIG_SYN_OP2_ESC_U_HEX4
)
117 , ( SYN_GNU_REGEX_BV
|
118 ONIG_SYN_ALLOW_INTERVAL_LOW_ABBREV
|
119 ONIG_SYN_DIFFERENT_LEN_ALT_LOOK_BEHIND
|
120 ONIG_SYN_CAPTURE_ONLY_NAMED_GROUP
|
121 ONIG_SYN_ALLOW_MULTIPLEX_DEFINITION_NAME
|
122 ONIG_SYN_FIXED_INTERVAL_IS_GREEDY_ONLY
|
123 ONIG_SYN_WARN_CC_OP_NOT_ESCAPED
|
124 ONIG_SYN_WARN_REDUNDANT_NESTED_REPEAT
)
128 (OnigCodePoint
)'\\' /* esc */
129 , (OnigCodePoint
)ONIG_INEFFECTIVE_META_CHAR
/* anychar '.' */
130 , (OnigCodePoint
)ONIG_INEFFECTIVE_META_CHAR
/* anytime '*' */
131 , (OnigCodePoint
)ONIG_INEFFECTIVE_META_CHAR
/* zero or one time '?' */
132 , (OnigCodePoint
)ONIG_INEFFECTIVE_META_CHAR
/* one or more time '+' */
133 , (OnigCodePoint
)ONIG_INEFFECTIVE_META_CHAR
/* anychar anytime */
137 OnigSyntaxType
* OnigDefaultSyntax
= ONIG_SYNTAX_ONIGURUMA
;
139 extern void onig_null_warn(const char* s ARG_UNUSED
) { }
141 #ifdef DEFAULT_WARN_FUNCTION
142 static OnigWarnFunc onig_warn
= (OnigWarnFunc
)DEFAULT_WARN_FUNCTION
;
144 static OnigWarnFunc onig_warn
= onig_null_warn
;
147 #ifdef DEFAULT_VERB_WARN_FUNCTION
148 static OnigWarnFunc onig_verb_warn
= (OnigWarnFunc
)DEFAULT_VERB_WARN_FUNCTION
;
150 static OnigWarnFunc onig_verb_warn
= onig_null_warn
;
153 extern void onig_set_warn_func(OnigWarnFunc f
)
158 extern void onig_set_verb_warn_func(OnigWarnFunc f
)
164 onig_warning(const char* s
)
166 if (onig_warn
== onig_null_warn
) return ;
171 #define DEFAULT_MAX_CAPTURE_NUM 32767
173 static int MaxCaptureNum
= DEFAULT_MAX_CAPTURE_NUM
;
176 onig_set_capture_num_limit(int num
)
178 if (num
< 0) return -1;
184 static unsigned int ParseDepthLimit
= DEFAULT_PARSE_DEPTH_LIMIT
;
187 onig_get_parse_depth_limit(void)
189 return ParseDepthLimit
;
193 onig_set_parse_depth_limit(unsigned int depth
)
196 ParseDepthLimit
= DEFAULT_PARSE_DEPTH_LIMIT
;
198 ParseDepthLimit
= depth
;
203 bbuf_init(BBuf
* buf
, int size
)
210 buf
->p
= (UChar
* )xmalloc(size
);
211 if (IS_NULL(buf
->p
)) return(ONIGERR_MEMORY
);
220 bbuf_free(BBuf
* bbuf
)
222 if (IS_NOT_NULL(bbuf
)) {
223 if (IS_NOT_NULL(bbuf
->p
)) xfree(bbuf
->p
);
229 bbuf_clone(BBuf
** rto
, BBuf
* from
)
234 *rto
= to
= (BBuf
* )xmalloc(sizeof(BBuf
));
235 CHECK_NULL_RETURN_MEMERR(to
);
236 r
= BB_INIT(to
, from
->alloc
);
242 to
->used
= from
->used
;
243 xmemcpy(to
->p
, from
->p
, from
->used
);
247 static int backref_rel_to_abs(int rel_no
, ScanEnv
* env
)
250 return env
->num_mem
+ rel_no
;
253 return env
->num_mem
+ 1 + rel_no
;
257 #define OPTION_ON(v,f) ((v) |= (f))
258 #define OPTION_OFF(v,f) ((v) &= ~(f))
260 #define OPTION_NEGATE(v,f,negative) (negative) ? ((v) &= ~(f)) : ((v) |= (f))
262 #define MBCODE_START_POS(enc) \
263 (OnigCodePoint )(ONIGENC_MBC_MINLEN(enc) > 1 ? 0 : 0x80)
265 #define SET_ALL_MULTI_BYTE_RANGE(enc, pbuf) \
266 add_code_range_to_buf(pbuf, MBCODE_START_POS(enc), ~((OnigCodePoint )0))
268 #define ADD_ALL_MULTI_BYTE_RANGE(enc, mbuf) do {\
269 if (! ONIGENC_IS_SINGLEBYTE(enc)) {\
270 r = SET_ALL_MULTI_BYTE_RANGE(enc, &(mbuf));\
271 if (r != 0) return r;\
276 #define BITSET_IS_EMPTY(bs,empty) do {\
279 for (i = 0; i < (int )BITSET_SIZE; i++) {\
287 bitset_set_range(BitSetRef bs
, int from
, int to
)
290 for (i
= from
; i
<= to
&& i
< SINGLE_BYTE_SIZE
; i
++) {
291 BITSET_SET_BIT(bs
, i
);
297 bitset_set_all(BitSetRef bs
)
300 for (i
= 0; i
< BITSET_SIZE
; i
++) { bs
[i
] = ~((Bits
)0); }
305 bitset_invert(BitSetRef bs
)
308 for (i
= 0; i
< (int )BITSET_SIZE
; i
++) { bs
[i
] = ~(bs
[i
]); }
312 bitset_invert_to(BitSetRef from
, BitSetRef to
)
315 for (i
= 0; i
< (int )BITSET_SIZE
; i
++) { to
[i
] = ~(from
[i
]); }
319 bitset_and(BitSetRef dest
, BitSetRef bs
)
322 for (i
= 0; i
< (int )BITSET_SIZE
; i
++) { dest
[i
] &= bs
[i
]; }
326 bitset_or(BitSetRef dest
, BitSetRef bs
)
329 for (i
= 0; i
< (int )BITSET_SIZE
; i
++) { dest
[i
] |= bs
[i
]; }
333 bitset_copy(BitSetRef dest
, BitSetRef bs
)
336 for (i
= 0; i
< (int )BITSET_SIZE
; i
++) { dest
[i
] = bs
[i
]; }
340 onig_strncmp(const UChar
* s1
, const UChar
* s2
, int n
)
352 onig_strcpy(UChar
* dest
, const UChar
* src
, const UChar
* end
)
354 int len
= (int )(end
- src
);
356 xmemcpy(dest
, src
, len
);
357 dest
[len
] = (UChar
)0;
362 save_entry(ScanEnv
* env
, enum SaveType type
, int* id
)
364 int nid
= env
->save_num
;
367 if (IS_NULL(env
->saves
)) {
369 env
->saves
= (SaveItem
* )xmalloc(sizeof(SaveItem
) * n
);
370 CHECK_NULL_RETURN_MEMERR(env
->saves
);
371 env
->save_alloc_num
= n
;
373 else if (env
->save_alloc_num
<= nid
) {
374 int n
= env
->save_alloc_num
* 2;
375 SaveItem
* p
= (SaveItem
* )xrealloc(env
->saves
, sizeof(SaveItem
) * n
, sizeof(SaveItem
)*env
->save_alloc_num
);
376 CHECK_NULL_RETURN_MEMERR(p
);
378 env
->save_alloc_num
= n
;
381 env
->saves
[nid
].type
= type
;
389 /* scan pattern methods */
392 #define PFETCH_READY UChar* pfetch_prev
393 #define PEND (p < end ? 0 : 1)
394 #define PUNFETCH p = pfetch_prev
397 p += ONIGENC_MBC_ENC_LEN(enc, p); \
399 #define PFETCH(c) do { \
400 c = ONIGENC_MBC_TO_CODE(enc, p, end); \
402 p += ONIGENC_MBC_ENC_LEN(enc, p); \
405 #define PINC_S do { \
406 p += ONIGENC_MBC_ENC_LEN(enc, p); \
408 #define PFETCH_S(c) do { \
409 c = ONIGENC_MBC_TO_CODE(enc, p, end); \
410 p += ONIGENC_MBC_ENC_LEN(enc, p); \
413 #define PPEEK (p < end ? ONIGENC_MBC_TO_CODE(enc, p, end) : PEND_VALUE)
414 #define PPEEK_IS(c) (PPEEK == (OnigCodePoint )c)
417 strcat_capa(UChar
* dest
, UChar
* dest_end
, const UChar
* src
, const UChar
* src_end
,
418 int capa
, int oldCapa
)
423 r
= (UChar
* )xrealloc(dest
, capa
+ 1, oldCapa
);
425 r
= (UChar
* )xmalloc(capa
+ 1);
427 CHECK_NULL_RETURN(r
);
428 onig_strcpy(r
+ (dest_end
- dest
), src
, src_end
);
432 /* dest on static area */
434 strcat_capa_from_static(UChar
* dest
, UChar
* dest_end
,
435 const UChar
* src
, const UChar
* src_end
, int capa
)
439 r
= (UChar
* )xmalloc(capa
+ 1);
440 CHECK_NULL_RETURN(r
);
441 onig_strcpy(r
, dest
, dest_end
);
442 onig_strcpy(r
+ (dest_end
- dest
), src
, src_end
);
447 #ifdef USE_ST_LIBRARY
455 str_end_cmp(st_str_end_key
* x
, st_str_end_key
* y
)
460 if ((x
->end
- x
->s
) != (y
->end
- y
->s
))
466 c
= (int )*p
- (int )*q
;
467 if (c
!= 0) return c
;
476 str_end_hash(st_str_end_key
* x
)
483 val
= val
* 997 + (int )*p
++;
486 return val
+ (val
>> 5);
489 extern hash_table_type
*
490 onig_st_init_strend_table_with_size(int size
)
492 static struct st_hash_type hashType
= {
497 return (hash_table_type
* )
498 onig_st_init_table_with_size(&hashType
, size
);
502 onig_st_lookup_strend(hash_table_type
* table
, const UChar
* str_key
,
503 const UChar
* end_key
, hash_data_type
*value
)
507 key
.s
= (UChar
* )str_key
;
508 key
.end
= (UChar
* )end_key
;
510 return onig_st_lookup(table
, (st_data_t
)(&key
), value
);
514 onig_st_insert_strend(hash_table_type
* table
, const UChar
* str_key
,
515 const UChar
* end_key
, hash_data_type value
)
520 key
= (st_str_end_key
* )xmalloc(sizeof(st_str_end_key
));
521 CHECK_NULL_RETURN_MEMERR(key
);
523 key
->s
= (UChar
* )str_key
;
524 key
->end
= (UChar
* )end_key
;
525 result
= onig_st_insert(table
, (st_data_t
)key
, value
);
537 int type
; /* callout type: single or not */
540 } st_callout_name_key
;
543 callout_name_table_cmp(st_callout_name_key
* x
, st_callout_name_key
* y
)
548 if (x
->enc
!= y
->enc
) return 1;
549 if (x
->type
!= y
->type
) return 1;
550 if ((x
->end
- x
->s
) != (y
->end
- y
->s
))
556 c
= (int )*p
- (int )*q
;
557 if (c
!= 0) return c
;
566 callout_name_table_hash(st_callout_name_key
* x
)
573 val
= val
* 997 + (int )*p
++;
576 /* use intptr_t for escape warning in Windows */
577 return val
+ (val
>> 5) + ((intptr_t )x
->enc
& 0xffff) + x
->type
;
580 extern hash_table_type
*
581 onig_st_init_callout_name_table_with_size(int size
)
583 static struct st_hash_type hashType
= {
584 callout_name_table_cmp
,
585 callout_name_table_hash
,
588 return (hash_table_type
* )
589 onig_st_init_table_with_size(&hashType
, size
);
593 onig_st_lookup_callout_name_table(hash_table_type
* table
,
596 const UChar
* str_key
,
597 const UChar
* end_key
,
598 hash_data_type
*value
)
600 st_callout_name_key key
;
604 key
.s
= (UChar
* )str_key
;
605 key
.end
= (UChar
* )end_key
;
607 return onig_st_lookup(table
, (st_data_t
)(&key
), value
);
611 st_insert_callout_name_table(hash_table_type
* table
,
612 OnigEncoding enc
, int type
,
613 UChar
* str_key
, UChar
* end_key
,
614 hash_data_type value
)
616 st_callout_name_key
* key
;
619 key
= (st_callout_name_key
* )xmalloc(sizeof(st_callout_name_key
));
620 CHECK_NULL_RETURN_MEMERR(key
);
622 /* key->s: don't duplicate, because str_key is duped in callout_name_entry() */
627 result
= onig_st_insert(table
, (st_data_t
)key
, value
);
635 #endif /* USE_ST_LIBRARY */
638 #define INIT_NAME_BACKREFS_ALLOC_NUM 8
642 int name_len
; /* byte length */
643 int back_num
; /* number of backrefs */
649 #ifdef USE_ST_LIBRARY
651 #define INIT_NAMES_ALLOC_NUM 5
653 typedef st_table NameTable
;
654 typedef st_data_t HashDataType
; /* 1.6 st.h doesn't define st_data_t type */
656 #define NAMEBUF_SIZE 24
657 #define NAMEBUF_SIZE_1 25
661 i_print_name_entry(UChar
* key
, NameEntry
* e
, void* arg
)
664 FILE* fp
= (FILE* )arg
;
666 fprintf(fp
, "%s: ", e
->name
);
667 if (e
->back_num
== 0)
669 else if (e
->back_num
== 1)
670 fprintf(fp
, "%d", e
->back_ref1
);
672 for (i
= 0; i
< e
->back_num
; i
++) {
673 if (i
> 0) fprintf(fp
, ", ");
674 fprintf(fp
, "%d", e
->back_refs
[i
]);
682 onig_print_names(FILE* fp
, regex_t
* reg
)
684 NameTable
* t
= (NameTable
* )reg
->name_table
;
686 if (IS_NOT_NULL(t
)) {
687 fprintf(fp
, "name table\n");
688 onig_st_foreach(t
, i_print_name_entry
, (HashDataType
)fp
);
693 #endif /* ONIG_DEBUG */
696 i_free_name_entry(UChar
* key
, NameEntry
* e
, void* arg ARG_UNUSED
)
699 if (IS_NOT_NULL(e
->back_refs
)) xfree(e
->back_refs
);
706 names_clear(regex_t
* reg
)
708 NameTable
* t
= (NameTable
* )reg
->name_table
;
710 if (IS_NOT_NULL(t
)) {
711 onig_st_foreach(t
, i_free_name_entry
, 0);
717 onig_names_free(regex_t
* reg
)
722 r
= names_clear(reg
);
723 if (r
!= 0) return r
;
725 t
= (NameTable
* )reg
->name_table
;
726 if (IS_NOT_NULL(t
)) onig_st_free_table(t
);
727 reg
->name_table
= (void* )NULL
;
732 name_find(regex_t
* reg
, const UChar
* name
, const UChar
* name_end
)
735 NameTable
* t
= (NameTable
* )reg
->name_table
;
737 e
= (NameEntry
* )NULL
;
738 if (IS_NOT_NULL(t
)) {
739 onig_st_lookup_strend(t
, name
, name_end
, (HashDataType
* )((void* )(&e
)));
745 int (*func
)(const UChar
*, const UChar
*,int,int*,regex_t
*,void*);
753 i_names(UChar
* key ARG_UNUSED
, NameEntry
* e
, INamesArg
* arg
)
755 int r
= (*(arg
->func
))(e
->name
,
756 e
->name
+ e
->name_len
,
758 (e
->back_num
> 1 ? e
->back_refs
: &(e
->back_ref1
)),
768 onig_foreach_name(regex_t
* reg
,
769 int (*func
)(const UChar
*, const UChar
*,int,int*,regex_t
*,void*), void* arg
)
772 NameTable
* t
= (NameTable
* )reg
->name_table
;
775 if (IS_NOT_NULL(t
)) {
779 narg
.enc
= reg
->enc
; /* should be pattern encoding. */
780 onig_st_foreach(t
, i_names
, (HashDataType
)&narg
);
786 i_renumber_name(UChar
* key ARG_UNUSED
, NameEntry
* e
, GroupNumRemap
* map
)
790 if (e
->back_num
> 1) {
791 for (i
= 0; i
< e
->back_num
; i
++) {
792 e
->back_refs
[i
] = map
[e
->back_refs
[i
]].new_val
;
795 else if (e
->back_num
== 1) {
796 e
->back_ref1
= map
[e
->back_ref1
].new_val
;
803 onig_renumber_name_table(regex_t
* reg
, GroupNumRemap
* map
)
805 NameTable
* t
= (NameTable
* )reg
->name_table
;
807 if (IS_NOT_NULL(t
)) {
808 onig_st_foreach(t
, i_renumber_name
, (HashDataType
)map
);
815 onig_number_of_names(regex_t
* reg
)
817 NameTable
* t
= (NameTable
* )reg
->name_table
;
820 return t
->num_entries
;
825 #else /* USE_ST_LIBRARY */
827 #define INIT_NAMES_ALLOC_NUM 8
837 onig_print_names(FILE* fp
, regex_t
* reg
)
841 NameTable
* t
= (NameTable
* )reg
->name_table
;
843 if (IS_NOT_NULL(t
) && t
->num
> 0) {
844 fprintf(fp
, "name table\n");
845 for (i
= 0; i
< t
->num
; i
++) {
847 fprintf(fp
, "%s: ", e
->name
);
848 if (e
->back_num
== 0) {
851 else if (e
->back_num
== 1) {
852 fprintf(fp
, "%d", e
->back_ref1
);
855 for (j
= 0; j
< e
->back_num
; j
++) {
856 if (j
> 0) fprintf(fp
, ", ");
857 fprintf(fp
, "%d", e
->back_refs
[j
]);
869 names_clear(regex_t
* reg
)
873 NameTable
* t
= (NameTable
* )reg
->name_table
;
875 if (IS_NOT_NULL(t
)) {
876 for (i
= 0; i
< t
->num
; i
++) {
878 if (IS_NOT_NULL(e
->name
)) {
884 if (IS_NOT_NULL(e
->back_refs
)) xfree(e
->back_refs
);
885 e
->back_refs
= (int* )NULL
;
888 if (IS_NOT_NULL(t
->e
)) {
898 onig_names_free(regex_t
* reg
)
903 r
= names_clear(reg
);
904 if (r
!= 0) return r
;
906 t
= (NameTable
* )reg
->name_table
;
907 if (IS_NOT_NULL(t
)) xfree(t
);
908 reg
->name_table
= NULL
;
913 name_find(regex_t
* reg
, UChar
* name
, UChar
* name_end
)
917 NameTable
* t
= (NameTable
* )reg
->name_table
;
919 if (IS_NOT_NULL(t
)) {
920 len
= name_end
- name
;
921 for (i
= 0; i
< t
->num
; i
++) {
923 if (len
== e
->name_len
&& onig_strncmp(name
, e
->name
, len
) == 0)
927 return (NameEntry
* )NULL
;
931 onig_foreach_name(regex_t
* reg
,
932 int (*func
)(const UChar
*, const UChar
*,int,int*,regex_t
*,void*), void* arg
)
936 NameTable
* t
= (NameTable
* )reg
->name_table
;
938 if (IS_NOT_NULL(t
)) {
939 for (i
= 0; i
< t
->num
; i
++) {
941 r
= (*func
)(e
->name
, e
->name
+ e
->name_len
, e
->back_num
,
942 (e
->back_num
> 1 ? e
->back_refs
: &(e
->back_ref1
)),
944 if (r
!= 0) return r
;
951 onig_number_of_names(regex_t
* reg
)
953 NameTable
* t
= (NameTable
* )reg
->name_table
;
961 #endif /* else USE_ST_LIBRARY */
964 name_add(regex_t
* reg
, UChar
* name
, UChar
* name_end
, int backref
, ScanEnv
* env
)
969 NameTable
* t
= (NameTable
* )reg
->name_table
;
971 if (name_end
- name
<= 0)
972 return ONIGERR_EMPTY_GROUP_NAME
;
974 e
= name_find(reg
, name
, name_end
);
976 #ifdef USE_ST_LIBRARY
978 t
= onig_st_init_strend_table_with_size(INIT_NAMES_ALLOC_NUM
);
979 CHECK_NULL_RETURN_MEMERR(t
);
980 reg
->name_table
= (void* )t
;
982 e
= (NameEntry
* )xmalloc(sizeof(NameEntry
));
983 CHECK_NULL_RETURN_MEMERR(e
);
985 e
->name
= onigenc_strdup(reg
->enc
, name
, name_end
);
986 if (IS_NULL(e
->name
)) {
987 xfree(e
); return ONIGERR_MEMORY
;
989 r
= onig_st_insert_strend(t
, e
->name
, (e
->name
+ (name_end
- name
)),
993 e
->name_len
= (int )(name_end
- name
);
996 e
->back_refs
= (int* )NULL
;
1001 alloc
= INIT_NAMES_ALLOC_NUM
;
1002 t
= (NameTable
* )xmalloc(sizeof(NameTable
));
1003 CHECK_NULL_RETURN_MEMERR(t
);
1008 t
->e
= (NameEntry
* )xmalloc(sizeof(NameEntry
) * alloc
);
1009 if (IS_NULL(t
->e
)) {
1011 return ONIGERR_MEMORY
;
1014 reg
->name_table
= t
;
1017 else if (t
->num
== t
->alloc
) {
1020 alloc
= t
->alloc
* 2;
1021 t
->e
= (NameEntry
* )xrealloc(t
->e
, sizeof(NameEntry
) * alloc
, sizeof(NameEntry
) * t
->alloc
);
1022 CHECK_NULL_RETURN_MEMERR(t
->e
);
1026 for (i
= t
->num
; i
< t
->alloc
; i
++) {
1027 t
->e
[i
].name
= NULL
;
1028 t
->e
[i
].name_len
= 0;
1029 t
->e
[i
].back_num
= 0;
1030 t
->e
[i
].back_alloc
= 0;
1031 t
->e
[i
].back_refs
= (int* )NULL
;
1034 e
= &(t
->e
[t
->num
]);
1036 e
->name
= onigenc_strdup(reg
->enc
, name
, name_end
);
1037 if (IS_NULL(e
->name
)) return ONIGERR_MEMORY
;
1038 e
->name_len
= name_end
- name
;
1042 if (e
->back_num
>= 1 &&
1043 ! IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_ALLOW_MULTIPLEX_DEFINITION_NAME
)) {
1044 onig_scan_env_set_error_string(env
, ONIGERR_MULTIPLEX_DEFINED_NAME
,
1046 return ONIGERR_MULTIPLEX_DEFINED_NAME
;
1050 if (e
->back_num
== 1) {
1051 e
->back_ref1
= backref
;
1054 if (e
->back_num
== 2) {
1055 alloc
= INIT_NAME_BACKREFS_ALLOC_NUM
;
1056 e
->back_refs
= (int* )xmalloc(sizeof(int) * alloc
);
1057 CHECK_NULL_RETURN_MEMERR(e
->back_refs
);
1058 e
->back_alloc
= alloc
;
1059 e
->back_refs
[0] = e
->back_ref1
;
1060 e
->back_refs
[1] = backref
;
1063 if (e
->back_num
> e
->back_alloc
) {
1064 alloc
= e
->back_alloc
* 2;
1065 e
->back_refs
= (int* )xrealloc(e
->back_refs
, sizeof(int) * alloc
, sizeof(int) * e
->back_alloc
);
1066 CHECK_NULL_RETURN_MEMERR(e
->back_refs
);
1067 e
->back_alloc
= alloc
;
1069 e
->back_refs
[e
->back_num
- 1] = backref
;
1077 onig_name_to_group_numbers(regex_t
* reg
, const UChar
* name
,
1078 const UChar
* name_end
, int** nums
)
1080 NameEntry
* e
= name_find(reg
, name
, name_end
);
1082 if (IS_NULL(e
)) return ONIGERR_UNDEFINED_NAME_REFERENCE
;
1084 switch (e
->back_num
) {
1088 *nums
= &(e
->back_ref1
);
1091 *nums
= e
->back_refs
;
1098 name_to_group_numbers(ScanEnv
* env
, const UChar
* name
, const UChar
* name_end
,
1105 e
= name_find(reg
, name
, name_end
);
1108 onig_scan_env_set_error_string(env
, ONIGERR_UNDEFINED_NAME_REFERENCE
,
1109 (UChar
* )name
, (UChar
* )name_end
);
1110 return ONIGERR_UNDEFINED_NAME_REFERENCE
;
1113 switch (e
->back_num
) {
1117 *nums
= &(e
->back_ref1
);
1120 *nums
= e
->back_refs
;
1127 onig_name_to_backref_number(regex_t
* reg
, const UChar
* name
,
1128 const UChar
* name_end
, OnigRegion
*region
)
1132 n
= onig_name_to_group_numbers(reg
, name
, name_end
, &nums
);
1136 return ONIGERR_PARSER_BUG
;
1140 if (IS_NOT_NULL(region
)) {
1141 for (i
= n
- 1; i
>= 0; i
--) {
1142 if (region
->beg
[nums
[i
]] != ONIG_REGION_NOTPOS
)
1151 onig_noname_group_capture_is_active(regex_t
* reg
)
1153 if (ONIG_IS_OPTION_ON(reg
->options
, ONIG_OPTION_DONT_CAPTURE_GROUP
))
1156 if (onig_number_of_names(reg
) > 0 &&
1157 IS_SYNTAX_BV(reg
->syntax
, ONIG_SYN_CAPTURE_ONLY_NAMED_GROUP
) &&
1158 !ONIG_IS_OPTION_ON(reg
->options
, ONIG_OPTION_CAPTURE_GROUP
)) {
1168 OnigCalloutType type
;
1170 OnigCalloutFunc start_func
;
1171 OnigCalloutFunc end_func
;
1174 unsigned int arg_types
[ONIG_CALLOUT_MAX_ARGS_NUM
];
1175 OnigValue opt_defaults
[ONIG_CALLOUT_MAX_ARGS_NUM
];
1176 UChar
* name
; /* reference to GlobalCalloutNameTable entry: e->name */
1177 } CalloutNameListEntry
;
1182 CalloutNameListEntry
* v
;
1183 } CalloutNameListType
;
1185 static CalloutNameListType
* GlobalCalloutNameList
;
1188 make_callout_func_list(CalloutNameListType
** rs
, int init_size
)
1190 CalloutNameListType
* s
;
1191 CalloutNameListEntry
* v
;
1195 s
= xmalloc(sizeof(*s
));
1196 if (IS_NULL(s
)) return ONIGERR_MEMORY
;
1198 v
= (CalloutNameListEntry
* )xmalloc(sizeof(CalloutNameListEntry
) * init_size
);
1201 return ONIGERR_MEMORY
;
1205 s
->alloc
= init_size
;
1213 free_callout_func_list(CalloutNameListType
* s
)
1215 if (IS_NOT_NULL(s
)) {
1216 if (IS_NOT_NULL(s
->v
)) {
1219 for (i
= 0; i
< s
->n
; i
++) {
1220 CalloutNameListEntry
* e
= s
->v
+ i
;
1221 for (j
= e
->arg_num
- e
->opt_arg_num
; j
< e
->arg_num
; j
++) {
1222 if (e
->arg_types
[j
] == ONIG_TYPE_STRING
) {
1223 UChar
* p
= e
->opt_defaults
[j
].s
.start
;
1224 if (IS_NOT_NULL(p
)) xfree(p
);
1235 callout_func_list_add(CalloutNameListType
* s
, int* rid
)
1237 if (s
->n
>= s
->alloc
) {
1238 int new_size
= s
->alloc
* 2;
1239 CalloutNameListEntry
* nv
= (CalloutNameListEntry
* )
1240 xrealloc(s
->v
, sizeof(CalloutNameListEntry
) * new_size
, sizeof(CalloutNameListEntry
)*s
->alloc
);
1241 if (IS_NULL(nv
)) return ONIGERR_MEMORY
;
1243 s
->alloc
= new_size
;
1249 xmemset(&(s
->v
[s
->n
]), 0, sizeof(*(s
->v
)));
1257 int name_len
; /* byte length */
1261 #ifdef USE_ST_LIBRARY
1262 typedef st_table CalloutNameTable
;
1265 CalloutNameEntry
* e
;
1271 static CalloutNameTable
* GlobalCalloutNameTable
;
1272 static int CalloutNameIDCounter
;
1274 #ifdef USE_ST_LIBRARY
1277 i_free_callout_name_entry(st_callout_name_key
* key
, CalloutNameEntry
* e
,
1278 void* arg ARG_UNUSED
)
1281 /*xfree(key->s); */ /* is same as e->name */
1288 callout_name_table_clear(CalloutNameTable
* t
)
1290 if (IS_NOT_NULL(t
)) {
1291 onig_st_foreach(t
, i_free_callout_name_entry
, 0);
1297 global_callout_name_table_free(void)
1299 if (IS_NOT_NULL(GlobalCalloutNameTable
)) {
1300 int r
= callout_name_table_clear(GlobalCalloutNameTable
);
1301 if (r
!= 0) return r
;
1303 onig_st_free_table(GlobalCalloutNameTable
);
1304 GlobalCalloutNameTable
= 0;
1305 CalloutNameIDCounter
= 0;
1311 static CalloutNameEntry
*
1312 callout_name_find(OnigEncoding enc
, int is_not_single
,
1313 const UChar
* name
, const UChar
* name_end
)
1316 CalloutNameEntry
* e
;
1317 CalloutNameTable
* t
= GlobalCalloutNameTable
;
1319 e
= (CalloutNameEntry
* )NULL
;
1320 if (IS_NOT_NULL(t
)) {
1321 r
= onig_st_lookup_callout_name_table(t
, enc
, is_not_single
, name
, name_end
,
1322 (HashDataType
* )((void* )(&e
)));
1323 if (r
== 0) { /* not found */
1324 if (enc
!= ONIG_ENCODING_ASCII
&&
1325 ONIGENC_IS_ASCII_COMPATIBLE_ENCODING(enc
)) {
1326 enc
= ONIG_ENCODING_ASCII
;
1327 onig_st_lookup_callout_name_table(t
, enc
, is_not_single
, name
, name_end
,
1328 (HashDataType
* )((void* )(&e
)));
1338 callout_name_table_clear(CalloutNameTable
* t
)
1341 CalloutNameEntry
* e
;
1343 if (IS_NOT_NULL(t
)) {
1344 for (i
= 0; i
< t
->num
; i
++) {
1346 if (IS_NOT_NULL(e
->name
)) {
1354 if (IS_NOT_NULL(t
->e
)) {
1364 global_callout_name_table_free(void)
1366 if (IS_NOT_NULL(GlobalCalloutNameTable
)) {
1367 int r
= callout_name_table_clear(GlobalCalloutNameTable
);
1368 if (r
!= 0) return r
;
1370 xfree(GlobalCalloutNameTable
);
1371 GlobalCalloutNameTable
= 0;
1372 CalloutNameIDCounter
= 0;
1377 static CalloutNameEntry
*
1378 callout_name_find(UChar
* name
, UChar
* name_end
)
1381 CalloutNameEntry
* e
;
1382 CalloutNameTable
* t
= Calloutnames
;
1384 if (IS_NOT_NULL(t
)) {
1385 len
= name_end
- name
;
1386 for (i
= 0; i
< t
->num
; i
++) {
1388 if (len
== e
->name_len
&& onig_strncmp(name
, e
->name
, len
) == 0)
1392 return (CalloutNameEntry
* )NULL
;
1397 /* name string must be single byte char string. */
1399 callout_name_entry(CalloutNameEntry
** rentry
, OnigEncoding enc
,
1400 int is_not_single
, UChar
* name
, UChar
* name_end
)
1403 CalloutNameEntry
* e
;
1404 CalloutNameTable
* t
= GlobalCalloutNameTable
;
1407 if (name_end
- name
<= 0)
1408 return ONIGERR_INVALID_CALLOUT_NAME
;
1410 e
= callout_name_find(enc
, is_not_single
, name
, name_end
);
1412 #ifdef USE_ST_LIBRARY
1414 t
= onig_st_init_callout_name_table_with_size(INIT_NAMES_ALLOC_NUM
);
1415 CHECK_NULL_RETURN_MEMERR(t
);
1416 GlobalCalloutNameTable
= t
;
1418 e
= (CalloutNameEntry
* )xmalloc(sizeof(CalloutNameEntry
));
1419 CHECK_NULL_RETURN_MEMERR(e
);
1421 e
->name
= onigenc_strdup(enc
, name
, name_end
);
1422 if (IS_NULL(e
->name
)) {
1423 xfree(e
); return ONIGERR_MEMORY
;
1426 r
= st_insert_callout_name_table(t
, enc
, is_not_single
,
1427 e
->name
, (e
->name
+ (name_end
- name
)),
1429 if (r
< 0) return r
;
1436 alloc
= INIT_NAMES_ALLOC_NUM
;
1437 t
= (CalloutNameTable
* )xmalloc(sizeof(CalloutNameTable
));
1438 CHECK_NULL_RETURN_MEMERR(t
);
1443 t
->e
= (CalloutNameEntry
* )xmalloc(sizeof(CalloutNameEntry
) * alloc
);
1444 if (IS_NULL(t
->e
)) {
1446 return ONIGERR_MEMORY
;
1449 GlobalCalloutNameTable
= t
;
1452 else if (t
->num
== t
->alloc
) {
1455 alloc
= t
->alloc
* 2;
1456 t
->e
= (CalloutNameEntry
* )xrealloc(t
->e
, sizeof(CalloutNameEntry
) * alloc
, sizeof(CalloutNameEntry
)*t
->alloc
);
1457 CHECK_NULL_RETURN_MEMERR(t
->e
);
1461 for (i
= t
->num
; i
< t
->alloc
; i
++) {
1462 t
->e
[i
].name
= NULL
;
1463 t
->e
[i
].name_len
= 0;
1467 e
= &(t
->e
[t
->num
]);
1469 e
->name
= onigenc_strdup(enc
, name
, name_end
);
1470 if (IS_NULL(e
->name
)) return ONIGERR_MEMORY
;
1473 CalloutNameIDCounter
++;
1474 e
->id
= CalloutNameIDCounter
;
1475 e
->name_len
= (int )(name_end
- name
);
1483 is_allowed_callout_name(OnigEncoding enc
, UChar
* name
, UChar
* name_end
)
1488 if (name
>= name_end
) return 0;
1491 while (p
< name_end
) {
1492 c
= ONIGENC_MBC_TO_CODE(enc
, p
, name_end
);
1493 if (! IS_ALLOWED_CODE_IN_CALLOUT_NAME(c
))
1497 if (c
>= '0' && c
<= '9') return 0;
1500 p
+= ONIGENC_MBC_ENC_LEN(enc
, p
);
1507 is_allowed_callout_tag_name(OnigEncoding enc
, UChar
* name
, UChar
* name_end
)
1512 if (name
>= name_end
) return 0;
1515 while (p
< name_end
) {
1516 c
= ONIGENC_MBC_TO_CODE(enc
, p
, name_end
);
1517 if (! IS_ALLOWED_CODE_IN_CALLOUT_TAG_NAME(c
))
1521 if (c
>= '0' && c
<= '9') return 0;
1524 p
+= ONIGENC_MBC_ENC_LEN(enc
, p
);
1531 onig_set_callout_of_name(OnigEncoding enc
, OnigCalloutType callout_type
,
1532 UChar
* name
, UChar
* name_end
, int in
,
1533 OnigCalloutFunc start_func
,
1534 OnigCalloutFunc end_func
,
1535 int arg_num
, unsigned int arg_types
[],
1536 int opt_arg_num
, OnigValue opt_defaults
[])
1543 CalloutNameEntry
* e
;
1544 CalloutNameListEntry
* fe
;
1546 if (callout_type
!= ONIG_CALLOUT_TYPE_SINGLE
)
1547 return ONIGERR_INVALID_ARGUMENT
;
1549 if (arg_num
< 0 || arg_num
> ONIG_CALLOUT_MAX_ARGS_NUM
)
1550 return ONIGERR_INVALID_CALLOUT_ARG
;
1552 if (opt_arg_num
< 0 || opt_arg_num
> arg_num
)
1553 return ONIGERR_INVALID_CALLOUT_ARG
;
1555 if (start_func
== 0 && end_func
== 0)
1556 return ONIGERR_INVALID_CALLOUT_ARG
;
1558 if ((in
& ONIG_CALLOUT_IN_PROGRESS
) == 0 && (in
& ONIG_CALLOUT_IN_RETRACTION
) == 0)
1559 return ONIGERR_INVALID_CALLOUT_ARG
;
1561 for (i
= 0; i
< arg_num
; i
++) {
1562 unsigned int t
= arg_types
[i
];
1563 if (t
== ONIG_TYPE_VOID
)
1564 return ONIGERR_INVALID_CALLOUT_ARG
;
1566 if (i
>= arg_num
- opt_arg_num
) {
1567 if (t
!= ONIG_TYPE_LONG
&& t
!= ONIG_TYPE_CHAR
&& t
!= ONIG_TYPE_STRING
&&
1569 return ONIGERR_INVALID_CALLOUT_ARG
;
1572 if (t
!= ONIG_TYPE_LONG
) {
1573 t
= t
& ~ONIG_TYPE_LONG
;
1574 if (t
!= ONIG_TYPE_CHAR
&& t
!= ONIG_TYPE_STRING
&& t
!= ONIG_TYPE_TAG
)
1575 return ONIGERR_INVALID_CALLOUT_ARG
;
1581 if (! is_allowed_callout_name(enc
, name
, name_end
)) {
1582 return ONIGERR_INVALID_CALLOUT_NAME
;
1585 is_not_single
= (callout_type
!= ONIG_CALLOUT_TYPE_SINGLE
);
1586 id
= callout_name_entry(&e
, enc
, is_not_single
, name
, name_end
);
1587 if (id
< 0) return id
;
1590 if (IS_NULL(GlobalCalloutNameList
)) {
1591 r
= make_callout_func_list(&GlobalCalloutNameList
, 10);
1592 if (r
!= ONIG_NORMAL
) return r
;
1595 while (id
>= GlobalCalloutNameList
->n
) {
1597 r
= callout_func_list_add(GlobalCalloutNameList
, &rid
);
1598 if (r
!= ONIG_NORMAL
) return r
;
1601 fe
= GlobalCalloutNameList
->v
+ id
;
1602 fe
->type
= callout_type
;
1604 fe
->start_func
= start_func
;
1605 fe
->end_func
= end_func
;
1606 fe
->arg_num
= arg_num
;
1607 fe
->opt_arg_num
= opt_arg_num
;
1610 for (i
= 0; i
< arg_num
; i
++) {
1611 fe
->arg_types
[i
] = arg_types
[i
];
1613 for (i
= arg_num
- opt_arg_num
, j
= 0; i
< arg_num
; i
++, j
++) {
1614 if(IS_NULL(opt_defaults
))return ONIGERR_INVALID_ARGUMENT
;
1615 if (fe
->arg_types
[i
] == ONIG_TYPE_STRING
) {
1619 if (IS_NULL(opt_defaults
)) return ONIGERR_INVALID_ARGUMENT
;
1621 val
= opt_defaults
+ j
;
1622 ds
= onigenc_strdup(enc
, val
->s
.start
, val
->s
.end
);
1623 CHECK_NULL_RETURN_MEMERR(ds
);
1625 fe
->opt_defaults
[i
].s
.start
= ds
;
1626 fe
->opt_defaults
[i
].s
.end
= ds
+ (val
->s
.end
- val
->s
.start
);
1629 fe
->opt_defaults
[i
] = opt_defaults
[j
];
1638 get_callout_name_id_by_name(OnigEncoding enc
, int is_not_single
,
1639 UChar
* name
, UChar
* name_end
, int* rid
)
1642 CalloutNameEntry
* e
;
1644 if (! is_allowed_callout_name(enc
, name
, name_end
)) {
1645 return ONIGERR_INVALID_CALLOUT_NAME
;
1648 e
= callout_name_find(enc
, is_not_single
, name
, name_end
);
1650 return ONIGERR_UNDEFINED_CALLOUT_NAME
;
1659 extern OnigCalloutFunc
1660 onig_get_callout_start_func(regex_t
* reg
, int callout_num
)
1662 /* If used for callouts of contents, return 0. */
1663 CalloutListEntry
* e
;
1665 e
= onig_reg_callout_list_at(reg
, callout_num
);
1666 CHECK_NULL_RETURN(e
);
1667 return e
->start_func
;
1671 onig_get_callout_tag_start(regex_t
* reg
, int callout_num
)
1673 CalloutListEntry
* e
= onig_reg_callout_list_at(reg
, callout_num
);
1674 CHECK_NULL_RETURN(e
);
1675 return e
->tag_start
;
1679 onig_get_callout_tag_end(regex_t
* reg
, int callout_num
)
1681 CalloutListEntry
* e
= onig_reg_callout_list_at(reg
, callout_num
);
1682 CHECK_NULL_RETURN(e
);
1687 extern OnigCalloutType
1688 onig_get_callout_type_by_name_id(int name_id
)
1690 if (name_id
< 0 || name_id
>= GlobalCalloutNameList
->n
)
1693 return GlobalCalloutNameList
->v
[name_id
].type
;
1696 extern OnigCalloutFunc
1697 onig_get_callout_start_func_by_name_id(int name_id
)
1699 if (name_id
< 0 || name_id
>= GlobalCalloutNameList
->n
)
1702 return GlobalCalloutNameList
->v
[name_id
].start_func
;
1705 extern OnigCalloutFunc
1706 onig_get_callout_end_func_by_name_id(int name_id
)
1708 if (name_id
< 0 || name_id
>= GlobalCalloutNameList
->n
)
1711 return GlobalCalloutNameList
->v
[name_id
].end_func
;
1715 onig_get_callout_in_by_name_id(int name_id
)
1717 if (name_id
< 0 || name_id
>= GlobalCalloutNameList
->n
)
1720 return GlobalCalloutNameList
->v
[name_id
].in
;
1724 get_callout_arg_num_by_name_id(int name_id
)
1726 return GlobalCalloutNameList
->v
[name_id
].arg_num
;
1730 get_callout_opt_arg_num_by_name_id(int name_id
)
1732 return GlobalCalloutNameList
->v
[name_id
].opt_arg_num
;
1736 get_callout_arg_type_by_name_id(int name_id
, int index
)
1738 return GlobalCalloutNameList
->v
[name_id
].arg_types
[index
];
1742 get_callout_opt_default_by_name_id(int name_id
, int index
)
1744 return GlobalCalloutNameList
->v
[name_id
].opt_defaults
[index
];
1748 onig_get_callout_name_by_name_id(int name_id
)
1750 if (name_id
< 0 || name_id
>= GlobalCalloutNameList
->n
)
1753 return GlobalCalloutNameList
->v
[name_id
].name
;
1757 onig_global_callout_names_free(void)
1759 free_callout_func_list(GlobalCalloutNameList
);
1760 GlobalCalloutNameList
= 0;
1762 global_callout_name_table_free();
1767 typedef st_table CalloutTagTable
;
1768 typedef intptr_t CalloutTagVal
;
1770 #define CALLOUT_TAG_LIST_FLAG_TAG_EXIST (1<<0)
1773 i_callout_callout_list_set(UChar
* key
, CalloutTagVal e
, void* arg
)
1776 RegexExt
* ext
= (RegexExt
* )arg
;
1779 ext
->callout_list
[num
].flag
|= CALLOUT_TAG_LIST_FLAG_TAG_EXIST
;
1784 setup_ext_callout_list_values(regex_t
* reg
)
1790 if (IS_NOT_NULL(ext
->tag_table
)) {
1791 onig_st_foreach((CalloutTagTable
*)ext
->tag_table
, i_callout_callout_list_set
,
1795 for (i
= 0; i
< ext
->callout_num
; i
++) {
1796 CalloutListEntry
* e
= ext
->callout_list
+ i
;
1797 if (e
->of
== ONIG_CALLOUT_OF_NAME
) {
1798 for (j
= 0; j
< e
->u
.arg
.num
; j
++) {
1799 if (e
->u
.arg
.types
[j
] == ONIG_TYPE_TAG
) {
1803 start
= e
->u
.arg
.vals
[j
].s
.start
;
1804 end
= e
->u
.arg
.vals
[j
].s
.end
;
1805 num
= onig_get_callout_num_by_tag(reg
, start
, end
);
1806 if (num
< 0) return num
;
1807 e
->u
.arg
.vals
[j
].tag
= num
;
1817 onig_callout_tag_is_exist_at_callout_num(regex_t
* reg
, int callout_num
)
1819 RegexExt
* ext
= reg
->extp
;
1821 if (IS_NULL(ext
) || IS_NULL(ext
->callout_list
)) return 0;
1822 if (callout_num
> ext
->callout_num
) return 0;
1824 return (ext
->callout_list
[callout_num
].flag
&
1825 CALLOUT_TAG_LIST_FLAG_TAG_EXIST
) != 0;
1829 i_free_callout_tag_entry(UChar
* key
, CalloutTagVal e
, void* arg ARG_UNUSED
)
1836 callout_tag_table_clear(CalloutTagTable
* t
)
1838 if (IS_NOT_NULL(t
)) {
1839 onig_st_foreach(t
, i_free_callout_tag_entry
, 0);
1845 onig_callout_tag_table_free(void* table
)
1847 CalloutTagTable
* t
= (CalloutTagTable
* )table
;
1849 if (IS_NOT_NULL(t
)) {
1850 int r
= callout_tag_table_clear(t
);
1851 if (r
!= 0) return r
;
1853 onig_st_free_table(t
);
1860 onig_get_callout_num_by_tag(regex_t
* reg
,
1861 const UChar
* tag
, const UChar
* tag_end
)
1868 if (IS_NULL(ext
) || IS_NULL(ext
->tag_table
))
1869 return ONIGERR_INVALID_CALLOUT_TAG_NAME
;
1871 r
= onig_st_lookup_strend(ext
->tag_table
, tag
, tag_end
,
1872 (HashDataType
* )((void* )(&e
)));
1873 if (r
== 0) return ONIGERR_INVALID_CALLOUT_TAG_NAME
;
1877 static CalloutTagVal
1878 callout_tag_find(CalloutTagTable
* t
, const UChar
* name
, const UChar
* name_end
)
1883 if (IS_NOT_NULL(t
)) {
1884 onig_st_lookup_strend(t
, name
, name_end
, (HashDataType
* )((void* )(&e
)));
1890 callout_tag_table_new(CalloutTagTable
** rt
)
1895 t
= onig_st_init_strend_table_with_size(INIT_TAG_NAMES_ALLOC_NUM
);
1896 CHECK_NULL_RETURN_MEMERR(t
);
1903 callout_tag_entry_raw(ScanEnv
* env
, CalloutTagTable
* t
, UChar
* name
,
1904 UChar
* name_end
, CalloutTagVal entry_val
)
1909 if (name_end
- name
<= 0)
1910 return ONIGERR_INVALID_CALLOUT_TAG_NAME
;
1912 val
= callout_tag_find(t
, name
, name_end
);
1914 onig_scan_env_set_error_string(env
, ONIGERR_MULTIPLEX_DEFINED_NAME
,
1916 return ONIGERR_MULTIPLEX_DEFINED_NAME
;
1919 r
= onig_st_insert_strend(t
, name
, name_end
, (HashDataType
)entry_val
);
1920 if (r
< 0) return r
;
1926 ext_ensure_tag_table(regex_t
* reg
)
1932 ext
= onig_get_regex_ext(reg
);
1933 CHECK_NULL_RETURN_MEMERR(ext
);
1935 if (IS_NULL(ext
->tag_table
)) {
1936 r
= callout_tag_table_new(&t
);
1937 if (r
!= ONIG_NORMAL
) return r
;
1946 callout_tag_entry(ScanEnv
* env
, regex_t
* reg
, UChar
* name
, UChar
* name_end
,
1947 CalloutTagVal entry_val
)
1951 CalloutListEntry
* e
;
1953 r
= ext_ensure_tag_table(reg
);
1954 if (r
!= ONIG_NORMAL
) return r
;
1956 ext
= onig_get_regex_ext(reg
);
1957 CHECK_NULL_RETURN_MEMERR(ext
);
1958 CHECK_NULL_RETURN_MEMERR(ext
->tag_table
);
1959 r
= callout_tag_entry_raw(env
, ext
->tag_table
, name
, name_end
, entry_val
);
1961 e
= onig_reg_callout_list_at(reg
, (int )entry_val
);
1962 CHECK_NULL_RETURN_MEMERR(e
);
1963 e
->tag_start
= name
;
1964 e
->tag_end
= name_end
;
1969 #endif /* USE_CALLOUT */
1972 #define INIT_SCANENV_MEMENV_ALLOC_SIZE 16
1975 scan_env_clear(ScanEnv
* env
)
1977 MEM_STATUS_CLEAR(env
->capture_history
);
1978 MEM_STATUS_CLEAR(env
->bt_mem_start
);
1979 MEM_STATUS_CLEAR(env
->bt_mem_end
);
1980 MEM_STATUS_CLEAR(env
->backrefed_mem
);
1981 env
->error
= (UChar
* )NULL
;
1982 env
->error_end
= (UChar
* )NULL
;
1986 env
->unset_addr_list
= NULL
;
1987 env
->has_call_zero
= 0;
1993 env
->mem_env_dynamic
= (MemEnv
* )NULL
;
1995 xmemset(env
->mem_env_static
, 0, sizeof(env
->mem_env_static
));
1997 env
->parse_depth
= 0;
2000 env
->save_alloc_num
= 0;
2005 scan_env_add_mem_entry(ScanEnv
* env
)
2010 need
= env
->num_mem
+ 1;
2011 if (need
> MaxCaptureNum
&& MaxCaptureNum
!= 0)
2012 return ONIGERR_TOO_MANY_CAPTURES
;
2014 if (need
>= SCANENV_MEMENV_SIZE
) {
2015 if (env
->mem_alloc
<= need
) {
2016 if (IS_NULL(env
->mem_env_dynamic
)) {
2017 alloc
= INIT_SCANENV_MEMENV_ALLOC_SIZE
;
2018 p
= (MemEnv
* )xmalloc(sizeof(MemEnv
) * alloc
);
2019 CHECK_NULL_RETURN_MEMERR(p
);
2020 xmemcpy(p
, env
->mem_env_static
, sizeof(env
->mem_env_static
));
2023 alloc
= env
->mem_alloc
* 2;
2024 p
= (MemEnv
* )xrealloc(env
->mem_env_dynamic
, sizeof(MemEnv
) * alloc
, sizeof(MemEnv
)*env
->mem_alloc
);
2025 CHECK_NULL_RETURN_MEMERR(p
);
2028 for (i
= env
->num_mem
+ 1; i
< alloc
; i
++) {
2029 p
[i
].node
= NULL_NODE
;
2036 env
->mem_env_dynamic
= p
;
2037 env
->mem_alloc
= alloc
;
2042 return env
->num_mem
;
2046 scan_env_set_mem_node(ScanEnv
* env
, int num
, Node
* node
)
2048 if (env
->num_mem
>= num
)
2049 SCANENV_MEMENV(env
)[num
].node
= node
;
2051 return ONIGERR_PARSER_BUG
;
2056 onig_node_free(Node
* node
)
2059 if (IS_NULL(node
)) return ;
2061 #ifdef DEBUG_NODE_FREE
2062 fprintf(stderr
, "onig_node_free: %p\n", node
);
2065 switch (NODE_TYPE(node
)) {
2067 if (STR_(node
)->capacity
!= 0 &&
2068 IS_NOT_NULL(STR_(node
)->s
) && STR_(node
)->s
!= STR_(node
)->buf
) {
2069 xfree(STR_(node
)->s
);
2075 onig_node_free(NODE_CAR(node
));
2077 Node
* next_node
= NODE_CDR(node
);
2087 CClassNode
* cc
= CCLASS_(node
);
2090 bbuf_free(cc
->mbuf
);
2095 if (IS_NOT_NULL(BACKREF_(node
)->back_dynamic
))
2096 xfree(BACKREF_(node
)->back_dynamic
);
2100 if (NODE_BODY(node
))
2101 onig_node_free(NODE_BODY(node
));
2104 BagNode
* en
= BAG_(node
);
2105 if (en
->type
== BAG_IF_ELSE
) {
2106 onig_node_free(en
->te
.Then
);
2107 onig_node_free(en
->te
.Else
);
2114 if (NODE_BODY(node
))
2115 onig_node_free(NODE_BODY(node
));
2128 cons_node_free_alone(Node
* node
)
2132 onig_node_free(node
);
2140 node
= (Node
* )xmalloc(sizeof(Node
));
2141 CHECK_NULL_RETURN(node
);
2142 xmemset(node
, 0, sizeof(*node
));
2144 #ifdef DEBUG_NODE_FREE
2145 fprintf(stderr
, "node_new: %p\n", node
);
2152 initialize_cclass(CClassNode
* cc
)
2154 BITSET_CLEAR(cc
->bs
);
2160 node_new_cclass(void)
2162 Node
* node
= node_new();
2163 CHECK_NULL_RETURN(node
);
2165 NODE_SET_TYPE(node
, NODE_CCLASS
);
2166 initialize_cclass(CCLASS_(node
));
2171 node_new_ctype(int type
, int not, OnigOptionType options
)
2173 Node
* node
= node_new();
2174 CHECK_NULL_RETURN(node
);
2176 NODE_SET_TYPE(node
, NODE_CTYPE
);
2177 CTYPE_(node
)->ctype
= type
;
2178 CTYPE_(node
)->not = not;
2179 CTYPE_(node
)->options
= options
;
2180 CTYPE_(node
)->ascii_mode
= IS_ASCII_MODE_CTYPE_OPTION(type
, options
);
2185 node_new_anychar(void)
2187 Node
* node
= node_new_ctype(CTYPE_ANYCHAR
, 0, ONIG_OPTION_NONE
);
2192 node_new_anychar_with_fixed_option(OnigOptionType option
)
2197 node
= node_new_anychar();
2198 CHECK_NULL_RETURN(node
);
2201 ct
->options
= option
;
2202 NODE_STATUS_ADD(node
, FIXED_OPTION
);
2207 node_new_no_newline(Node
** node
, ScanEnv
* env
)
2211 n
= node_new_anychar_with_fixed_option(ONIG_OPTION_NONE
);
2212 CHECK_NULL_RETURN_MEMERR(n
);
2218 node_new_true_anychar(Node
** node
, ScanEnv
* env
)
2222 n
= node_new_anychar_with_fixed_option(ONIG_OPTION_MULTILINE
);
2223 CHECK_NULL_RETURN_MEMERR(n
);
2229 node_new_list(Node
* left
, Node
* right
)
2231 Node
* node
= node_new();
2232 CHECK_NULL_RETURN(node
);
2234 NODE_SET_TYPE(node
, NODE_LIST
);
2235 NODE_CAR(node
) = left
;
2236 NODE_CDR(node
) = right
;
2241 onig_node_new_list(Node
* left
, Node
* right
)
2243 return node_new_list(left
, right
);
2247 onig_node_list_add(Node
* list
, Node
* x
)
2251 n
= onig_node_new_list(x
, NULL
);
2252 if (IS_NULL(n
)) return NULL_NODE
;
2254 if (IS_NOT_NULL(list
)) {
2255 while (IS_NOT_NULL(NODE_CDR(list
)))
2256 list
= NODE_CDR(list
);
2265 onig_node_new_alt(Node
* left
, Node
* right
)
2267 Node
* node
= node_new();
2268 CHECK_NULL_RETURN(node
);
2270 NODE_SET_TYPE(node
, NODE_ALT
);
2271 NODE_CAR(node
) = left
;
2272 NODE_CDR(node
) = right
;
2277 make_list_or_alt(NodeType type
, int n
, Node
* ns
[])
2281 if (n
<= 0) return NULL_NODE
;
2285 CHECK_NULL_RETURN(r
);
2286 NODE_SET_TYPE(r
, type
);
2287 NODE_CAR(r
) = ns
[0];
2288 NODE_CDR(r
) = NULL_NODE
;
2294 CHECK_NULL_RETURN(r
);
2296 right
= make_list_or_alt(type
, n
- 1, ns
+ 1);
2297 if (IS_NULL(right
)) {
2302 NODE_SET_TYPE(r
, type
);
2303 NODE_CAR(r
) = ns
[0];
2304 NODE_CDR(r
) = right
;
2311 make_list(int n
, Node
* ns
[])
2313 return make_list_or_alt(NODE_LIST
, n
, ns
);
2317 make_alt(int n
, Node
* ns
[])
2319 return make_list_or_alt(NODE_ALT
, n
, ns
);
2323 onig_node_new_anchor(int type
, int ascii_mode
)
2325 Node
* node
= node_new();
2326 CHECK_NULL_RETURN(node
);
2328 NODE_SET_TYPE(node
, NODE_ANCHOR
);
2329 ANCHOR_(node
)->type
= type
;
2330 ANCHOR_(node
)->char_len
= -1;
2331 ANCHOR_(node
)->ascii_mode
= ascii_mode
;
2336 node_new_backref(int back_num
, int* backrefs
, int by_name
,
2337 #ifdef USE_BACKREF_WITH_LEVEL
2338 int exist_level
, int nest_level
,
2343 Node
* node
= node_new();
2345 CHECK_NULL_RETURN(node
);
2347 NODE_SET_TYPE(node
, NODE_BACKREF
);
2348 BACKREF_(node
)->back_num
= back_num
;
2349 BACKREF_(node
)->back_dynamic
= (int* )NULL
;
2351 NODE_STATUS_ADD(node
, BY_NAME
);
2353 #ifdef USE_BACKREF_WITH_LEVEL
2354 if (exist_level
!= 0) {
2355 NODE_STATUS_ADD(node
, NEST_LEVEL
);
2356 BACKREF_(node
)->nest_level
= nest_level
;
2360 for (i
= 0; i
< back_num
; i
++) {
2361 if (backrefs
[i
] <= env
->num_mem
&&
2362 IS_NULL(SCANENV_MEMENV(env
)[backrefs
[i
]].node
)) {
2363 NODE_STATUS_ADD(node
, RECURSION
); /* /...(\1).../ */
2368 if (back_num
<= NODE_BACKREFS_SIZE
) {
2369 for (i
= 0; i
< back_num
; i
++)
2370 BACKREF_(node
)->back_static
[i
] = backrefs
[i
];
2373 int* p
= (int* )xmalloc(sizeof(int) * back_num
);
2375 onig_node_free(node
);
2378 BACKREF_(node
)->back_dynamic
= p
;
2379 for (i
= 0; i
< back_num
; i
++)
2386 node_new_backref_checker(int back_num
, int* backrefs
, int by_name
,
2387 #ifdef USE_BACKREF_WITH_LEVEL
2388 int exist_level
, int nest_level
,
2394 node
= node_new_backref(back_num
, backrefs
, by_name
,
2395 #ifdef USE_BACKREF_WITH_LEVEL
2396 exist_level
, nest_level
,
2399 CHECK_NULL_RETURN(node
);
2401 NODE_STATUS_ADD(node
, CHECKER
);
2407 node_new_call(UChar
* name
, UChar
* name_end
, int gnum
, int by_number
)
2409 Node
* node
= node_new();
2410 CHECK_NULL_RETURN(node
);
2412 NODE_SET_TYPE(node
, NODE_CALL
);
2413 CALL_(node
)->by_number
= by_number
;
2414 CALL_(node
)->name
= name
;
2415 CALL_(node
)->name_end
= name_end
;
2416 CALL_(node
)->group_num
= gnum
;
2417 CALL_(node
)->entry_count
= 1;
2423 node_new_quantifier(int lower
, int upper
, int by_number
)
2425 Node
* node
= node_new();
2426 CHECK_NULL_RETURN(node
);
2428 NODE_SET_TYPE(node
, NODE_QUANT
);
2429 QUANT_(node
)->lower
= lower
;
2430 QUANT_(node
)->upper
= upper
;
2431 QUANT_(node
)->greedy
= 1;
2432 QUANT_(node
)->emptiness
= BODY_IS_NOT_EMPTY
;
2433 QUANT_(node
)->head_exact
= NULL_NODE
;
2434 QUANT_(node
)->next_head_exact
= NULL_NODE
;
2435 QUANT_(node
)->is_refered
= 0;
2437 NODE_STATUS_ADD(node
, BY_NUMBER
);
2443 node_new_bag(enum BagType type
)
2445 Node
* node
= node_new();
2446 CHECK_NULL_RETURN(node
);
2448 NODE_SET_TYPE(node
, NODE_BAG
);
2449 BAG_(node
)->type
= type
;
2453 BAG_(node
)->m
.regnum
= 0;
2454 BAG_(node
)->m
.called_addr
= -1;
2455 BAG_(node
)->m
.entry_count
= 1;
2456 BAG_(node
)->m
.called_state
= 0;
2460 BAG_(node
)->o
.options
= 0;
2463 case BAG_STOP_BACKTRACK
:
2467 BAG_(node
)->te
.Then
= 0;
2468 BAG_(node
)->te
.Else
= 0;
2472 BAG_(node
)->opt_count
= 0;
2477 onig_node_new_bag(enum BagType type
)
2479 return node_new_bag(type
);
2483 node_new_bag_if_else(Node
* cond
, Node
* Then
, Node
* Else
)
2486 n
= node_new_bag(BAG_IF_ELSE
);
2487 CHECK_NULL_RETURN(n
);
2489 NODE_BODY(n
) = cond
;
2490 BAG_(n
)->te
.Then
= Then
;
2491 BAG_(n
)->te
.Else
= Else
;
2496 node_new_memory(int is_named
)
2498 Node
* node
= node_new_bag(BAG_MEMORY
);
2499 CHECK_NULL_RETURN(node
);
2501 NODE_STATUS_ADD(node
, NAMED_GROUP
);
2507 node_new_option(OnigOptionType option
)
2509 Node
* node
= node_new_bag(BAG_OPTION
);
2510 CHECK_NULL_RETURN(node
);
2511 BAG_(node
)->o
.options
= option
;
2516 node_new_group(Node
* content
)
2521 CHECK_NULL_RETURN(node
);
2522 NODE_SET_TYPE(node
, NODE_LIST
);
2523 NODE_CAR(node
) = content
;
2524 NODE_CDR(node
) = NULL_NODE
;
2530 node_drop_group(Node
* group
)
2534 content
= NODE_CAR(group
);
2535 NODE_CAR(group
) = NULL_NODE
;
2536 onig_node_free(group
);
2541 node_new_fail(Node
** node
, ScanEnv
* env
)
2544 CHECK_NULL_RETURN_MEMERR(*node
);
2546 NODE_SET_TYPE(*node
, NODE_GIMMICK
);
2547 GIMMICK_(*node
)->type
= GIMMICK_FAIL
;
2552 node_new_save_gimmick(Node
** node
, enum SaveType save_type
, ScanEnv
* env
)
2557 r
= save_entry(env
, save_type
, &id
);
2558 if (r
!= ONIG_NORMAL
) return r
;
2561 CHECK_NULL_RETURN_MEMERR(*node
);
2563 NODE_SET_TYPE(*node
, NODE_GIMMICK
);
2564 GIMMICK_(*node
)->id
= id
;
2565 GIMMICK_(*node
)->type
= GIMMICK_SAVE
;
2566 GIMMICK_(*node
)->detail_type
= (int )save_type
;
2572 node_new_update_var_gimmick(Node
** node
, enum UpdateVarType update_var_type
,
2573 int id
, ScanEnv
* env
)
2576 CHECK_NULL_RETURN_MEMERR(*node
);
2578 NODE_SET_TYPE(*node
, NODE_GIMMICK
);
2579 GIMMICK_(*node
)->id
= id
;
2580 GIMMICK_(*node
)->type
= GIMMICK_UPDATE_VAR
;
2581 GIMMICK_(*node
)->detail_type
= (int )update_var_type
;
2587 node_new_keep(Node
** node
, ScanEnv
* env
)
2591 r
= node_new_save_gimmick(node
, SAVE_KEEP
, env
);
2592 if (r
!= 0) return r
;
2601 onig_free_reg_callout_list(int n
, CalloutListEntry
* list
)
2606 if (IS_NULL(list
)) return ;
2608 for (i
= 0; i
< n
; i
++) {
2609 if (list
[i
].of
== ONIG_CALLOUT_OF_NAME
) {
2610 for (j
= 0; j
< list
[i
].u
.arg
.passed_num
; j
++) {
2611 if (list
[i
].u
.arg
.types
[j
] == ONIG_TYPE_STRING
) {
2612 if (IS_NOT_NULL(list
[i
].u
.arg
.vals
[j
].s
.start
))
2613 xfree(list
[i
].u
.arg
.vals
[j
].s
.start
);
2617 else { /* ONIG_CALLOUT_OF_CONTENTS */
2618 if (IS_NOT_NULL(list
[i
].u
.content
.start
)) {
2619 xfree((void* )list
[i
].u
.content
.start
);
2627 extern CalloutListEntry
*
2628 onig_reg_callout_list_at(regex_t
* reg
, int num
)
2630 RegexExt
* ext
= reg
->extp
;
2631 CHECK_NULL_RETURN(ext
);
2633 if (num
<= 0 || num
> ext
->callout_num
)
2637 return ext
->callout_list
+ num
;
2641 reg_callout_list_entry(ScanEnv
* env
, int* rnum
)
2643 #define INIT_CALLOUT_LIST_NUM 3
2646 CalloutListEntry
* list
;
2647 CalloutListEntry
* e
;
2650 ext
= onig_get_regex_ext(env
->reg
);
2651 CHECK_NULL_RETURN_MEMERR(ext
);
2653 if (IS_NULL(ext
->callout_list
)) {
2654 list
= (CalloutListEntry
* )xmalloc(sizeof(*list
) * INIT_CALLOUT_LIST_NUM
);
2655 CHECK_NULL_RETURN_MEMERR(list
);
2657 ext
->callout_list
= list
;
2658 ext
->callout_list_alloc
= INIT_CALLOUT_LIST_NUM
;
2659 ext
->callout_num
= 0;
2662 num
= ext
->callout_num
+ 1;
2663 if (num
> ext
->callout_list_alloc
) {
2664 int alloc
= ext
->callout_list_alloc
* 2;
2665 list
= (CalloutListEntry
* )xrealloc(ext
->callout_list
,
2666 sizeof(CalloutListEntry
) * alloc
,
2667 sizeof(CalloutListEntry
) * ext
->callout_list_alloc
);
2668 CHECK_NULL_RETURN_MEMERR(list
);
2670 ext
->callout_list
= list
;
2671 ext
->callout_list_alloc
= alloc
;
2674 e
= ext
->callout_list
+ (num
- 1);
2678 e
->in
= ONIG_CALLOUT_OF_CONTENTS
;
2685 e
->u
.arg
.passed_num
= 0;
2687 ext
->callout_num
= num
;
2693 node_new_callout(Node
** node
, OnigCalloutOf callout_of
, int num
, int id
,
2697 CHECK_NULL_RETURN_MEMERR(*node
);
2699 NODE_SET_TYPE(*node
, NODE_GIMMICK
);
2700 GIMMICK_(*node
)->id
= id
;
2701 GIMMICK_(*node
)->num
= num
;
2702 GIMMICK_(*node
)->type
= GIMMICK_CALLOUT
;
2703 GIMMICK_(*node
)->detail_type
= (int )callout_of
;
2710 make_text_segment(Node
** node
, ScanEnv
* env
)
2717 /* \X == (?>\O(?:\Y\O)*) */
2722 ns
[0] = onig_node_new_anchor(ANCR_NO_TEXT_SEGMENT_BOUNDARY
, 0);
2723 if (IS_NULL(ns
[0])) goto err
;
2725 r
= node_new_true_anychar(&ns
[1], env
);
2726 if (r
!= 0) goto err1
;
2728 x
= make_list(2, ns
);
2729 if (IS_NULL(x
)) goto err
;
2733 x
= node_new_quantifier(0, INFINITE_REPEAT
, 1);
2734 if (IS_NULL(x
)) goto err
;
2736 NODE_BODY(x
) = ns
[0];
2740 r
= node_new_true_anychar(&ns
[0], env
);
2741 if (r
!= 0) goto err1
;
2743 x
= make_list(2, ns
);
2744 if (IS_NULL(x
)) goto err
;
2749 x
= node_new_bag(BAG_STOP_BACKTRACK
);
2750 if (IS_NULL(x
)) goto err
;
2752 NODE_BODY(x
) = ns
[0];
2760 for (i
= 0; i
< 2; i
++) onig_node_free(ns
[i
]);
2765 make_absent_engine(Node
** node
, int pre_save_right_id
, Node
* absent
,
2766 Node
* step_one
, int lower
, int upper
, int possessive
,
2767 int is_range_cutter
, ScanEnv
* env
)
2775 for (i
= 0; i
< 4; i
++) ns
[i
] = NULL_NODE
;
2778 ns
[3] = step_one
; /* for err */
2779 r
= node_new_save_gimmick(&ns
[0], SAVE_S
, env
);
2780 if (r
!= 0) goto err
;
2782 id
= GIMMICK_(ns
[0])->id
;
2783 r
= node_new_update_var_gimmick(&ns
[2], UPDATE_VAR_RIGHT_RANGE_FROM_S_STACK
,
2785 if (r
!= 0) goto err
;
2787 r
= node_new_fail(&ns
[3], env
);
2788 if (r
!= 0) goto err
;
2790 x
= make_list(4, ns
);
2791 if (IS_NULL(x
)) goto err0
;
2795 ns
[2] = ns
[3] = NULL_NODE
;
2797 x
= make_alt(2, ns
);
2798 if (IS_NULL(x
)) goto err0
;
2802 x
= node_new_quantifier(lower
, upper
, 0);
2803 if (IS_NULL(x
)) goto err0
;
2805 NODE_BODY(x
) = ns
[0];
2808 if (possessive
!= 0) {
2809 x
= node_new_bag(BAG_STOP_BACKTRACK
);
2810 if (IS_NULL(x
)) goto err0
;
2812 NODE_BODY(x
) = ns
[0];
2816 r
= node_new_update_var_gimmick(&ns
[1], UPDATE_VAR_RIGHT_RANGE_FROM_STACK
,
2817 pre_save_right_id
, env
);
2818 if (r
!= 0) goto err
;
2820 r
= node_new_fail(&ns
[2], env
);
2821 if (r
!= 0) goto err
;
2823 x
= make_list(2, ns
+ 1);
2824 if (IS_NULL(x
)) goto err0
;
2826 ns
[1] = x
; ns
[2] = NULL_NODE
;
2828 x
= make_alt(2, ns
);
2829 if (IS_NULL(x
)) goto err0
;
2831 if (is_range_cutter
!= 0)
2832 NODE_STATUS_ADD(x
, SUPER
);
2840 for (i
= 0; i
< 4; i
++) onig_node_free(ns
[i
]);
2845 make_absent_tail(Node
** node1
, Node
** node2
, int pre_save_right_id
,
2854 *node1
= *node2
= NULL_NODE
;
2855 save
= ns
[0] = ns
[1] = NULL_NODE
;
2857 r
= node_new_save_gimmick(&save
, SAVE_RIGHT_RANGE
, env
);
2858 if (r
!= 0) goto err
;
2860 id
= GIMMICK_(save
)->id
;
2861 r
= node_new_update_var_gimmick(&ns
[0], UPDATE_VAR_RIGHT_RANGE_FROM_STACK
,
2863 if (r
!= 0) goto err
;
2865 r
= node_new_fail(&ns
[1], env
);
2866 if (r
!= 0) goto err
;
2868 x
= make_list(2, ns
);
2869 if (IS_NULL(x
)) goto err0
;
2871 ns
[0] = NULL_NODE
; ns
[1] = x
;
2873 r
= node_new_update_var_gimmick(&ns
[0], UPDATE_VAR_RIGHT_RANGE_FROM_STACK
,
2874 pre_save_right_id
, env
);
2875 if (r
!= 0) goto err
;
2877 x
= make_alt(2, ns
);
2878 if (IS_NULL(x
)) goto err0
;
2887 onig_node_free(save
);
2888 onig_node_free(ns
[0]);
2889 onig_node_free(ns
[1]);
2894 make_range_clear(Node
** node
, ScanEnv
* env
)
2903 save
= ns
[0] = ns
[1] = NULL_NODE
;
2905 r
= node_new_save_gimmick(&save
, SAVE_RIGHT_RANGE
, env
);
2906 if (r
!= 0) goto err
;
2908 id
= GIMMICK_(save
)->id
;
2909 r
= node_new_update_var_gimmick(&ns
[0], UPDATE_VAR_RIGHT_RANGE_FROM_STACK
,
2911 if (r
!= 0) goto err
;
2913 r
= node_new_fail(&ns
[1], env
);
2914 if (r
!= 0) goto err
;
2916 x
= make_list(2, ns
);
2917 if (IS_NULL(x
)) goto err0
;
2919 ns
[0] = NULL_NODE
; ns
[1] = x
;
2921 r
= node_new_update_var_gimmick(&ns
[0], UPDATE_VAR_RIGHT_RANGE_INIT
, 0, env
);
2922 if (r
!= 0) goto err
;
2924 x
= make_alt(2, ns
);
2925 if (IS_NULL(x
)) goto err0
;
2927 NODE_STATUS_ADD(x
, SUPER
);
2932 x
= make_list(2, ns
);
2933 if (IS_NULL(x
)) goto err0
;
2941 onig_node_free(save
);
2942 onig_node_free(ns
[0]);
2943 onig_node_free(ns
[1]);
2948 is_simple_one_char_repeat(Node
* node
, Node
** rquant
, Node
** rbody
,
2949 int* is_possessive
, ScanEnv
* env
)
2954 *rquant
= *rbody
= 0;
2957 if (NODE_TYPE(node
) == NODE_QUANT
) {
2961 if (NODE_TYPE(node
) == NODE_BAG
) {
2962 BagNode
* en
= BAG_(node
);
2963 if (en
->type
== BAG_STOP_BACKTRACK
) {
2965 quant
= NODE_BAG_BODY(en
);
2966 if (NODE_TYPE(quant
) != NODE_QUANT
)
2976 if (QUANT_(quant
)->greedy
== 0)
2979 body
= NODE_BODY(quant
);
2980 switch (NODE_TYPE(body
)) {
2984 StrNode
* sn
= STR_(body
);
2988 while (s
< sn
->end
) {
2989 s
+= enclen(env
->enc
, s
);
3004 if (node
!= quant
) {
3005 NODE_BODY(node
) = 0;
3006 onig_node_free(node
);
3008 NODE_BODY(quant
) = NULL_NODE
;
3015 make_absent_tree_for_simple_one_char_repeat(Node
** node
, Node
* absent
, Node
* quant
,
3016 Node
* body
, int possessive
, ScanEnv
* env
)
3027 ns
[0] = ns
[1] = NULL_NODE
;
3028 ns
[2] = body
, ns
[3] = absent
;
3030 lower
= QUANT_(quant
)->lower
;
3031 upper
= QUANT_(quant
)->upper
;
3032 onig_node_free(quant
);
3034 r
= node_new_save_gimmick(&ns
[0], SAVE_RIGHT_RANGE
, env
);
3035 if (r
!= 0) goto err
;
3037 id1
= GIMMICK_(ns
[0])->id
;
3039 r
= make_absent_engine(&ns
[1], id1
, absent
, body
, lower
, upper
, possessive
,
3041 if (r
!= 0) goto err
;
3043 ns
[2] = ns
[3] = NULL_NODE
;
3045 r
= node_new_update_var_gimmick(&ns
[2], UPDATE_VAR_RIGHT_RANGE_FROM_STACK
,
3047 if (r
!= 0) goto err
;
3049 x
= make_list(3, ns
);
3050 if (IS_NULL(x
)) goto err0
;
3058 for (i
= 0; i
< 4; i
++) onig_node_free(ns
[i
]);
3063 make_absent_tree(Node
** node
, Node
* absent
, Node
* expr
, int is_range_cutter
,
3074 for (i
= 0; i
< 7; i
++) ns
[i
] = NULL_NODE
;
3075 ns
[4] = expr
; ns
[5] = absent
;
3077 if (is_range_cutter
== 0) {
3081 if (expr
== NULL_NODE
) {
3082 /* default expr \O* */
3083 quant
= node_new_quantifier(0, INFINITE_REPEAT
, 0);
3084 if (IS_NULL(quant
)) goto err0
;
3086 r
= node_new_true_anychar(&body
, env
);
3088 onig_node_free(quant
);
3095 if (is_simple_one_char_repeat(expr
, &quant
, &body
, &possessive
, env
)) {
3097 r
= make_absent_tree_for_simple_one_char_repeat(node
, absent
, quant
,
3098 body
, possessive
, env
);
3101 onig_node_free(quant
);
3102 onig_node_free(body
);
3111 r
= node_new_save_gimmick(&ns
[0], SAVE_RIGHT_RANGE
, env
);
3112 if (r
!= 0) goto err
;
3114 id1
= GIMMICK_(ns
[0])->id
;
3116 r
= node_new_save_gimmick(&ns
[1], SAVE_S
, env
);
3117 if (r
!= 0) goto err
;
3119 id2
= GIMMICK_(ns
[1])->id
;
3121 r
= node_new_true_anychar(&ns
[3], env
);
3122 if (r
!= 0) goto err
;
3125 r
= make_absent_engine(&ns
[2], id1
, absent
, ns
[3], 0, INFINITE_REPEAT
,
3126 possessive
, is_range_cutter
, env
);
3127 if (r
!= 0) goto err
;
3132 r
= node_new_update_var_gimmick(&ns
[3], UPDATE_VAR_S_FROM_STACK
, id2
, env
);
3133 if (r
!= 0) goto err
;
3135 if (is_range_cutter
!= 0) {
3136 x
= make_list(4, ns
);
3137 if (IS_NULL(x
)) goto err0
;
3140 r
= make_absent_tail(&ns
[5], &ns
[6], id1
, env
);
3141 if (r
!= 0) goto err
;
3143 x
= make_list(7, ns
);
3144 if (IS_NULL(x
)) goto err0
;
3153 for (i
= 0; i
< 7; i
++) onig_node_free(ns
[i
]);
3158 onig_node_str_cat(Node
* node
, const UChar
* s
, const UChar
* end
)
3160 int addlen
= (int )(end
- s
);
3163 int len
= (int )(STR_(node
)->end
- STR_(node
)->s
);
3165 if (STR_(node
)->capacity
> 0 || (len
+ addlen
> NODE_STRING_BUF_SIZE
- 1)) {
3167 int capa
= len
+ addlen
+ NODE_STRING_MARGIN
;
3169 if (capa
<= STR_(node
)->capacity
) {
3170 onig_strcpy(STR_(node
)->s
+ len
, s
, end
);
3173 if (STR_(node
)->s
== STR_(node
)->buf
)
3174 p
= strcat_capa_from_static(STR_(node
)->s
, STR_(node
)->end
,
3177 p
= strcat_capa(STR_(node
)->s
, STR_(node
)->end
, s
, end
, capa
, STR_(node
)->capacity
);
3179 CHECK_NULL_RETURN_MEMERR(p
);
3181 STR_(node
)->capacity
= capa
;
3185 onig_strcpy(STR_(node
)->s
+ len
, s
, end
);
3187 STR_(node
)->end
= STR_(node
)->s
+ len
+ addlen
;
3194 onig_node_str_set(Node
* node
, const UChar
* s
, const UChar
* end
)
3196 onig_node_str_clear(node
);
3197 return onig_node_str_cat(node
, s
, end
);
3201 node_str_cat_char(Node
* node
, UChar c
)
3206 return onig_node_str_cat(node
, s
, s
+ 1);
3210 onig_node_conv_to_str_node(Node
* node
, int flag
)
3212 NODE_SET_TYPE(node
, NODE_STRING
);
3213 STR_(node
)->flag
= flag
;
3214 STR_(node
)->capacity
= 0;
3215 STR_(node
)->s
= STR_(node
)->buf
;
3216 STR_(node
)->end
= STR_(node
)->buf
;
3220 onig_node_str_clear(Node
* node
)
3222 if (STR_(node
)->capacity
!= 0 &&
3223 IS_NOT_NULL(STR_(node
)->s
) && STR_(node
)->s
!= STR_(node
)->buf
) {
3224 xfree(STR_(node
)->s
);
3227 STR_(node
)->capacity
= 0;
3228 STR_(node
)->flag
= 0;
3229 STR_(node
)->s
= STR_(node
)->buf
;
3230 STR_(node
)->end
= STR_(node
)->buf
;
3234 node_new_str(const UChar
* s
, const UChar
* end
)
3236 Node
* node
= node_new();
3237 CHECK_NULL_RETURN(node
);
3239 NODE_SET_TYPE(node
, NODE_STRING
);
3240 STR_(node
)->capacity
= 0;
3241 STR_(node
)->flag
= 0;
3242 STR_(node
)->s
= STR_(node
)->buf
;
3243 STR_(node
)->end
= STR_(node
)->buf
;
3244 if (onig_node_str_cat(node
, s
, end
)) {
3245 onig_node_free(node
);
3252 onig_node_new_str(const UChar
* s
, const UChar
* end
)
3254 return node_new_str(s
, end
);
3258 node_new_str_raw(UChar
* s
, UChar
* end
)
3260 Node
* node
= node_new_str(s
, end
);
3261 CHECK_NULL_RETURN(node
);
3262 NODE_STRING_SET_RAW(node
);
3267 node_new_empty(void)
3269 return node_new_str(NULL
, NULL
);
3273 node_new_str_raw_char(UChar c
)
3280 node
= node_new_str_raw(p
, p
+ 1);
3281 CHECK_NULL_RETURN(node
);
3283 /* clear buf tail */
3284 for (i
= 1; i
< NODE_STRING_BUF_SIZE
; i
++)
3285 STR_(node
)->buf
[i
] = '\0';
3291 str_node_split_last_char(Node
* node
, OnigEncoding enc
)
3299 if (sn
->end
> sn
->s
) {
3300 p
= onigenc_get_prev_char_head(enc
, sn
->s
, sn
->end
);
3301 if (p
&& p
> sn
->s
) { /* can be split. */
3302 rn
= node_new_str(p
, sn
->end
);
3303 CHECK_NULL_RETURN(rn
);
3304 if (NODE_STRING_IS_RAW(node
))
3305 NODE_STRING_SET_RAW(rn
);
3307 sn
->end
= (UChar
* )p
;
3314 str_node_can_be_split(Node
* node
, OnigEncoding enc
)
3316 StrNode
* sn
= STR_(node
);
3317 if (sn
->end
> sn
->s
) {
3318 return ((enclen(enc
, sn
->s
) < sn
->end
- sn
->s
) ? 1 : 0);
3324 onig_scan_unsigned_number(UChar
** src
, const UChar
* end
, OnigEncoding enc
)
3326 unsigned int num
, val
;
3334 if (IS_CODE_DIGIT_ASCII(enc
, c
)) {
3335 val
= (unsigned int )DIGITVAL(c
);
3336 if ((INT_MAX_LIMIT
- val
) / 10UL < num
)
3337 return -1; /* overflow */
3339 num
= num
* 10 + val
;
3351 scan_unsigned_hexadecimal_number(UChar
** src
, UChar
* end
, int minlen
,
3352 int maxlen
, OnigEncoding enc
)
3355 unsigned int num
, val
;
3362 while (! PEND
&& n
< maxlen
) {
3364 if (IS_CODE_XDIGIT_ASCII(enc
, c
)) {
3366 val
= (unsigned int )XDIGITVAL(enc
,c
);
3367 if ((INT_MAX_LIMIT
- val
) / 16UL < num
)
3368 return ONIGERR_TOO_BIG_NUMBER
; /* overflow */
3370 num
= (num
<< 4) + XDIGITVAL(enc
,c
);
3379 return ONIGERR_INVALID_CODE_POINT_VALUE
;
3386 scan_unsigned_octal_number(UChar
** src
, UChar
* end
, int maxlen
,
3390 unsigned int num
, val
;
3395 while (! PEND
&& maxlen
-- != 0) {
3397 if (IS_CODE_DIGIT_ASCII(enc
, c
) && c
< '8') {
3399 if ((INT_MAX_LIMIT
- val
) / 8UL < num
)
3400 return -1; /* overflow */
3402 num
= (num
<< 3) + val
;
3414 #define BB_WRITE_CODE_POINT(bbuf,pos,code) \
3415 BB_WRITE(bbuf, pos, &(code), SIZE_CODE_POINT)
3418 [n][from-1][to-1][from-2][to-2] ... [from-n][to-n]
3419 (all data size is OnigCodePoint)
3422 new_code_range(BBuf
** pbuf
)
3424 #define INIT_MULTI_BYTE_RANGE_SIZE (SIZE_CODE_POINT * 5)
3429 bbuf
= *pbuf
= (BBuf
* )xmalloc(sizeof(BBuf
));
3430 CHECK_NULL_RETURN_MEMERR(bbuf
);
3431 r
= BB_INIT(bbuf
, INIT_MULTI_BYTE_RANGE_SIZE
);
3439 BB_WRITE_CODE_POINT(bbuf
, 0, n
);
3444 add_code_range_to_buf(BBuf
** pbuf
, OnigCodePoint from
, OnigCodePoint to
)
3447 int low
, high
, bound
, x
;
3448 OnigCodePoint n
, *data
;
3452 n
= from
; from
= to
; to
= n
;
3455 if (IS_NULL(*pbuf
)) {
3456 r
= new_code_range(pbuf
);
3457 if (r
!= 0) return r
;
3463 GET_CODE_POINT(n
, bbuf
->p
);
3465 data
= (OnigCodePoint
* )(bbuf
->p
);
3468 for (low
= 0, bound
= n
; low
< bound
; ) {
3469 x
= (low
+ bound
) >> 1;
3470 if (from
> data
[x
*2 + 1])
3476 high
= (to
== ~((OnigCodePoint
)0)) ? n
: low
;
3477 for (bound
= n
; high
< bound
; ) {
3478 x
= (high
+ bound
) >> 1;
3479 if (to
+ 1 >= data
[x
*2])
3485 inc_n
= low
+ 1 - high
;
3486 if (n
+ inc_n
> ONIG_MAX_MULTI_BYTE_RANGES_NUM
)
3487 return ONIGERR_TOO_MANY_MULTI_BYTE_RANGES
;
3490 if (from
> data
[low
*2])
3492 if (to
< data
[(high
- 1)*2 + 1])
3493 to
= data
[(high
- 1)*2 + 1];
3496 if (inc_n
!= 0 && (OnigCodePoint
)high
< n
) {
3497 int from_pos
= SIZE_CODE_POINT
* (1 + high
* 2);
3498 int to_pos
= SIZE_CODE_POINT
* (1 + (low
+ 1) * 2);
3499 int size
= (n
- high
) * 2 * SIZE_CODE_POINT
;
3502 BB_MOVE_RIGHT(bbuf
, from_pos
, to_pos
, size
);
3505 BB_MOVE_LEFT_REDUCE(bbuf
, from_pos
, to_pos
);
3509 pos
= SIZE_CODE_POINT
* (1 + low
* 2);
3510 BB_ENSURE_SIZE(bbuf
, pos
+ SIZE_CODE_POINT
* 2);
3511 BB_WRITE_CODE_POINT(bbuf
, pos
, from
);
3512 BB_WRITE_CODE_POINT(bbuf
, pos
+ SIZE_CODE_POINT
, to
);
3514 BB_WRITE_CODE_POINT(bbuf
, 0, n
);
3520 add_code_range(BBuf
** pbuf
, ScanEnv
* env
, OnigCodePoint from
, OnigCodePoint to
)
3523 if (IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_ALLOW_EMPTY_RANGE_IN_CC
))
3526 return ONIGERR_EMPTY_RANGE_IN_CHAR_CLASS
;
3529 return add_code_range_to_buf(pbuf
, from
, to
);
3533 not_code_range_buf(OnigEncoding enc
, BBuf
* bbuf
, BBuf
** pbuf
)
3536 OnigCodePoint pre
, from
, *data
, to
= 0;
3538 *pbuf
= (BBuf
* )NULL
;
3539 if (IS_NULL(bbuf
)) {
3541 return SET_ALL_MULTI_BYTE_RANGE(enc
, pbuf
);
3544 data
= (OnigCodePoint
* )(bbuf
->p
);
3545 GET_CODE_POINT(n
, data
);
3547 if (n
<= 0) goto set_all
;
3550 pre
= MBCODE_START_POS(enc
);
3551 for (i
= 0; i
< n
; i
++) {
3554 if (pre
<= from
- 1) {
3555 r
= add_code_range_to_buf(pbuf
, pre
, from
- 1);
3556 if (r
!= 0) return r
;
3558 if (to
== ~((OnigCodePoint
)0)) break;
3561 if (to
< ~((OnigCodePoint
)0)) {
3562 r
= add_code_range_to_buf(pbuf
, to
+ 1, ~((OnigCodePoint
)0));
3567 #define SWAP_BB_NOT(bbuf1, not1, bbuf2, not2) do {\
3570 tnot = not1; not1 = not2; not2 = tnot; \
3571 tbuf = bbuf1; bbuf1 = bbuf2; bbuf2 = tbuf; \
3575 or_code_range_buf(OnigEncoding enc
, BBuf
* bbuf1
, int not1
,
3576 BBuf
* bbuf2
, int not2
, BBuf
** pbuf
)
3579 OnigCodePoint i
, n1
, *data1
;
3580 OnigCodePoint from
, to
;
3582 *pbuf
= (BBuf
* )NULL
;
3583 if (IS_NULL(bbuf1
) && IS_NULL(bbuf2
)) {
3584 if (not1
!= 0 || not2
!= 0)
3585 return SET_ALL_MULTI_BYTE_RANGE(enc
, pbuf
);
3591 SWAP_BB_NOT(bbuf1
, not1
, bbuf2
, not2
);
3593 if (IS_NULL(bbuf1
)) {
3595 return SET_ALL_MULTI_BYTE_RANGE(enc
, pbuf
);
3599 return bbuf_clone(pbuf
, bbuf2
);
3602 return not_code_range_buf(enc
, bbuf2
, pbuf
);
3608 SWAP_BB_NOT(bbuf1
, not1
, bbuf2
, not2
);
3610 data1
= (OnigCodePoint
* )(bbuf1
->p
);
3611 GET_CODE_POINT(n1
, data1
);
3614 if (not2
== 0 && not1
== 0) { /* 1 OR 2 */
3615 r
= bbuf_clone(pbuf
, bbuf2
);
3617 else if (not1
== 0) { /* 1 OR (not 2) */
3618 r
= not_code_range_buf(enc
, bbuf2
, pbuf
);
3620 if (r
!= 0) return r
;
3622 for (i
= 0; i
< n1
; i
++) {
3625 r
= add_code_range_to_buf(pbuf
, from
, to
);
3626 if (r
!= 0) return r
;
3632 and_code_range1(BBuf
** pbuf
, OnigCodePoint from1
, OnigCodePoint to1
,
3633 OnigCodePoint
* data
, int n
)
3636 OnigCodePoint from2
, to2
;
3638 for (i
= 0; i
< n
; i
++) {
3641 if (from2
< from1
) {
3642 if (to2
< from1
) continue;
3647 else if (from2
<= to1
) {
3649 if (from1
<= from2
- 1) {
3650 r
= add_code_range_to_buf(pbuf
, from1
, from2
-1);
3651 if (r
!= 0) return r
;
3662 if (from1
> to1
) break;
3665 r
= add_code_range_to_buf(pbuf
, from1
, to1
);
3666 if (r
!= 0) return r
;
3672 and_code_range_buf(BBuf
* bbuf1
, int not1
, BBuf
* bbuf2
, int not2
, BBuf
** pbuf
)
3675 OnigCodePoint i
, j
, n1
, n2
, *data1
, *data2
;
3676 OnigCodePoint from
, to
, from1
, to1
, from2
, to2
;
3678 *pbuf
= (BBuf
* )NULL
;
3679 if (IS_NULL(bbuf1
)) {
3680 if (not1
!= 0 && IS_NOT_NULL(bbuf2
)) /* not1 != 0 -> not2 == 0 */
3681 return bbuf_clone(pbuf
, bbuf2
);
3684 else if (IS_NULL(bbuf2
)) {
3686 return bbuf_clone(pbuf
, bbuf1
);
3691 SWAP_BB_NOT(bbuf1
, not1
, bbuf2
, not2
);
3693 data1
= (OnigCodePoint
* )(bbuf1
->p
);
3694 data2
= (OnigCodePoint
* )(bbuf2
->p
);
3695 GET_CODE_POINT(n1
, data1
);
3696 GET_CODE_POINT(n2
, data2
);
3700 if (not2
== 0 && not1
== 0) { /* 1 AND 2 */
3701 for (i
= 0; i
< n1
; i
++) {
3704 for (j
= 0; j
< n2
; j
++) {
3707 if (from2
> to1
) break;
3708 if (to2
< from1
) continue;
3709 from
= MAX(from1
, from2
);
3711 r
= add_code_range_to_buf(pbuf
, from
, to
);
3712 if (r
!= 0) return r
;
3716 else if (not1
== 0) { /* 1 AND (not 2) */
3717 for (i
= 0; i
< n1
; i
++) {
3720 r
= and_code_range1(pbuf
, from1
, to1
, data2
, n2
);
3721 if (r
!= 0) return r
;
3729 and_cclass(CClassNode
* dest
, CClassNode
* cc
, OnigEncoding enc
)
3732 BBuf
*buf1
, *buf2
, *pbuf
;
3733 BitSetRef bsr1
, bsr2
;
3736 not1
= IS_NCCLASS_NOT(dest
);
3739 not2
= IS_NCCLASS_NOT(cc
);
3744 bitset_invert_to(bsr1
, bs1
);
3748 bitset_invert_to(bsr2
, bs2
);
3751 bitset_and(bsr1
, bsr2
);
3752 if (bsr1
!= dest
->bs
) {
3753 bitset_copy(dest
->bs
, bsr1
);
3756 bitset_invert(dest
->bs
);
3759 if (! ONIGENC_IS_SINGLEBYTE(enc
)) {
3760 if (not1
!= 0 && not2
!= 0) {
3761 r
= or_code_range_buf(enc
, buf1
, 0, buf2
, 0, &pbuf
);
3764 r
= and_code_range_buf(buf1
, not1
, buf2
, not2
, &pbuf
);
3765 if (r
== 0 && not1
!= 0) {
3767 r
= not_code_range_buf(enc
, pbuf
, &tbuf
);
3776 if (r
!= 0) return r
;
3786 or_cclass(CClassNode
* dest
, CClassNode
* cc
, OnigEncoding enc
)
3789 BBuf
*buf1
, *buf2
, *pbuf
;
3790 BitSetRef bsr1
, bsr2
;
3793 not1
= IS_NCCLASS_NOT(dest
);
3796 not2
= IS_NCCLASS_NOT(cc
);
3801 bitset_invert_to(bsr1
, bs1
);
3805 bitset_invert_to(bsr2
, bs2
);
3808 bitset_or(bsr1
, bsr2
);
3809 if (bsr1
!= dest
->bs
) {
3810 bitset_copy(dest
->bs
, bsr1
);
3813 bitset_invert(dest
->bs
);
3816 if (! ONIGENC_IS_SINGLEBYTE(enc
)) {
3817 if (not1
!= 0 && not2
!= 0) {
3818 r
= and_code_range_buf(buf1
, 0, buf2
, 0, &pbuf
);
3821 r
= or_code_range_buf(enc
, buf1
, not1
, buf2
, not2
, &pbuf
);
3822 if (r
== 0 && not1
!= 0) {
3824 r
= not_code_range_buf(enc
, pbuf
, &tbuf
);
3833 if (r
!= 0) return r
;
3843 static OnigCodePoint
3844 conv_backslash_value(OnigCodePoint c
, ScanEnv
* env
)
3846 if (IS_SYNTAX_OP(env
->syntax
, ONIG_SYN_OP_ESC_CONTROL_CHARS
)) {
3848 case 'n': return '\n';
3849 case 't': return '\t';
3850 case 'r': return '\r';
3851 case 'f': return '\f';
3852 case 'a': return '\007';
3853 case 'b': return '\010';
3854 case 'e': return '\033';
3856 if (IS_SYNTAX_OP2(env
->syntax
, ONIG_SYN_OP2_ESC_V_VTAB
))
3868 is_invalid_quantifier_target(Node
* node
)
3870 switch (NODE_TYPE(node
)) {
3877 /* allow enclosed elements */
3878 /* return is_invalid_quantifier_target(NODE_BODY(node)); */
3883 if (! is_invalid_quantifier_target(NODE_CAR(node
))) return 0;
3884 } while (IS_NOT_NULL(node
= NODE_CDR(node
)));
3890 if (is_invalid_quantifier_target(NODE_CAR(node
))) return 1;
3891 } while (IS_NOT_NULL(node
= NODE_CDR(node
)));
3900 /* ?:0, *:1, +:2, ??:3, *?:4, +?:5 */
3902 quantifier_type_num(QuantNode
* q
)
3905 if (q
->lower
== 0) {
3906 if (q
->upper
== 1) return 0;
3907 else if (IS_INFINITE_REPEAT(q
->upper
)) return 1;
3909 else if (q
->lower
== 1) {
3910 if (IS_INFINITE_REPEAT(q
->upper
)) return 2;
3914 if (q
->lower
== 0) {
3915 if (q
->upper
== 1) return 3;
3916 else if (IS_INFINITE_REPEAT(q
->upper
)) return 4;
3918 else if (q
->lower
== 1) {
3919 if (IS_INFINITE_REPEAT(q
->upper
)) return 5;
3927 RQ_ASIS
= 0, /* as is */
3928 RQ_DEL
= 1, /* delete parent */
3930 RQ_AQ
, /* to '*?' */
3931 RQ_QQ
, /* to '??' */
3932 RQ_P_QQ
, /* to '+)??' */
3933 RQ_PQ_Q
/* to '+?)?' */
3936 static enum ReduceType ReduceTypeTable
[6][6] = {
3937 {RQ_DEL
, RQ_A
, RQ_A
, RQ_QQ
, RQ_AQ
, RQ_ASIS
}, /* '?' */
3938 {RQ_DEL
, RQ_DEL
, RQ_DEL
, RQ_P_QQ
, RQ_P_QQ
, RQ_DEL
}, /* '*' */
3939 {RQ_A
, RQ_A
, RQ_DEL
, RQ_ASIS
, RQ_P_QQ
, RQ_DEL
}, /* '+' */
3940 {RQ_DEL
, RQ_AQ
, RQ_AQ
, RQ_DEL
, RQ_AQ
, RQ_AQ
}, /* '??' */
3941 {RQ_DEL
, RQ_DEL
, RQ_DEL
, RQ_DEL
, RQ_DEL
, RQ_DEL
}, /* '*?' */
3942 {RQ_ASIS
, RQ_PQ_Q
, RQ_DEL
, RQ_AQ
, RQ_AQ
, RQ_DEL
} /* '+?' */
3946 onig_reduce_nested_quantifier(Node
* pnode
, Node
* cnode
)
3953 pnum
= quantifier_type_num(p
);
3954 cnum
= quantifier_type_num(c
);
3955 if (pnum
< 0 || cnum
< 0) {
3956 if ((p
->lower
== p
->upper
) && ! IS_INFINITE_REPEAT(p
->upper
)) {
3957 if ((c
->lower
== c
->upper
) && ! IS_INFINITE_REPEAT(c
->upper
)) {
3958 int n
= onig_positive_int_multiply(p
->lower
, c
->lower
);
3960 p
->lower
= p
->upper
= n
;
3961 NODE_BODY(pnode
) = NODE_BODY(cnode
);
3970 switch(ReduceTypeTable
[cnum
][pnum
]) {
3975 NODE_BODY(pnode
) = NODE_BODY(cnode
);
3976 p
->lower
= 0; p
->upper
= INFINITE_REPEAT
; p
->greedy
= 1;
3979 NODE_BODY(pnode
) = NODE_BODY(cnode
);
3980 p
->lower
= 0; p
->upper
= INFINITE_REPEAT
; p
->greedy
= 0;
3983 NODE_BODY(pnode
) = NODE_BODY(cnode
);
3984 p
->lower
= 0; p
->upper
= 1; p
->greedy
= 0;
3987 NODE_BODY(pnode
) = cnode
;
3988 p
->lower
= 0; p
->upper
= 1; p
->greedy
= 0;
3989 c
->lower
= 1; c
->upper
= INFINITE_REPEAT
; c
->greedy
= 1;
3993 NODE_BODY(pnode
) = cnode
;
3994 p
->lower
= 0; p
->upper
= 1; p
->greedy
= 1;
3995 c
->lower
= 1; c
->upper
= INFINITE_REPEAT
; c
->greedy
= 0;
3999 NODE_BODY(pnode
) = cnode
;
4005 NODE_BODY(cnode
) = NULL_NODE
;
4006 onig_node_free(cnode
);
4010 node_new_general_newline(Node
** node
, ScanEnv
* env
)
4014 UChar buf
[ONIGENC_CODE_TO_MBC_MAXLEN
* 2];
4020 dlen
= ONIGENC_CODE_TO_MBC(env
->enc
, 0x0d, buf
);
4021 if (dlen
< 0) return dlen
;
4022 alen
= ONIGENC_CODE_TO_MBC(env
->enc
, 0x0a, buf
+ dlen
);
4023 if (alen
< 0) return alen
;
4025 crnl
= node_new_str_raw(buf
, buf
+ dlen
+ alen
);
4026 CHECK_NULL_RETURN_MEMERR(crnl
);
4028 ncc
= node_new_cclass();
4029 if (IS_NULL(ncc
)) goto err2
;
4033 bitset_set_range(cc
->bs
, 0x0a, 0x0d);
4036 r
= add_code_range(&(cc
->mbuf
), env
, 0x0a, 0x0d);
4039 onig_node_free(ncc
);
4041 onig_node_free(crnl
);
4042 return ONIGERR_MEMORY
;
4046 if (ONIGENC_IS_UNICODE_ENCODING(env
->enc
)) {
4047 r
= add_code_range(&(cc
->mbuf
), env
, 0x85, 0x85);
4048 if (r
!= 0) goto err1
;
4049 r
= add_code_range(&(cc
->mbuf
), env
, 0x2028, 0x2029);
4050 if (r
!= 0) goto err1
;
4053 x
= node_new_bag_if_else(crnl
, 0, ncc
);
4054 if (IS_NULL(x
)) goto err1
;
4061 TK_EOT
= 0, /* end of token */
4073 TK_ANYCHAR_ANYTIME
, /* SQL '%' == .* */
4079 TK_CHAR_PROPERTY
, /* \p{...}, \P{...} */
4081 TK_GENERAL_NEWLINE
, /* \R */
4082 TK_NO_NEWLINE
, /* \N */
4083 TK_TRUE_ANYCHAR
, /* \O */
4084 TK_TEXT_SEGMENT
, /* \X */
4089 TK_POSIX_BRACKET_OPEN
,
4091 TK_CC_CC_OPEN
/* [ */
4095 enum TokenSyms type
;
4097 int base
; /* is number: 8, 16 (used in [....]) */
4116 #ifdef USE_BACKREF_WITH_LEVEL
4118 int level
; /* \k<name+n> */
4136 fetch_interval_quantifier(UChar
** src
, UChar
* end
, PToken
* tok
, ScanEnv
* env
)
4138 int low
, up
, syn_allow
, non_low
= 0;
4141 OnigEncoding enc
= env
->enc
;
4145 syn_allow
= IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_ALLOW_INVALID_INTERVAL
);
4149 return 1; /* "....{" : OK! */
4151 return ONIGERR_END_PATTERN_AT_LEFT_BRACE
; /* "....{" syntax error */
4156 if (c
== ')' || c
== '(' || c
== '|') {
4157 return ONIGERR_END_PATTERN_AT_LEFT_BRACE
;
4161 low
= onig_scan_unsigned_number(&p
, end
, env
->enc
);
4162 if (low
< 0) return ONIGERR_TOO_BIG_NUMBER_FOR_REPEAT_RANGE
;
4163 if (low
> ONIG_MAX_REPEAT_NUM
)
4164 return ONIGERR_TOO_BIG_NUMBER_FOR_REPEAT_RANGE
;
4166 if (p
== *src
) { /* can't read low */
4167 if (IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_ALLOW_INTERVAL_LOW_ABBREV
)) {
4168 /* allow {,n} as {0,n} */
4176 if (PEND
) goto invalid
;
4180 up
= onig_scan_unsigned_number(&p
, end
, env
->enc
);
4181 if (up
< 0) return ONIGERR_TOO_BIG_NUMBER_FOR_REPEAT_RANGE
;
4182 if (up
> ONIG_MAX_REPEAT_NUM
)
4183 return ONIGERR_TOO_BIG_NUMBER_FOR_REPEAT_RANGE
;
4188 up
= INFINITE_REPEAT
; /* {n,} : {n,infinite} */
4196 up
= low
; /* {n} : exact n times */
4200 if (PEND
) goto invalid
;
4202 if (IS_SYNTAX_OP(env
->syntax
, ONIG_SYN_OP_ESC_BRACE_INTERVAL
)) {
4203 if (c
!= MC_ESC(env
->syntax
)) goto invalid
;
4206 if (c
!= '}') goto invalid
;
4208 if (!IS_INFINITE_REPEAT(up
) && low
> up
) {
4209 /* {n,m}+ supported case */
4210 if (IS_SYNTAX_OP2(env
->syntax
, ONIG_SYN_OP2_PLUS_POSSESSIVE_INTERVAL
))
4211 return ONIGERR_UPPER_SMALLER_THAN_LOWER_IN_REPEAT_RANGE
;
4213 tok
->u
.repeat
.possessive
= 1;
4216 tmp
= low
; low
= up
; up
= tmp
;
4220 tok
->u
.repeat
.possessive
= 0;
4222 tok
->type
= TK_INTERVAL
;
4223 tok
->u
.repeat
.lower
= low
;
4224 tok
->u
.repeat
.upper
= up
;
4226 return r
; /* 0: normal {n,m}, 2: fixed {n} */
4230 /* *src = p; */ /* !!! Don't do this line !!! */
4234 return ONIGERR_INVALID_REPEAT_RANGE_PATTERN
;
4237 /* \M-, \C-, \c, or \... */
4239 fetch_escaped_value(UChar
** src
, UChar
* end
, ScanEnv
* env
, OnigCodePoint
* val
)
4243 OnigEncoding enc
= env
->enc
;
4246 if (PEND
) return ONIGERR_END_PATTERN_AT_ESCAPE
;
4251 if (IS_SYNTAX_OP2(env
->syntax
, ONIG_SYN_OP2_ESC_CAPITAL_M_BAR_META
)) {
4252 if (PEND
) return ONIGERR_END_PATTERN_AT_META
;
4254 if (c
!= '-') return ONIGERR_META_CODE_SYNTAX
;
4255 if (PEND
) return ONIGERR_END_PATTERN_AT_META
;
4257 if (c
== MC_ESC(env
->syntax
)) {
4258 v
= fetch_escaped_value(&p
, end
, env
, &c
);
4259 if (v
< 0) return v
;
4261 c
= ((c
& 0xff) | 0x80);
4268 if (IS_SYNTAX_OP2(env
->syntax
, ONIG_SYN_OP2_ESC_CAPITAL_C_BAR_CONTROL
)) {
4269 if (PEND
) return ONIGERR_END_PATTERN_AT_CONTROL
;
4271 if (c
!= '-') return ONIGERR_CONTROL_CODE_SYNTAX
;
4278 if (IS_SYNTAX_OP(env
->syntax
, ONIG_SYN_OP_ESC_C_CONTROL
)) {
4280 if (PEND
) return ONIGERR_END_PATTERN_AT_CONTROL
;
4286 if (c
== MC_ESC(env
->syntax
)) {
4287 v
= fetch_escaped_value(&p
, end
, env
, &c
);
4288 if (v
< 0) return v
;
4299 c
= conv_backslash_value(c
, env
);
4309 static int fetch_token(PToken
* tok
, UChar
** src
, UChar
* end
, ScanEnv
* env
);
4311 static OnigCodePoint
4312 get_name_end_code_point(OnigCodePoint start
)
4315 case '<': return (OnigCodePoint
)'>'; break;
4316 case '\'': return (OnigCodePoint
)'\''; break;
4317 case '(': return (OnigCodePoint
)')'; break;
4322 return (OnigCodePoint
)0;
4331 #ifdef USE_BACKREF_WITH_LEVEL
4333 \k<name+n>, \k<name-n>
4334 \k<num+n>, \k<num-n>
4335 \k<-num+n>, \k<-num-n>
4336 \k<+num+n>, \k<+num-n>
4339 fetch_name_with_level(OnigCodePoint start_code
, UChar
** src
, UChar
* end
,
4340 UChar
** rname_end
, ScanEnv
* env
,
4341 int* rback_num
, int* rlevel
, enum REF_NUM
* num_type
)
4343 int r
, sign
, exist_level
;
4345 OnigCodePoint end_code
;
4346 OnigCodePoint c
= 0;
4347 OnigEncoding enc
= env
->enc
;
4355 *num_type
= IS_NOT_NUM
;
4359 end_code
= get_name_end_code_point(start_code
);
4365 return ONIGERR_EMPTY_GROUP_NAME
;
4370 return ONIGERR_EMPTY_GROUP_NAME
;
4372 if (IS_CODE_DIGIT_ASCII(enc
, c
)) {
4373 *num_type
= IS_ABS_NUM
;
4376 else if (c
== '-') {
4377 *num_type
= IS_REL_NUM
;
4381 else if (c
== '+') {
4382 *num_type
= IS_REL_NUM
;
4386 else if (!ONIGENC_IS_CODE_WORD(enc
, c
)) {
4387 r
= ONIGERR_INVALID_CHAR_IN_GROUP_NAME
;
4394 if (c
== end_code
|| c
== ')' || c
== '+' || c
== '-') {
4395 if (*num_type
!= IS_NOT_NUM
&& digit_count
== 0)
4396 r
= ONIGERR_INVALID_GROUP_NAME
;
4400 if (*num_type
!= IS_NOT_NUM
) {
4401 if (IS_CODE_DIGIT_ASCII(enc
, c
)) {
4405 r
= ONIGERR_INVALID_GROUP_NAME
;
4406 *num_type
= IS_NOT_NUM
;
4409 else if (!ONIGENC_IS_CODE_WORD(enc
, c
)) {
4410 r
= ONIGERR_INVALID_CHAR_IN_GROUP_NAME
;
4414 if (r
== 0 && c
!= end_code
) {
4415 if (c
== '+' || c
== '-') {
4417 int flag
= (c
== '-' ? -1 : 1);
4420 r
= ONIGERR_INVALID_CHAR_IN_GROUP_NAME
;
4424 if (! IS_CODE_DIGIT_ASCII(enc
, c
)) goto err
;
4426 level
= onig_scan_unsigned_number(&p
, end
, enc
);
4427 if (level
< 0) return ONIGERR_TOO_BIG_NUMBER
;
4428 *rlevel
= (level
* flag
);
4441 r
= ONIGERR_INVALID_GROUP_NAME
;
4446 if (*num_type
!= IS_NOT_NUM
) {
4447 *rback_num
= onig_scan_unsigned_number(&pnum_head
, name_end
, enc
);
4448 if (*rback_num
< 0) return ONIGERR_TOO_BIG_NUMBER
;
4449 else if (*rback_num
== 0) {
4450 if (*num_type
== IS_REL_NUM
)
4457 *rname_end
= name_end
;
4459 return (exist_level
? 1 : 0);
4462 onig_scan_env_set_error_string(env
, r
, *src
, name_end
);
4466 #endif /* USE_BACKREF_WITH_LEVEL */
4469 ref: 0 -> define name (don't allow number name)
4470 1 -> reference name (allow number name)
4473 fetch_name(OnigCodePoint start_code
, UChar
** src
, UChar
* end
,
4474 UChar
** rname_end
, ScanEnv
* env
, int* rback_num
,
4475 enum REF_NUM
* num_type
, int ref
)
4479 OnigCodePoint end_code
;
4480 OnigCodePoint c
= 0;
4481 OnigEncoding enc
= env
->enc
;
4488 end_code
= get_name_end_code_point(start_code
);
4494 *num_type
= IS_NOT_NUM
;
4497 return ONIGERR_EMPTY_GROUP_NAME
;
4502 return ONIGERR_EMPTY_GROUP_NAME
;
4504 if (IS_CODE_DIGIT_ASCII(enc
, c
)) {
4506 *num_type
= IS_ABS_NUM
;
4508 r
= ONIGERR_INVALID_GROUP_NAME
;
4512 else if (c
== '-') {
4514 *num_type
= IS_REL_NUM
;
4519 r
= ONIGERR_INVALID_GROUP_NAME
;
4522 else if (c
== '+') {
4524 *num_type
= IS_REL_NUM
;
4529 r
= ONIGERR_INVALID_GROUP_NAME
;
4532 else if (!ONIGENC_IS_CODE_WORD(enc
, c
)) {
4533 r
= ONIGERR_INVALID_CHAR_IN_GROUP_NAME
;
4541 if (c
== end_code
|| c
== ')') {
4542 if (*num_type
!= IS_NOT_NUM
&& digit_count
== 0)
4543 r
= ONIGERR_INVALID_GROUP_NAME
;
4547 if (*num_type
!= IS_NOT_NUM
) {
4548 if (IS_CODE_DIGIT_ASCII(enc
, c
)) {
4552 if (!ONIGENC_IS_CODE_WORD(enc
, c
))
4553 r
= ONIGERR_INVALID_CHAR_IN_GROUP_NAME
;
4555 r
= ONIGERR_INVALID_GROUP_NAME
;
4557 *num_type
= IS_NOT_NUM
;
4561 if (!ONIGENC_IS_CODE_WORD(enc
, c
)) {
4562 r
= ONIGERR_INVALID_CHAR_IN_GROUP_NAME
;
4567 if (c
!= end_code
) {
4568 r
= ONIGERR_INVALID_GROUP_NAME
;
4572 if (*num_type
!= IS_NOT_NUM
) {
4573 *rback_num
= onig_scan_unsigned_number(&pnum_head
, name_end
, enc
);
4574 if (*rback_num
< 0) return ONIGERR_TOO_BIG_NUMBER
;
4575 else if (*rback_num
== 0) {
4576 if (*num_type
== IS_REL_NUM
) {
4577 r
= ONIGERR_INVALID_GROUP_NAME
;
4585 *rname_end
= name_end
;
4593 if (c
== end_code
|| c
== ')')
4600 onig_scan_env_set_error_string(env
, r
, *src
, name_end
);
4606 CC_ESC_WARN(ScanEnv
* env
, UChar
*c
)
4608 if (onig_warn
== onig_null_warn
) return ;
4610 if (IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_WARN_CC_OP_NOT_ESCAPED
) &&
4611 IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_BACKSLASH_ESCAPE_IN_CC
)) {
4612 UChar buf
[WARN_BUFSIZE
];
4613 onig_snprintf_with_pattern(buf
, WARN_BUFSIZE
, env
->enc
,
4614 env
->pattern
, env
->pattern_end
,
4615 (UChar
* )"character class has '%s' without escape",
4617 (*onig_warn
)((char* )buf
);
4622 CLOSE_BRACKET_WITHOUT_ESC_WARN(ScanEnv
* env
, UChar
* c
)
4624 if (onig_warn
== onig_null_warn
) return ;
4626 if (IS_SYNTAX_BV((env
)->syntax
, ONIG_SYN_WARN_CC_OP_NOT_ESCAPED
)) {
4627 UChar buf
[WARN_BUFSIZE
];
4628 onig_snprintf_with_pattern(buf
, WARN_BUFSIZE
, (env
)->enc
,
4629 (env
)->pattern
, (env
)->pattern_end
,
4630 (UChar
* )"regular expression has '%s' without escape", c
);
4631 (*onig_warn
)((char* )buf
);
4636 find_str_position(OnigCodePoint s
[], int n
, UChar
* from
, UChar
* to
,
4637 UChar
**next
, OnigEncoding enc
)
4645 x
= ONIGENC_MBC_TO_CODE(enc
, p
, to
);
4646 q
= p
+ enclen(enc
, p
);
4648 for (i
= 1; i
< n
&& q
< to
; i
++) {
4649 x
= ONIGENC_MBC_TO_CODE(enc
, q
, to
);
4650 if (x
!= s
[i
]) break;
4651 q
+= enclen(enc
, q
);
4654 if (IS_NOT_NULL(next
))
4665 str_exist_check_with_esc(OnigCodePoint s
[], int n
, UChar
* from
, UChar
* to
,
4666 OnigCodePoint bad
, OnigEncoding enc
, OnigSyntaxType
* syn
)
4677 p
+= enclen(enc
, p
);
4680 x
= ONIGENC_MBC_TO_CODE(enc
, p
, to
);
4681 q
= p
+ enclen(enc
, p
);
4683 for (i
= 1; i
< n
&& q
< to
; i
++) {
4684 x
= ONIGENC_MBC_TO_CODE(enc
, q
, to
);
4685 if (x
!= s
[i
]) break;
4686 q
+= enclen(enc
, q
);
4688 if (i
>= n
) return 1;
4689 p
+= enclen(enc
, p
);
4692 x
= ONIGENC_MBC_TO_CODE(enc
, p
, to
);
4693 if (x
== bad
) return 0;
4694 else if (x
== MC_ESC(syn
)) in_esc
= 1;
4703 fetch_token_in_cc(PToken
* tok
, UChar
** src
, UChar
* end
, ScanEnv
* env
)
4706 OnigCodePoint c
, c2
;
4707 OnigSyntaxType
* syn
= env
->syntax
;
4708 OnigEncoding enc
= env
->enc
;
4719 tok
->type
= TK_CHAR
;
4725 tok
->type
= TK_CC_CLOSE
;
4727 else if (c
== '-') {
4728 tok
->type
= TK_CC_RANGE
;
4730 else if (c
== MC_ESC(syn
)) {
4731 if (! IS_SYNTAX_BV(syn
, ONIG_SYN_BACKSLASH_ESCAPE_IN_CC
))
4734 if (PEND
) return ONIGERR_END_PATTERN_AT_ESCAPE
;
4741 tok
->type
= TK_CHAR_TYPE
;
4742 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_WORD
;
4743 tok
->u
.prop
.not = 0;
4746 tok
->type
= TK_CHAR_TYPE
;
4747 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_WORD
;
4748 tok
->u
.prop
.not = 1;
4751 tok
->type
= TK_CHAR_TYPE
;
4752 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_DIGIT
;
4753 tok
->u
.prop
.not = 0;
4756 tok
->type
= TK_CHAR_TYPE
;
4757 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_DIGIT
;
4758 tok
->u
.prop
.not = 1;
4761 tok
->type
= TK_CHAR_TYPE
;
4762 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_SPACE
;
4763 tok
->u
.prop
.not = 0;
4766 tok
->type
= TK_CHAR_TYPE
;
4767 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_SPACE
;
4768 tok
->u
.prop
.not = 1;
4771 if (! IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_H_XDIGIT
)) break;
4772 tok
->type
= TK_CHAR_TYPE
;
4773 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_XDIGIT
;
4774 tok
->u
.prop
.not = 0;
4777 if (! IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_H_XDIGIT
)) break;
4778 tok
->type
= TK_CHAR_TYPE
;
4779 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_XDIGIT
;
4780 tok
->u
.prop
.not = 1;
4789 IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_P_BRACE_CHAR_PROPERTY
)) {
4791 tok
->type
= TK_CHAR_PROPERTY
;
4792 tok
->u
.prop
.not = c
== 'P';
4794 if (!PEND
&& IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_P_BRACE_CIRCUMFLEX_NOT
)) {
4797 tok
->u
.prop
.not = tok
->u
.prop
.not == 0;
4809 if (PPEEK_IS('{') && IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_O_BRACE_OCTAL
)) {
4811 num
= scan_unsigned_octal_number(&p
, end
, 11, enc
);
4812 if (num
< 0) return ONIGERR_TOO_BIG_WIDE_CHAR_VALUE
;
4815 if (IS_CODE_DIGIT_ASCII(enc
, c2
))
4816 return ONIGERR_TOO_LONG_WIDE_CHAR_VALUE
;
4819 if (p
> prev
+ enclen(enc
, prev
) && !PEND
&& (PPEEK_IS('}'))) {
4821 tok
->type
= TK_CODE_POINT
;
4823 tok
->u
.code
= (OnigCodePoint
)num
;
4826 /* can't read nothing or invalid format */
4836 if (PPEEK_IS('{') && IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_X_BRACE_HEX8
)) {
4838 num
= scan_unsigned_hexadecimal_number(&p
, end
, 0, 8, enc
);
4840 if (num
== ONIGERR_TOO_BIG_NUMBER
)
4841 return ONIGERR_TOO_BIG_WIDE_CHAR_VALUE
;
4847 if (IS_CODE_XDIGIT_ASCII(enc
, c2
))
4848 return ONIGERR_TOO_LONG_WIDE_CHAR_VALUE
;
4851 if (p
> prev
+ enclen(enc
, prev
) && !PEND
&& (PPEEK_IS('}'))) {
4853 tok
->type
= TK_CODE_POINT
;
4855 tok
->u
.code
= (OnigCodePoint
)num
;
4858 /* can't read nothing or invalid format */
4862 else if (IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_X_HEX2
)) {
4863 num
= scan_unsigned_hexadecimal_number(&p
, end
, 0, 2, enc
);
4864 if (num
< 0) return num
;
4865 if (p
== prev
) { /* can't read nothing. */
4866 num
= 0; /* but, it's not error */
4868 tok
->type
= TK_RAW_BYTE
;
4878 if (IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_U_HEX4
)) {
4879 num
= scan_unsigned_hexadecimal_number(&p
, end
, 4, 4, enc
);
4880 if (num
< 0) return num
;
4881 if (p
== prev
) { /* can't read nothing. */
4882 num
= 0; /* but, it's not error */
4884 tok
->type
= TK_CODE_POINT
;
4886 tok
->u
.code
= (OnigCodePoint
)num
;
4891 case '1': case '2': case '3': case '4': case '5': case '6': case '7':
4892 if (IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_OCTAL3
)) {
4895 num
= scan_unsigned_octal_number(&p
, end
, 3, enc
);
4896 if (num
< 0 || num
>= 256) return ONIGERR_TOO_BIG_NUMBER
;
4897 if (p
== prev
) { /* can't read nothing. */
4898 num
= 0; /* but, it's not error */
4900 tok
->type
= TK_RAW_BYTE
;
4908 num
= fetch_escaped_value(&p
, end
, env
, &c2
);
4909 if (num
< 0) return num
;
4910 if (tok
->u
.c
!= c2
) {
4912 tok
->type
= TK_CODE_POINT
;
4917 else if (c
== '[') {
4918 if (IS_SYNTAX_OP(syn
, ONIG_SYN_OP_POSIX_BRACKET
) && (PPEEK_IS(':'))) {
4919 OnigCodePoint send
[] = { (OnigCodePoint
)':', (OnigCodePoint
)']' };
4920 tok
->backp
= p
; /* point at '[' is read */
4922 if (str_exist_check_with_esc(send
, 2, p
, end
,
4923 (OnigCodePoint
)']', enc
, syn
)) {
4924 tok
->type
= TK_POSIX_BRACKET_OPEN
;
4933 if (IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_CCLASS_SET_OP
)) {
4934 tok
->type
= TK_CC_CC_OPEN
;
4937 CC_ESC_WARN(env
, (UChar
* )"[");
4941 else if (c
== '&') {
4942 if (IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_CCLASS_SET_OP
) &&
4943 !PEND
&& (PPEEK_IS('&'))) {
4945 tok
->type
= TK_CC_AND
;
4955 fetch_token(PToken
* tok
, UChar
** src
, UChar
* end
, ScanEnv
* env
)
4959 OnigEncoding enc
= env
->enc
;
4960 OnigSyntaxType
* syn
= env
->syntax
;
4971 tok
->type
= TK_STRING
;
4976 if (IS_MC_ESC_CODE(c
, syn
)) {
4977 if (PEND
) return ONIGERR_END_PATTERN_AT_ESCAPE
;
4986 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_ASTERISK_ZERO_INF
)) break;
4987 tok
->type
= TK_REPEAT
;
4988 tok
->u
.repeat
.lower
= 0;
4989 tok
->u
.repeat
.upper
= INFINITE_REPEAT
;
4994 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_PLUS_ONE_INF
)) break;
4995 tok
->type
= TK_REPEAT
;
4996 tok
->u
.repeat
.lower
= 1;
4997 tok
->u
.repeat
.upper
= INFINITE_REPEAT
;
5002 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_QMARK_ZERO_ONE
)) break;
5003 tok
->type
= TK_REPEAT
;
5004 tok
->u
.repeat
.lower
= 0;
5005 tok
->u
.repeat
.upper
= 1;
5007 tok
->u
.repeat
.possessive
= 0;
5009 if (!PEND
&& PPEEK_IS('?') &&
5010 IS_SYNTAX_OP(syn
, ONIG_SYN_OP_QMARK_NON_GREEDY
) &&
5011 tok
->u
.repeat
.possessive
== 0) {
5013 tok
->u
.repeat
.greedy
= 0;
5014 tok
->u
.repeat
.possessive
= 0;
5018 tok
->u
.repeat
.greedy
= 1;
5019 if (!PEND
&& PPEEK_IS('+') &&
5020 ((IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_PLUS_POSSESSIVE_REPEAT
) &&
5021 tok
->type
!= TK_INTERVAL
) ||
5022 (IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_PLUS_POSSESSIVE_INTERVAL
) &&
5023 tok
->type
== TK_INTERVAL
)) &&
5024 tok
->u
.repeat
.possessive
== 0) {
5026 tok
->u
.repeat
.possessive
= 1;
5032 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_BRACE_INTERVAL
)) break;
5033 r
= fetch_interval_quantifier(&p
, end
, tok
, env
);
5034 if (r
< 0) return r
; /* error */
5035 if (r
== 0) goto greedy_check2
;
5036 else if (r
== 2) { /* {n} */
5037 if (IS_SYNTAX_BV(syn
, ONIG_SYN_FIXED_INTERVAL_IS_GREEDY_ONLY
))
5038 goto possessive_check
;
5042 /* r == 1 : normal char */
5046 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_VBAR_ALT
)) break;
5051 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_LPAREN_SUBEXP
)) break;
5052 tok
->type
= TK_SUBEXP_OPEN
;
5056 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_LPAREN_SUBEXP
)) break;
5057 tok
->type
= TK_SUBEXP_CLOSE
;
5061 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_W_WORD
)) break;
5062 tok
->type
= TK_CHAR_TYPE
;
5063 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_WORD
;
5064 tok
->u
.prop
.not = 0;
5068 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_W_WORD
)) break;
5069 tok
->type
= TK_CHAR_TYPE
;
5070 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_WORD
;
5071 tok
->u
.prop
.not = 1;
5075 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_B_WORD_BOUND
)) break;
5076 tok
->type
= TK_ANCHOR
;
5077 tok
->u
.anchor
= ANCR_WORD_BOUNDARY
;
5081 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_B_WORD_BOUND
)) break;
5082 tok
->type
= TK_ANCHOR
;
5083 tok
->u
.anchor
= ANCR_NO_WORD_BOUNDARY
;
5087 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP2_ESC_X_Y_TEXT_SEGMENT
)) break;
5088 tok
->type
= TK_ANCHOR
;
5089 tok
->u
.anchor
= ANCR_TEXT_SEGMENT_BOUNDARY
;
5093 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP2_ESC_X_Y_TEXT_SEGMENT
)) break;
5094 tok
->type
= TK_ANCHOR
;
5095 tok
->u
.anchor
= ANCR_NO_TEXT_SEGMENT_BOUNDARY
;
5098 #ifdef USE_WORD_BEGIN_END
5100 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_LTGT_WORD_BEGIN_END
)) break;
5101 tok
->type
= TK_ANCHOR
;
5102 tok
->u
.anchor
= ANCR_WORD_BEGIN
;
5106 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_LTGT_WORD_BEGIN_END
)) break;
5107 tok
->type
= TK_ANCHOR
;
5108 tok
->u
.anchor
= ANCR_WORD_END
;
5113 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_S_WHITE_SPACE
)) break;
5114 tok
->type
= TK_CHAR_TYPE
;
5115 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_SPACE
;
5116 tok
->u
.prop
.not = 0;
5120 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_S_WHITE_SPACE
)) break;
5121 tok
->type
= TK_CHAR_TYPE
;
5122 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_SPACE
;
5123 tok
->u
.prop
.not = 1;
5127 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_D_DIGIT
)) break;
5128 tok
->type
= TK_CHAR_TYPE
;
5129 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_DIGIT
;
5130 tok
->u
.prop
.not = 0;
5134 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_D_DIGIT
)) break;
5135 tok
->type
= TK_CHAR_TYPE
;
5136 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_DIGIT
;
5137 tok
->u
.prop
.not = 1;
5141 if (! IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_H_XDIGIT
)) break;
5142 tok
->type
= TK_CHAR_TYPE
;
5143 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_XDIGIT
;
5144 tok
->u
.prop
.not = 0;
5148 if (! IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_H_XDIGIT
)) break;
5149 tok
->type
= TK_CHAR_TYPE
;
5150 tok
->u
.prop
.ctype
= ONIGENC_CTYPE_XDIGIT
;
5151 tok
->u
.prop
.not = 1;
5155 if (! IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_CAPITAL_K_KEEP
)) break;
5156 tok
->type
= TK_KEEP
;
5160 if (! IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_CAPITAL_R_GENERAL_NEWLINE
)) break;
5161 tok
->type
= TK_GENERAL_NEWLINE
;
5165 if (! IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_CAPITAL_N_O_SUPER_DOT
)) break;
5166 tok
->type
= TK_NO_NEWLINE
;
5170 if (! IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_CAPITAL_N_O_SUPER_DOT
)) break;
5171 tok
->type
= TK_TRUE_ANYCHAR
;
5175 if (! IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_X_Y_TEXT_SEGMENT
)) break;
5176 tok
->type
= TK_TEXT_SEGMENT
;
5180 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_AZ_BUF_ANCHOR
)) break;
5182 tok
->type
= TK_ANCHOR
;
5183 tok
->u
.subtype
= ANCR_BEGIN_BUF
;
5187 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_AZ_BUF_ANCHOR
)) break;
5188 tok
->type
= TK_ANCHOR
;
5189 tok
->u
.subtype
= ANCR_SEMI_END_BUF
;
5193 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_AZ_BUF_ANCHOR
)) break;
5195 tok
->type
= TK_ANCHOR
;
5196 tok
->u
.subtype
= ANCR_END_BUF
;
5200 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_CAPITAL_G_BEGIN_ANCHOR
)) break;
5201 tok
->type
= TK_ANCHOR
;
5202 tok
->u
.subtype
= ANCR_BEGIN_POSITION
;
5206 if (! IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_GNU_BUF_ANCHOR
)) break;
5211 if (! IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_GNU_BUF_ANCHOR
)) break;
5219 if (PPEEK_IS('{') && IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_O_BRACE_OCTAL
)) {
5221 num
= scan_unsigned_octal_number(&p
, end
, 11, enc
);
5222 if (num
< 0) return ONIGERR_TOO_BIG_WIDE_CHAR_VALUE
;
5224 if (IS_CODE_DIGIT_ASCII(enc
, PPEEK
))
5225 return ONIGERR_TOO_LONG_WIDE_CHAR_VALUE
;
5228 if ((p
> prev
+ enclen(enc
, prev
)) && !PEND
&& PPEEK_IS('}')) {
5230 tok
->type
= TK_CODE_POINT
;
5231 tok
->u
.code
= (OnigCodePoint
)num
;
5234 /* can't read nothing or invalid format */
5244 if (PPEEK_IS('{') && IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_X_BRACE_HEX8
)) {
5246 num
= scan_unsigned_hexadecimal_number(&p
, end
, 0, 8, enc
);
5248 if (num
== ONIGERR_TOO_BIG_NUMBER
)
5249 return ONIGERR_TOO_BIG_WIDE_CHAR_VALUE
;
5254 if (IS_CODE_XDIGIT_ASCII(enc
, PPEEK
))
5255 return ONIGERR_TOO_LONG_WIDE_CHAR_VALUE
;
5258 if ((p
> prev
+ enclen(enc
, prev
)) && !PEND
&& PPEEK_IS('}')) {
5260 tok
->type
= TK_CODE_POINT
;
5261 tok
->u
.code
= (OnigCodePoint
)num
;
5264 /* can't read nothing or invalid format */
5268 else if (IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_X_HEX2
)) {
5269 num
= scan_unsigned_hexadecimal_number(&p
, end
, 0, 2, enc
);
5270 if (num
< 0) return num
;
5271 if (p
== prev
) { /* can't read nothing. */
5272 num
= 0; /* but, it's not error */
5274 tok
->type
= TK_RAW_BYTE
;
5284 if (IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_U_HEX4
)) {
5285 num
= scan_unsigned_hexadecimal_number(&p
, end
, 4, 4, enc
);
5286 if (num
< 0) return num
;
5287 if (p
== prev
) { /* can't read nothing. */
5288 num
= 0; /* but, it's not error */
5290 tok
->type
= TK_CODE_POINT
;
5292 tok
->u
.code
= (OnigCodePoint
)num
;
5296 case '1': case '2': case '3': case '4':
5297 case '5': case '6': case '7': case '8': case '9':
5300 num
= onig_scan_unsigned_number(&p
, end
, enc
);
5301 if (num
< 0 || num
> ONIG_MAX_BACKREF_NUM
) {
5305 if (IS_SYNTAX_OP(syn
, ONIG_SYN_OP_DECIMAL_BACKREF
) &&
5306 (num
<= env
->num_mem
|| num
<= 9)) { /* This spec. from GNU regex */
5307 if (IS_SYNTAX_BV(syn
, ONIG_SYN_STRICT_CHECK_BACKREF
)) {
5308 if (num
> env
->num_mem
|| IS_NULL(SCANENV_MEMENV(env
)[num
].node
))
5309 return ONIGERR_INVALID_BACKREF
;
5312 tok
->type
= TK_BACKREF
;
5313 tok
->u
.backref
.num
= 1;
5314 tok
->u
.backref
.ref1
= num
;
5315 tok
->u
.backref
.by_name
= 0;
5316 #ifdef USE_BACKREF_WITH_LEVEL
5317 tok
->u
.backref
.exist_level
= 0;
5323 if (c
== '8' || c
== '9') {
5332 if (IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ESC_OCTAL3
)) {
5334 num
= scan_unsigned_octal_number(&p
, end
, (c
== '0' ? 2:3), enc
);
5335 if (num
< 0 || num
>= 256) return ONIGERR_TOO_BIG_NUMBER
;
5336 if (p
== prev
) { /* can't read nothing. */
5337 num
= 0; /* but, it's not error */
5339 tok
->type
= TK_RAW_BYTE
;
5343 else if (c
!= '0') {
5349 if (!PEND
&& IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_K_NAMED_BACKREF
)) {
5351 if (c
== '<' || c
== '\'') {
5355 enum REF_NUM num_type
;
5359 #ifdef USE_BACKREF_WITH_LEVEL
5360 name_end
= NULL_UCHARP
; /* no need. escape gcc warning. */
5361 r
= fetch_name_with_level((OnigCodePoint
)c
, &p
, end
, &name_end
,
5362 env
, &back_num
, &tok
->u
.backref
.level
, &num_type
);
5363 if (r
== 1) tok
->u
.backref
.exist_level
= 1;
5364 else tok
->u
.backref
.exist_level
= 0;
5366 r
= fetch_name(c
, &p
, end
, &name_end
, env
, &back_num
, &num_type
, 1);
5368 if (r
< 0) return r
;
5370 if (num_type
!= IS_NOT_NUM
) {
5371 if (num_type
== IS_REL_NUM
) {
5372 back_num
= backref_rel_to_abs(back_num
, env
);
5375 return ONIGERR_INVALID_BACKREF
;
5377 if (IS_SYNTAX_BV(syn
, ONIG_SYN_STRICT_CHECK_BACKREF
)) {
5378 if (back_num
> env
->num_mem
||
5379 IS_NULL(SCANENV_MEMENV(env
)[back_num
].node
))
5380 return ONIGERR_INVALID_BACKREF
;
5382 tok
->type
= TK_BACKREF
;
5383 tok
->u
.backref
.by_name
= 0;
5384 tok
->u
.backref
.num
= 1;
5385 tok
->u
.backref
.ref1
= back_num
;
5388 num
= name_to_group_numbers(env
, prev
, name_end
, &backs
);
5390 return ONIGERR_UNDEFINED_NAME_REFERENCE
;
5392 if (IS_SYNTAX_BV(syn
, ONIG_SYN_STRICT_CHECK_BACKREF
)) {
5394 for (i
= 0; i
< num
; i
++) {
5395 if (backs
[i
] > env
->num_mem
||
5396 IS_NULL(SCANENV_MEMENV(env
)[backs
[i
]].node
))
5397 return ONIGERR_INVALID_BACKREF
;
5401 tok
->type
= TK_BACKREF
;
5402 tok
->u
.backref
.by_name
= 1;
5404 tok
->u
.backref
.num
= 1;
5405 tok
->u
.backref
.ref1
= backs
[0];
5408 tok
->u
.backref
.num
= num
;
5409 tok
->u
.backref
.refs
= backs
;
5420 if (!PEND
&& IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_G_SUBEXP_CALL
)) {
5422 if (c
== '<' || c
== '\'') {
5425 enum REF_NUM num_type
;
5428 r
= fetch_name((OnigCodePoint
)c
, &p
, end
, &name_end
, env
,
5429 &gnum
, &num_type
, 1);
5430 if (r
< 0) return r
;
5432 if (num_type
!= IS_NOT_NUM
) {
5433 if (num_type
== IS_REL_NUM
) {
5434 gnum
= backref_rel_to_abs(gnum
, env
);
5436 onig_scan_env_set_error_string(env
, ONIGERR_UNDEFINED_NAME_REFERENCE
,
5438 return ONIGERR_UNDEFINED_GROUP_REFERENCE
;
5441 tok
->u
.call
.by_number
= 1;
5442 tok
->u
.call
.gnum
= gnum
;
5445 tok
->u
.call
.by_number
= 0;
5446 tok
->u
.call
.gnum
= 0;
5449 tok
->type
= TK_CALL
;
5450 tok
->u
.call
.name
= prev
;
5451 tok
->u
.call
.name_end
= name_end
;
5460 if (IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_CAPITAL_Q_QUOTE
)) {
5461 tok
->type
= TK_QUOTE_OPEN
;
5467 if (!PEND
&& PPEEK_IS('{') &&
5468 IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_P_BRACE_CHAR_PROPERTY
)) {
5470 tok
->type
= TK_CHAR_PROPERTY
;
5471 tok
->u
.prop
.not = c
== 'P';
5474 IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_ESC_P_BRACE_CIRCUMFLEX_NOT
)) {
5477 tok
->u
.prop
.not = tok
->u
.prop
.not == 0;
5490 num
= fetch_escaped_value(&p
, end
, env
, &c2
);
5491 if (num
< 0) return num
;
5493 if (tok
->u
.c
!= c2
) {
5494 tok
->type
= TK_CODE_POINT
;
5498 p
= tok
->backp
+ enclen(enc
, tok
->backp
);
5508 #ifdef USE_VARIABLE_META_CHARS
5509 if ((c
!= ONIG_INEFFECTIVE_META_CHAR
) &&
5510 IS_SYNTAX_OP(syn
, ONIG_SYN_OP_VARIABLE_META_CHARACTERS
)) {
5511 if (c
== MC_ANYCHAR(syn
))
5513 else if (c
== MC_ANYTIME(syn
))
5515 else if (c
== MC_ZERO_OR_ONE_TIME(syn
))
5516 goto zero_or_one_time
;
5517 else if (c
== MC_ONE_OR_MORE_TIME(syn
))
5518 goto one_or_more_time
;
5519 else if (c
== MC_ANYCHAR_ANYTIME(syn
)) {
5520 tok
->type
= TK_ANYCHAR_ANYTIME
;
5528 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_DOT_ANYCHAR
)) break;
5529 #ifdef USE_VARIABLE_META_CHARS
5532 tok
->type
= TK_ANYCHAR
;
5536 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_ASTERISK_ZERO_INF
)) break;
5537 #ifdef USE_VARIABLE_META_CHARS
5540 tok
->type
= TK_REPEAT
;
5541 tok
->u
.repeat
.lower
= 0;
5542 tok
->u
.repeat
.upper
= INFINITE_REPEAT
;
5547 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_PLUS_ONE_INF
)) break;
5548 #ifdef USE_VARIABLE_META_CHARS
5551 tok
->type
= TK_REPEAT
;
5552 tok
->u
.repeat
.lower
= 1;
5553 tok
->u
.repeat
.upper
= INFINITE_REPEAT
;
5558 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_QMARK_ZERO_ONE
)) break;
5559 #ifdef USE_VARIABLE_META_CHARS
5562 tok
->type
= TK_REPEAT
;
5563 tok
->u
.repeat
.lower
= 0;
5564 tok
->u
.repeat
.upper
= 1;
5569 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_BRACE_INTERVAL
)) break;
5570 r
= fetch_interval_quantifier(&p
, end
, tok
, env
);
5571 if (r
< 0) return r
; /* error */
5572 if (r
== 0) goto greedy_check2
;
5573 else if (r
== 2) { /* {n} */
5574 if (IS_SYNTAX_BV(syn
, ONIG_SYN_FIXED_INTERVAL_IS_GREEDY_ONLY
))
5575 goto possessive_check
;
5579 /* r == 1 : normal char */
5583 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_VBAR_ALT
)) break;
5588 if (!PEND
&& PPEEK_IS('?') &&
5589 IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_QMARK_GROUP_EFFECT
)) {
5596 if (PEND
) return ONIGERR_END_PATTERN_IN_GROUP
;
5598 if (c
== MC_ESC(syn
)) {
5599 if (! PEND
) PFETCH(c
);
5602 if (c
== ')') break;
5607 else if (IS_SYNTAX_OP2(syn
, ONIG_SYN_OP2_QMARK_PERL_SUBEXP_CALL
)) {
5611 enum REF_NUM num_type
;
5618 r
= fetch_name((OnigCodePoint
)'(', &p
, end
, &name_end
, env
, &gnum
,
5620 if (r
< 0) return r
;
5622 tok
->type
= TK_CALL
;
5623 tok
->u
.call
.by_number
= 0;
5624 tok
->u
.call
.gnum
= 0;
5625 tok
->u
.call
.name
= name
;
5626 tok
->u
.call
.name_end
= name_end
;
5631 tok
->type
= TK_CALL
;
5632 tok
->u
.call
.by_number
= 1;
5633 tok
->u
.call
.gnum
= 0;
5634 tok
->u
.call
.name
= p
;
5636 if (! PPEEK_IS(')')) return ONIGERR_UNDEFINED_GROUP_OPTION
;
5637 tok
->u
.call
.name_end
= p
;
5642 goto lparen_qmark_num
;
5645 if (! ONIGENC_IS_CODE_DIGIT(enc
, c
)) goto lparen_qmark_end
;
5650 r
= fetch_name((OnigCodePoint
)'(', &p
, end
, &name_end
, env
,
5651 &gnum
, &num_type
, 1);
5652 if (r
< 0) return r
;
5654 if (num_type
== IS_NOT_NUM
) {
5655 return ONIGERR_INVALID_GROUP_NAME
;
5658 if (num_type
== IS_REL_NUM
) {
5659 gnum
= backref_rel_to_abs(gnum
, env
);
5661 onig_scan_env_set_error_string(env
,
5662 ONIGERR_UNDEFINED_NAME_REFERENCE
, name
, name_end
);
5663 return ONIGERR_UNDEFINED_GROUP_REFERENCE
;
5666 tok
->u
.call
.by_number
= 1;
5667 tok
->u
.call
.gnum
= gnum
;
5670 tok
->type
= TK_CALL
;
5671 tok
->u
.call
.name
= name
;
5672 tok
->u
.call
.name_end
= name_end
;
5682 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_LPAREN_SUBEXP
)) break;
5683 tok
->type
= TK_SUBEXP_OPEN
;
5687 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_LPAREN_SUBEXP
)) break;
5688 tok
->type
= TK_SUBEXP_CLOSE
;
5692 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_LINE_ANCHOR
)) break;
5693 tok
->type
= TK_ANCHOR
;
5694 tok
->u
.subtype
= (IS_SINGLELINE(env
->options
)
5695 ? ANCR_BEGIN_BUF
: ANCR_BEGIN_LINE
);
5699 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_LINE_ANCHOR
)) break;
5700 tok
->type
= TK_ANCHOR
;
5701 tok
->u
.subtype
= (IS_SINGLELINE(env
->options
)
5702 ? ANCR_SEMI_END_BUF
: ANCR_END_LINE
);
5706 if (! IS_SYNTAX_OP(syn
, ONIG_SYN_OP_BRACKET_CC
)) break;
5707 tok
->type
= TK_CC_OPEN
;
5711 if (*src
> env
->pattern
) /* /].../ is allowed. */
5712 CLOSE_BRACKET_WITHOUT_ESC_WARN(env
, (UChar
* )"]");
5716 if (IS_EXTEND(env
->options
)) {
5719 if (ONIGENC_IS_CODE_NEWLINE(enc
, c
))
5727 case ' ': case '\t': case '\n': case '\r': case '\f':
5728 if (IS_EXTEND(env
->options
))
5738 #ifdef USE_VARIABLE_META_CHARS
5746 add_ctype_to_cc_by_range(CClassNode
* cc
, int ctype ARG_UNUSED
, int not,
5747 OnigEncoding enc ARG_UNUSED
, OnigCodePoint sb_out
,
5748 const OnigCodePoint mbr
[])
5753 int n
= ONIGENC_CODE_RANGE_NUM(mbr
);
5756 for (i
= 0; i
< n
; i
++) {
5757 for (j
= ONIGENC_CODE_RANGE_FROM(mbr
, i
);
5758 j
<= ONIGENC_CODE_RANGE_TO(mbr
, i
); j
++) {
5760 if (j
> ONIGENC_CODE_RANGE_FROM(mbr
, i
)) {
5761 r
= add_code_range_to_buf(&(cc
->mbuf
), j
,
5762 ONIGENC_CODE_RANGE_TO(mbr
, i
));
5763 if (r
!= 0) return r
;
5769 BITSET_SET_BIT(cc
->bs
, j
);
5774 for ( ; i
< n
; i
++) {
5775 r
= add_code_range_to_buf(&(cc
->mbuf
),
5776 ONIGENC_CODE_RANGE_FROM(mbr
, i
),
5777 ONIGENC_CODE_RANGE_TO(mbr
, i
));
5778 if (r
!= 0) return r
;
5782 OnigCodePoint prev
= 0;
5784 for (i
= 0; i
< n
; i
++) {
5785 for (j
= prev
; j
< ONIGENC_CODE_RANGE_FROM(mbr
, i
); j
++) {
5789 BITSET_SET_BIT(cc
->bs
, j
);
5791 prev
= ONIGENC_CODE_RANGE_TO(mbr
, i
) + 1;
5793 for (j
= prev
; j
< sb_out
; j
++) {
5794 BITSET_SET_BIT(cc
->bs
, j
);
5800 for (i
= 0; i
< n
; i
++) {
5801 if (prev
< ONIGENC_CODE_RANGE_FROM(mbr
, i
)) {
5802 r
= add_code_range_to_buf(&(cc
->mbuf
), prev
,
5803 ONIGENC_CODE_RANGE_FROM(mbr
, i
) - 1);
5804 if (r
!= 0) return r
;
5806 prev
= ONIGENC_CODE_RANGE_TO(mbr
, i
) + 1;
5807 if (prev
== 0) goto end
;
5810 r
= add_code_range_to_buf(&(cc
->mbuf
), prev
, MAX_CODE_POINT
);
5811 if (r
!= 0) return r
;
5819 add_ctype_to_cc_by_range_limit(CClassNode
* cc
, int ctype ARG_UNUSED
, int not,
5820 OnigEncoding enc ARG_UNUSED
,
5821 OnigCodePoint sb_out
,
5822 const OnigCodePoint mbr
[], OnigCodePoint limit
)
5829 int n
= ONIGENC_CODE_RANGE_NUM(mbr
);
5832 for (i
= 0; i
< n
; i
++) {
5833 for (j
= ONIGENC_CODE_RANGE_FROM(mbr
, i
);
5834 j
<= ONIGENC_CODE_RANGE_TO(mbr
, i
); j
++) {
5835 if (j
> limit
) goto end
;
5837 if (j
> ONIGENC_CODE_RANGE_FROM(mbr
, i
)) {
5838 to
= ONIGENC_CODE_RANGE_TO(mbr
, i
);
5839 if (to
> limit
) to
= limit
;
5840 r
= add_code_range_to_buf(&(cc
->mbuf
), j
, to
);
5841 if (r
!= 0) return r
;
5847 BITSET_SET_BIT(cc
->bs
, j
);
5852 for ( ; i
< n
; i
++) {
5853 from
= ONIGENC_CODE_RANGE_FROM(mbr
, i
);
5854 to
= ONIGENC_CODE_RANGE_TO(mbr
, i
);
5855 if (from
> limit
) break;
5856 if (to
> limit
) to
= limit
;
5857 r
= add_code_range_to_buf(&(cc
->mbuf
), from
, to
);
5858 if (r
!= 0) return r
;
5862 OnigCodePoint prev
= 0;
5864 for (i
= 0; i
< n
; i
++) {
5865 from
= ONIGENC_CODE_RANGE_FROM(mbr
, i
);
5867 for (j
= prev
; j
< sb_out
; j
++) {
5868 BITSET_SET_BIT(cc
->bs
, j
);
5872 for (j
= prev
; j
< from
; j
++) {
5873 if (j
>= sb_out
) goto sb_end2
;
5874 BITSET_SET_BIT(cc
->bs
, j
);
5876 prev
= ONIGENC_CODE_RANGE_TO(mbr
, i
);
5877 if (prev
> limit
) prev
= limit
;
5879 if (prev
== 0) goto end
;
5881 for (j
= prev
; j
< sb_out
; j
++) {
5882 BITSET_SET_BIT(cc
->bs
, j
);
5888 for (i
= 0; i
< n
; i
++) {
5889 from
= ONIGENC_CODE_RANGE_FROM(mbr
, i
);
5890 if (from
> limit
) goto last
;
5893 r
= add_code_range_to_buf(&(cc
->mbuf
), prev
, from
- 1);
5894 if (r
!= 0) return r
;
5896 prev
= ONIGENC_CODE_RANGE_TO(mbr
, i
);
5897 if (prev
> limit
) prev
= limit
;
5899 if (prev
== 0) goto end
;
5903 r
= add_code_range_to_buf(&(cc
->mbuf
), prev
, MAX_CODE_POINT
);
5904 if (r
!= 0) return r
;
5912 add_ctype_to_cc(CClassNode
* cc
, int ctype
, int not, ScanEnv
* env
)
5914 #define ASCII_LIMIT 127
5918 const OnigCodePoint
*ranges
;
5919 OnigCodePoint limit
;
5920 OnigCodePoint sb_out
;
5921 OnigEncoding enc
= env
->enc
;
5923 ascii_mode
= IS_ASCII_MODE_CTYPE_OPTION(ctype
, env
->options
);
5925 r
= ONIGENC_GET_CTYPE_CODE_RANGE(enc
, ctype
, &sb_out
, &ranges
);
5927 if (ascii_mode
== 0)
5928 r
= add_ctype_to_cc_by_range(cc
, ctype
, not, env
->enc
, sb_out
, ranges
);
5930 r
= add_ctype_to_cc_by_range_limit(cc
, ctype
, not, env
->enc
, sb_out
,
5931 ranges
, ASCII_LIMIT
);
5934 else if (r
!= ONIG_NO_SUPPORT_CONFIG
) {
5939 limit
= ascii_mode
? ASCII_LIMIT
: SINGLE_BYTE_SIZE
;
5942 case ONIGENC_CTYPE_ALPHA
:
5943 case ONIGENC_CTYPE_BLANK
:
5944 case ONIGENC_CTYPE_CNTRL
:
5945 case ONIGENC_CTYPE_DIGIT
:
5946 case ONIGENC_CTYPE_LOWER
:
5947 case ONIGENC_CTYPE_PUNCT
:
5948 case ONIGENC_CTYPE_SPACE
:
5949 case ONIGENC_CTYPE_UPPER
:
5950 case ONIGENC_CTYPE_XDIGIT
:
5951 case ONIGENC_CTYPE_ASCII
:
5952 case ONIGENC_CTYPE_ALNUM
:
5954 for (c
= 0; c
< (int )limit
; c
++) {
5955 if (! ONIGENC_IS_CODE_CTYPE(enc
, (OnigCodePoint
)c
, ctype
))
5956 BITSET_SET_BIT(cc
->bs
, c
);
5958 for (c
= limit
; c
< SINGLE_BYTE_SIZE
; c
++) {
5959 BITSET_SET_BIT(cc
->bs
, c
);
5962 ADD_ALL_MULTI_BYTE_RANGE(enc
, cc
->mbuf
);
5965 for (c
= 0; c
< (int )limit
; c
++) {
5966 if (ONIGENC_IS_CODE_CTYPE(enc
, (OnigCodePoint
)c
, ctype
))
5967 BITSET_SET_BIT(cc
->bs
, c
);
5972 case ONIGENC_CTYPE_GRAPH
:
5973 case ONIGENC_CTYPE_PRINT
:
5974 case ONIGENC_CTYPE_WORD
:
5976 for (c
= 0; c
< (int )limit
; c
++) {
5977 if (ONIGENC_CODE_TO_MBCLEN(enc
, c
) > 0 /* check invalid code point */
5978 && ! ONIGENC_IS_CODE_CTYPE(enc
, (OnigCodePoint
)c
, ctype
))
5979 BITSET_SET_BIT(cc
->bs
, c
);
5981 for (c
= limit
; c
< SINGLE_BYTE_SIZE
; c
++) {
5982 if (ONIGENC_CODE_TO_MBCLEN(enc
, c
) > 0)
5983 BITSET_SET_BIT(cc
->bs
, c
);
5987 for (c
= 0; c
< (int )limit
; c
++) {
5988 if (ONIGENC_IS_CODE_CTYPE(enc
, (OnigCodePoint
)c
, ctype
))
5989 BITSET_SET_BIT(cc
->bs
, c
);
5991 if (ascii_mode
== 0)
5992 ADD_ALL_MULTI_BYTE_RANGE(enc
, cc
->mbuf
);
5997 return ONIGERR_PARSER_BUG
;
6005 parse_posix_bracket(CClassNode
* cc
, UChar
** src
, UChar
* end
, ScanEnv
* env
)
6007 #define POSIX_BRACKET_CHECK_LIMIT_LENGTH 20
6008 #define POSIX_BRACKET_NAME_MIN_LEN 4
6010 static PosixBracketEntryType PBS
[] = {
6011 { (UChar
* )"alnum", ONIGENC_CTYPE_ALNUM
, 5 },
6012 { (UChar
* )"alpha", ONIGENC_CTYPE_ALPHA
, 5 },
6013 { (UChar
* )"blank", ONIGENC_CTYPE_BLANK
, 5 },
6014 { (UChar
* )"cntrl", ONIGENC_CTYPE_CNTRL
, 5 },
6015 { (UChar
* )"digit", ONIGENC_CTYPE_DIGIT
, 5 },
6016 { (UChar
* )"graph", ONIGENC_CTYPE_GRAPH
, 5 },
6017 { (UChar
* )"lower", ONIGENC_CTYPE_LOWER
, 5 },
6018 { (UChar
* )"print", ONIGENC_CTYPE_PRINT
, 5 },
6019 { (UChar
* )"punct", ONIGENC_CTYPE_PUNCT
, 5 },
6020 { (UChar
* )"space", ONIGENC_CTYPE_SPACE
, 5 },
6021 { (UChar
* )"upper", ONIGENC_CTYPE_UPPER
, 5 },
6022 { (UChar
* )"xdigit", ONIGENC_CTYPE_XDIGIT
, 6 },
6023 { (UChar
* )"ascii", ONIGENC_CTYPE_ASCII
, 5 },
6024 { (UChar
* )"word", ONIGENC_CTYPE_WORD
, 4 },
6025 { (UChar
* )NULL
, -1, 0 }
6028 PosixBracketEntryType
*pb
;
6031 OnigEncoding enc
= env
->enc
;
6034 if (PPEEK_IS('^')) {
6041 if (onigenc_strlen(enc
, p
, end
) < POSIX_BRACKET_NAME_MIN_LEN
+ 3)
6042 goto not_posix_bracket
;
6044 for (pb
= PBS
; IS_NOT_NULL(pb
->name
); pb
++) {
6045 if (onigenc_with_ascii_strncmp(enc
, p
, end
, pb
->name
, pb
->len
) == 0) {
6046 p
= (UChar
* )onigenc_step(enc
, p
, end
, pb
->len
);
6047 if (onigenc_with_ascii_strncmp(enc
, p
, end
, (UChar
* )":]", 2) != 0)
6048 return ONIGERR_INVALID_POSIX_BRACKET_TYPE
;
6050 r
= add_ctype_to_cc(cc
, pb
->ctype
, not, env
);
6051 if (r
!= 0) return r
;
6062 while (!PEND
&& ((c
= PPEEK
) != ':') && c
!= ']') {
6064 if (++i
> POSIX_BRACKET_CHECK_LIMIT_LENGTH
) break;
6066 if (c
== ':' && ! PEND
) {
6071 return ONIGERR_INVALID_POSIX_BRACKET_TYPE
;
6075 return 1; /* 1: is not POSIX bracket, but no error. */
6079 fetch_char_property_to_ctype(UChar
** src
, UChar
* end
, ScanEnv
* env
)
6083 OnigEncoding enc
= env
->enc
;
6084 UChar
*prev
, *start
, *p
= *src
;
6093 r
= ONIGENC_PROPERTY_NAME_TO_CTYPE(enc
, start
, prev
);
6099 else if (c
== '(' || c
== ')' || c
== '{' || c
== '|') {
6100 r
= ONIGERR_INVALID_CHAR_PROPERTY_NAME
;
6105 onig_scan_env_set_error_string(env
, r
, *src
, prev
);
6110 parse_char_property(Node
** np
, PToken
* tok
, UChar
** src
, UChar
* end
, ScanEnv
* env
)
6115 ctype
= fetch_char_property_to_ctype(src
, end
, env
);
6116 if (ctype
< 0) return ctype
;
6118 *np
= node_new_cclass();
6119 CHECK_NULL_RETURN_MEMERR(*np
);
6121 r
= add_ctype_to_cc(cc
, ctype
, 0, env
);
6122 if (r
!= 0) return r
;
6123 if (tok
->u
.prop
.not != 0) NCCLASS_SET_NOT(cc
);
6143 next_state_class(CClassNode
* cc
, OnigCodePoint
* vs
, enum CCVALTYPE
* type
,
6144 enum CCSTATE
* state
, ScanEnv
* env
)
6148 if (*state
== CCS_RANGE
)
6149 return ONIGERR_CHAR_CLASS_VALUE_AT_END_OF_RANGE
;
6151 if (*state
== CCS_VALUE
&& *type
!= CCV_CLASS
) {
6152 if (*type
== CCV_SB
)
6153 BITSET_SET_BIT(cc
->bs
, (int )(*vs
));
6154 else if (*type
== CCV_CODE_POINT
) {
6155 r
= add_code_range(&(cc
->mbuf
), env
, *vs
, *vs
);
6156 if (r
< 0) return r
;
6166 next_state_val(CClassNode
* cc
, OnigCodePoint
*from
, OnigCodePoint to
,
6167 int* from_israw
, int to_israw
,
6168 enum CCVALTYPE intype
, enum CCVALTYPE
* type
,
6169 enum CCSTATE
* state
, ScanEnv
* env
)
6175 if (*type
== CCV_SB
) {
6177 return ONIGERR_INVALID_CODE_POINT_VALUE
;
6179 BITSET_SET_BIT(cc
->bs
, (int )(*from
));
6181 else if (*type
== CCV_CODE_POINT
) {
6182 r
= add_code_range(&(cc
->mbuf
), env
, *from
, *from
);
6183 if (r
< 0) return r
;
6188 if (intype
== *type
) {
6189 if (intype
== CCV_SB
) {
6190 if (*from
> 0xff || to
> 0xff)
6191 return ONIGERR_INVALID_CODE_POINT_VALUE
;
6194 if (IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_ALLOW_EMPTY_RANGE_IN_CC
))
6197 return ONIGERR_EMPTY_RANGE_IN_CHAR_CLASS
;
6199 bitset_set_range(cc
->bs
, (int )*from
, (int )to
);
6202 r
= add_code_range(&(cc
->mbuf
), env
, *from
, to
);
6203 if (r
< 0) return r
;
6208 if (IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_ALLOW_EMPTY_RANGE_IN_CC
))
6211 return ONIGERR_EMPTY_RANGE_IN_CHAR_CLASS
;
6213 bitset_set_range(cc
->bs
, (int )*from
, (int )(to
< 0xff ? to
: 0xff));
6214 r
= add_code_range(&(cc
->mbuf
), env
, (OnigCodePoint
)*from
, to
);
6215 if (r
< 0) return r
;
6218 *state
= CCS_COMPLETE
;
6230 *from_israw
= to_israw
;
6237 code_exist_check(OnigCodePoint c
, UChar
* from
, UChar
* end
, int ignore_escaped
,
6242 OnigEncoding enc
= env
->enc
;
6247 if (ignore_escaped
&& in_esc
) {
6252 if (code
== c
) return 1;
6253 if (code
== MC_ESC(env
->syntax
)) in_esc
= 1;
6260 parse_char_class(Node
** np
, PToken
* tok
, UChar
** src
, UChar
* end
, ScanEnv
* env
)
6262 int r
, neg
, len
, fetched
, and_start
;
6263 OnigCodePoint v
, vs
;
6266 CClassNode
*cc
, *prev_cc
;
6270 enum CCVALTYPE val_type
, in_type
;
6271 int val_israw
, in_israw
;
6275 if (env
->parse_depth
> ParseDepthLimit
)
6276 return ONIGERR_PARSE_DEPTH_LIMIT_OVER
;
6278 prev_cc
= (CClassNode
* )NULL
;
6279 r
= fetch_token_in_cc(tok
, src
, end
, env
);
6280 if (r
== TK_CHAR
&& tok
->u
.c
== '^' && tok
->escaped
== 0) {
6282 r
= fetch_token_in_cc(tok
, src
, end
, env
);
6288 if (r
< 0) return r
;
6289 if (r
== TK_CC_CLOSE
) {
6290 if (! code_exist_check((OnigCodePoint
)']',
6291 *src
, env
->pattern_end
, 1, env
))
6292 return ONIGERR_EMPTY_CHAR_CLASS
;
6294 CC_ESC_WARN(env
, (UChar
* )"]");
6295 r
= tok
->type
= TK_CHAR
; /* allow []...] */
6298 *np
= node
= node_new_cclass();
6299 CHECK_NULL_RETURN_MEMERR(node
);
6305 while (r
!= TK_CC_CLOSE
) {
6310 len
= ONIGENC_CODE_TO_MBCLEN(env
->enc
, tok
->u
.c
);
6312 in_type
= CCV_CODE_POINT
;
6322 v
= (OnigCodePoint
)tok
->u
.c
;
6328 /* tok->base != 0 : octal or hexadec. */
6329 if (! ONIGENC_IS_SINGLEBYTE(env
->enc
) && tok
->base
!= 0) {
6331 UChar buf
[ONIGENC_CODE_TO_MBC_MAXLEN
];
6332 UChar
* bufe
= buf
+ ONIGENC_CODE_TO_MBC_MAXLEN
;
6334 int base
= tok
->base
;
6337 for (i
= 1; i
< ONIGENC_MBC_MAXLEN(env
->enc
); i
++) {
6338 r
= fetch_token_in_cc(tok
, &p
, end
, env
);
6339 if (r
< 0) goto err
;
6340 if (r
!= TK_RAW_BYTE
|| tok
->base
!= base
) {
6347 if (i
< ONIGENC_MBC_MINLEN(env
->enc
)) {
6348 r
= ONIGERR_TOO_SHORT_MULTI_BYTE_STRING
;
6352 /* clear buf tail */
6353 for (j
= i
; j
< ONIGENC_CODE_TO_MBC_MAXLEN
; j
++) buf
[j
] = '\0';
6355 len
= enclen(env
->enc
, buf
);
6357 r
= ONIGERR_TOO_SHORT_MULTI_BYTE_STRING
;
6360 else if (i
> len
) { /* fetch back */
6362 for (i
= 1; i
< len
; i
++) {
6363 r
= fetch_token_in_cc(tok
, &p
, end
, env
);
6369 v
= (OnigCodePoint
)buf
[0];
6373 v
= ONIGENC_MBC_TO_CODE(env
->enc
, buf
, bufe
);
6374 in_type
= CCV_CODE_POINT
;
6378 v
= (OnigCodePoint
)tok
->u
.c
;
6390 len
= ONIGENC_CODE_TO_MBCLEN(env
->enc
, v
);
6392 if (state
!= CCS_RANGE
||
6393 ! IS_SYNTAX_BV(env
->syntax
,
6394 ONIG_SYN_ALLOW_INVALID_CODE_END_OF_RANGE_IN_CC
) ||
6395 v
< 0x100 || ONIGENC_MBC_MAXLEN(env
->enc
) == 1) {
6400 in_type
= (len
== 1 ? CCV_SB
: CCV_CODE_POINT
);
6402 r
= next_state_val(cc
, &vs
, v
, &val_israw
, in_israw
, in_type
, &val_type
,
6404 if (r
!= 0) goto err
;
6407 case TK_POSIX_BRACKET_OPEN
:
6408 r
= parse_posix_bracket(cc
, &p
, end
, env
);
6409 if (r
< 0) goto err
;
6410 if (r
== 1) { /* is not POSIX bracket */
6411 CC_ESC_WARN(env
, (UChar
* )"[");
6413 v
= (OnigCodePoint
)tok
->u
.c
;
6421 r
= add_ctype_to_cc(cc
, tok
->u
.prop
.ctype
, tok
->u
.prop
.not, env
);
6422 if (r
!= 0) goto err
;
6425 r
= next_state_class(cc
, &vs
, &val_type
, &state
, env
);
6426 if (r
!= 0) goto err
;
6429 case TK_CHAR_PROPERTY
:
6431 int ctype
= fetch_char_property_to_ctype(&p
, end
, env
);
6436 r
= add_ctype_to_cc(cc
, ctype
, tok
->u
.prop
.not, env
);
6437 if (r
!= 0) goto err
;
6443 if (state
== CCS_VALUE
) {
6444 r
= fetch_token_in_cc(tok
, &p
, end
, env
);
6445 if (r
< 0) goto err
;
6447 if (r
== TK_CC_CLOSE
) { /* allow [x-] */
6449 v
= (OnigCodePoint
)'-';
6453 else if (r
== TK_CC_AND
) {
6454 CC_ESC_WARN(env
, (UChar
* )"-");
6458 if (val_type
== CCV_CLASS
) {
6459 r
= ONIGERR_UNMATCHED_RANGE_SPECIFIER_IN_CHAR_CLASS
;
6465 else if (state
== CCS_START
) {
6466 /* [-xa] is allowed */
6467 v
= (OnigCodePoint
)tok
->u
.c
;
6470 r
= fetch_token_in_cc(tok
, &p
, end
, env
);
6471 if (r
< 0) goto err
;
6473 /* [--x] or [a&&-x] is warned. */
6474 if (r
== TK_CC_RANGE
|| and_start
!= 0)
6475 CC_ESC_WARN(env
, (UChar
* )"-");
6479 else if (state
== CCS_RANGE
) {
6480 CC_ESC_WARN(env
, (UChar
* )"-");
6481 goto any_char_in
; /* [!--x] is allowed */
6483 else { /* CCS_COMPLETE */
6484 r
= fetch_token_in_cc(tok
, &p
, end
, env
);
6485 if (r
< 0) goto err
;
6487 if (r
== TK_CC_CLOSE
) goto range_end_val
; /* allow [a-b-] */
6488 else if (r
== TK_CC_AND
) {
6489 CC_ESC_WARN(env
, (UChar
* )"-");
6493 if (IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_ALLOW_DOUBLE_RANGE_OP_IN_CC
)) {
6494 CC_ESC_WARN(env
, (UChar
* )"-");
6495 goto range_end_val
; /* [0-9-a] is allowed as [0-9\-a] */
6497 r
= ONIGERR_UNMATCHED_RANGE_SPECIFIER_IN_CHAR_CLASS
;
6502 case TK_CC_CC_OPEN
: /* [ */
6507 r
= parse_char_class(&anode
, tok
, &p
, end
, env
);
6509 onig_node_free(anode
);
6512 acc
= CCLASS_(anode
);
6513 r
= or_cclass(cc
, acc
, env
->enc
);
6514 onig_node_free(anode
);
6517 if (r
!= 0) goto err
;
6521 case TK_CC_AND
: /* && */
6523 if (state
== CCS_VALUE
) {
6524 r
= next_state_val(cc
, &vs
, 0, &val_israw
, 0, val_type
,
6525 &val_type
, &state
, env
);
6526 if (r
!= 0) goto err
;
6528 /* initialize local variables */
6532 if (IS_NOT_NULL(prev_cc
)) {
6533 r
= and_cclass(prev_cc
, cc
, env
->enc
);
6534 if (r
!= 0) goto err
;
6535 bbuf_free(cc
->mbuf
);
6541 initialize_cclass(cc
);
6546 r
= ONIGERR_PREMATURE_END_OF_CHAR_CLASS
;
6550 r
= ONIGERR_PARSER_BUG
;
6558 r
= fetch_token_in_cc(tok
, &p
, end
, env
);
6559 if (r
< 0) goto err
;
6563 if (state
== CCS_VALUE
) {
6564 r
= next_state_val(cc
, &vs
, 0, &val_israw
, 0, val_type
,
6565 &val_type
, &state
, env
);
6566 if (r
!= 0) goto err
;
6569 if (IS_NOT_NULL(prev_cc
)) {
6570 r
= and_cclass(prev_cc
, cc
, env
->enc
);
6571 if (r
!= 0) goto err
;
6572 bbuf_free(cc
->mbuf
);
6577 NCCLASS_SET_NOT(cc
);
6579 NCCLASS_CLEAR_NOT(cc
);
6580 if (IS_NCCLASS_NOT(cc
) &&
6581 IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_NOT_NEWLINE_IN_NEGATIVE_CC
)) {
6582 int is_empty
= (IS_NULL(cc
->mbuf
) ? 1 : 0);
6584 BITSET_IS_EMPTY(cc
->bs
, is_empty
);
6586 if (is_empty
== 0) {
6587 #define NEWLINE_CODE 0x0a
6589 if (ONIGENC_IS_CODE_NEWLINE(env
->enc
, NEWLINE_CODE
)) {
6590 if (ONIGENC_CODE_TO_MBCLEN(env
->enc
, NEWLINE_CODE
) == 1)
6591 BITSET_SET_BIT(cc
->bs
, NEWLINE_CODE
);
6593 add_code_range(&(cc
->mbuf
), env
, NEWLINE_CODE
, NEWLINE_CODE
);
6602 if (cc
!= CCLASS_(*np
))
6603 bbuf_free(cc
->mbuf
);
6607 static int parse_subexp(Node
** top
, PToken
* tok
, int term
,
6608 UChar
** src
, UChar
* end
, ScanEnv
* env
, int group_head
);
6612 /* (?{...}[tag][+-]) (?{{...}}[tag][+-]) */
6614 parse_callout_of_contents(Node
** np
, int cterm
, UChar
** src
, UChar
* end
, ScanEnv
* env
)
6627 CalloutListEntry
* e
;
6629 OnigEncoding enc
= env
->enc
;
6632 if (PEND
) return ONIGERR_INVALID_CALLOUT_PATTERN
;
6635 while (PPEEK_IS('{')) {
6638 if (PEND
) return ONIGERR_INVALID_CALLOUT_PATTERN
;
6641 in
= ONIG_CALLOUT_IN_PROGRESS
;
6644 if (PEND
) return ONIGERR_INVALID_CALLOUT_PATTERN
;
6651 if (PEND
) return ONIGERR_INVALID_CALLOUT_PATTERN
;
6660 if (PEND
) return ONIGERR_END_PATTERN_IN_GROUP
;
6664 if (PEND
) return ONIGERR_END_PATTERN_IN_GROUP
;
6665 tag_end
= tag_start
= p
;
6667 if (PEND
) return ONIGERR_END_PATTERN_IN_GROUP
;
6670 if (c
== ']') break;
6672 if (! is_allowed_callout_tag_name(enc
, tag_start
, tag_end
))
6673 return ONIGERR_INVALID_CALLOUT_TAG_NAME
;
6675 if (PEND
) return ONIGERR_END_PATTERN_IN_GROUP
;
6679 tag_start
= tag_end
= 0;
6683 in
|= ONIG_CALLOUT_IN_RETRACTION
;
6684 if (PEND
) return ONIGERR_END_PATTERN_IN_GROUP
;
6687 else if (c
== '<') {
6688 in
= ONIG_CALLOUT_IN_RETRACTION
;
6689 if (PEND
) return ONIGERR_END_PATTERN_IN_GROUP
;
6692 else if (c
== '>') { /* no needs (default) */
6693 if (PEND
) return ONIGERR_END_PATTERN_IN_GROUP
;
6698 return ONIGERR_INVALID_CALLOUT_PATTERN
;
6700 r
= reg_callout_list_entry(env
, &num
);
6701 if (r
!= 0) return r
;
6703 ext
= onig_get_regex_ext(env
->reg
);
6704 CHECK_NULL_RETURN_MEMERR(ext
);
6705 if (IS_NULL(ext
->pattern
)) {
6706 r
= onig_ext_set_pattern(env
->reg
, env
->pattern
, env
->pattern_end
);
6707 if (r
!= ONIG_NORMAL
) return r
;
6710 if (tag_start
!= tag_end
) {
6711 r
= callout_tag_entry(env
, env
->reg
, tag_start
, tag_end
, num
);
6712 if (r
!= ONIG_NORMAL
) return r
;
6715 contents
= onigenc_strdup(enc
, code_start
, code_end
);
6716 CHECK_NULL_RETURN_MEMERR(contents
);
6718 r
= node_new_callout(np
, ONIG_CALLOUT_OF_CONTENTS
, num
, ONIG_NON_NAME_ID
, env
);
6724 e
= onig_reg_callout_list_at(env
->reg
, num
);
6727 return ONIGERR_MEMORY
;
6730 e
->of
= ONIG_CALLOUT_OF_CONTENTS
;
6732 e
->name_id
= ONIG_NON_NAME_ID
;
6733 e
->u
.content
.start
= contents
;
6734 e
->u
.content
.end
= contents
+ (code_end
- code_start
);
6741 parse_long(OnigEncoding enc
, UChar
* s
, UChar
* end
, int sign_on
, long max
, long* rl
)
6749 if (s
>= end
) return ONIGERR_INVALID_CALLOUT_ARG
;
6755 c
= ONIGENC_MBC_TO_CODE(enc
, p
, end
);
6756 p
+= ONIGENC_MBC_ENC_LEN(enc
, p
);
6757 if (c
>= '0' && c
<= '9') {
6758 d
= (long )(c
- '0');
6759 if (v
> (max
- d
) / 10)
6760 return ONIGERR_INVALID_CALLOUT_ARG
;
6764 else if (sign_on
!= 0 && (c
== '-' || c
== '+')) {
6765 if (c
== '-') flag
= -1;
6768 return ONIGERR_INVALID_CALLOUT_ARG
;
6778 parse_callout_args(int skip_mode
, int cterm
, UChar
** src
, UChar
* end
,
6779 unsigned int types
[], OnigValue vals
[], ScanEnv
* env
)
6781 #define MAX_CALLOUT_ARG_BYTE_LENGTH 128
6792 UChar buf
[MAX_CALLOUT_ARG_BYTE_LENGTH
];
6793 OnigEncoding enc
= env
->enc
;
6796 if (PEND
) return ONIGERR_INVALID_CALLOUT_PATTERN
;
6799 while (n
< ONIG_CALLOUT_MAX_ARGS_NUM
) {
6807 if (PEND
) return ONIGERR_INVALID_CALLOUT_PATTERN
;
6813 if (c
== '\\' || c
== cterm
|| c
== ',') {
6827 else if (c
== cterm
|| c
== ',')
6833 if (skip_mode
== 0) {
6835 if (bufend
+ clen
> buf
+ MAX_CALLOUT_ARG_BYTE_LENGTH
)
6836 return ONIGERR_INVALID_CALLOUT_ARG
; /* too long argument */
6838 xmemcpy(bufend
, e
, clen
);
6847 if (skip_mode
== 0) {
6848 if ((types
[n
] & ONIG_TYPE_LONG
) != 0) {
6852 r
= parse_long(enc
, buf
, bufend
, 1, LONG_MAX
, &rl
);
6853 if (r
== ONIG_NORMAL
) {
6856 types
[n
] = ONIG_TYPE_LONG
;
6861 types
[n
] = (types
[n
] & ~ONIG_TYPE_LONG
);
6862 if (types
[n
] == ONIG_TYPE_VOID
)
6863 return ONIGERR_INVALID_CALLOUT_ARG
;
6868 case ONIG_TYPE_LONG
:
6871 case ONIG_TYPE_CHAR
:
6872 if (cn
!= 1) return ONIGERR_INVALID_CALLOUT_ARG
;
6873 vals
[n
].c
= ONIGENC_MBC_TO_CODE(enc
, buf
, bufend
);
6876 case ONIG_TYPE_STRING
:
6878 UChar
* rs
= onigenc_strdup(enc
, buf
, bufend
);
6879 CHECK_NULL_RETURN_MEMERR(rs
);
6880 vals
[n
].s
.start
= rs
;
6881 vals
[n
].s
.end
= rs
+ (e
- s
);
6886 if (eesc
!= 0 || ! is_allowed_callout_tag_name(enc
, s
, e
))
6887 return ONIGERR_INVALID_CALLOUT_TAG_NAME
;
6889 vals
[n
].s
.start
= s
;
6893 case ONIG_TYPE_VOID
:
6894 case ONIG_TYPE_POINTER
:
6895 return ONIGERR_PARSER_BUG
;
6903 if (c
== cterm
) break;
6906 if (c
!= cterm
) return ONIGERR_INVALID_CALLOUT_PATTERN
;
6912 /* (*name[TAG]) (*name[TAG]{a,b,..}) */
6914 parse_callout_of_name(Node
** np
, int cterm
, UChar
** src
, UChar
* end
, ScanEnv
* env
)
6931 CalloutListEntry
* e
;
6933 unsigned int types
[ONIG_CALLOUT_MAX_ARGS_NUM
];
6934 OnigValue vals
[ONIG_CALLOUT_MAX_ARGS_NUM
];
6935 OnigEncoding enc
= env
->enc
;
6939 if (PEND
) return ONIGERR_INVALID_CALLOUT_PATTERN
;
6944 if (PEND
) return ONIGERR_END_PATTERN_IN_GROUP
;
6947 if (c
== cterm
|| c
== '[' || c
== '{') break;
6950 if (! is_allowed_callout_name(enc
, name_start
, name_end
))
6951 return ONIGERR_INVALID_CALLOUT_NAME
;
6954 if (PEND
) return ONIGERR_END_PATTERN_IN_GROUP
;
6955 tag_end
= tag_start
= p
;
6957 if (PEND
) return ONIGERR_END_PATTERN_IN_GROUP
;
6960 if (c
== ']') break;
6962 if (! is_allowed_callout_tag_name(enc
, tag_start
, tag_end
))
6963 return ONIGERR_INVALID_CALLOUT_TAG_NAME
;
6965 if (PEND
) return ONIGERR_END_PATTERN_IN_GROUP
;
6969 tag_start
= tag_end
= 0;
6975 if (PEND
) return ONIGERR_END_PATTERN_IN_GROUP
;
6977 /* read for single check only */
6979 arg_num
= parse_callout_args(1, '}', &p
, end
, 0, 0, env
);
6980 if (arg_num
< 0) return arg_num
;
6982 is_not_single
= PPEEK_IS(cterm
) ? 0 : 1;
6984 r
= get_callout_name_id_by_name(enc
, is_not_single
, name_start
, name_end
,
6986 if (r
!= ONIG_NORMAL
) return r
;
6988 max_arg_num
= get_callout_arg_num_by_name_id(name_id
);
6989 for (i
= 0; i
< max_arg_num
; i
++) {
6990 types
[i
] = get_callout_arg_type_by_name_id(name_id
, i
);
6993 arg_num
= parse_callout_args(0, '}', &p
, end
, types
, vals
, env
);
6994 if (arg_num
< 0) return arg_num
;
6996 if (PEND
) return ONIGERR_END_PATTERN_IN_GROUP
;
7003 r
= get_callout_name_id_by_name(enc
, is_not_single
, name_start
, name_end
,
7005 if (r
!= ONIG_NORMAL
) return r
;
7007 max_arg_num
= get_callout_arg_num_by_name_id(name_id
);
7008 for (i
= 0; i
< max_arg_num
; i
++) {
7009 types
[i
] = get_callout_arg_type_by_name_id(name_id
, i
);
7013 in
= onig_get_callout_in_by_name_id(name_id
);
7014 opt_arg_num
= get_callout_opt_arg_num_by_name_id(name_id
);
7015 if (arg_num
> max_arg_num
|| arg_num
< (max_arg_num
- opt_arg_num
))
7016 return ONIGERR_INVALID_CALLOUT_ARG
;
7019 return ONIGERR_INVALID_CALLOUT_PATTERN
;
7021 r
= reg_callout_list_entry(env
, &num
);
7022 if (r
!= 0) return r
;
7024 ext
= onig_get_regex_ext(env
->reg
);
7025 CHECK_NULL_RETURN_MEMERR(ext
);
7026 if (IS_NULL(ext
->pattern
)) {
7027 r
= onig_ext_set_pattern(env
->reg
, env
->pattern
, env
->pattern_end
);
7028 if (r
!= ONIG_NORMAL
) return r
;
7031 if (tag_start
!= tag_end
) {
7032 r
= callout_tag_entry(env
, env
->reg
, tag_start
, tag_end
, num
);
7033 if (r
!= ONIG_NORMAL
) return r
;
7036 r
= node_new_callout(&node
, ONIG_CALLOUT_OF_NAME
, num
, name_id
, env
);
7037 if (r
!= ONIG_NORMAL
) return r
;
7039 e
= onig_reg_callout_list_at(env
->reg
, num
);
7040 CHECK_NULL_RETURN_MEMERR(e
);
7042 e
->of
= ONIG_CALLOUT_OF_NAME
;
7044 e
->name_id
= name_id
;
7045 e
->type
= onig_get_callout_type_by_name_id(name_id
);
7046 e
->start_func
= onig_get_callout_start_func_by_name_id(name_id
);
7047 e
->end_func
= onig_get_callout_end_func_by_name_id(name_id
);
7048 e
->u
.arg
.num
= max_arg_num
;
7049 e
->u
.arg
.passed_num
= arg_num
;
7050 for (i
= 0; i
< max_arg_num
; i
++) {
7051 e
->u
.arg
.types
[i
] = types
[i
];
7053 e
->u
.arg
.vals
[i
] = vals
[i
];
7055 e
->u
.arg
.vals
[i
] = get_callout_opt_default_by_name_id(name_id
, i
);
7065 parse_bag(Node
** np
, PToken
* tok
, int term
, UChar
** src
, UChar
* end
,
7070 OnigOptionType option
;
7073 OnigEncoding enc
= env
->enc
;
7079 if (PEND
) return ONIGERR_END_PATTERN_WITH_UNMATCHED_PARENTHESIS
;
7081 option
= env
->options
;
7083 if (c
== '?' && IS_SYNTAX_OP2(env
->syntax
, ONIG_SYN_OP2_QMARK_GROUP_EFFECT
)) {
7085 if (PEND
) return ONIGERR_END_PATTERN_IN_GROUP
;
7089 case ':': /* (?:...) grouping only */
7091 r
= fetch_token(tok
, &p
, end
, env
);
7092 if (r
< 0) return r
;
7093 r
= parse_subexp(np
, tok
, term
, &p
, end
, env
, 0);
7094 if (r
< 0) return r
;
7096 return 1; /* group */
7100 *np
= onig_node_new_anchor(ANCR_PREC_READ
, 0);
7102 case '!': /* preceding read */
7103 *np
= onig_node_new_anchor(ANCR_PREC_READ_NOT
, 0);
7105 case '>': /* (?>...) stop backtrack */
7106 *np
= node_new_bag(BAG_STOP_BACKTRACK
);
7110 if (IS_SYNTAX_OP2(env
->syntax
, ONIG_SYN_OP2_QMARK_LT_NAMED_GROUP
)) {
7114 return ONIGERR_UNDEFINED_GROUP_OPTION
;
7117 case '<': /* look behind (?<=...), (?<!...) */
7118 if (PEND
) return ONIGERR_END_PATTERN_WITH_UNMATCHED_PARENTHESIS
;
7121 *np
= onig_node_new_anchor(ANCR_LOOK_BEHIND
, 0);
7123 *np
= onig_node_new_anchor(ANCR_LOOK_BEHIND_NOT
, 0);
7125 if (IS_SYNTAX_OP2(env
->syntax
, ONIG_SYN_OP2_QMARK_LT_NAMED_GROUP
)) {
7128 enum REF_NUM num_type
;
7138 r
= fetch_name((OnigCodePoint
)c
, &p
, end
, &name_end
, env
, &num
,
7140 if (r
< 0) return r
;
7142 num
= scan_env_add_mem_entry(env
);
7143 if (num
< 0) return num
;
7144 if (list_capture
!= 0 && num
>= (int )MEM_STATUS_BITS_NUM
)
7145 return ONIGERR_GROUP_NUMBER_OVER_FOR_CAPTURE_HISTORY
;
7147 r
= name_add(env
->reg
, name
, name_end
, num
, env
);
7148 if (r
!= 0) return r
;
7149 *np
= node_new_memory(1);
7150 CHECK_NULL_RETURN_MEMERR(*np
);
7151 BAG_(*np
)->m
.regnum
= num
;
7152 if (list_capture
!= 0)
7153 MEM_STATUS_ON_SIMPLE(env
->capture_history
, num
);
7157 return ONIGERR_UNDEFINED_GROUP_OPTION
;
7163 if (IS_SYNTAX_OP2(env
->syntax
, ONIG_SYN_OP2_QMARK_TILDE_ABSENT_GROUP
)) {
7167 int is_range_cutter
;
7169 if (PEND
) return ONIGERR_END_PATTERN_IN_GROUP
;
7171 if (PPEEK_IS('|')) { /* (?~|generator|absent) */
7173 if (PEND
) return ONIGERR_END_PATTERN_IN_GROUP
;
7176 if (PPEEK_IS(')')) { /* (?~|) : range clear */
7178 r
= make_range_clear(np
, env
);
7179 if (r
!= 0) return r
;
7186 r
= fetch_token(tok
, &p
, end
, env
);
7187 if (r
< 0) return r
;
7188 r
= parse_subexp(&absent
, tok
, term
, &p
, end
, env
, 1);
7190 onig_node_free(absent
);
7195 is_range_cutter
= 0;
7196 if (head_bar
!= 0) {
7198 if (NODE_TYPE(top
) != NODE_ALT
|| IS_NULL(NODE_CDR(top
))) {
7200 is_range_cutter
= 1;
7201 /* return ONIGERR_INVALID_ABSENT_GROUP_GENERATOR_PATTERN; */
7204 absent
= NODE_CAR(top
);
7205 expr
= NODE_CDR(top
);
7206 NODE_CAR(top
) = NULL_NODE
;
7207 NODE_CDR(top
) = NULL_NODE
;
7208 onig_node_free(top
);
7209 if (IS_NULL(NODE_CDR(expr
))) {
7211 expr
= NODE_CAR(top
);
7212 NODE_CAR(top
) = NULL_NODE
;
7213 onig_node_free(top
);
7218 r
= make_absent_tree(np
, absent
, expr
, is_range_cutter
, env
);
7225 return ONIGERR_UNDEFINED_GROUP_OPTION
;
7231 if (! IS_SYNTAX_OP2(env
->syntax
, ONIG_SYN_OP2_QMARK_BRACE_CALLOUT_CONTENTS
))
7232 return ONIGERR_UNDEFINED_GROUP_OPTION
;
7234 r
= parse_callout_of_contents(np
, ')', &p
, end
, env
);
7235 if (r
!= 0) return r
;
7243 if (IS_SYNTAX_OP2(env
->syntax
, ONIG_SYN_OP2_QMARK_LPAREN_IF_ELSE
)) {
7246 int condition_is_checker
;
7248 if (PEND
) return ONIGERR_END_PATTERN_IN_GROUP
;
7250 if (PEND
) return ONIGERR_END_PATTERN_IN_GROUP
;
7252 if (IS_CODE_DIGIT_ASCII(enc
, c
)
7253 || c
== '-' || c
== '+' || c
== '<' || c
== '\'') {
7258 enum REF_NUM num_type
;
7261 is_enclosed
= (c
== '<' || c
== '\'') ? 1 : 0;
7266 #ifdef USE_BACKREF_WITH_LEVEL
7267 name_end
= NULL_UCHARP
; /* no need. escape gcc warning. */
7268 r
= fetch_name_with_level(
7269 (OnigCodePoint
)(is_enclosed
!= 0 ? c
: '('),
7271 env
, &back_num
, &level
, &num_type
);
7272 if (r
== 1) exist_level
= 1;
7274 r
= fetch_name((OnigCodePoint
)(is_enclosed
!= 0 ? c
: '('),
7275 &p
, end
, &name_end
, env
, &back_num
, &num_type
, 1);
7278 if (is_enclosed
== 0) {
7285 condition_is_checker
= 1;
7286 if (num_type
!= IS_NOT_NUM
) {
7287 if (num_type
== IS_REL_NUM
) {
7288 back_num
= backref_rel_to_abs(back_num
, env
);
7291 return ONIGERR_INVALID_BACKREF
;
7293 if (IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_STRICT_CHECK_BACKREF
)) {
7294 if (back_num
> env
->num_mem
||
7295 IS_NULL(SCANENV_MEMENV(env
)[back_num
].node
))
7296 return ONIGERR_INVALID_BACKREF
;
7299 condition
= node_new_backref_checker(1, &back_num
, 0,
7300 #ifdef USE_BACKREF_WITH_LEVEL
7309 num
= name_to_group_numbers(env
, prev
, name_end
, &backs
);
7311 return ONIGERR_UNDEFINED_NAME_REFERENCE
;
7313 if (IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_STRICT_CHECK_BACKREF
)) {
7315 for (i
= 0; i
< num
; i
++) {
7316 if (backs
[i
] > env
->num_mem
||
7317 IS_NULL(SCANENV_MEMENV(env
)[backs
[i
]].node
))
7318 return ONIGERR_INVALID_BACKREF
;
7322 condition
= node_new_backref_checker(num
, backs
, 1,
7323 #ifdef USE_BACKREF_WITH_LEVEL
7329 if (is_enclosed
!= 0) {
7330 if (PEND
) goto err_if_else
;
7332 if (c
!= ')') goto err_if_else
;
7336 else if (c
== '?') {
7337 if (IS_SYNTAX_OP2(env
->syntax
,
7338 ONIG_SYN_OP2_QMARK_BRACE_CALLOUT_CONTENTS
)) {
7339 if (! PEND
&& PPEEK_IS('{')) {
7340 /* condition part is callouts of contents: (?(?{...})THEN|ELSE) */
7341 condition_is_checker
= 0;
7343 r
= parse_callout_of_contents(&condition
, ')', &p
, end
, env
);
7344 if (r
!= 0) return r
;
7350 else if (c
== '*' &&
7351 IS_SYNTAX_OP2(env
->syntax
, ONIG_SYN_OP2_ASTERISK_CALLOUT_NAME
)) {
7352 condition_is_checker
= 0;
7353 r
= parse_callout_of_name(&condition
, ')', &p
, end
, env
);
7354 if (r
!= 0) return r
;
7361 condition_is_checker
= 0;
7362 r
= fetch_token(tok
, &p
, end
, env
);
7363 if (r
< 0) return r
;
7364 r
= parse_subexp(&condition
, tok
, term
, &p
, end
, env
, 0);
7366 onig_node_free(condition
);
7374 CHECK_NULL_RETURN_MEMERR(condition
);
7378 onig_node_free(condition
);
7379 return ONIGERR_END_PATTERN_IN_GROUP
;
7382 if (PPEEK_IS(')')) { /* case: empty body: make backref checker */
7383 if (condition_is_checker
== 0) {
7384 onig_node_free(condition
);
7385 return ONIGERR_INVALID_IF_ELSE_SYNTAX
;
7390 else { /* if-else */
7395 if (PPEEK_IS('|')) {
7402 r
= fetch_token(tok
, &p
, end
, env
);
7404 onig_node_free(condition
);
7407 r
= parse_subexp(&target
, tok
, term
, &p
, end
, env
, 1);
7409 onig_node_free(condition
);
7410 onig_node_free(target
);
7414 if (then_is_empty
!= 0) {
7418 if (NODE_TYPE(target
) == NODE_ALT
) {
7419 Then
= NODE_CAR(target
);
7420 if (NODE_CDR(NODE_CDR(target
)) == NULL_NODE
) {
7421 Else
= NODE_CAR(NODE_CDR(target
));
7422 cons_node_free_alone(NODE_CDR(target
));
7425 Else
= NODE_CDR(target
);
7427 cons_node_free_alone(target
);
7435 *np
= node_new_bag_if_else(condition
, Then
, Else
);
7437 onig_node_free(condition
);
7438 onig_node_free(Then
);
7439 onig_node_free(Else
);
7440 return ONIGERR_MEMORY
;
7446 return ONIGERR_UNDEFINED_GROUP_OPTION
;
7450 #ifdef USE_CAPTURE_HISTORY
7452 if (IS_SYNTAX_OP2(env
->syntax
, ONIG_SYN_OP2_ATMARK_CAPTURE_HISTORY
)) {
7453 if (IS_SYNTAX_OP2(env
->syntax
, ONIG_SYN_OP2_QMARK_LT_NAMED_GROUP
)) {
7455 if (c
== '<' || c
== '\'') {
7457 goto named_group2
; /* (?@<name>...) */
7462 *np
= node_new_memory(0);
7463 CHECK_NULL_RETURN_MEMERR(*np
);
7464 num
= scan_env_add_mem_entry(env
);
7468 else if (num
>= (int )MEM_STATUS_BITS_NUM
) {
7469 return ONIGERR_GROUP_NUMBER_OVER_FOR_CAPTURE_HISTORY
;
7471 BAG_(*np
)->m
.regnum
= num
;
7472 MEM_STATUS_ON_SIMPLE(env
->capture_history
, num
);
7475 return ONIGERR_UNDEFINED_GROUP_OPTION
;
7480 #ifdef USE_POSIXLINE_OPTION
7483 case '-': case 'i': case 'm': case 's': case 'x':
7484 case 'W': case 'D': case 'S': case 'P':
7495 case '-': neg
= 1; break;
7496 case 'x': OPTION_NEGATE(option
, ONIG_OPTION_EXTEND
, neg
); break;
7497 case 'i': OPTION_NEGATE(option
, ONIG_OPTION_IGNORECASE
, neg
); break;
7499 if (IS_SYNTAX_OP2(env
->syntax
, ONIG_SYN_OP2_OPTION_PERL
)) {
7500 OPTION_NEGATE(option
, ONIG_OPTION_MULTILINE
, neg
);
7503 return ONIGERR_UNDEFINED_GROUP_OPTION
;
7507 if (IS_SYNTAX_OP2(env
->syntax
, ONIG_SYN_OP2_OPTION_PERL
)) {
7508 OPTION_NEGATE(option
, ONIG_OPTION_SINGLELINE
, (neg
== 0 ? 1 : 0));
7510 else if (IS_SYNTAX_OP2(env
->syntax
,
7511 ONIG_SYN_OP2_OPTION_ONIGURUMA
|ONIG_SYN_OP2_OPTION_RUBY
)) {
7512 OPTION_NEGATE(option
, ONIG_OPTION_MULTILINE
, neg
);
7515 return ONIGERR_UNDEFINED_GROUP_OPTION
;
7517 #ifdef USE_POSIXLINE_OPTION
7519 OPTION_NEGATE(option
, ONIG_OPTION_MULTILINE
|ONIG_OPTION_SINGLELINE
, neg
);
7522 case 'W': OPTION_NEGATE(option
, ONIG_OPTION_WORD_IS_ASCII
, neg
); break;
7523 case 'D': OPTION_NEGATE(option
, ONIG_OPTION_DIGIT_IS_ASCII
, neg
); break;
7524 case 'S': OPTION_NEGATE(option
, ONIG_OPTION_SPACE_IS_ASCII
, neg
); break;
7525 case 'P': OPTION_NEGATE(option
, ONIG_OPTION_POSIX_IS_ASCII
, neg
); break;
7527 case 'y': /* y{g}, y{w} */
7529 if (! IS_SYNTAX_OP2(env
->syntax
, ONIG_SYN_OP2_OPTION_ONIGURUMA
))
7530 return ONIGERR_UNDEFINED_GROUP_OPTION
;
7532 if (neg
!= 0) return ONIGERR_UNDEFINED_GROUP_OPTION
;
7534 if (PEND
) return ONIGERR_END_PATTERN_IN_GROUP
;
7535 if (! PPEEK_IS('{')) return ONIGERR_UNDEFINED_GROUP_OPTION
;
7537 if (PEND
) return ONIGERR_END_PATTERN_IN_GROUP
;
7541 if (! ONIGENC_IS_UNICODE_ENCODING(enc
))
7542 return ONIGERR_UNDEFINED_GROUP_OPTION
;
7544 OPTION_NEGATE(option
, ONIG_OPTION_TEXT_SEGMENT_EXTENDED_GRAPHEME_CLUSTER
, 0);
7545 OPTION_NEGATE(option
, ONIG_OPTION_TEXT_SEGMENT_WORD
, 1);
7547 #ifdef USE_UNICODE_WORD_BREAK
7549 if (! ONIGENC_IS_UNICODE_ENCODING(enc
))
7550 return ONIGERR_UNDEFINED_GROUP_OPTION
;
7552 OPTION_NEGATE(option
, ONIG_OPTION_TEXT_SEGMENT_WORD
, 0);
7553 OPTION_NEGATE(option
, ONIG_OPTION_TEXT_SEGMENT_EXTENDED_GRAPHEME_CLUSTER
, 1);
7557 return ONIGERR_UNDEFINED_GROUP_OPTION
;
7560 if (PEND
) return ONIGERR_END_PATTERN_IN_GROUP
;
7563 return ONIGERR_UNDEFINED_GROUP_OPTION
;
7568 return ONIGERR_UNDEFINED_GROUP_OPTION
;
7572 *np
= node_new_option(option
);
7573 CHECK_NULL_RETURN_MEMERR(*np
);
7575 return 2; /* option only */
7577 else if (c
== ':') {
7578 OnigOptionType prev
= env
->options
;
7580 env
->options
= option
;
7581 r
= fetch_token(tok
, &p
, end
, env
);
7582 if (r
< 0) return r
;
7583 r
= parse_subexp(&target
, tok
, term
, &p
, end
, env
, 0);
7584 env
->options
= prev
;
7586 onig_node_free(target
);
7589 *np
= node_new_option(option
);
7590 CHECK_NULL_RETURN_MEMERR(*np
);
7591 NODE_BODY(*np
) = target
;
7596 if (PEND
) return ONIGERR_END_PATTERN_IN_GROUP
;
7603 return ONIGERR_UNDEFINED_GROUP_OPTION
;
7607 else if (c
== '*' &&
7608 IS_SYNTAX_OP2(env
->syntax
, ONIG_SYN_OP2_ASTERISK_CALLOUT_NAME
)) {
7610 r
= parse_callout_of_name(np
, ')', &p
, end
, env
);
7611 if (r
!= 0) return r
;
7617 if (ONIG_IS_OPTION_ON(env
->options
, ONIG_OPTION_DONT_CAPTURE_GROUP
))
7620 *np
= node_new_memory(0);
7621 CHECK_NULL_RETURN_MEMERR(*np
);
7622 num
= scan_env_add_mem_entry(env
);
7623 if (num
< 0) return num
;
7624 BAG_(*np
)->m
.regnum
= num
;
7627 CHECK_NULL_RETURN_MEMERR(*np
);
7628 r
= fetch_token(tok
, &p
, end
, env
);
7629 if (r
< 0) return r
;
7630 r
= parse_subexp(&target
, tok
, term
, &p
, end
, env
, 0);
7632 onig_node_free(target
);
7636 NODE_BODY(*np
) = target
;
7638 if (NODE_TYPE(*np
) == NODE_BAG
) {
7639 if (BAG_(*np
)->type
== BAG_MEMORY
) {
7640 /* Don't move this to previous of parse_subexp() */
7641 r
= scan_env_set_mem_node(env
, BAG_(*np
)->m
.regnum
, *np
);
7642 if (r
!= 0) return r
;
7651 static const char* PopularQStr
[] = {
7652 "?", "*", "+", "??", "*?", "+?"
7655 static const char* ReduceQStr
[] = {
7656 "", "", "*", "*?", "??", "+ and ??", "+? and ?"
7660 set_quantifier(Node
* qnode
, Node
* target
, int group
, ScanEnv
* env
)
7665 if (qn
->lower
== 1 && qn
->upper
== 1)
7668 switch (NODE_TYPE(target
)) {
7671 if (str_node_can_be_split(target
, env
->enc
)) {
7672 Node
* n
= str_node_split_last_char(target
, env
->enc
);
7673 if (IS_NOT_NULL(n
)) {
7674 NODE_BODY(qnode
) = n
;
7682 { /* check redundant double repeat. */
7683 /* verbose warn (?:.?)? etc... but not warn (.?)? etc... */
7684 QuantNode
* qnt
= QUANT_(target
);
7685 int nestq_num
= quantifier_type_num(qn
);
7686 int targetq_num
= quantifier_type_num(qnt
);
7688 #ifdef USE_WARNING_REDUNDANT_NESTED_REPEAT_OPERATOR
7689 if (targetq_num
>= 0 && nestq_num
>= 0 &&
7690 IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_WARN_REDUNDANT_NESTED_REPEAT
)) {
7691 UChar buf
[WARN_BUFSIZE
];
7693 switch(ReduceTypeTable
[targetq_num
][nestq_num
]) {
7698 if (onig_verb_warn
!= onig_null_warn
) {
7699 onig_snprintf_with_pattern(buf
, WARN_BUFSIZE
, env
->enc
,
7700 env
->pattern
, env
->pattern_end
,
7701 (UChar
* )"redundant nested repeat operator");
7702 (*onig_verb_warn
)((char* )buf
);
7708 if (onig_verb_warn
!= onig_null_warn
) {
7709 onig_snprintf_with_pattern(buf
, WARN_BUFSIZE
, env
->enc
,
7710 env
->pattern
, env
->pattern_end
,
7711 (UChar
* )"nested repeat operator %s and %s was replaced with '%s'",
7712 PopularQStr
[targetq_num
], PopularQStr
[nestq_num
],
7713 ReduceQStr
[ReduceTypeTable
[targetq_num
][nestq_num
]]);
7714 (*onig_verb_warn
)((char* )buf
);
7723 if (targetq_num
>= 0 && nestq_num
< 0) {
7724 if (targetq_num
== 1 || targetq_num
== 2) { /* * or + */
7725 /* (?:a*){n,m}, (?:a+){n,m} => (?:a*){n,n}, (?:a+){n,n} */
7726 if (! IS_INFINITE_REPEAT(qn
->upper
) && qn
->upper
> 1 && qn
->greedy
) {
7727 qn
->upper
= (qn
->lower
== 0 ? 1 : qn
->lower
);
7732 NODE_BODY(qnode
) = target
;
7733 onig_reduce_nested_quantifier(qnode
, target
);
7743 NODE_BODY(qnode
) = target
;
7749 #ifndef CASE_FOLD_IS_APPLIED_INSIDE_NEGATIVE_CCLASS
7751 clear_not_flag_cclass(CClassNode
* cc
, OnigEncoding enc
)
7756 if (IS_NCCLASS_NOT(cc
)) {
7757 bitset_invert(cc
->bs
);
7759 if (! ONIGENC_IS_SINGLEBYTE(enc
)) {
7760 r
= not_code_range_buf(enc
, cc
->mbuf
, &tbuf
);
7761 if (r
!= 0) return r
;
7763 bbuf_free(cc
->mbuf
);
7767 NCCLASS_CLEAR_NOT(cc
);
7772 #endif /* CASE_FOLD_IS_APPLIED_INSIDE_NEGATIVE_CCLASS */
7779 } IApplyCaseFoldArg
;
7782 i_apply_case_fold(OnigCodePoint from
, OnigCodePoint to
[], int to_len
, void* arg
)
7784 IApplyCaseFoldArg
* iarg
;
7789 iarg
= (IApplyCaseFoldArg
* )arg
;
7795 int is_in
= onig_is_code_in_cc(env
->enc
, from
, cc
);
7796 #ifdef CASE_FOLD_IS_APPLIED_INSIDE_NEGATIVE_CCLASS
7797 if ((is_in
!= 0 && !IS_NCCLASS_NOT(cc
)) ||
7798 (is_in
== 0 && IS_NCCLASS_NOT(cc
))) {
7799 if (ONIGENC_MBC_MINLEN(env
->enc
) > 1 || *to
>= SINGLE_BYTE_SIZE
) {
7800 add_code_range(&(cc
->mbuf
), env
, *to
, *to
);
7803 BITSET_SET_BIT(bs
, *to
);
7808 if (ONIGENC_MBC_MINLEN(env
->enc
) > 1 || *to
>= SINGLE_BYTE_SIZE
) {
7809 if (IS_NCCLASS_NOT(cc
)) clear_not_flag_cclass(cc
, env
->enc
);
7810 add_code_range(&(cc
->mbuf
), env
, *to
, *to
);
7813 if (IS_NCCLASS_NOT(cc
)) {
7814 BITSET_CLEAR_BIT(bs
, *to
);
7817 BITSET_SET_BIT(bs
, *to
);
7820 #endif /* CASE_FOLD_IS_APPLIED_INSIDE_NEGATIVE_CCLASS */
7824 UChar buf
[ONIGENC_CODE_TO_MBC_MAXLEN
];
7825 Node
*snode
= NULL_NODE
;
7827 if (onig_is_code_in_cc(env
->enc
, from
, cc
)
7828 #ifdef CASE_FOLD_IS_APPLIED_INSIDE_NEGATIVE_CCLASS
7829 && !IS_NCCLASS_NOT(cc
)
7832 for (i
= 0; i
< to_len
; i
++) {
7833 len
= ONIGENC_CODE_TO_MBC(env
->enc
, to
[i
], buf
);
7835 snode
= onig_node_new_str(buf
, buf
+ len
);
7836 CHECK_NULL_RETURN_MEMERR(snode
);
7838 /* char-class expanded multi-char only
7839 compare with string folded at match time. */
7840 NODE_STRING_SET_AMBIG(snode
);
7843 r
= onig_node_str_cat(snode
, buf
, buf
+ len
);
7845 onig_node_free(snode
);
7851 *(iarg
->ptail
) = onig_node_new_alt(snode
, NULL_NODE
);
7852 CHECK_NULL_RETURN_MEMERR(*(iarg
->ptail
));
7853 iarg
->ptail
= &(NODE_CDR((*(iarg
->ptail
))));
7861 parse_exp(Node
** np
, PToken
* tok
, int term
, UChar
** src
, UChar
* end
,
7862 ScanEnv
* env
, int group_head
)
7867 unsigned int parse_depth
;
7871 if (tok
->type
== (enum TokenSyms
)term
)
7874 parse_depth
= env
->parse_depth
;
7876 switch (tok
->type
) {
7880 *np
= node_new_empty();
7881 CHECK_NULL_RETURN_MEMERR(*np
);
7885 case TK_SUBEXP_OPEN
:
7886 r
= parse_bag(np
, tok
, TK_SUBEXP_CLOSE
, src
, end
, env
);
7887 if (r
< 0) return r
;
7888 if (r
== 1) { /* group */
7889 if (group_head
== 0)
7893 *np
= node_new_group(target
);
7895 onig_node_free(target
);
7896 return ONIGERR_MEMORY
;
7901 else if (r
== 2) { /* option only */
7903 OnigOptionType prev
= env
->options
;
7905 env
->options
= BAG_(*np
)->o
.options
;
7906 r
= fetch_token(tok
, src
, end
, env
);
7907 if (r
< 0) return r
;
7908 r
= parse_subexp(&target
, tok
, term
, src
, end
, env
, 0);
7909 env
->options
= prev
;
7911 onig_node_free(target
);
7914 NODE_BODY(*np
) = target
;
7919 case TK_SUBEXP_CLOSE
:
7920 if (! IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_ALLOW_UNMATCHED_CLOSE_SUBEXP
))
7921 return ONIGERR_UNMATCHED_CLOSE_PARENTHESIS
;
7923 if (tok
->escaped
) goto tk_raw_byte
;
7930 *np
= node_new_str(tok
->backp
, *src
);
7931 CHECK_NULL_RETURN_MEMERR(*np
);
7934 r
= fetch_token(tok
, src
, end
, env
);
7935 if (r
< 0) return r
;
7936 if (r
!= TK_STRING
) break;
7938 r
= onig_node_str_cat(*np
, tok
->backp
, *src
);
7939 if (r
< 0) return r
;
7951 *np
= node_new_str_raw_char((UChar
)tok
->u
.c
);
7952 CHECK_NULL_RETURN_MEMERR(*np
);
7955 if (len
>= ONIGENC_MBC_MINLEN(env
->enc
)) {
7956 if (len
== enclen(env
->enc
, STR_(*np
)->s
)) {
7957 r
= fetch_token(tok
, src
, end
, env
);
7958 goto tk_raw_byte_end
;
7962 r
= fetch_token(tok
, src
, end
, env
);
7963 if (r
< 0) return r
;
7964 if (r
!= TK_RAW_BYTE
)
7965 return ONIGERR_TOO_SHORT_MULTI_BYTE_STRING
;
7967 r
= node_str_cat_char(*np
, (UChar
)tok
->u
.c
);
7968 if (r
< 0) return r
;
7974 if (! ONIGENC_IS_VALID_MBC_STRING(env
->enc
, STR_(*np
)->s
, STR_(*np
)->end
))
7975 return ONIGERR_INVALID_WIDE_CHAR_VALUE
;
7977 NODE_STRING_CLEAR_RAW(*np
);
7984 UChar buf
[ONIGENC_CODE_TO_MBC_MAXLEN
];
7985 len
= ONIGENC_CODE_TO_MBC(env
->enc
, tok
->u
.code
, buf
);
7986 if (len
< 0) return len
;
7987 #ifdef NUMBERED_CHAR_IS_NOT_CASE_AMBIG
7988 *np
= node_new_str_raw(buf
, buf
+ len
);
7990 *np
= node_new_str(buf
, buf
+ len
);
7992 CHECK_NULL_RETURN_MEMERR(*np
);
7998 OnigCodePoint end_op
[2];
7999 UChar
*qstart
, *qend
, *nextp
;
8001 end_op
[0] = (OnigCodePoint
)MC_ESC(env
->syntax
);
8002 end_op
[1] = (OnigCodePoint
)'E';
8004 qend
= find_str_position(end_op
, 2, qstart
, end
, &nextp
, env
->enc
);
8005 if (IS_NULL(qend
)) {
8008 *np
= node_new_str(qstart
, qend
);
8009 CHECK_NULL_RETURN_MEMERR(*np
);
8016 switch (tok
->u
.prop
.ctype
) {
8017 case ONIGENC_CTYPE_WORD
:
8018 *np
= node_new_ctype(tok
->u
.prop
.ctype
, tok
->u
.prop
.not, env
->options
);
8019 CHECK_NULL_RETURN_MEMERR(*np
);
8022 case ONIGENC_CTYPE_SPACE
:
8023 case ONIGENC_CTYPE_DIGIT
:
8024 case ONIGENC_CTYPE_XDIGIT
:
8028 *np
= node_new_cclass();
8029 CHECK_NULL_RETURN_MEMERR(*np
);
8031 add_ctype_to_cc(cc
, tok
->u
.prop
.ctype
, 0, env
);
8032 if (tok
->u
.prop
.not != 0) NCCLASS_SET_NOT(cc
);
8037 return ONIGERR_PARSER_BUG
;
8043 case TK_CHAR_PROPERTY
:
8044 r
= parse_char_property(np
, tok
, src
, end
, env
);
8045 if (r
!= 0) return r
;
8052 r
= parse_char_class(np
, tok
, src
, end
, env
);
8053 if (r
!= 0) return r
;
8056 if (IS_IGNORECASE(env
->options
)) {
8057 IApplyCaseFoldArg iarg
;
8061 iarg
.alt_root
= NULL_NODE
;
8062 iarg
.ptail
= &(iarg
.alt_root
);
8064 r
= ONIGENC_APPLY_ALL_CASE_FOLD(env
->enc
, env
->case_fold_flag
,
8065 i_apply_case_fold
, &iarg
);
8067 onig_node_free(iarg
.alt_root
);
8070 if (IS_NOT_NULL(iarg
.alt_root
)) {
8071 Node
* work
= onig_node_new_alt(*np
, iarg
.alt_root
);
8072 if (IS_NULL(work
)) {
8073 onig_node_free(iarg
.alt_root
);
8074 return ONIGERR_MEMORY
;
8083 *np
= node_new_anychar();
8084 CHECK_NULL_RETURN_MEMERR(*np
);
8087 case TK_ANYCHAR_ANYTIME
:
8088 *np
= node_new_anychar();
8089 CHECK_NULL_RETURN_MEMERR(*np
);
8090 qn
= node_new_quantifier(0, INFINITE_REPEAT
, 0);
8091 CHECK_NULL_RETURN_MEMERR(qn
);
8092 NODE_BODY(qn
) = *np
;
8097 len
= tok
->u
.backref
.num
;
8098 *np
= node_new_backref(len
,
8099 (len
> 1 ? tok
->u
.backref
.refs
: &(tok
->u
.backref
.ref1
)),
8100 tok
->u
.backref
.by_name
,
8101 #ifdef USE_BACKREF_WITH_LEVEL
8102 tok
->u
.backref
.exist_level
,
8103 tok
->u
.backref
.level
,
8106 CHECK_NULL_RETURN_MEMERR(*np
);
8112 int gnum
= tok
->u
.call
.gnum
;
8114 *np
= node_new_call(tok
->u
.call
.name
, tok
->u
.call
.name_end
,
8115 gnum
, tok
->u
.call
.by_number
);
8116 CHECK_NULL_RETURN_MEMERR(*np
);
8118 if (tok
->u
.call
.by_number
!= 0 && gnum
== 0) {
8119 env
->has_call_zero
= 1;
8128 IS_WORD_ASCII(env
->options
) && IS_WORD_ANCHOR_TYPE(tok
->u
.anchor
) ? 1 : 0;
8129 *np
= onig_node_new_anchor(tok
->u
.anchor
, ascii_mode
);
8130 CHECK_NULL_RETURN_MEMERR(*np
);
8136 if (IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_CONTEXT_INDEP_REPEAT_OPS
)) {
8137 if (IS_SYNTAX_BV(env
->syntax
, ONIG_SYN_CONTEXT_INVALID_REPEAT_OPS
))
8138 return ONIGERR_TARGET_OF_REPEAT_OPERATOR_NOT_SPECIFIED
;
8140 *np
= node_new_empty();
8141 CHECK_NULL_RETURN_MEMERR(*np
);
8150 r
= node_new_keep(np
, env
);
8151 if (r
< 0) return r
;
8154 case TK_GENERAL_NEWLINE
:
8155 r
= node_new_general_newline(np
, env
);
8156 if (r
< 0) return r
;
8160 r
= node_new_no_newline(np
, env
);
8161 if (r
< 0) return r
;
8164 case TK_TRUE_ANYCHAR
:
8165 r
= node_new_true_anychar(np
, env
);
8166 if (r
< 0) return r
;
8169 case TK_TEXT_SEGMENT
:
8170 r
= make_text_segment(np
, env
);
8171 if (r
< 0) return r
;
8175 return ONIGERR_PARSER_BUG
;
8183 r
= fetch_token(tok
, src
, end
, env
);
8184 if (r
< 0) return r
;
8187 if (r
== TK_REPEAT
|| r
== TK_INTERVAL
) {
8190 if (is_invalid_quantifier_target(*tp
))
8191 return ONIGERR_TARGET_OF_REPEAT_OPERATOR_INVALID
;
8194 if (parse_depth
> ParseDepthLimit
)
8195 return ONIGERR_PARSE_DEPTH_LIMIT_OVER
;
8197 qn
= node_new_quantifier(tok
->u
.repeat
.lower
, tok
->u
.repeat
.upper
,
8199 CHECK_NULL_RETURN_MEMERR(qn
);
8200 QUANT_(qn
)->greedy
= tok
->u
.repeat
.greedy
;
8202 target
= node_drop_group(*tp
);
8208 r
= set_quantifier(qn
, target
, group
, env
);
8214 if (tok
->u
.repeat
.possessive
!= 0) {
8216 en
= node_new_bag(BAG_STOP_BACKTRACK
);
8219 return ONIGERR_MEMORY
;
8228 else if (r
== 1) { /* x{1,1} ==> x */
8232 else if (r
== 2) { /* split case: /abc+/ */
8235 *tp
= node_new_list(*tp
, NULL
);
8238 return ONIGERR_MEMORY
;
8240 tmp
= NODE_CDR(*tp
) = node_new_list(qn
, NULL
);
8243 return ONIGERR_MEMORY
;
8245 tp
= &(NODE_CAR(tmp
));
8256 parse_branch(Node
** top
, PToken
* tok
, int term
, UChar
** src
, UChar
* end
,
8257 ScanEnv
* env
, int group_head
)
8260 Node
*node
, **headp
;
8263 r
= parse_exp(&node
, tok
, term
, src
, end
, env
, group_head
);
8265 onig_node_free(node
);
8269 if (r
== TK_EOT
|| r
== term
|| r
== TK_ALT
) {
8273 *top
= node_new_list(node
, NULL
);
8274 if (IS_NULL(*top
)) {
8275 onig_node_free(node
);
8276 return ONIGERR_MEMORY
;
8279 headp
= &(NODE_CDR(*top
));
8280 while (r
!= TK_EOT
&& r
!= term
&& r
!= TK_ALT
) {
8281 r
= parse_exp(&node
, tok
, term
, src
, end
, env
, 0);
8283 onig_node_free(node
);
8287 if (NODE_TYPE(node
) == NODE_LIST
) {
8289 while (IS_NOT_NULL(NODE_CDR(node
))) node
= NODE_CDR(node
);
8290 headp
= &(NODE_CDR(node
));
8293 *headp
= node_new_list(node
, NULL
);
8294 headp
= &(NODE_CDR(*headp
));
8302 /* term_tok: TK_EOT or TK_SUBEXP_CLOSE */
8304 parse_subexp(Node
** top
, PToken
* tok
, int term
, UChar
** src
, UChar
* end
,
8305 ScanEnv
* env
, int group_head
)
8308 Node
*node
, **headp
;
8312 if (env
->parse_depth
> ParseDepthLimit
)
8313 return ONIGERR_PARSE_DEPTH_LIMIT_OVER
;
8315 r
= parse_branch(&node
, tok
, term
, src
, end
, env
, group_head
);
8317 onig_node_free(node
);
8324 else if (r
== TK_ALT
) {
8325 *top
= onig_node_new_alt(node
, NULL
);
8326 if (IS_NULL(*top
)) {
8327 onig_node_free(node
);
8328 return ONIGERR_MEMORY
;
8331 headp
= &(NODE_CDR(*top
));
8332 while (r
== TK_ALT
) {
8333 r
= fetch_token(tok
, src
, end
, env
);
8334 if (r
< 0) return r
;
8335 r
= parse_branch(&node
, tok
, term
, src
, end
, env
, 0);
8337 onig_node_free(node
);
8340 *headp
= onig_node_new_alt(node
, NULL
);
8341 if (IS_NULL(*headp
)) {
8342 onig_node_free(node
);
8343 onig_node_free(*top
);
8344 return ONIGERR_MEMORY
;
8347 headp
= &(NODE_CDR(*headp
));
8350 if (tok
->type
!= (enum TokenSyms
)term
)
8354 onig_node_free(node
);
8356 if (term
== TK_SUBEXP_CLOSE
)
8357 return ONIGERR_END_PATTERN_WITH_UNMATCHED_PARENTHESIS
;
8359 return ONIGERR_PARSER_BUG
;
8367 parse_regexp(Node
** top
, UChar
** src
, UChar
* end
, ScanEnv
* env
)
8372 r
= fetch_token(&tok
, src
, end
, env
);
8373 if (r
< 0) return r
;
8374 r
= parse_subexp(top
, &tok
, TK_EOT
, src
, end
, env
, 0);
8375 if (r
< 0) return r
;
8382 make_call_zero_body(Node
* node
, ScanEnv
* env
, Node
** rnode
)
8386 Node
* x
= node_new_memory(0 /* 0: is not named */);
8387 CHECK_NULL_RETURN_MEMERR(x
);
8389 NODE_BODY(x
) = node
;
8390 BAG_(x
)->m
.regnum
= 0;
8391 r
= scan_env_set_mem_node(env
, 0, x
);
8403 onig_parse_tree(Node
** root
, const UChar
* pattern
, const UChar
* end
,
8404 regex_t
* reg
, ScanEnv
* env
)
8414 scan_env_clear(env
);
8415 env
->options
= reg
->options
;
8416 env
->case_fold_flag
= reg
->case_fold_flag
;
8417 env
->enc
= reg
->enc
;
8418 env
->syntax
= reg
->syntax
;
8419 env
->pattern
= (UChar
* )pattern
;
8420 env
->pattern_end
= (UChar
* )end
;
8425 if (! ONIGENC_IS_VALID_MBC_STRING(env
->enc
, pattern
, end
))
8426 return ONIGERR_INVALID_WIDE_CHAR_VALUE
;
8428 p
= (UChar
* )pattern
;
8429 r
= parse_regexp(root
, &p
, (UChar
* )end
, env
);
8432 if (r
!= 0) return r
;
8434 if (env
->has_call_zero
!= 0) {
8436 r
= make_call_zero_body(*root
, env
, &zero_node
);
8437 if (r
!= 0) return r
;
8443 reg
->num_mem
= env
->num_mem
;
8447 if (IS_NOT_NULL(ext
) && ext
->callout_num
> 0) {
8448 r
= setup_ext_callout_list_values(reg
);
8456 onig_scan_env_set_error_string(ScanEnv
* env
, int ecode ARG_UNUSED
,
8457 UChar
* arg
, UChar
* arg_end
)
8460 env
->error_end
= arg_end
;