mruby-regexp: close a class range at the first codepoint of a \u{...} list - #7263

Two defects at the range step of compile_charclass in mrbgems/mruby-regexp/src/re_compile.c, fixed together because the second is not fully observable without the first: with the range end read from the wrong codepoint, [b-\u{61 63}] compiles to b-c and no reversed range is ever seen there.

A reversed range was dropped without a word. The emission was guarded by cp <= hi with no else, so a positive class silently lacked the span and a negated one admitted every character. CRuby raises for either.

Regexp.new("[b-a]")            # CRuby: RegexpError (empty range in char class), mruby before: compiles and matches nothing, after: RegexpError
Regexp.new("[^b-a]") =~ "x"    # CRuby: RegexpError, mruby before: 0, after: RegexpError
Regexp.new("[\\u{62}-\\u{61}]")  # CRuby: RegexpError, mruby before: compiles, after: RegexpError
Regexp.new("[\\u{62 63}-a]")     # CRuby: RegexpError, mruby before: compiles to `b`, after: RegexpError

A \u{...} list closing a range was bound at its last codepoint. read_class_atom handed every list over the same way, all but the last codepoint as members and the last returned, which is right before a - ([\u{61 62}-z] is a plus b-z) and wrong after one, where CRuby closes the range with the codepoint next to the - and takes the rest as members. The class held a different set in either direction.

/[a-\u{63 7a}]/ =~ "m"   # CRuby: nil, mruby before: 0 (`a-z` plus `c`), after: nil (`a-c` plus `z`)
/[a-\u{7a 41}]/ =~ "a"   # CRuby: 0, mruby before: nil (`a` down to `A`, dropped, and `z` alone), after: 0 (`a-z` plus `A`)
/[\u{3042}-\u{3044 3046}]/ =~ "ぅ"   # CRuby: nil, mruby before: 0, after: nil
Regexp.new("[b-\\u{61 63}]")   # CRuby: RegexpError (empty range in char class), mruby before: `a-c`, after: RegexpError

Fix

• After the byte-versus-character check on the two ends, cp > hi raises RegexpError with CRuby's wording, empty range in char class: /.../. The comparison is sound where it runs: that check leaves no pair of a byte and a character above ASCII, and ASCII sits below either kind.
• read_class_atom takes a closes_range flag. For a \u{...} list that closes a range the first codepoint is returned as the end and the rest join the class as members; a list that does not keeps the old order (last codepoint returned). On a build reading a String by byte the end is still the last byte of that codepoint's spelling, as for any \u in a class there.
• README: the class paragraph on \u{...} lists now states both sides of the - and that a reversed range raises.

Both [a-\u{61}] and [\u{61}-\u{61}] (a range of one) still compile, [-a] and [a-] still take - as a member, and the byte-versus-character rule for \x ends is untouched.

Testing

• regexp_syntax.rb: new block reversed character class range ([b-a], [^b-a] with the exact message, [xz-ay], and the non-cases [a-a], [-a], [a-]).
• regexp_utf8.rb: new blocks reversed character class range through \u and a \u list closing a character class range; the ASCII \u rows run on every build, the rows with codepoints above ASCII ([\u{3044}-\u{3042}], [\u{100}-\u{FF}], [\u{3042}-\u{3044 3046}], [\u{3044}-\u{3046 3042}]) under __ENCODING__ == "UTF-8", since on a byte-read build the ends are the last bytes of the spellings and their order is not the codepoints' order. The two existing list blocks gain a HI-side row [a-\u{63 7a}].
• Every value in the tests and above was checked against CRuby 4.0.6; a probe of 41 class-range patterns gives byte-identical output (including error messages) from bin/mruby and ruby.

Full suite green at every commit (MRUBY_CONFIG=ci/gcc-clang rake -m test at both commits, default rake -m test at the tip after rm -rf build/host):

At the first commit the totals are one lower on each of the five builds (2352 / 2352 / 2352 / 2282 / 2349), KO 0, Crash 0.

Environment

# full-debug
gcc -std=gnu99 -g -O3 -Wall -Wundef -Werror-implicit-function-declaration -Wwrite-strings -g3 -O0 -DMRB_GC_STRESS -DMRB_USE_DEBUG_HOOK -DMRB_DEBUG -DMRB_USE_BIGINT -DMRB_USE_COMPLEX -DHAVE_MRUBY_ENCODING_GEM -DMRB_UTF8_STRING -DHAVE_MRUBY_IO_GEM -DMRB_USE_RATIONAL -DHAVE_MRUBY_REGEXP_GEM -DMRB_USE_SET -DMRB_USE_TASK_SCHEDULER src/string.c
# bintest
gcc -std=gnu99 -g -O3 -Wall -Wundef -Werror-implicit-function-declaration -Wwrite-strings -DMRB_GC_FIXED_ARENA -DMRB_USE_BIGINT -DMRB_USE_COMPLEX -DHAVE_MRUBY_ENCODING_GEM -DMRB_UTF8_STRING -DHAVE_MRUBY_IO_GEM -DMRB_USE_RATIONAL -DHAVE_MRUBY_REGEXP_GEM -DMRB_USE_SET -DMRB_USE_TASK_SCHEDULER -DMRB_USE_DEBUG_HOOK src/string.c
# cxx_abi
gcc -g -O3 -Wall -Wundef -Wwrite-strings -x c++ -std=gnu++03 -DMRB_GC_FIXED_ARENA -DMRB_USE_CXX_EXCEPTION -DMRB_USE_CXX_ABI -DMRB_USE_BIGINT -DMRB_USE_COMPLEX -DHAVE_MRUBY_ENCODING_GEM -DMRB_UTF8_STRING -DHAVE_MRUBY_IO_GEM -DMRB_USE_RATIONAL -DHAVE_MRUBY_REGEXP_GEM -DMRB_USE_SET -DMRB_USE_TASK_SCHEDULER src/string.c
# byte-string
gcc -std=gnu99 -g -O3 -Wall -Wundef -Werror-implicit-function-declaration -Wwrite-strings -DMRB_USE_BIGINT -DMRB_USE_COMPLEX -DHAVE_MRUBY_IO_GEM -DMRB_USE_RATIONAL -DHAVE_MRUBY_REGEXP_GEM -DMRB_USE_SET -DMRB_USE_TASK_SCHEDULER src/string.c
# ascii-case
gcc -std=gnu99 -g -O3 -Wall -Wundef -Werror-implicit-function-declaration -Wwrite-strings -DMRB_USE_ASCII_CASE -DMRB_USE_BIGINT -DMRB_USE_COMPLEX -DHAVE_MRUBY_ENCODING_GEM -DMRB_UTF8_STRING -DHAVE_MRUBY_IO_GEM -DMRB_USE_RATIONAL -DHAVE_MRUBY_REGEXP_GEM -DMRB_USE_SET -DMRB_USE_TASK_SCHEDULER src/string.c

Summary by CodeRabbit

• Bug Fixes

  • Improved regular expression character classes using \u{...} codepoint lists.
  • Reversed ranges now correctly raise RegexpError instead of being silently ignored.
  • Valid ranges and mixed codepoint-list patterns now produce the expected matches, including negated classes.

• Documentation

  • Clarified how codepoint lists and range boundaries are interpreted in character classes.