#define reguni(a,b,c) S_reguni(aTHX_ a,b,c)
#define regwhite S_regwhite
#define scan_commit(a,b,c,d) S_scan_commit(aTHX_ a,b,c,d)
-#define set_regclass_bit(a,b,c,d) S_set_regclass_bit(aTHX_ a,b,c,d)
-#define set_regclass_bit_fold(a,b,c,d) S_set_regclass_bit_fold(aTHX_ a,b,c,d)
+#define set_regclass_bit(a,b,c,d,e) S_set_regclass_bit(aTHX_ a,b,c,d,e)
+#define set_regclass_bit_fold(a,b,c,d,e) S_set_regclass_bit_fold(aTHX_ a,b,c,d,e)
#define study_chunk(a,b,c,d,e,f,g,h,i,j,k) S_study_chunk(aTHX_ a,b,c,d,e,f,g,h,i,j,k)
# endif
# if defined(PERL_IN_REGEXEC_C)
#define PERL_ARGS_ASSERT_SCAN_COMMIT \
assert(pRExC_state); assert(data); assert(minlenp)
-PERL_STATIC_INLINE U8 S_set_regclass_bit(pTHX_ struct RExC_state_t* pRExC_state, regnode* node, const U8 value, HV** nonbitmap_ptr)
+PERL_STATIC_INLINE U8 S_set_regclass_bit(pTHX_ struct RExC_state_t* pRExC_state, regnode* node, const U8 value, HV** invlist_ptr, AV** alternate_ptr)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2)
- __attribute__nonnull__(pTHX_4);
+ __attribute__nonnull__(pTHX_4)
+ __attribute__nonnull__(pTHX_5);
#define PERL_ARGS_ASSERT_SET_REGCLASS_BIT \
- assert(pRExC_state); assert(node); assert(nonbitmap_ptr)
+ assert(pRExC_state); assert(node); assert(invlist_ptr); assert(alternate_ptr)
-STATIC U8 S_set_regclass_bit_fold(pTHX_ struct RExC_state_t *pRExC_state, regnode* node, const U8 value, HV** nonbitmap_ptr)
+STATIC U8 S_set_regclass_bit_fold(pTHX_ struct RExC_state_t *pRExC_state, regnode* node, const U8 value, HV** invlist_ptr, AV** alternate_ptr)
__attribute__nonnull__(pTHX_1)
__attribute__nonnull__(pTHX_2)
- __attribute__nonnull__(pTHX_4);
+ __attribute__nonnull__(pTHX_4)
+ __attribute__nonnull__(pTHX_5);
#define PERL_ARGS_ASSERT_SET_REGCLASS_BIT_FOLD \
- assert(pRExC_state); assert(node); assert(nonbitmap_ptr)
+ assert(pRExC_state); assert(node); assert(invlist_ptr); assert(alternate_ptr)
STATIC I32 S_study_chunk(pTHX_ struct RExC_state_t *pRExC_state, regnode **scanp, I32 *minlenp, I32 *deltap, regnode *last, struct scan_data_t *data, I32 stopparen, U8* recursed, struct regnode_charclass_class *and_withp, U32 flags, U32 depth)
__attribute__nonnull__(pTHX_1)
ANYOF_##NAME: \
for (value = 0; value < 256; value++) \
if (TEST) \
- stored += set_regclass_bit(pRExC_state, ret, (U8) value, &nonbitmap); \
+ stored += set_regclass_bit(pRExC_state, ret, (U8) value, &nonbitmap, &unicode_alternate); \
yesno = '+'; \
what = WORD; \
break; \
case ANYOF_N##NAME: \
for (value = 0; value < 256; value++) \
if (!TEST) \
- stored += set_regclass_bit(pRExC_state, ret, (U8) value, &nonbitmap); \
+ stored += set_regclass_bit(pRExC_state, ret, (U8) value, &nonbitmap, &unicode_alternate); \
yesno = '!'; \
what = WORD; \
break
else if (UNI_SEMANTICS) { \
for (value = 0; value < 256; value++) { \
if (TEST_8(value)) stored += \
- set_regclass_bit(pRExC_state, ret, (U8) value, &nonbitmap); \
+ set_regclass_bit(pRExC_state, ret, (U8) value, &nonbitmap, &unicode_alternate); \
} \
} \
else { \
for (value = 0; value < 128; value++) { \
if (TEST_7(UNI_TO_NATIVE(value))) stored += \
set_regclass_bit(pRExC_state, ret, \
- (U8) UNI_TO_NATIVE(value), &nonbitmap); \
+ (U8) UNI_TO_NATIVE(value), &nonbitmap, &unicode_alternate); \
} \
} \
yesno = '+'; \
else if (UNI_SEMANTICS) { \
for (value = 0; value < 256; value++) { \
if (! TEST_8(value)) stored += \
- set_regclass_bit(pRExC_state, ret, (U8) value, &nonbitmap); \
+ set_regclass_bit(pRExC_state, ret, (U8) value, &nonbitmap, &unicode_alternate); \
} \
} \
else { \
for (value = 0; value < 128; value++) { \
if (! TEST_7(UNI_TO_NATIVE(value))) stored += set_regclass_bit( \
- pRExC_state, ret, (U8) UNI_TO_NATIVE(value), &nonbitmap); \
+ pRExC_state, ret, (U8) UNI_TO_NATIVE(value), &nonbitmap, &unicode_alternate); \
} \
if (AT_LEAST_ASCII_RESTRICTED) { \
for (value = 128; value < 256; value++) { \
stored += set_regclass_bit( \
- pRExC_state, ret, (U8) UNI_TO_NATIVE(value), &nonbitmap); \
+ pRExC_state, ret, (U8) UNI_TO_NATIVE(value), &nonbitmap, &unicode_alternate); \
} \
ANYOF_FLAGS(ret) |= ANYOF_UNICODE_ALL; \
} \
#endif
STATIC U8
-S_set_regclass_bit_fold(pTHX_ RExC_state_t *pRExC_state, regnode* node, const U8 value, HV** nonbitmap_ptr)
+S_set_regclass_bit_fold(pTHX_ RExC_state_t *pRExC_state, regnode* node, const U8 value, HV** invlist_ptr, AV** alternate_ptr)
{
/* Handle the setting of folds in the bitmap for non-locale ANYOF nodes.
and they have a fold, they should match if the target is utf8, and
not otherwise. We add the character here, and calculate the fold
later, with the other nonbitmap folds */
- *nonbitmap_ptr = add_range_to_invlist(*nonbitmap_ptr, value, value);
+ *invlist_ptr = add_range_to_invlist(*invlist_ptr, value, value);
}
return stored;
PERL_STATIC_INLINE U8
-S_set_regclass_bit(pTHX_ RExC_state_t *pRExC_state, regnode* node, const U8 value, HV** nonbitmap_ptr)
+S_set_regclass_bit(pTHX_ RExC_state_t *pRExC_state, regnode* node, const U8 value, HV** invlist_ptr, AV** alternate_ptr)
{
/* This inline function sets a bit in the bitmap if not already set, and if
* appropriate, its fold, returning the number of bits that actually
stored = 1;
if (FOLD && ! LOC) { /* Locale folds aren't known until runtime */
- stored += set_regclass_bit_fold(pRExC_state, node, value, nonbitmap_ptr);
+ stored += set_regclass_bit_fold(pRExC_state, node, value, invlist_ptr, alternate_ptr);
}
return stored;
w, w, rangebegin);
stored +=
- set_regclass_bit(pRExC_state, ret, '-', &nonbitmap);
+ set_regclass_bit(pRExC_state, ret, '-', &nonbitmap, &unicode_alternate);
if (prevvalue < 256) {
stored +=
- set_regclass_bit(pRExC_state, ret, (U8) prevvalue, &nonbitmap);
+ set_regclass_bit(pRExC_state, ret, (U8) prevvalue, &nonbitmap, &unicode_alternate);
}
else {
nonbitmap = add_cp_to_invlist(nonbitmap, prevvalue);
else {
for (value = 0; value < 128; value++)
stored +=
- set_regclass_bit(pRExC_state, ret, (U8) ASCII_TO_NATIVE(value), &nonbitmap);
+ set_regclass_bit(pRExC_state, ret, (U8) ASCII_TO_NATIVE(value), &nonbitmap, &unicode_alternate);
}
yesno = '+';
what = NULL; /* Doesn't match outside ascii, so
else {
for (value = 128; value < 256; value++)
stored +=
- set_regclass_bit(pRExC_state, ret, (U8) ASCII_TO_NATIVE(value), &nonbitmap);
+ set_regclass_bit(pRExC_state, ret, (U8) ASCII_TO_NATIVE(value), &nonbitmap, &unicode_alternate);
}
ANYOF_FLAGS(ret) |= ANYOF_UNICODE_ALL;
yesno = '!';
/* consecutive digits assumed */
for (value = '0'; value <= '9'; value++)
stored +=
- set_regclass_bit(pRExC_state, ret, (U8) value, &nonbitmap);
+ set_regclass_bit(pRExC_state, ret, (U8) value, &nonbitmap, &unicode_alternate);
}
yesno = '+';
what = POSIX_CC_UNI_NAME("Digit");
/* consecutive digits assumed */
for (value = 0; value < '0'; value++)
stored +=
- set_regclass_bit(pRExC_state, ret, (U8) value, &nonbitmap);
+ set_regclass_bit(pRExC_state, ret, (U8) value, &nonbitmap, &unicode_alternate);
for (value = '9' + 1; value < 256; value++)
stored +=
- set_regclass_bit(pRExC_state, ret, (U8) value, &nonbitmap);
+ set_regclass_bit(pRExC_state, ret, (U8) value, &nonbitmap, &unicode_alternate);
}
yesno = '!';
what = POSIX_CC_UNI_NAME("Digit");
}
if (!SIZE_ONLY)
stored +=
- set_regclass_bit(pRExC_state, ret, '-', &nonbitmap);
+ set_regclass_bit(pRExC_state, ret, '-', &nonbitmap, &unicode_alternate);
} else
range = 1; /* yeah, it's a range! */
continue; /* but do it the next time */
for (i = prevvalue; i <= ceilvalue; i++)
if (isLOWER(i) && !ANYOF_BITMAP_TEST(ret,i)) {
stored +=
- set_regclass_bit(pRExC_state, ret, (U8) i, &nonbitmap);
+ set_regclass_bit(pRExC_state, ret, (U8) i, &nonbitmap, &unicode_alternate);
}
} else {
for (i = prevvalue; i <= ceilvalue; i++)
if (isUPPER(i) && !ANYOF_BITMAP_TEST(ret,i)) {
stored +=
- set_regclass_bit(pRExC_state, ret, (U8) i, &nonbitmap);
+ set_regclass_bit(pRExC_state, ret, (U8) i, &nonbitmap, &unicode_alternate);
}
}
}
else
#endif
for (i = prevvalue; i <= ceilvalue; i++) {
- stored += set_regclass_bit(pRExC_state, ret, (U8) i, &nonbitmap);
+ stored += set_regclass_bit(pRExC_state, ret, (U8) i, &nonbitmap, &unicode_alternate);
}
}
if (value > 255) {
}
if (c < 256 && AT_LEAST_UNI_SEMANTICS) {
- stored += set_regclass_bit(pRExC_state, ret, (U8) c, &nonbitmap);
+ stored += set_regclass_bit(pRExC_state, ret, (U8) c, &nonbitmap, &unicode_alternate);
}
/* It may be that the code point is already
* in this range or already in the bitmap,