Constify encoding type in universal parser

nobu · yui-knk · commit 3c16d93cd3a7 · 2024-05-13T08:26:54.000+09:00
Fixed warning about discarding modifiers.

```
../src/ruby_parser.c:677:48: warning: passing 'rb_encoding *' (aka 'const struct OnigEncodingTypeST *') to parameter of type 'void *' discards qualifiers [-Wincompatible-pointer-types-discards-qualifiers]
  677 |     ast = rb_parser_compile(p, gets, ptr, len, enc, input, line);
      |                                                ^~~
../src/internal/parse.h:58:128: note: passing argument to parameter 'fname_enc' here
   58 | rb_ast_t *rb_parser_compile(rb_parser_t *p, rb_parser_lex_gets_func *gets, const char *fname_ptr, long fname_len, rb_encoding *fname_enc, rb_parser_input_data input, int line);
      |                                                                                                                                ^
```
diff --git a/internal/parse.h b/internal/parse.h
@@ -13,7 +13,7 @@
 #include "internal/static_assert.h"
 
 #ifdef UNIVERSAL_PARSER
-#define rb_encoding void
+#define rb_encoding const void
 #endif
 
 struct rb_iseq_struct;          /* in vm_core.h */
diff --git a/ruby_parser.c b/ruby_parser.c
@@ -32,6 +32,8 @@
 #include "vm_core.h"
 #include "symbol.h"
 
+#define parser_encoding const void
+
 static int
 is_ascii_string2(VALUE str)
 {
@@ -41,9 +43,9 @@ is_ascii_string2(VALUE str)
 RBIMPL_ATTR_FORMAT(RBIMPL_PRINTF_FORMAT, 6, 0)
 static VALUE
 syntax_error_append(VALUE exc, VALUE file, int line, int column,
-                       void *enc, const char *fmt, va_list args)
+                    parser_encoding *enc, const char *fmt, va_list args)
 {
-    return rb_syntax_error_append(exc, file, line, column, (rb_encoding *)enc, fmt, args);
+    return rb_syntax_error_append(exc, file, line, column, enc, fmt, args);
 }
 
 static int
@@ -59,9 +61,9 @@ dvar_defined(ID id, const void *p)
 }
 
 static int
-is_usascii_enc(void *enc)
+is_usascii_enc(parser_encoding *enc)
 {
-    return rb_is_usascii_enc((rb_encoding *)enc);
+    return rb_is_usascii_enc(enc);
 }
 
 static int
@@ -83,21 +85,21 @@ is_notop_id2(ID id)
 }
 
 static VALUE
-enc_str_new(const char *ptr, long len, void *enc)
+enc_str_new(const char *ptr, long len, parser_encoding *enc)
 {
-    return rb_enc_str_new(ptr, len, (rb_encoding *)enc);
+    return rb_enc_str_new(ptr, len, enc);
 }
 
 static int
-enc_isalnum(OnigCodePoint c, void *enc)
+enc_isalnum(OnigCodePoint c, parser_encoding *enc)
 {
-    return rb_enc_isalnum(c, (rb_encoding *)enc);
+    return rb_enc_isalnum(c, enc);
 }
 
 static int
-enc_precise_mbclen(const char *p, const char *e, void *enc)
+enc_precise_mbclen(const char *p, const char *e, parser_encoding *enc)
 {
-    return rb_enc_precise_mbclen(p, e, (rb_encoding *)enc);
+    return rb_enc_precise_mbclen(p, e, enc);
 }
 
 static int
@@ -113,93 +115,93 @@ mbclen_charfound_len(int len)
 }
 
 static const char *
-enc_name(void *enc)
+enc_name(parser_encoding *enc)
 {
-    return rb_enc_name((rb_encoding *)enc);
+    return rb_enc_name(enc);
 }
 
 static char *
-enc_prev_char(const char *s, const char *p, const char *e, void *enc)
+enc_prev_char(const char *s, const char *p, const char *e, parser_encoding *enc)
 {
-    return rb_enc_prev_char(s, p, e, (rb_encoding *)enc);
+    return rb_enc_prev_char(s, p, e, enc);
 }
 
-static void *
+static parser_encoding *
 enc_get(VALUE obj)
 {
-    return (void *)rb_enc_get(obj);
+    return rb_enc_get(obj);
 }
 
 static int
-enc_asciicompat(void *enc)
+enc_asciicompat(parser_encoding *enc)
 {
-    return rb_enc_asciicompat((rb_encoding *)enc);
+    return rb_enc_asciicompat(enc);
 }
 
-static void *
+static parser_encoding *
 utf8_encoding(void)
 {
-    return (void *)rb_utf8_encoding();
+    return rb_utf8_encoding();
 }
 
 static VALUE
-enc_associate(VALUE obj, void *enc)
+enc_associate(VALUE obj, parser_encoding *enc)
 {
-    return rb_enc_associate(obj, (rb_encoding *)enc);
+    return rb_enc_associate(obj, enc);
 }
 
-static void *
+static parser_encoding *
 ascii8bit_encoding(void)
 {
-    return (void *)rb_ascii8bit_encoding();
+    return rb_ascii8bit_encoding();
 }
 
 static int
-enc_codelen(int c, void *enc)
+enc_codelen(int c, parser_encoding *enc)
 {
-    return rb_enc_codelen(c, (rb_encoding *)enc);
+    return rb_enc_codelen(c, enc);
 }
 
 static int
-enc_mbcput(unsigned int c, void *buf, void *enc)
+enc_mbcput(unsigned int c, void *buf, parser_encoding *enc)
 {
-    return rb_enc_mbcput(c, buf, (rb_encoding *)enc);
+    return rb_enc_mbcput(c, buf, enc);
 }
 
 static int
-enc_mbclen(const char *p, const char *e, void *enc)
+enc_mbclen(const char *p, const char *e, parser_encoding *enc)
 {
-    return rb_enc_mbclen(p, e, (rb_encoding *)enc);
+    return rb_enc_mbclen(p, e, enc);
 }
 
-static void *
+static parser_encoding *
 enc_from_index(int idx)
 {
-    return (void *)rb_enc_from_index(idx);
+    return rb_enc_from_index(idx);
 }
 
 static int
-enc_isspace(OnigCodePoint c, void *enc)
+enc_isspace(OnigCodePoint c, parser_encoding *enc)
 {
-    return rb_enc_isspace(c, (rb_encoding *)enc);
+    return rb_enc_isspace(c, enc);
 }
 
 static ID
-intern3(const char *name, long len, void *enc)
+intern3(const char *name, long len, parser_encoding *enc)
 {
-    return rb_intern3(name, len, (rb_encoding *)enc);
+    return rb_intern3(name, len, enc);
 }
 
-static void *
+static parser_encoding *
 usascii_encoding(void)
 {
-    return (void *)rb_usascii_encoding();
+    return rb_usascii_encoding();
 }
 
 static int
-enc_symname_type(const char *name, long len, void *enc, unsigned int allowed_attrset)
+enc_symname_type(const char *name, long len, parser_encoding *enc, unsigned int allowed_attrset)
 {
-    return rb_enc_symname_type(name, len, (rb_encoding *)enc, allowed_attrset);
+    return rb_enc_symname_type(name, len, enc, allowed_attrset);
 }
 
 typedef struct {
@@ -220,7 +222,7 @@ reg_named_capture_assign_iter(const OnigUChar *name, const OnigUChar *name_end,
     long len = name_end - name;
     const char *s = (const char *)name;
 
-    return rb_reg_named_capture_assign_iter_impl(p, s, len, (void *)enc, &arg->succ_block, loc);
+    return rb_reg_named_capture_assign_iter_impl(p, s, len, enc, &arg->succ_block, loc);
 }
 
 static NODE *
@@ -305,25 +307,25 @@ static_id2sym(ID id)
 }
 
 static long
-str_coderange_scan_restartable(const char *s, const char *e, void *enc, int *cr)
+str_coderange_scan_restartable(const char *s, const char *e, parser_encoding *enc, int *cr)
 {
-    return rb_str_coderange_scan_restartable(s, e, (rb_encoding *)enc, cr);
+    return rb_str_coderange_scan_restartable(s, e, enc, cr);
 }
 
 static int
-enc_mbminlen(void *enc)
+enc_mbminlen(parser_encoding *enc)
 {
-    return rb_enc_mbminlen((rb_encoding *)enc);
+    return rb_enc_mbminlen(enc);
 }
 
 static bool
-enc_isascii(OnigCodePoint c, void *enc)
+enc_isascii(OnigCodePoint c, parser_encoding *enc)
 {
-    return rb_enc_isascii(c, (rb_encoding *)enc);
+    return rb_enc_isascii(c, enc);
 }
 
 static OnigCodePoint
-enc_mbc_to_codepoint(const char *p, const char *e, void *enc)
+enc_mbc_to_codepoint(const char *p, const char *e, parser_encoding *enc)
 {
     const OnigUChar *up = RBIMPL_CAST((const OnigUChar *)p);
     const OnigUChar *ue = RBIMPL_CAST((const OnigUChar *)e);
diff --git a/rubyparser.h b/rubyparser.h
@@ -9,7 +9,7 @@
 
 #ifdef UNIVERSAL_PARSER
 
-#define rb_encoding void
+#define rb_encoding const void
 #define OnigCodePoint unsigned int
 #include "parser_st.h"
 #ifndef RUBY_RUBY_H
diff --git a/universal_parser.c b/universal_parser.c
@@ -59,7 +59,7 @@
 #undef st_lookup
 #define st_lookup rb_parser_st_lookup
 
-#define rb_encoding void
+#define rb_encoding const void
 
 #undef xmalloc
 #define xmalloc p->config->malloc

Original file line number	Diff line number	Diff line change
`@@ -32,6 +32,8 @@`
`32`	`32`	`#include "vm_core.h"`
`33`	`33`	`#include "symbol.h"`
`34`	`34`
	`35`	`+#define parser_encoding const void`
	`36`	`+`
`35`	`37`	`static int`
`36`	`38`	`is_ascii_string2(VALUE str)`
`37`	`39`	`{`
`@@ -41,9 +43,9 @@ is_ascii_string2(VALUE str)`
`41`	`43`	`RBIMPL_ATTR_FORMAT(RBIMPL_PRINTF_FORMAT, 6, 0)`
`42`	`44`	`static VALUE`
`43`	`45`	`syntax_error_append(VALUE exc, VALUE file, int line, int column,`
`44`		`- void enc, const char fmt, va_list args)`
	`46`	`+ parser_encoding enc, const char fmt, va_list args)`
`45`	`47`	`{`
`46`		`- return rb_syntax_error_append(exc, file, line, column, (rb_encoding *)enc, fmt, args);`
	`48`	`+ return rb_syntax_error_append(exc, file, line, column, enc, fmt, args);`
`47`	`49`	`}`
`48`	`50`
`49`	`51`	`static int`
`@@ -59,9 +61,9 @@ dvar_defined(ID id, const void *p)`
`59`	`61`	`}`
`60`	`62`
`61`	`63`	`static int`
`62`		`-is_usascii_enc(void *enc)`
	`64`	`+is_usascii_enc(parser_encoding *enc)`
`63`	`65`	`{`
`64`		`- return rb_is_usascii_enc((rb_encoding *)enc);`
	`66`	`+ return rb_is_usascii_enc(enc);`
`65`	`67`	`}`
`66`	`68`
`67`	`69`	`static int`
`@@ -83,21 +85,21 @@ is_notop_id2(ID id)`
`83`	`85`	`}`
`84`	`86`
`85`	`87`	`static VALUE`
`86`		`-enc_str_new(const char ptr, long len, void enc)`
	`88`	`+enc_str_new(const char ptr, long len, parser_encoding enc)`
`87`	`89`	`{`
`88`		`- return rb_enc_str_new(ptr, len, (rb_encoding *)enc);`
	`90`	`+ return rb_enc_str_new(ptr, len, enc);`
`89`	`91`	`}`
`90`	`92`
`91`	`93`	`static int`
`92`		`-enc_isalnum(OnigCodePoint c, void *enc)`
	`94`	`+enc_isalnum(OnigCodePoint c, parser_encoding *enc)`
`93`	`95`	`{`
`94`		`- return rb_enc_isalnum(c, (rb_encoding *)enc);`
	`96`	`+ return rb_enc_isalnum(c, enc);`
`95`	`97`	`}`
`96`	`98`
`97`	`99`	`static int`
`98`		`-enc_precise_mbclen(const char p, const char e, void *enc)`
	`100`	`+enc_precise_mbclen(const char p, const char e, parser_encoding *enc)`
`99`	`101`	`{`
`100`		`- return rb_enc_precise_mbclen(p, e, (rb_encoding *)enc);`
	`102`	`+ return rb_enc_precise_mbclen(p, e, enc);`
`101`	`103`	`}`
`102`	`104`
`103`	`105`	`static int`
`@@ -113,93 +115,93 @@ mbclen_charfound_len(int len)`
`113`	`115`	`}`
`114`	`116`
`115`	`117`	`static const char *`
`116`		`-enc_name(void *enc)`
	`118`	`+enc_name(parser_encoding *enc)`
`117`	`119`	`{`
`118`		`- return rb_enc_name((rb_encoding *)enc);`
	`120`	`+ return rb_enc_name(enc);`
`119`	`121`	`}`
`120`	`122`
`121`	`123`	`static char *`
`122`		`-enc_prev_char(const char s, const char p, const char e, void enc)`
	`124`	`+enc_prev_char(const char s, const char p, const char e, parser_encoding enc)`
`123`	`125`	`{`
`124`		`- return rb_enc_prev_char(s, p, e, (rb_encoding *)enc);`
	`126`	`+ return rb_enc_prev_char(s, p, e, enc);`
`125`	`127`	`}`
`126`	`128`
`127`		`-static void *`
	`129`	`+static parser_encoding *`
`128`	`130`	`enc_get(VALUE obj)`
`129`	`131`	`{`
`130`		`- return (void *)rb_enc_get(obj);`
	`132`	`+ return rb_enc_get(obj);`
`131`	`133`	`}`
`132`	`134`
`133`	`135`	`static int`
`134`		`-enc_asciicompat(void *enc)`
	`136`	`+enc_asciicompat(parser_encoding *enc)`
`135`	`137`	`{`
`136`		`- return rb_enc_asciicompat((rb_encoding *)enc);`
	`138`	`+ return rb_enc_asciicompat(enc);`
`137`	`139`	`}`
`138`	`140`
`139`		`-static void *`
	`141`	`+static parser_encoding *`
`140`	`142`	`utf8_encoding(void)`
`141`	`143`	`{`
`142`		`- return (void *)rb_utf8_encoding();`
	`144`	`+ return rb_utf8_encoding();`
`143`	`145`	`}`
`144`	`146`
`145`	`147`	`static VALUE`
`146`		`-enc_associate(VALUE obj, void *enc)`
	`148`	`+enc_associate(VALUE obj, parser_encoding *enc)`
`147`	`149`	`{`
`148`		`- return rb_enc_associate(obj, (rb_encoding *)enc);`
	`150`	`+ return rb_enc_associate(obj, enc);`
`149`	`151`	`}`
`150`	`152`
`151`		`-static void *`
	`153`	`+static parser_encoding *`
`152`	`154`	`ascii8bit_encoding(void)`
`153`	`155`	`{`
`154`		`- return (void *)rb_ascii8bit_encoding();`
	`156`	`+ return rb_ascii8bit_encoding();`
`155`	`157`	`}`
`156`	`158`
`157`	`159`	`static int`
`158`		`-enc_codelen(int c, void *enc)`
	`160`	`+enc_codelen(int c, parser_encoding *enc)`
`159`	`161`	`{`
`160`		`- return rb_enc_codelen(c, (rb_encoding *)enc);`
	`162`	`+ return rb_enc_codelen(c, enc);`
`161`	`163`	`}`
`162`	`164`
`163`	`165`	`static int`
`164`		`-enc_mbcput(unsigned int c, void buf, void enc)`
	`166`	`+enc_mbcput(unsigned int c, void buf, parser_encoding enc)`
`165`	`167`	`{`
`166`		`- return rb_enc_mbcput(c, buf, (rb_encoding *)enc);`
	`168`	`+ return rb_enc_mbcput(c, buf, enc);`
`167`	`169`	`}`
`168`	`170`
`169`	`171`	`static int`
`170`		`-enc_mbclen(const char p, const char e, void *enc)`
	`172`	`+enc_mbclen(const char p, const char e, parser_encoding *enc)`
`171`	`173`	`{`
`172`		`- return rb_enc_mbclen(p, e, (rb_encoding *)enc);`
	`174`	`+ return rb_enc_mbclen(p, e, enc);`
`173`	`175`	`}`
`174`	`176`
`175`		`-static void *`
	`177`	`+static parser_encoding *`
`176`	`178`	`enc_from_index(int idx)`
`177`	`179`	`{`
`178`		`- return (void *)rb_enc_from_index(idx);`
	`180`	`+ return rb_enc_from_index(idx);`
`179`	`181`	`}`
`180`	`182`
`181`	`183`	`static int`
`182`		`-enc_isspace(OnigCodePoint c, void *enc)`
	`184`	`+enc_isspace(OnigCodePoint c, parser_encoding *enc)`
`183`	`185`	`{`
`184`		`- return rb_enc_isspace(c, (rb_encoding *)enc);`
	`186`	`+ return rb_enc_isspace(c, enc);`
`185`	`187`	`}`
`186`	`188`
`187`	`189`	`static ID`
`188`		`-intern3(const char name, long len, void enc)`
	`190`	`+intern3(const char name, long len, parser_encoding enc)`
`189`	`191`	`{`
`190`		`- return rb_intern3(name, len, (rb_encoding *)enc);`
	`192`	`+ return rb_intern3(name, len, enc);`
`191`	`193`	`}`
`192`	`194`
`193`		`-static void *`
	`195`	`+static parser_encoding *`
`194`	`196`	`usascii_encoding(void)`
`195`	`197`	`{`
`196`		`- return (void *)rb_usascii_encoding();`
	`198`	`+ return rb_usascii_encoding();`
`197`	`199`	`}`
`198`	`200`
`199`	`201`	`static int`
`200`		`-enc_symname_type(const char name, long len, void enc, unsigned int allowed_attrset)`
	`202`	`+enc_symname_type(const char name, long len, parser_encoding enc, unsigned int allowed_attrset)`
`201`	`203`	`{`
`202`		`- return rb_enc_symname_type(name, len, (rb_encoding *)enc, allowed_attrset);`
	`204`	`+ return rb_enc_symname_type(name, len, enc, allowed_attrset);`
`203`	`205`	`}`
`204`	`206`
`205`	`207`	`typedef struct {`
`@@ -220,7 +222,7 @@ reg_named_capture_assign_iter(const OnigUChar name, const OnigUChar name_end,`
`220`	`222`	`long len = name_end - name;`
`221`	`223`	`const char s = (const char )name;`
`222`	`224`
`223`		`- return rb_reg_named_capture_assign_iter_impl(p, s, len, (void *)enc, &arg->succ_block, loc);`
	`225`	`+ return rb_reg_named_capture_assign_iter_impl(p, s, len, enc, &arg->succ_block, loc);`
`224`	`226`	`}`
`225`	`227`
`226`	`228`	`static NODE *`
`@@ -305,25 +307,25 @@ static_id2sym(ID id)`
`305`	`307`	`}`
`306`	`308`
`307`	`309`	`static long`
`308`		`-str_coderange_scan_restartable(const char s, const char e, void enc, int cr)`
	`310`	`+str_coderange_scan_restartable(const char s, const char e, parser_encoding enc, int cr)`
`309`	`311`	`{`
`310`		`- return rb_str_coderange_scan_restartable(s, e, (rb_encoding *)enc, cr);`
	`312`	`+ return rb_str_coderange_scan_restartable(s, e, enc, cr);`
`311`	`313`	`}`
`312`	`314`
`313`	`315`	`static int`
`314`		`-enc_mbminlen(void *enc)`
	`316`	`+enc_mbminlen(parser_encoding *enc)`
`315`	`317`	`{`
`316`		`- return rb_enc_mbminlen((rb_encoding *)enc);`
	`318`	`+ return rb_enc_mbminlen(enc);`
`317`	`319`	`}`
`318`	`320`
`319`	`321`	`static bool`
`320`		`-enc_isascii(OnigCodePoint c, void *enc)`
	`322`	`+enc_isascii(OnigCodePoint c, parser_encoding *enc)`
`321`	`323`	`{`
`322`		`- return rb_enc_isascii(c, (rb_encoding *)enc);`
	`324`	`+ return rb_enc_isascii(c, enc);`
`323`	`325`	`}`
`324`	`326`
`325`	`327`	`static OnigCodePoint`
`326`		`-enc_mbc_to_codepoint(const char p, const char e, void *enc)`
	`328`	`+enc_mbc_to_codepoint(const char p, const char e, parser_encoding *enc)`
`327`	`329`	`{`
`328`	`330`	`const OnigUChar up = RBIMPL_CAST((const OnigUChar )p);`
`329`	`331`	`const OnigUChar ue = RBIMPL_CAST((const OnigUChar )e);`