internal.h: move writing a string's encoding and coderange inside - #7179

Stacked on #7178, which is the first commit here. The second commit is this PR's own change, and the diff to read is git diff 33723b692..HEAD. Merging #7178 first leaves this one a single commit.

include/mruby/string.h hands out both of a string's answers about its bytes and both ways of writing them:

#define RSTR_CODERANGE(s)          /* read  */
#define RSTR_CODERANGE_SET(s, cr)  /* write */
#define RSTR_ENCODING(s)           /* read  */
#define RSTR_ENCODING_SET(s, e)    /* write */
#define RSTR_ENC_COPY(dst, src)
#define RSTR_ENC_CR_COPY(dst, src)
#define RSTR_ENC_CR_COPY_FOR_SUBSTR(dst, src)

Reading one is asking the string what its bytes were found to be, and asking costs it nothing. Writing one is making a claim about them, and a claim the bytes do not support is caught nowhere: a wrong encoding index has the bytes read as something they are not, and a string wrongly saying it reads whole and sound walks straight through the check a regexp makes of its subject before handing it to the engine.

This PR moves the writes to include/mruby/internal.h, which is where what has to be answered for already lives.

The line CRuby draws in the same place

rb_enc_str_coderange() is in include/ruby/encoding.h; ENC_CODERANGE_CLEAR and ENC_CODERANGE_SET are in internal/encoding/coderange.h. Read published, written inside.

What stays behind

The answers themselves. Naming one is reading, and what reads MRB_STR_CODERANGE_7BIT off a string has to be able to say it:

#define MRB_STR_CODERANGE_UNKNOWN 0
#define MRB_STR_CODERANGE_7BIT    1
#define MRB_STR_CODERANGE_VALID   2
#define MRB_STR_CODERANGE_BROKEN  3
#define MRB_STR_ENCODING_DEFAULT  0
#define MRB_STR_ENCODING_BINARY   1

along with the _SHIFT / _BITS / _MASK triples the readers expand to, and RSTR_CODERANGE, RSTR_ENCODING, RSTR_BINARY_P, RSTR_SINGLE_BYTE_P.

Nothing in the tree has to follow

Ten files write one of the fields, 46 writes in all:

$ git grep -c 'RSTR_CODERANGE_SET\|RSTR_ENCODING_SET\|RSTR_ENC_COPY\|RSTR_ENC_CR_COPY' -- '*.c'
mrbgems/mruby-encoding/src/encoding.c:2
mrbgems/mruby-regexp/src/regexp.c:1
mrbgems/mruby-sprintf/src/sprintf.c:2
mrbgems/mruby-string-bitops/src/string_bitops.c:1
mrbgems/mruby-string-ext/src/string.c:12
mrbgems/mruby-time/src/time.c:1
src/numeric.c:2
src/object.c:4
src/string.c:19
src/symbol.c:2

Every one of them already includes mruby/internal.h, and every one includes mruby/string.h before it:

mrbgems/mruby-encoding/src/encoding.c                string.h:2     internal.h:4
mrbgems/mruby-regexp/src/regexp.c                    string.h:10    internal.h:15
mrbgems/mruby-sprintf/src/sprintf.c                  string.h:8     internal.h:11
mrbgems/mruby-string-bitops/src/string_bitops.c      string.h:12    internal.h:13
mrbgems/mruby-string-ext/src/string.c                string.h:5     internal.h:7
mrbgems/mruby-time/src/time.c                        string.h:12    internal.h:13
src/numeric.c                                        string.h:10    internal.h:12
src/object.c                                         string.h:10    internal.h:12
src/string.c                                         string.h:16    internal.h:18
src/symbol.c                                         string.h:10    internal.h:17

So no #include line is added or moved:

$ git diff 33723b692..HEAD --stat
 include/mruby/internal.h | 68 ++++++++++++++++++++++++++++++++++++++++++++++++
 include/mruby/string.h   | 43 +++---------------------------
 2 files changed, 72 insertions(+), 39 deletions(-)

$ git diff 33723b692..HEAD | grep '^[+-]#include'
$

No #ifdef MRUBY_STRING_H guard is needed around the moved block either: what a macro spells has to be defined where it is expanded, not where it is written, and the four names it reaches for stay in mruby/string.h.

The amalgamated header carries them

lib/mruby/amalgam.rb inlines mruby/internal.h whole, so the move needs no change there. Generating mruby.h on master and on this branch and comparing the two, sorted so a block that only moved does not show:

$ diff <(sort master/amalgam/mruby.h) <(sort this-pr/amalgam/mruby.h) | grep '^<'
$ diff <(sort master/amalgam/mruby.h) <(sort this-pr/amalgam/mruby.h) | grep '^>' | grep '#'
> #define RSTR_SINGLE_BYTE_P(s) \
> #else
> #endif
> #ifdef MRB_UTF8_STRING

Nothing is dropped, and what is added is #7178's macro and the #ifdef MRB_UTF8_STRING the moved block brings with it. The rest of the 40 added lines are the comments the two commits write. The moved writes land at mruby.h:8800 onwards in the generated header, inside the mruby/internal.h section.

Generated code

A move of macro definitions, so nothing changes in what is generated. gcc 13.3.0 -O3, x86-64, .text of bin/mruby, against the same objects built from master:

Objects differing between this commit and #7178, comparing objdump -d over every .o in the build:

cxx_abi is the one build in ci/gcc-clang that goes through the C++ compiler, and the moved block is reached from mrbgems/mruby-string-bitops, mrbgems/mruby-time and src/symbol.c there as everywhere else.

Testing

rake -m test, on each commit, all green, 0 KO, 0 crash, 0 warnings, and the same counts as master:

build_config/host-m32.rb needs a multilib toolchain, so the 32-bit build above is full-core with the compiler set to i686-linux-gnu-gcc instead.

No test accompanies the change. A macro spells what it spelled and is expanded where it was expanded, so no string answers anything different.

For a gem outside the tree

One that writes either field has to include mruby/internal.h after this. That is a compile error and not a quiet change of behavior, which is what a gem making a claim about a string's bytes should get.

Not in this PR

What the two fields mean, how wide they are, and where in the flags word they sit are all untouched. So is every write in the tree: the 46 above are the same 46, spelled the same way, in the same order.

Summary by CodeRabbit

• Refactor
  • Moved the macros that write a string's encoding index and character-range from the public string header to the internal one, leaving the reads and the named values where they were.